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 VkBufferUsageFlags2CreateInfoKHR32
 567 {
 568     VkStructureType sType;
 569     PTR32 pNext;
 570     VkBufferUsageFlags2KHR DECLSPEC_ALIGN(8) usage;
 571 } VkBufferUsageFlags2CreateInfoKHR32;
 572
 573 typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32
 574 {
 575     VkStructureType sType;
 576     PTR32 pNext;
 577     VkBuffer DECLSPEC_ALIGN(8) buffer;
 578 } VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32;
 579
 580 typedef struct VkDescriptorBufferBindingInfoEXT32
 581 {
 582     VkStructureType sType;
 583     PTR32 pNext;
 584     VkDeviceAddress DECLSPEC_ALIGN(8) address;
 585     VkBufferUsageFlags usage;
 586 } VkDescriptorBufferBindingInfoEXT32;
 587
 588 typedef struct VkCopyCommandTransformInfoQCOM32
 589 {
 590     VkStructureType sType;
 591     PTR32 pNext;
 592     VkSurfaceTransformFlagBitsKHR transform;
 593 } VkCopyCommandTransformInfoQCOM32;
 594
 595 typedef struct VkImageBlit232
 596 {
 597     VkStructureType sType;
 598     PTR32 pNext;
 599     VkImageSubresourceLayers srcSubresource;
 600     VkOffset3D srcOffsets[2];
 601     VkImageSubresourceLayers dstSubresource;
 602     VkOffset3D dstOffsets[2];
 603 } VkImageBlit232;
 604 typedef VkImageBlit232 VkImageBlit2KHR32;
 605
 606 typedef struct VkBlitImageInfo232
 607 {
 608     VkStructureType sType;
 609     PTR32 pNext;
 610     VkImage DECLSPEC_ALIGN(8) srcImage;
 611     VkImageLayout srcImageLayout;
 612     VkImage DECLSPEC_ALIGN(8) dstImage;
 613     VkImageLayout dstImageLayout;
 614     uint32_t regionCount;
 615     PTR32 pRegions;
 616     VkFilter filter;
 617 } VkBlitImageInfo232;
 618 typedef VkBlitImageInfo232 VkBlitImageInfo2KHR32;
 619
 620 typedef struct VkGeometryTrianglesNV32
 621 {
 622     VkStructureType sType;
 623     PTR32 pNext;
 624     VkBuffer DECLSPEC_ALIGN(8) vertexData;
 625     VkDeviceSize DECLSPEC_ALIGN(8) vertexOffset;
 626     uint32_t vertexCount;
 627     VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
 628     VkFormat vertexFormat;
 629     VkBuffer DECLSPEC_ALIGN(8) indexData;
 630     VkDeviceSize DECLSPEC_ALIGN(8) indexOffset;
 631     uint32_t indexCount;
 632     VkIndexType indexType;
 633     VkBuffer DECLSPEC_ALIGN(8) transformData;
 634     VkDeviceSize DECLSPEC_ALIGN(8) transformOffset;
 635 } VkGeometryTrianglesNV32;
 636
 637 typedef struct VkGeometryAABBNV32
 638 {
 639     VkStructureType sType;
 640     PTR32 pNext;
 641     VkBuffer DECLSPEC_ALIGN(8) aabbData;
 642     uint32_t numAABBs;
 643     uint32_t stride;
 644     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 645 } VkGeometryAABBNV32;
 646
 647 typedef struct VkGeometryDataNV32
 648 {
 649     VkGeometryTrianglesNV32 DECLSPEC_ALIGN(8) triangles;
 650     VkGeometryAABBNV32 DECLSPEC_ALIGN(8) aabbs;
 651 } VkGeometryDataNV32;
 652
 653 typedef struct VkGeometryNV32
 654 {
 655     VkStructureType sType;
 656     PTR32 pNext;
 657     VkGeometryTypeKHR geometryType;
 658     VkGeometryDataNV32 DECLSPEC_ALIGN(8) geometry;
 659     VkGeometryFlagsKHR flags;
 660 } VkGeometryNV32;
 661
 662 typedef struct VkAccelerationStructureInfoNV32
 663 {
 664     VkStructureType sType;
 665     PTR32 pNext;
 666     VkAccelerationStructureTypeNV type;
 667     VkBuildAccelerationStructureFlagsNV flags;
 668     uint32_t instanceCount;
 669     uint32_t geometryCount;
 670     PTR32 pGeometries;
 671 } VkAccelerationStructureInfoNV32;
 672
 673 typedef struct VkCopyAccelerationStructureInfoKHR32
 674 {
 675     VkStructureType sType;
 676     PTR32 pNext;
 677     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
 678     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
 679     VkCopyAccelerationStructureModeKHR mode;
 680 } VkCopyAccelerationStructureInfoKHR32;
 681
 682 typedef struct VkCopyAccelerationStructureToMemoryInfoKHR32
 683 {
 684     VkStructureType sType;
 685     PTR32 pNext;
 686     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
 687     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
 688     VkCopyAccelerationStructureModeKHR mode;
 689 } VkCopyAccelerationStructureToMemoryInfoKHR32;
 690
 691 typedef struct VkBufferCopy32
 692 {
 693     VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
 694     VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
 695     VkDeviceSize DECLSPEC_ALIGN(8) size;
 696 } VkBufferCopy32;
 697
 698 typedef struct VkBufferCopy232
 699 {
 700     VkStructureType sType;
 701     PTR32 pNext;
 702     VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
 703     VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
 704     VkDeviceSize DECLSPEC_ALIGN(8) size;
 705 } VkBufferCopy232;
 706 typedef VkBufferCopy232 VkBufferCopy2KHR32;
 707
 708 typedef struct VkCopyBufferInfo232
 709 {
 710     VkStructureType sType;
 711     PTR32 pNext;
 712     VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
 713     VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
 714     uint32_t regionCount;
 715     PTR32 pRegions;
 716 } VkCopyBufferInfo232;
 717 typedef VkCopyBufferInfo232 VkCopyBufferInfo2KHR32;
 718
 719 typedef struct VkBufferImageCopy32
 720 {
 721     VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
 722     uint32_t bufferRowLength;
 723     uint32_t bufferImageHeight;
 724     VkImageSubresourceLayers imageSubresource;
 725     VkOffset3D imageOffset;
 726     VkExtent3D imageExtent;
 727 } VkBufferImageCopy32;
 728
 729 typedef struct VkBufferImageCopy232
 730 {
 731     VkStructureType sType;
 732     PTR32 pNext;
 733     VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
 734     uint32_t bufferRowLength;
 735     uint32_t bufferImageHeight;
 736     VkImageSubresourceLayers imageSubresource;
 737     VkOffset3D imageOffset;
 738     VkExtent3D imageExtent;
 739 } VkBufferImageCopy232;
 740 typedef VkBufferImageCopy232 VkBufferImageCopy2KHR32;
 741
 742 typedef struct VkCopyBufferToImageInfo232
 743 {
 744     VkStructureType sType;
 745     PTR32 pNext;
 746     VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
 747     VkImage DECLSPEC_ALIGN(8) dstImage;
 748     VkImageLayout dstImageLayout;
 749     uint32_t regionCount;
 750     PTR32 pRegions;
 751 } VkCopyBufferToImageInfo232;
 752 typedef VkCopyBufferToImageInfo232 VkCopyBufferToImageInfo2KHR32;
 753
 754 typedef struct VkImageCopy232
 755 {
 756     VkStructureType sType;
 757     PTR32 pNext;
 758     VkImageSubresourceLayers srcSubresource;
 759     VkOffset3D srcOffset;
 760     VkImageSubresourceLayers dstSubresource;
 761     VkOffset3D dstOffset;
 762     VkExtent3D extent;
 763 } VkImageCopy232;
 764 typedef VkImageCopy232 VkImageCopy2KHR32;
 765
 766 typedef struct VkCopyImageInfo232
 767 {
 768     VkStructureType sType;
 769     PTR32 pNext;
 770     VkImage DECLSPEC_ALIGN(8) srcImage;
 771     VkImageLayout srcImageLayout;
 772     VkImage DECLSPEC_ALIGN(8) dstImage;
 773     VkImageLayout dstImageLayout;
 774     uint32_t regionCount;
 775     PTR32 pRegions;
 776 } VkCopyImageInfo232;
 777 typedef VkCopyImageInfo232 VkCopyImageInfo2KHR32;
 778
 779 typedef struct VkCopyImageToBufferInfo232
 780 {
 781     VkStructureType sType;
 782     PTR32 pNext;
 783     VkImage DECLSPEC_ALIGN(8) srcImage;
 784     VkImageLayout srcImageLayout;
 785     VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
 786     uint32_t regionCount;
 787     PTR32 pRegions;
 788 } VkCopyImageToBufferInfo232;
 789 typedef VkCopyImageToBufferInfo232 VkCopyImageToBufferInfo2KHR32;
 790
 791 typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32
 792 {
 793     VkStructureType sType;
 794     PTR32 pNext;
 795     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
 796     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
 797     VkCopyAccelerationStructureModeKHR mode;
 798 } VkCopyMemoryToAccelerationStructureInfoKHR32;
 799
 800 typedef struct VkCopyMemoryToMicromapInfoEXT32
 801 {
 802     VkStructureType sType;
 803     PTR32 pNext;
 804     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
 805     VkMicromapEXT DECLSPEC_ALIGN(8) dst;
 806     VkCopyMicromapModeEXT mode;
 807 } VkCopyMemoryToMicromapInfoEXT32;
 808
 809 typedef struct VkCopyMicromapInfoEXT32
 810 {
 811     VkStructureType sType;
 812     PTR32 pNext;
 813     VkMicromapEXT DECLSPEC_ALIGN(8) src;
 814     VkMicromapEXT DECLSPEC_ALIGN(8) dst;
 815     VkCopyMicromapModeEXT mode;
 816 } VkCopyMicromapInfoEXT32;
 817
 818 typedef struct VkCopyMicromapToMemoryInfoEXT32
 819 {
 820     VkStructureType sType;
 821     PTR32 pNext;
 822     VkMicromapEXT DECLSPEC_ALIGN(8) src;
 823     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
 824     VkCopyMicromapModeEXT mode;
 825 } VkCopyMicromapToMemoryInfoEXT32;
 826
 827 typedef struct VkCuLaunchInfoNVX32
 828 {
 829     VkStructureType sType;
 830     PTR32 pNext;
 831     VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
 832     uint32_t gridDimX;
 833     uint32_t gridDimY;
 834     uint32_t gridDimZ;
 835     uint32_t blockDimX;
 836     uint32_t blockDimY;
 837     uint32_t blockDimZ;
 838     uint32_t sharedMemBytes;
 839     PTR32 paramCount;
 840     PTR32 pParams;
 841     PTR32 extraCount;
 842     PTR32 pExtras;
 843 } VkCuLaunchInfoNVX32;
 844
 845 typedef struct VkDebugMarkerMarkerInfoEXT32
 846 {
 847     VkStructureType sType;
 848     PTR32 pNext;
 849     PTR32 pMarkerName;
 850     float color[4];
 851 } VkDebugMarkerMarkerInfoEXT32;
 852
 853 typedef struct VkDecompressMemoryRegionNV32
 854 {
 855     VkDeviceAddress DECLSPEC_ALIGN(8) srcAddress;
 856     VkDeviceAddress DECLSPEC_ALIGN(8) dstAddress;
 857     VkDeviceSize DECLSPEC_ALIGN(8) compressedSize;
 858     VkDeviceSize DECLSPEC_ALIGN(8) decompressedSize;
 859     VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethod;
 860 } VkDecompressMemoryRegionNV32;
 861
 862 typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM32
 863 {
 864     VkStructureType sType;
 865     PTR32 pNext;
 866     uint32_t fragmentDensityOffsetCount;
 867     PTR32 pFragmentDensityOffsets;
 868 } VkSubpassFragmentDensityMapOffsetEndInfoQCOM32;
 869
 870 typedef struct VkSubpassEndInfo32
 871 {
 872     VkStructureType sType;
 873     PTR32 pNext;
 874 } VkSubpassEndInfo32;
 875 typedef VkSubpassEndInfo32 VkSubpassEndInfoKHR32;
 876
 877 typedef struct VkIndirectCommandsStreamNV32
 878 {
 879     VkBuffer DECLSPEC_ALIGN(8) buffer;
 880     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 881 } VkIndirectCommandsStreamNV32;
 882
 883 typedef struct VkGeneratedCommandsInfoNV32
 884 {
 885     VkStructureType sType;
 886     PTR32 pNext;
 887     VkPipelineBindPoint pipelineBindPoint;
 888     VkPipeline DECLSPEC_ALIGN(8) pipeline;
 889     VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
 890     uint32_t streamCount;
 891     PTR32 pStreams;
 892     uint32_t sequencesCount;
 893     VkBuffer DECLSPEC_ALIGN(8) preprocessBuffer;
 894     VkDeviceSize DECLSPEC_ALIGN(8) preprocessOffset;
 895     VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize;
 896     VkBuffer DECLSPEC_ALIGN(8) sequencesCountBuffer;
 897     VkDeviceSize DECLSPEC_ALIGN(8) sequencesCountOffset;
 898     VkBuffer DECLSPEC_ALIGN(8) sequencesIndexBuffer;
 899     VkDeviceSize DECLSPEC_ALIGN(8) sequencesIndexOffset;
 900 } VkGeneratedCommandsInfoNV32;
 901
 902 typedef struct VkOpticalFlowExecuteInfoNV32
 903 {
 904     VkStructureType sType;
 905     PTR32 pNext;
 906     VkOpticalFlowExecuteFlagsNV flags;
 907     uint32_t regionCount;
 908     PTR32 pRegions;
 909 } VkOpticalFlowExecuteInfoNV32;
 910
 911 typedef struct VkMemoryBarrier32
 912 {
 913     VkStructureType sType;
 914     PTR32 pNext;
 915     VkAccessFlags srcAccessMask;
 916     VkAccessFlags dstAccessMask;
 917 } VkMemoryBarrier32;
 918
 919 typedef struct VkExternalMemoryAcquireUnmodifiedEXT32
 920 {
 921     VkStructureType sType;
 922     PTR32 pNext;
 923     VkBool32 acquireUnmodifiedMemory;
 924 } VkExternalMemoryAcquireUnmodifiedEXT32;
 925
 926 typedef struct VkBufferMemoryBarrier32
 927 {
 928     VkStructureType sType;
 929     PTR32 pNext;
 930     VkAccessFlags srcAccessMask;
 931     VkAccessFlags dstAccessMask;
 932     uint32_t srcQueueFamilyIndex;
 933     uint32_t dstQueueFamilyIndex;
 934     VkBuffer DECLSPEC_ALIGN(8) buffer;
 935     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 936     VkDeviceSize DECLSPEC_ALIGN(8) size;
 937 } VkBufferMemoryBarrier32;
 938
 939 typedef struct VkImageMemoryBarrier32
 940 {
 941     VkStructureType sType;
 942     PTR32 pNext;
 943     VkAccessFlags srcAccessMask;
 944     VkAccessFlags dstAccessMask;
 945     VkImageLayout oldLayout;
 946     VkImageLayout newLayout;
 947     uint32_t srcQueueFamilyIndex;
 948     uint32_t dstQueueFamilyIndex;
 949     VkImage DECLSPEC_ALIGN(8) image;
 950     VkImageSubresourceRange subresourceRange;
 951 } VkImageMemoryBarrier32;
 952
 953 typedef struct VkMemoryBarrier232
 954 {
 955     VkStructureType sType;
 956     PTR32 pNext;
 957     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 958     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 959     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 960     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 961 } VkMemoryBarrier232;
 962 typedef VkMemoryBarrier232 VkMemoryBarrier2KHR32;
 963
 964 typedef struct VkBufferMemoryBarrier232
 965 {
 966     VkStructureType sType;
 967     PTR32 pNext;
 968     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 969     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 970     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 971     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 972     uint32_t srcQueueFamilyIndex;
 973     uint32_t dstQueueFamilyIndex;
 974     VkBuffer DECLSPEC_ALIGN(8) buffer;
 975     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 976     VkDeviceSize DECLSPEC_ALIGN(8) size;
 977 } VkBufferMemoryBarrier232;
 978 typedef VkBufferMemoryBarrier232 VkBufferMemoryBarrier2KHR32;
 979
 980 typedef struct VkImageMemoryBarrier232
 981 {
 982     VkStructureType sType;
 983     PTR32 pNext;
 984     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 985     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 986     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 987     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 988     VkImageLayout oldLayout;
 989     VkImageLayout newLayout;
 990     uint32_t srcQueueFamilyIndex;
 991     uint32_t dstQueueFamilyIndex;
 992     VkImage DECLSPEC_ALIGN(8) image;
 993     VkImageSubresourceRange subresourceRange;
 994 } VkImageMemoryBarrier232;
 995 typedef VkImageMemoryBarrier232 VkImageMemoryBarrier2KHR32;
 996
 997 typedef struct VkDependencyInfo32
 998 {
 999     VkStructureType sType;
1000     PTR32 pNext;
1001     VkDependencyFlags dependencyFlags;
1002     uint32_t memoryBarrierCount;
1003     PTR32 pMemoryBarriers;
1004     uint32_t bufferMemoryBarrierCount;
1005     PTR32 pBufferMemoryBarriers;
1006     uint32_t imageMemoryBarrierCount;
1007     PTR32 pImageMemoryBarriers;
1008 } VkDependencyInfo32;
1009 typedef VkDependencyInfo32 VkDependencyInfoKHR32;
1010
1011 typedef struct VkDescriptorImageInfo32
1012 {
1013     VkSampler DECLSPEC_ALIGN(8) sampler;
1014     VkImageView DECLSPEC_ALIGN(8) imageView;
1015     VkImageLayout imageLayout;
1016 } VkDescriptorImageInfo32;
1017
1018 typedef struct VkDescriptorBufferInfo32
1019 {
1020     VkBuffer DECLSPEC_ALIGN(8) buffer;
1021     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1022     VkDeviceSize DECLSPEC_ALIGN(8) range;
1023 } VkDescriptorBufferInfo32;
1024
1025 typedef struct VkWriteDescriptorSetInlineUniformBlock32
1026 {
1027     VkStructureType sType;
1028     PTR32 pNext;
1029     uint32_t dataSize;
1030     PTR32 pData;
1031 } VkWriteDescriptorSetInlineUniformBlock32;
1032 typedef VkWriteDescriptorSetInlineUniformBlock32 VkWriteDescriptorSetInlineUniformBlockEXT32;
1033
1034 typedef struct VkWriteDescriptorSetAccelerationStructureKHR32
1035 {
1036     VkStructureType sType;
1037     PTR32 pNext;
1038     uint32_t accelerationStructureCount;
1039     PTR32 pAccelerationStructures;
1040 } VkWriteDescriptorSetAccelerationStructureKHR32;
1041
1042 typedef struct VkWriteDescriptorSetAccelerationStructureNV32
1043 {
1044     VkStructureType sType;
1045     PTR32 pNext;
1046     uint32_t accelerationStructureCount;
1047     PTR32 pAccelerationStructures;
1048 } VkWriteDescriptorSetAccelerationStructureNV32;
1049
1050 typedef struct VkWriteDescriptorSet32
1051 {
1052     VkStructureType sType;
1053     PTR32 pNext;
1054     VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
1055     uint32_t dstBinding;
1056     uint32_t dstArrayElement;
1057     uint32_t descriptorCount;
1058     VkDescriptorType descriptorType;
1059     PTR32 pImageInfo;
1060     PTR32 pBufferInfo;
1061     PTR32 pTexelBufferView;
1062 } VkWriteDescriptorSet32;
1063
1064 typedef struct VkImageResolve232
1065 {
1066     VkStructureType sType;
1067     PTR32 pNext;
1068     VkImageSubresourceLayers srcSubresource;
1069     VkOffset3D srcOffset;
1070     VkImageSubresourceLayers dstSubresource;
1071     VkOffset3D dstOffset;
1072     VkExtent3D extent;
1073 } VkImageResolve232;
1074 typedef VkImageResolve232 VkImageResolve2KHR32;
1075
1076 typedef struct VkResolveImageInfo232
1077 {
1078     VkStructureType sType;
1079     PTR32 pNext;
1080     VkImage DECLSPEC_ALIGN(8) srcImage;
1081     VkImageLayout srcImageLayout;
1082     VkImage DECLSPEC_ALIGN(8) dstImage;
1083     VkImageLayout dstImageLayout;
1084     uint32_t regionCount;
1085     PTR32 pRegions;
1086 } VkResolveImageInfo232;
1087 typedef VkResolveImageInfo232 VkResolveImageInfo2KHR32;
1088
1089 typedef struct VkCoarseSampleOrderCustomNV32
1090 {
1091     VkShadingRatePaletteEntryNV shadingRate;
1092     uint32_t sampleCount;
1093     uint32_t sampleLocationCount;
1094     PTR32 pSampleLocations;
1095 } VkCoarseSampleOrderCustomNV32;
1096
1097 typedef struct VkDepthBiasRepresentationInfoEXT32
1098 {
1099     VkStructureType sType;
1100     PTR32 pNext;
1101     VkDepthBiasRepresentationEXT depthBiasRepresentation;
1102     VkBool32 depthBiasExact;
1103 } VkDepthBiasRepresentationInfoEXT32;
1104
1105 typedef struct VkDepthBiasInfoEXT32
1106 {
1107     VkStructureType sType;
1108     PTR32 pNext;
1109     float depthBiasConstantFactor;
1110     float depthBiasClamp;
1111     float depthBiasSlopeFactor;
1112 } VkDepthBiasInfoEXT32;
1113
1114 typedef struct VkPerformanceMarkerInfoINTEL32
1115 {
1116     VkStructureType sType;
1117     PTR32 pNext;
1118     uint64_t DECLSPEC_ALIGN(8) marker;
1119 } VkPerformanceMarkerInfoINTEL32;
1120
1121 typedef struct VkPerformanceOverrideInfoINTEL32
1122 {
1123     VkStructureType sType;
1124     PTR32 pNext;
1125     VkPerformanceOverrideTypeINTEL type;
1126     VkBool32 enable;
1127     uint64_t DECLSPEC_ALIGN(8) parameter;
1128 } VkPerformanceOverrideInfoINTEL32;
1129
1130 typedef struct VkPerformanceStreamMarkerInfoINTEL32
1131 {
1132     VkStructureType sType;
1133     PTR32 pNext;
1134     uint32_t marker;
1135 } VkPerformanceStreamMarkerInfoINTEL32;
1136
1137 typedef struct VkVertexInputBindingDescription2EXT32
1138 {
1139     VkStructureType sType;
1140     PTR32 pNext;
1141     uint32_t binding;
1142     uint32_t stride;
1143     VkVertexInputRate inputRate;
1144     uint32_t divisor;
1145 } VkVertexInputBindingDescription2EXT32;
1146
1147 typedef struct VkVertexInputAttributeDescription2EXT32
1148 {
1149     VkStructureType sType;
1150     PTR32 pNext;
1151     uint32_t location;
1152     uint32_t binding;
1153     VkFormat format;
1154     uint32_t offset;
1155 } VkVertexInputAttributeDescription2EXT32;
1156
1157 typedef struct VkShadingRatePaletteNV32
1158 {
1159     uint32_t shadingRatePaletteEntryCount;
1160     PTR32 pShadingRatePaletteEntries;
1161 } VkShadingRatePaletteNV32;
1162
1163 typedef struct VkStridedDeviceAddressRegionKHR32
1164 {
1165     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1166     VkDeviceSize DECLSPEC_ALIGN(8) stride;
1167     VkDeviceSize DECLSPEC_ALIGN(8) size;
1168 } VkStridedDeviceAddressRegionKHR32;
1169
1170 typedef struct VkCopyImageToImageInfoEXT32
1171 {
1172     VkStructureType sType;
1173     PTR32 pNext;
1174     VkHostImageCopyFlagsEXT flags;
1175     VkImage DECLSPEC_ALIGN(8) srcImage;
1176     VkImageLayout srcImageLayout;
1177     VkImage DECLSPEC_ALIGN(8) dstImage;
1178     VkImageLayout dstImageLayout;
1179     uint32_t regionCount;
1180     PTR32 pRegions;
1181 } VkCopyImageToImageInfoEXT32;
1182
1183 typedef struct VkImageToMemoryCopyEXT32
1184 {
1185     VkStructureType sType;
1186     PTR32 pNext;
1187     PTR32 pHostPointer;
1188     uint32_t memoryRowLength;
1189     uint32_t memoryImageHeight;
1190     VkImageSubresourceLayers imageSubresource;
1191     VkOffset3D imageOffset;
1192     VkExtent3D imageExtent;
1193 } VkImageToMemoryCopyEXT32;
1194
1195 typedef struct VkCopyImageToMemoryInfoEXT32
1196 {
1197     VkStructureType sType;
1198     PTR32 pNext;
1199     VkHostImageCopyFlagsEXT flags;
1200     VkImage DECLSPEC_ALIGN(8) srcImage;
1201     VkImageLayout srcImageLayout;
1202     uint32_t regionCount;
1203     PTR32 pRegions;
1204 } VkCopyImageToMemoryInfoEXT32;
1205
1206 typedef struct VkMemoryToImageCopyEXT32
1207 {
1208     VkStructureType sType;
1209     PTR32 pNext;
1210     PTR32 pHostPointer;
1211     uint32_t memoryRowLength;
1212     uint32_t memoryImageHeight;
1213     VkImageSubresourceLayers imageSubresource;
1214     VkOffset3D imageOffset;
1215     VkExtent3D imageExtent;
1216 } VkMemoryToImageCopyEXT32;
1217
1218 typedef struct VkCopyMemoryToImageInfoEXT32
1219 {
1220     VkStructureType sType;
1221     PTR32 pNext;
1222     VkHostImageCopyFlagsEXT flags;
1223     VkImage DECLSPEC_ALIGN(8) dstImage;
1224     VkImageLayout dstImageLayout;
1225     uint32_t regionCount;
1226     PTR32 pRegions;
1227 } VkCopyMemoryToImageInfoEXT32;
1228
1229 typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT32
1230 {
1231     VkStructureType sType;
1232     PTR32 pNext;
1233     PTR32 opaqueCaptureDescriptorData;
1234 } VkOpaqueCaptureDescriptorDataCreateInfoEXT32;
1235
1236 typedef struct VkAccelerationStructureMotionInfoNV32
1237 {
1238     VkStructureType sType;
1239     PTR32 pNext;
1240     uint32_t maxInstances;
1241     VkAccelerationStructureMotionInfoFlagsNV flags;
1242 } VkAccelerationStructureMotionInfoNV32;
1243
1244 typedef struct VkAccelerationStructureCreateInfoKHR32
1245 {
1246     VkStructureType sType;
1247     PTR32 pNext;
1248     VkAccelerationStructureCreateFlagsKHR createFlags;
1249     VkBuffer DECLSPEC_ALIGN(8) buffer;
1250     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1251     VkDeviceSize DECLSPEC_ALIGN(8) size;
1252     VkAccelerationStructureTypeKHR type;
1253     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1254 } VkAccelerationStructureCreateInfoKHR32;
1255
1256 typedef struct VkAccelerationStructureCreateInfoNV32
1257 {
1258     VkStructureType sType;
1259     PTR32 pNext;
1260     VkDeviceSize DECLSPEC_ALIGN(8) compactedSize;
1261     VkAccelerationStructureInfoNV32 info;
1262 } VkAccelerationStructureCreateInfoNV32;
1263
1264 typedef struct VkDedicatedAllocationBufferCreateInfoNV32
1265 {
1266     VkStructureType sType;
1267     PTR32 pNext;
1268     VkBool32 dedicatedAllocation;
1269 } VkDedicatedAllocationBufferCreateInfoNV32;
1270
1271 typedef struct VkExternalMemoryBufferCreateInfo32
1272 {
1273     VkStructureType sType;
1274     PTR32 pNext;
1275     VkExternalMemoryHandleTypeFlags handleTypes;
1276 } VkExternalMemoryBufferCreateInfo32;
1277 typedef VkExternalMemoryBufferCreateInfo32 VkExternalMemoryBufferCreateInfoKHR32;
1278
1279 typedef struct VkBufferOpaqueCaptureAddressCreateInfo32
1280 {
1281     VkStructureType sType;
1282     PTR32 pNext;
1283     uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
1284 } VkBufferOpaqueCaptureAddressCreateInfo32;
1285 typedef VkBufferOpaqueCaptureAddressCreateInfo32 VkBufferOpaqueCaptureAddressCreateInfoKHR32;
1286
1287 typedef struct VkBufferDeviceAddressCreateInfoEXT32
1288 {
1289     VkStructureType sType;
1290     PTR32 pNext;
1291     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1292 } VkBufferDeviceAddressCreateInfoEXT32;
1293
1294 typedef struct VkBufferCreateInfo32
1295 {
1296     VkStructureType sType;
1297     PTR32 pNext;
1298     VkBufferCreateFlags flags;
1299     VkDeviceSize DECLSPEC_ALIGN(8) size;
1300     VkBufferUsageFlags usage;
1301     VkSharingMode sharingMode;
1302     uint32_t queueFamilyIndexCount;
1303     PTR32 pQueueFamilyIndices;
1304 } VkBufferCreateInfo32;
1305
1306 typedef struct VkBufferViewCreateInfo32
1307 {
1308     VkStructureType sType;
1309     PTR32 pNext;
1310     VkBufferViewCreateFlags flags;
1311     VkBuffer DECLSPEC_ALIGN(8) buffer;
1312     VkFormat format;
1313     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1314     VkDeviceSize DECLSPEC_ALIGN(8) range;
1315 } VkBufferViewCreateInfo32;
1316
1317 typedef struct VkCommandPoolCreateInfo32
1318 {
1319     VkStructureType sType;
1320     PTR32 pNext;
1321     VkCommandPoolCreateFlags flags;
1322     uint32_t queueFamilyIndex;
1323 } VkCommandPoolCreateInfo32;
1324
1325 typedef struct VkPipelineCreationFeedback32
1326 {
1327     VkPipelineCreationFeedbackFlags flags;
1328     uint64_t DECLSPEC_ALIGN(8) duration;
1329 } VkPipelineCreationFeedback32;
1330 typedef VkPipelineCreationFeedback32 VkPipelineCreationFeedbackEXT32;
1331
1332 typedef struct VkSpecializationMapEntry32
1333 {
1334     uint32_t constantID;
1335     uint32_t offset;
1336     PTR32 size;
1337 } VkSpecializationMapEntry32;
1338
1339 typedef struct VkSpecializationInfo32
1340 {
1341     uint32_t mapEntryCount;
1342     PTR32 pMapEntries;
1343     PTR32 dataSize;
1344     PTR32 pData;
1345 } VkSpecializationInfo32;
1346
1347 typedef struct VkShaderModuleCreateInfo32
1348 {
1349     VkStructureType sType;
1350     PTR32 pNext;
1351     VkShaderModuleCreateFlags flags;
1352     PTR32 codeSize;
1353     PTR32 pCode;
1354 } VkShaderModuleCreateInfo32;
1355
1356 typedef struct VkShaderModuleValidationCacheCreateInfoEXT32
1357 {
1358     VkStructureType sType;
1359     PTR32 pNext;
1360     VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
1361 } VkShaderModuleValidationCacheCreateInfoEXT32;
1362
1363 typedef struct VkDebugUtilsObjectNameInfoEXT32
1364 {
1365     VkStructureType sType;
1366     PTR32 pNext;
1367     VkObjectType objectType;
1368     uint64_t DECLSPEC_ALIGN(8) objectHandle;
1369     PTR32 pObjectName;
1370 } VkDebugUtilsObjectNameInfoEXT32;
1371
1372 typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32
1373 {
1374     VkStructureType sType;
1375     PTR32 pNext;
1376     uint32_t requiredSubgroupSize;
1377 } VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32;
1378 typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT32;
1379 typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkShaderRequiredSubgroupSizeCreateInfoEXT32;
1380
1381 typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT32
1382 {
1383     VkStructureType sType;
1384     PTR32 pNext;
1385     uint32_t identifierSize;
1386     PTR32 pIdentifier;
1387 } VkPipelineShaderStageModuleIdentifierCreateInfoEXT32;
1388
1389 typedef struct VkPipelineRobustnessCreateInfoEXT32
1390 {
1391     VkStructureType sType;
1392     PTR32 pNext;
1393     VkPipelineRobustnessBufferBehaviorEXT storageBuffers;
1394     VkPipelineRobustnessBufferBehaviorEXT uniformBuffers;
1395     VkPipelineRobustnessBufferBehaviorEXT vertexInputs;
1396     VkPipelineRobustnessImageBehaviorEXT images;
1397 } VkPipelineRobustnessCreateInfoEXT32;
1398
1399 typedef struct VkPipelineShaderStageCreateInfo32
1400 {
1401     VkStructureType sType;
1402     PTR32 pNext;
1403     VkPipelineShaderStageCreateFlags flags;
1404     VkShaderStageFlagBits stage;
1405     VkShaderModule DECLSPEC_ALIGN(8) module;
1406     PTR32 pName;
1407     PTR32 pSpecializationInfo;
1408 } VkPipelineShaderStageCreateInfo32;
1409
1410 typedef struct VkPipelineCreateFlags2CreateInfoKHR32
1411 {
1412     VkStructureType sType;
1413     PTR32 pNext;
1414     VkPipelineCreateFlags2KHR DECLSPEC_ALIGN(8) flags;
1415 } VkPipelineCreateFlags2CreateInfoKHR32;
1416
1417 typedef struct VkPipelineCreationFeedbackCreateInfo32
1418 {
1419     VkStructureType sType;
1420     PTR32 pNext;
1421     PTR32 pPipelineCreationFeedback;
1422     uint32_t pipelineStageCreationFeedbackCount;
1423     PTR32 pPipelineStageCreationFeedbacks;
1424 } VkPipelineCreationFeedbackCreateInfo32;
1425 typedef VkPipelineCreationFeedbackCreateInfo32 VkPipelineCreationFeedbackCreateInfoEXT32;
1426
1427 typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI32
1428 {
1429     VkStructureType sType;
1430     PTR32 pNext;
1431     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
1432     uint32_t subpass;
1433 } VkSubpassShadingPipelineCreateInfoHUAWEI32;
1434
1435 typedef struct VkPipelineCompilerControlCreateInfoAMD32
1436 {
1437     VkStructureType sType;
1438     PTR32 pNext;
1439     VkPipelineCompilerControlFlagsAMD compilerControlFlags;
1440 } VkPipelineCompilerControlCreateInfoAMD32;
1441
1442 typedef struct VkComputePipelineCreateInfo32
1443 {
1444     VkStructureType sType;
1445     PTR32 pNext;
1446     VkPipelineCreateFlags flags;
1447     VkPipelineShaderStageCreateInfo32 DECLSPEC_ALIGN(8) stage;
1448     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
1449     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
1450     int32_t basePipelineIndex;
1451 } VkComputePipelineCreateInfo32;
1452
1453 typedef struct VkCuFunctionCreateInfoNVX32
1454 {
1455     VkStructureType sType;
1456     PTR32 pNext;
1457     VkCuModuleNVX DECLSPEC_ALIGN(8) module;
1458     PTR32 pName;
1459 } VkCuFunctionCreateInfoNVX32;
1460
1461 typedef struct VkCuModuleCreateInfoNVX32
1462 {
1463     VkStructureType sType;
1464     PTR32 pNext;
1465     PTR32 dataSize;
1466     PTR32 pData;
1467 } VkCuModuleCreateInfoNVX32;
1468
1469 typedef struct VkDebugReportCallbackCreateInfoEXT32
1470 {
1471     VkStructureType sType;
1472     PTR32 pNext;
1473     VkDebugReportFlagsEXT flags;
1474     PFN_vkDebugReportCallbackEXT pfnCallback;
1475     PTR32 pUserData;
1476 } VkDebugReportCallbackCreateInfoEXT32;
1477
1478 typedef struct VkDebugUtilsMessengerCreateInfoEXT32
1479 {
1480     VkStructureType sType;
1481     PTR32 pNext;
1482     VkDebugUtilsMessengerCreateFlagsEXT flags;
1483     VkDebugUtilsMessageSeverityFlagsEXT messageSeverity;
1484     VkDebugUtilsMessageTypeFlagsEXT messageType;
1485     PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
1486     PTR32 pUserData;
1487 } VkDebugUtilsMessengerCreateInfoEXT32;
1488
1489 typedef struct VkMutableDescriptorTypeListEXT32
1490 {
1491     uint32_t descriptorTypeCount;
1492     PTR32 pDescriptorTypes;
1493 } VkMutableDescriptorTypeListEXT32;
1494 typedef VkMutableDescriptorTypeListEXT32 VkMutableDescriptorTypeListVALVE32;
1495
1496 typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo32
1497 {
1498     VkStructureType sType;
1499     PTR32 pNext;
1500     uint32_t maxInlineUniformBlockBindings;
1501 } VkDescriptorPoolInlineUniformBlockCreateInfo32;
1502 typedef VkDescriptorPoolInlineUniformBlockCreateInfo32 VkDescriptorPoolInlineUniformBlockCreateInfoEXT32;
1503
1504 typedef struct VkMutableDescriptorTypeCreateInfoEXT32
1505 {
1506     VkStructureType sType;
1507     PTR32 pNext;
1508     uint32_t mutableDescriptorTypeListCount;
1509     PTR32 pMutableDescriptorTypeLists;
1510 } VkMutableDescriptorTypeCreateInfoEXT32;
1511 typedef VkMutableDescriptorTypeCreateInfoEXT32 VkMutableDescriptorTypeCreateInfoVALVE32;
1512
1513 typedef struct VkDescriptorPoolCreateInfo32
1514 {
1515     VkStructureType sType;
1516     PTR32 pNext;
1517     VkDescriptorPoolCreateFlags flags;
1518     uint32_t maxSets;
1519     uint32_t poolSizeCount;
1520     PTR32 pPoolSizes;
1521 } VkDescriptorPoolCreateInfo32;
1522
1523 typedef struct VkDescriptorSetLayoutBinding32
1524 {
1525     uint32_t binding;
1526     VkDescriptorType descriptorType;
1527     uint32_t descriptorCount;
1528     VkShaderStageFlags stageFlags;
1529     PTR32 pImmutableSamplers;
1530 } VkDescriptorSetLayoutBinding32;
1531
1532 typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo32
1533 {
1534     VkStructureType sType;
1535     PTR32 pNext;
1536     uint32_t bindingCount;
1537     PTR32 pBindingFlags;
1538 } VkDescriptorSetLayoutBindingFlagsCreateInfo32;
1539 typedef VkDescriptorSetLayoutBindingFlagsCreateInfo32 VkDescriptorSetLayoutBindingFlagsCreateInfoEXT32;
1540
1541 typedef struct VkDescriptorSetLayoutCreateInfo32
1542 {
1543     VkStructureType sType;
1544     PTR32 pNext;
1545     VkDescriptorSetLayoutCreateFlags flags;
1546     uint32_t bindingCount;
1547     PTR32 pBindings;
1548 } VkDescriptorSetLayoutCreateInfo32;
1549
1550 typedef struct VkDescriptorUpdateTemplateEntry32
1551 {
1552     uint32_t dstBinding;
1553     uint32_t dstArrayElement;
1554     uint32_t descriptorCount;
1555     VkDescriptorType descriptorType;
1556     PTR32 offset;
1557     PTR32 stride;
1558 } VkDescriptorUpdateTemplateEntry32;
1559 typedef VkDescriptorUpdateTemplateEntry32 VkDescriptorUpdateTemplateEntryKHR32;
1560
1561 typedef struct VkDescriptorUpdateTemplateCreateInfo32
1562 {
1563     VkStructureType sType;
1564     PTR32 pNext;
1565     VkDescriptorUpdateTemplateCreateFlags flags;
1566     uint32_t descriptorUpdateEntryCount;
1567     PTR32 pDescriptorUpdateEntries;
1568     VkDescriptorUpdateTemplateType templateType;
1569     VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
1570     VkPipelineBindPoint pipelineBindPoint;
1571     VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
1572     uint32_t set;
1573 } VkDescriptorUpdateTemplateCreateInfo32;
1574 typedef VkDescriptorUpdateTemplateCreateInfo32 VkDescriptorUpdateTemplateCreateInfoKHR32;
1575
1576 typedef struct VkDeviceQueueGlobalPriorityCreateInfoKHR32
1577 {
1578     VkStructureType sType;
1579     PTR32 pNext;
1580     VkQueueGlobalPriorityKHR globalPriority;
1581 } VkDeviceQueueGlobalPriorityCreateInfoKHR32;
1582 typedef VkDeviceQueueGlobalPriorityCreateInfoKHR32 VkDeviceQueueGlobalPriorityCreateInfoEXT32;
1583
1584 typedef struct VkDeviceQueueCreateInfo32
1585 {
1586     VkStructureType sType;
1587     PTR32 pNext;
1588     VkDeviceQueueCreateFlags flags;
1589     uint32_t queueFamilyIndex;
1590     uint32_t queueCount;
1591     PTR32 pQueuePriorities;
1592 } VkDeviceQueueCreateInfo32;
1593
1594 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32
1595 {
1596     VkStructureType sType;
1597     PTR32 pNext;
1598     VkBool32 deviceGeneratedCommands;
1599 } VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32;
1600
1601 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32
1602 {
1603     VkStructureType sType;
1604     PTR32 pNext;
1605     VkBool32 deviceGeneratedCompute;
1606     VkBool32 deviceGeneratedComputePipelines;
1607     VkBool32 deviceGeneratedComputeCaptureReplay;
1608 } VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32;
1609
1610 typedef struct VkDevicePrivateDataCreateInfo32
1611 {
1612     VkStructureType sType;
1613     PTR32 pNext;
1614     uint32_t privateDataSlotRequestCount;
1615 } VkDevicePrivateDataCreateInfo32;
1616 typedef VkDevicePrivateDataCreateInfo32 VkDevicePrivateDataCreateInfoEXT32;
1617
1618 typedef struct VkPhysicalDevicePrivateDataFeatures32
1619 {
1620     VkStructureType sType;
1621     PTR32 pNext;
1622     VkBool32 privateData;
1623 } VkPhysicalDevicePrivateDataFeatures32;
1624 typedef VkPhysicalDevicePrivateDataFeatures32 VkPhysicalDevicePrivateDataFeaturesEXT32;
1625
1626 typedef struct VkPhysicalDeviceFeatures232
1627 {
1628     VkStructureType sType;
1629     PTR32 pNext;
1630     VkPhysicalDeviceFeatures features;
1631 } VkPhysicalDeviceFeatures232;
1632 typedef VkPhysicalDeviceFeatures232 VkPhysicalDeviceFeatures2KHR32;
1633
1634 typedef struct VkPhysicalDeviceVariablePointersFeatures32
1635 {
1636     VkStructureType sType;
1637     PTR32 pNext;
1638     VkBool32 variablePointersStorageBuffer;
1639     VkBool32 variablePointers;
1640 } VkPhysicalDeviceVariablePointersFeatures32;
1641 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointersFeaturesKHR32;
1642 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeaturesKHR32;
1643 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeatures32;
1644
1645 typedef struct VkPhysicalDeviceMultiviewFeatures32
1646 {
1647     VkStructureType sType;
1648     PTR32 pNext;
1649     VkBool32 multiview;
1650     VkBool32 multiviewGeometryShader;
1651     VkBool32 multiviewTessellationShader;
1652 } VkPhysicalDeviceMultiviewFeatures32;
1653 typedef VkPhysicalDeviceMultiviewFeatures32 VkPhysicalDeviceMultiviewFeaturesKHR32;
1654
1655 typedef struct VkDeviceGroupDeviceCreateInfo32
1656 {
1657     VkStructureType sType;
1658     PTR32 pNext;
1659     uint32_t physicalDeviceCount;
1660     PTR32 pPhysicalDevices;
1661 } VkDeviceGroupDeviceCreateInfo32;
1662 typedef VkDeviceGroupDeviceCreateInfo32 VkDeviceGroupDeviceCreateInfoKHR32;
1663
1664 typedef struct VkPhysicalDevicePresentIdFeaturesKHR32
1665 {
1666     VkStructureType sType;
1667     PTR32 pNext;
1668     VkBool32 presentId;
1669 } VkPhysicalDevicePresentIdFeaturesKHR32;
1670
1671 typedef struct VkPhysicalDevicePresentWaitFeaturesKHR32
1672 {
1673     VkStructureType sType;
1674     PTR32 pNext;
1675     VkBool32 presentWait;
1676 } VkPhysicalDevicePresentWaitFeaturesKHR32;
1677
1678 typedef struct VkPhysicalDevice16BitStorageFeatures32
1679 {
1680     VkStructureType sType;
1681     PTR32 pNext;
1682     VkBool32 storageBuffer16BitAccess;
1683     VkBool32 uniformAndStorageBuffer16BitAccess;
1684     VkBool32 storagePushConstant16;
1685     VkBool32 storageInputOutput16;
1686 } VkPhysicalDevice16BitStorageFeatures32;
1687 typedef VkPhysicalDevice16BitStorageFeatures32 VkPhysicalDevice16BitStorageFeaturesKHR32;
1688
1689 typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32
1690 {
1691     VkStructureType sType;
1692     PTR32 pNext;
1693     VkBool32 shaderSubgroupExtendedTypes;
1694 } VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32;
1695 typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR32;
1696
1697 typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures32
1698 {
1699     VkStructureType sType;
1700     PTR32 pNext;
1701     VkBool32 samplerYcbcrConversion;
1702 } VkPhysicalDeviceSamplerYcbcrConversionFeatures32;
1703 typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures32 VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR32;
1704
1705 typedef struct VkPhysicalDeviceProtectedMemoryFeatures32
1706 {
1707     VkStructureType sType;
1708     PTR32 pNext;
1709     VkBool32 protectedMemory;
1710 } VkPhysicalDeviceProtectedMemoryFeatures32;
1711
1712 typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32
1713 {
1714     VkStructureType sType;
1715     PTR32 pNext;
1716     VkBool32 advancedBlendCoherentOperations;
1717 } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32;
1718
1719 typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT32
1720 {
1721     VkStructureType sType;
1722     PTR32 pNext;
1723     VkBool32 multiDraw;
1724 } VkPhysicalDeviceMultiDrawFeaturesEXT32;
1725
1726 typedef struct VkPhysicalDeviceInlineUniformBlockFeatures32
1727 {
1728     VkStructureType sType;
1729     PTR32 pNext;
1730     VkBool32 inlineUniformBlock;
1731     VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
1732 } VkPhysicalDeviceInlineUniformBlockFeatures32;
1733 typedef VkPhysicalDeviceInlineUniformBlockFeatures32 VkPhysicalDeviceInlineUniformBlockFeaturesEXT32;
1734
1735 typedef struct VkPhysicalDeviceMaintenance4Features32
1736 {
1737     VkStructureType sType;
1738     PTR32 pNext;
1739     VkBool32 maintenance4;
1740 } VkPhysicalDeviceMaintenance4Features32;
1741 typedef VkPhysicalDeviceMaintenance4Features32 VkPhysicalDeviceMaintenance4FeaturesKHR32;
1742
1743 typedef struct VkPhysicalDeviceMaintenance5FeaturesKHR32
1744 {
1745     VkStructureType sType;
1746     PTR32 pNext;
1747     VkBool32 maintenance5;
1748 } VkPhysicalDeviceMaintenance5FeaturesKHR32;
1749
1750 typedef struct VkPhysicalDeviceShaderDrawParametersFeatures32
1751 {
1752     VkStructureType sType;
1753     PTR32 pNext;
1754     VkBool32 shaderDrawParameters;
1755 } VkPhysicalDeviceShaderDrawParametersFeatures32;
1756 typedef VkPhysicalDeviceShaderDrawParametersFeatures32 VkPhysicalDeviceShaderDrawParameterFeatures32;
1757
1758 typedef struct VkPhysicalDeviceShaderFloat16Int8Features32
1759 {
1760     VkStructureType sType;
1761     PTR32 pNext;
1762     VkBool32 shaderFloat16;
1763     VkBool32 shaderInt8;
1764 } VkPhysicalDeviceShaderFloat16Int8Features32;
1765 typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceShaderFloat16Int8FeaturesKHR32;
1766 typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceFloat16Int8FeaturesKHR32;
1767
1768 typedef struct VkPhysicalDeviceHostQueryResetFeatures32
1769 {
1770     VkStructureType sType;
1771     PTR32 pNext;
1772     VkBool32 hostQueryReset;
1773 } VkPhysicalDeviceHostQueryResetFeatures32;
1774 typedef VkPhysicalDeviceHostQueryResetFeatures32 VkPhysicalDeviceHostQueryResetFeaturesEXT32;
1775
1776 typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32
1777 {
1778     VkStructureType sType;
1779     PTR32 pNext;
1780     VkBool32 globalPriorityQuery;
1781 } VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32;
1782 typedef VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT32;
1783
1784 typedef struct VkPhysicalDeviceDescriptorIndexingFeatures32
1785 {
1786     VkStructureType sType;
1787     PTR32 pNext;
1788     VkBool32 shaderInputAttachmentArrayDynamicIndexing;
1789     VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
1790     VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
1791     VkBool32 shaderUniformBufferArrayNonUniformIndexing;
1792     VkBool32 shaderSampledImageArrayNonUniformIndexing;
1793     VkBool32 shaderStorageBufferArrayNonUniformIndexing;
1794     VkBool32 shaderStorageImageArrayNonUniformIndexing;
1795     VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
1796     VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
1797     VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
1798     VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
1799     VkBool32 descriptorBindingSampledImageUpdateAfterBind;
1800     VkBool32 descriptorBindingStorageImageUpdateAfterBind;
1801     VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
1802     VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
1803     VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
1804     VkBool32 descriptorBindingUpdateUnusedWhilePending;
1805     VkBool32 descriptorBindingPartiallyBound;
1806     VkBool32 descriptorBindingVariableDescriptorCount;
1807     VkBool32 runtimeDescriptorArray;
1808 } VkPhysicalDeviceDescriptorIndexingFeatures32;
1809 typedef VkPhysicalDeviceDescriptorIndexingFeatures32 VkPhysicalDeviceDescriptorIndexingFeaturesEXT32;
1810
1811 typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures32
1812 {
1813     VkStructureType sType;
1814     PTR32 pNext;
1815     VkBool32 timelineSemaphore;
1816 } VkPhysicalDeviceTimelineSemaphoreFeatures32;
1817 typedef VkPhysicalDeviceTimelineSemaphoreFeatures32 VkPhysicalDeviceTimelineSemaphoreFeaturesKHR32;
1818
1819 typedef struct VkPhysicalDevice8BitStorageFeatures32
1820 {
1821     VkStructureType sType;
1822     PTR32 pNext;
1823     VkBool32 storageBuffer8BitAccess;
1824     VkBool32 uniformAndStorageBuffer8BitAccess;
1825     VkBool32 storagePushConstant8;
1826 } VkPhysicalDevice8BitStorageFeatures32;
1827 typedef VkPhysicalDevice8BitStorageFeatures32 VkPhysicalDevice8BitStorageFeaturesKHR32;
1828
1829 typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT32
1830 {
1831     VkStructureType sType;
1832     PTR32 pNext;
1833     VkBool32 conditionalRendering;
1834     VkBool32 inheritedConditionalRendering;
1835 } VkPhysicalDeviceConditionalRenderingFeaturesEXT32;
1836
1837 typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures32
1838 {
1839     VkStructureType sType;
1840     PTR32 pNext;
1841     VkBool32 vulkanMemoryModel;
1842     VkBool32 vulkanMemoryModelDeviceScope;
1843     VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
1844 } VkPhysicalDeviceVulkanMemoryModelFeatures32;
1845 typedef VkPhysicalDeviceVulkanMemoryModelFeatures32 VkPhysicalDeviceVulkanMemoryModelFeaturesKHR32;
1846
1847 typedef struct VkPhysicalDeviceShaderAtomicInt64Features32
1848 {
1849     VkStructureType sType;
1850     PTR32 pNext;
1851     VkBool32 shaderBufferInt64Atomics;
1852     VkBool32 shaderSharedInt64Atomics;
1853 } VkPhysicalDeviceShaderAtomicInt64Features32;
1854 typedef VkPhysicalDeviceShaderAtomicInt64Features32 VkPhysicalDeviceShaderAtomicInt64FeaturesKHR32;
1855
1856 typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32
1857 {
1858     VkStructureType sType;
1859     PTR32 pNext;
1860     VkBool32 shaderBufferFloat32Atomics;
1861     VkBool32 shaderBufferFloat32AtomicAdd;
1862     VkBool32 shaderBufferFloat64Atomics;
1863     VkBool32 shaderBufferFloat64AtomicAdd;
1864     VkBool32 shaderSharedFloat32Atomics;
1865     VkBool32 shaderSharedFloat32AtomicAdd;
1866     VkBool32 shaderSharedFloat64Atomics;
1867     VkBool32 shaderSharedFloat64AtomicAdd;
1868     VkBool32 shaderImageFloat32Atomics;
1869     VkBool32 shaderImageFloat32AtomicAdd;
1870     VkBool32 sparseImageFloat32Atomics;
1871     VkBool32 sparseImageFloat32AtomicAdd;
1872 } VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32;
1873
1874 typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32
1875 {
1876     VkStructureType sType;
1877     PTR32 pNext;
1878     VkBool32 shaderBufferFloat16Atomics;
1879     VkBool32 shaderBufferFloat16AtomicAdd;
1880     VkBool32 shaderBufferFloat16AtomicMinMax;
1881     VkBool32 shaderBufferFloat32AtomicMinMax;
1882     VkBool32 shaderBufferFloat64AtomicMinMax;
1883     VkBool32 shaderSharedFloat16Atomics;
1884     VkBool32 shaderSharedFloat16AtomicAdd;
1885     VkBool32 shaderSharedFloat16AtomicMinMax;
1886     VkBool32 shaderSharedFloat32AtomicMinMax;
1887     VkBool32 shaderSharedFloat64AtomicMinMax;
1888     VkBool32 shaderImageFloat32AtomicMinMax;
1889     VkBool32 sparseImageFloat32AtomicMinMax;
1890 } VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32;
1891
1892 typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32
1893 {
1894     VkStructureType sType;
1895     PTR32 pNext;
1896     VkBool32 vertexAttributeInstanceRateDivisor;
1897     VkBool32 vertexAttributeInstanceRateZeroDivisor;
1898 } VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32;
1899
1900 typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT32
1901 {
1902     VkStructureType sType;
1903     PTR32 pNext;
1904     VkBool32 decodeModeSharedExponent;
1905 } VkPhysicalDeviceASTCDecodeFeaturesEXT32;
1906
1907 typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT32
1908 {
1909     VkStructureType sType;
1910     PTR32 pNext;
1911     VkBool32 transformFeedback;
1912     VkBool32 geometryStreams;
1913 } VkPhysicalDeviceTransformFeedbackFeaturesEXT32;
1914
1915 typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32
1916 {
1917     VkStructureType sType;
1918     PTR32 pNext;
1919     VkBool32 representativeFragmentTest;
1920 } VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32;
1921
1922 typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV32
1923 {
1924     VkStructureType sType;
1925     PTR32 pNext;
1926     VkBool32 exclusiveScissor;
1927 } VkPhysicalDeviceExclusiveScissorFeaturesNV32;
1928
1929 typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV32
1930 {
1931     VkStructureType sType;
1932     PTR32 pNext;
1933     VkBool32 cornerSampledImage;
1934 } VkPhysicalDeviceCornerSampledImageFeaturesNV32;
1935
1936 typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32
1937 {
1938     VkStructureType sType;
1939     PTR32 pNext;
1940     VkBool32 computeDerivativeGroupQuads;
1941     VkBool32 computeDerivativeGroupLinear;
1942 } VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32;
1943
1944 typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV32
1945 {
1946     VkStructureType sType;
1947     PTR32 pNext;
1948     VkBool32 imageFootprint;
1949 } VkPhysicalDeviceShaderImageFootprintFeaturesNV32;
1950
1951 typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32
1952 {
1953     VkStructureType sType;
1954     PTR32 pNext;
1955     VkBool32 dedicatedAllocationImageAliasing;
1956 } VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32;
1957
1958 typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32
1959 {
1960     VkStructureType sType;
1961     PTR32 pNext;
1962     VkBool32 indirectCopy;
1963 } VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32;
1964
1965 typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV32
1966 {
1967     VkStructureType sType;
1968     PTR32 pNext;
1969     VkBool32 memoryDecompression;
1970 } VkPhysicalDeviceMemoryDecompressionFeaturesNV32;
1971
1972 typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV32
1973 {
1974     VkStructureType sType;
1975     PTR32 pNext;
1976     VkBool32 shadingRateImage;
1977     VkBool32 shadingRateCoarseSampleOrder;
1978 } VkPhysicalDeviceShadingRateImageFeaturesNV32;
1979
1980 typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32
1981 {
1982     VkStructureType sType;
1983     PTR32 pNext;
1984     VkBool32 invocationMask;
1985 } VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32;
1986
1987 typedef struct VkPhysicalDeviceMeshShaderFeaturesNV32
1988 {
1989     VkStructureType sType;
1990     PTR32 pNext;
1991     VkBool32 taskShader;
1992     VkBool32 meshShader;
1993 } VkPhysicalDeviceMeshShaderFeaturesNV32;
1994
1995 typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT32
1996 {
1997     VkStructureType sType;
1998     PTR32 pNext;
1999     VkBool32 taskShader;
2000     VkBool32 meshShader;
2001     VkBool32 multiviewMeshShader;
2002     VkBool32 primitiveFragmentShadingRateMeshShader;
2003     VkBool32 meshShaderQueries;
2004 } VkPhysicalDeviceMeshShaderFeaturesEXT32;
2005
2006 typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR32
2007 {
2008     VkStructureType sType;
2009     PTR32 pNext;
2010     VkBool32 accelerationStructure;
2011     VkBool32 accelerationStructureCaptureReplay;
2012     VkBool32 accelerationStructureIndirectBuild;
2013     VkBool32 accelerationStructureHostCommands;
2014     VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind;
2015 } VkPhysicalDeviceAccelerationStructureFeaturesKHR32;
2016
2017 typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR32
2018 {
2019     VkStructureType sType;
2020     PTR32 pNext;
2021     VkBool32 rayTracingPipeline;
2022     VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay;
2023     VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
2024     VkBool32 rayTracingPipelineTraceRaysIndirect;
2025     VkBool32 rayTraversalPrimitiveCulling;
2026 } VkPhysicalDeviceRayTracingPipelineFeaturesKHR32;
2027
2028 typedef struct VkPhysicalDeviceRayQueryFeaturesKHR32
2029 {
2030     VkStructureType sType;
2031     PTR32 pNext;
2032     VkBool32 rayQuery;
2033 } VkPhysicalDeviceRayQueryFeaturesKHR32;
2034
2035 typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32
2036 {
2037     VkStructureType sType;
2038     PTR32 pNext;
2039     VkBool32 rayTracingMaintenance1;
2040     VkBool32 rayTracingPipelineTraceRaysIndirect2;
2041 } VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32;
2042
2043 typedef struct VkDeviceMemoryOverallocationCreateInfoAMD32
2044 {
2045     VkStructureType sType;
2046     PTR32 pNext;
2047     VkMemoryOverallocationBehaviorAMD overallocationBehavior;
2048 } VkDeviceMemoryOverallocationCreateInfoAMD32;
2049
2050 typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT32
2051 {
2052     VkStructureType sType;
2053     PTR32 pNext;
2054     VkBool32 fragmentDensityMap;
2055     VkBool32 fragmentDensityMapDynamic;
2056     VkBool32 fragmentDensityMapNonSubsampledImages;
2057 } VkPhysicalDeviceFragmentDensityMapFeaturesEXT32;
2058
2059 typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32
2060 {
2061     VkStructureType sType;
2062     PTR32 pNext;
2063     VkBool32 fragmentDensityMapDeferred;
2064 } VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32;
2065
2066 typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32
2067 {
2068     VkStructureType sType;
2069     PTR32 pNext;
2070     VkBool32 fragmentDensityMapOffset;
2071 } VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32;
2072
2073 typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures32
2074 {
2075     VkStructureType sType;
2076     PTR32 pNext;
2077     VkBool32 scalarBlockLayout;
2078 } VkPhysicalDeviceScalarBlockLayoutFeatures32;
2079 typedef VkPhysicalDeviceScalarBlockLayoutFeatures32 VkPhysicalDeviceScalarBlockLayoutFeaturesEXT32;
2080
2081 typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures32
2082 {
2083     VkStructureType sType;
2084     PTR32 pNext;
2085     VkBool32 uniformBufferStandardLayout;
2086 } VkPhysicalDeviceUniformBufferStandardLayoutFeatures32;
2087 typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR32;
2088
2089 typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT32
2090 {
2091     VkStructureType sType;
2092     PTR32 pNext;
2093     VkBool32 depthClipEnable;
2094 } VkPhysicalDeviceDepthClipEnableFeaturesEXT32;
2095
2096 typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT32
2097 {
2098     VkStructureType sType;
2099     PTR32 pNext;
2100     VkBool32 memoryPriority;
2101 } VkPhysicalDeviceMemoryPriorityFeaturesEXT32;
2102
2103 typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32
2104 {
2105     VkStructureType sType;
2106     PTR32 pNext;
2107     VkBool32 pageableDeviceLocalMemory;
2108 } VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32;
2109
2110 typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures32
2111 {
2112     VkStructureType sType;
2113     PTR32 pNext;
2114     VkBool32 bufferDeviceAddress;
2115     VkBool32 bufferDeviceAddressCaptureReplay;
2116     VkBool32 bufferDeviceAddressMultiDevice;
2117 } VkPhysicalDeviceBufferDeviceAddressFeatures32;
2118 typedef VkPhysicalDeviceBufferDeviceAddressFeatures32 VkPhysicalDeviceBufferDeviceAddressFeaturesKHR32;
2119
2120 typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32
2121 {
2122     VkStructureType sType;
2123     PTR32 pNext;
2124     VkBool32 bufferDeviceAddress;
2125     VkBool32 bufferDeviceAddressCaptureReplay;
2126     VkBool32 bufferDeviceAddressMultiDevice;
2127 } VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32;
2128 typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 VkPhysicalDeviceBufferAddressFeaturesEXT32;
2129
2130 typedef struct VkPhysicalDeviceImagelessFramebufferFeatures32
2131 {
2132     VkStructureType sType;
2133     PTR32 pNext;
2134     VkBool32 imagelessFramebuffer;
2135 } VkPhysicalDeviceImagelessFramebufferFeatures32;
2136 typedef VkPhysicalDeviceImagelessFramebufferFeatures32 VkPhysicalDeviceImagelessFramebufferFeaturesKHR32;
2137
2138 typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures32
2139 {
2140     VkStructureType sType;
2141     PTR32 pNext;
2142     VkBool32 textureCompressionASTC_HDR;
2143 } VkPhysicalDeviceTextureCompressionASTCHDRFeatures32;
2144 typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT32;
2145
2146 typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV32
2147 {
2148     VkStructureType sType;
2149     PTR32 pNext;
2150     VkBool32 cooperativeMatrix;
2151     VkBool32 cooperativeMatrixRobustBufferAccess;
2152 } VkPhysicalDeviceCooperativeMatrixFeaturesNV32;
2153
2154 typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32
2155 {
2156     VkStructureType sType;
2157     PTR32 pNext;
2158     VkBool32 ycbcrImageArrays;
2159 } VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32;
2160
2161 typedef struct VkPhysicalDevicePresentBarrierFeaturesNV32
2162 {
2163     VkStructureType sType;
2164     PTR32 pNext;
2165     VkBool32 presentBarrier;
2166 } VkPhysicalDevicePresentBarrierFeaturesNV32;
2167
2168 typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR32
2169 {
2170     VkStructureType sType;
2171     PTR32 pNext;
2172     VkBool32 performanceCounterQueryPools;
2173     VkBool32 performanceCounterMultipleQueryPools;
2174 } VkPhysicalDevicePerformanceQueryFeaturesKHR32;
2175
2176 typedef struct VkPerformanceQueryReservationInfoKHR32
2177 {
2178     VkStructureType sType;
2179     PTR32 pNext;
2180     uint32_t maxPerformanceQueriesPerPool;
2181 } VkPerformanceQueryReservationInfoKHR32;
2182
2183 typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV32
2184 {
2185     VkStructureType sType;
2186     PTR32 pNext;
2187     VkBool32 coverageReductionMode;
2188 } VkPhysicalDeviceCoverageReductionModeFeaturesNV32;
2189
2190 typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32
2191 {
2192     VkStructureType sType;
2193     PTR32 pNext;
2194     VkBool32 shaderIntegerFunctions2;
2195 } VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32;
2196
2197 typedef struct VkPhysicalDeviceShaderClockFeaturesKHR32
2198 {
2199     VkStructureType sType;
2200     PTR32 pNext;
2201     VkBool32 shaderSubgroupClock;
2202     VkBool32 shaderDeviceClock;
2203 } VkPhysicalDeviceShaderClockFeaturesKHR32;
2204
2205 typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT32
2206 {
2207     VkStructureType sType;
2208     PTR32 pNext;
2209     VkBool32 indexTypeUint8;
2210 } VkPhysicalDeviceIndexTypeUint8FeaturesEXT32;
2211
2212 typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32
2213 {
2214     VkStructureType sType;
2215     PTR32 pNext;
2216     VkBool32 shaderSMBuiltins;
2217 } VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32;
2218
2219 typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32
2220 {
2221     VkStructureType sType;
2222     PTR32 pNext;
2223     VkBool32 fragmentShaderSampleInterlock;
2224     VkBool32 fragmentShaderPixelInterlock;
2225     VkBool32 fragmentShaderShadingRateInterlock;
2226 } VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32;
2227
2228 typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32
2229 {
2230     VkStructureType sType;
2231     PTR32 pNext;
2232     VkBool32 separateDepthStencilLayouts;
2233 } VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32;
2234 typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR32;
2235
2236 typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32
2237 {
2238     VkStructureType sType;
2239     PTR32 pNext;
2240     VkBool32 primitiveTopologyListRestart;
2241     VkBool32 primitiveTopologyPatchListRestart;
2242 } VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32;
2243
2244 typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32
2245 {
2246     VkStructureType sType;
2247     PTR32 pNext;
2248     VkBool32 pipelineExecutableInfo;
2249 } VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32;
2250
2251 typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32
2252 {
2253     VkStructureType sType;
2254     PTR32 pNext;
2255     VkBool32 shaderDemoteToHelperInvocation;
2256 } VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32;
2257 typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT32;
2258
2259 typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32
2260 {
2261     VkStructureType sType;
2262     PTR32 pNext;
2263     VkBool32 texelBufferAlignment;
2264 } VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32;
2265
2266 typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures32
2267 {
2268     VkStructureType sType;
2269     PTR32 pNext;
2270     VkBool32 subgroupSizeControl;
2271     VkBool32 computeFullSubgroups;
2272 } VkPhysicalDeviceSubgroupSizeControlFeatures32;
2273 typedef VkPhysicalDeviceSubgroupSizeControlFeatures32 VkPhysicalDeviceSubgroupSizeControlFeaturesEXT32;
2274
2275 typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT32
2276 {
2277     VkStructureType sType;
2278     PTR32 pNext;
2279     VkBool32 rectangularLines;
2280     VkBool32 bresenhamLines;
2281     VkBool32 smoothLines;
2282     VkBool32 stippledRectangularLines;
2283     VkBool32 stippledBresenhamLines;
2284     VkBool32 stippledSmoothLines;
2285 } VkPhysicalDeviceLineRasterizationFeaturesEXT32;
2286
2287 typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures32
2288 {
2289     VkStructureType sType;
2290     PTR32 pNext;
2291     VkBool32 pipelineCreationCacheControl;
2292 } VkPhysicalDevicePipelineCreationCacheControlFeatures32;
2293 typedef VkPhysicalDevicePipelineCreationCacheControlFeatures32 VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT32;
2294
2295 typedef struct VkPhysicalDeviceVulkan11Features32
2296 {
2297     VkStructureType sType;
2298     PTR32 pNext;
2299     VkBool32 storageBuffer16BitAccess;
2300     VkBool32 uniformAndStorageBuffer16BitAccess;
2301     VkBool32 storagePushConstant16;
2302     VkBool32 storageInputOutput16;
2303     VkBool32 multiview;
2304     VkBool32 multiviewGeometryShader;
2305     VkBool32 multiviewTessellationShader;
2306     VkBool32 variablePointersStorageBuffer;
2307     VkBool32 variablePointers;
2308     VkBool32 protectedMemory;
2309     VkBool32 samplerYcbcrConversion;
2310     VkBool32 shaderDrawParameters;
2311 } VkPhysicalDeviceVulkan11Features32;
2312
2313 typedef struct VkPhysicalDeviceVulkan12Features32
2314 {
2315     VkStructureType sType;
2316     PTR32 pNext;
2317     VkBool32 samplerMirrorClampToEdge;
2318     VkBool32 drawIndirectCount;
2319     VkBool32 storageBuffer8BitAccess;
2320     VkBool32 uniformAndStorageBuffer8BitAccess;
2321     VkBool32 storagePushConstant8;
2322     VkBool32 shaderBufferInt64Atomics;
2323     VkBool32 shaderSharedInt64Atomics;
2324     VkBool32 shaderFloat16;
2325     VkBool32 shaderInt8;
2326     VkBool32 descriptorIndexing;
2327     VkBool32 shaderInputAttachmentArrayDynamicIndexing;
2328     VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
2329     VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
2330     VkBool32 shaderUniformBufferArrayNonUniformIndexing;
2331     VkBool32 shaderSampledImageArrayNonUniformIndexing;
2332     VkBool32 shaderStorageBufferArrayNonUniformIndexing;
2333     VkBool32 shaderStorageImageArrayNonUniformIndexing;
2334     VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
2335     VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
2336     VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
2337     VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
2338     VkBool32 descriptorBindingSampledImageUpdateAfterBind;
2339     VkBool32 descriptorBindingStorageImageUpdateAfterBind;
2340     VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
2341     VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
2342     VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
2343     VkBool32 descriptorBindingUpdateUnusedWhilePending;
2344     VkBool32 descriptorBindingPartiallyBound;
2345     VkBool32 descriptorBindingVariableDescriptorCount;
2346     VkBool32 runtimeDescriptorArray;
2347     VkBool32 samplerFilterMinmax;
2348     VkBool32 scalarBlockLayout;
2349     VkBool32 imagelessFramebuffer;
2350     VkBool32 uniformBufferStandardLayout;
2351     VkBool32 shaderSubgroupExtendedTypes;
2352     VkBool32 separateDepthStencilLayouts;
2353     VkBool32 hostQueryReset;
2354     VkBool32 timelineSemaphore;
2355     VkBool32 bufferDeviceAddress;
2356     VkBool32 bufferDeviceAddressCaptureReplay;
2357     VkBool32 bufferDeviceAddressMultiDevice;
2358     VkBool32 vulkanMemoryModel;
2359     VkBool32 vulkanMemoryModelDeviceScope;
2360     VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
2361     VkBool32 shaderOutputViewportIndex;
2362     VkBool32 shaderOutputLayer;
2363     VkBool32 subgroupBroadcastDynamicId;
2364 } VkPhysicalDeviceVulkan12Features32;
2365
2366 typedef struct VkPhysicalDeviceVulkan13Features32
2367 {
2368     VkStructureType sType;
2369     PTR32 pNext;
2370     VkBool32 robustImageAccess;
2371     VkBool32 inlineUniformBlock;
2372     VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
2373     VkBool32 pipelineCreationCacheControl;
2374     VkBool32 privateData;
2375     VkBool32 shaderDemoteToHelperInvocation;
2376     VkBool32 shaderTerminateInvocation;
2377     VkBool32 subgroupSizeControl;
2378     VkBool32 computeFullSubgroups;
2379     VkBool32 synchronization2;
2380     VkBool32 textureCompressionASTC_HDR;
2381     VkBool32 shaderZeroInitializeWorkgroupMemory;
2382     VkBool32 dynamicRendering;
2383     VkBool32 shaderIntegerDotProduct;
2384     VkBool32 maintenance4;
2385 } VkPhysicalDeviceVulkan13Features32;
2386
2387 typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD32
2388 {
2389     VkStructureType sType;
2390     PTR32 pNext;
2391     VkBool32 deviceCoherentMemory;
2392 } VkPhysicalDeviceCoherentMemoryFeaturesAMD32;
2393
2394 typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT32
2395 {
2396     VkStructureType sType;
2397     PTR32 pNext;
2398     VkBool32 customBorderColors;
2399     VkBool32 customBorderColorWithoutFormat;
2400 } VkPhysicalDeviceCustomBorderColorFeaturesEXT32;
2401
2402 typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32
2403 {
2404     VkStructureType sType;
2405     PTR32 pNext;
2406     VkBool32 borderColorSwizzle;
2407     VkBool32 borderColorSwizzleFromImage;
2408 } VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32;
2409
2410 typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32
2411 {
2412     VkStructureType sType;
2413     PTR32 pNext;
2414     VkBool32 extendedDynamicState;
2415 } VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32;
2416
2417 typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32
2418 {
2419     VkStructureType sType;
2420     PTR32 pNext;
2421     VkBool32 extendedDynamicState2;
2422     VkBool32 extendedDynamicState2LogicOp;
2423     VkBool32 extendedDynamicState2PatchControlPoints;
2424 } VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32;
2425
2426 typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32
2427 {
2428     VkStructureType sType;
2429     PTR32 pNext;
2430     VkBool32 extendedDynamicState3TessellationDomainOrigin;
2431     VkBool32 extendedDynamicState3DepthClampEnable;
2432     VkBool32 extendedDynamicState3PolygonMode;
2433     VkBool32 extendedDynamicState3RasterizationSamples;
2434     VkBool32 extendedDynamicState3SampleMask;
2435     VkBool32 extendedDynamicState3AlphaToCoverageEnable;
2436     VkBool32 extendedDynamicState3AlphaToOneEnable;
2437     VkBool32 extendedDynamicState3LogicOpEnable;
2438     VkBool32 extendedDynamicState3ColorBlendEnable;
2439     VkBool32 extendedDynamicState3ColorBlendEquation;
2440     VkBool32 extendedDynamicState3ColorWriteMask;
2441     VkBool32 extendedDynamicState3RasterizationStream;
2442     VkBool32 extendedDynamicState3ConservativeRasterizationMode;
2443     VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize;
2444     VkBool32 extendedDynamicState3DepthClipEnable;
2445     VkBool32 extendedDynamicState3SampleLocationsEnable;
2446     VkBool32 extendedDynamicState3ColorBlendAdvanced;
2447     VkBool32 extendedDynamicState3ProvokingVertexMode;
2448     VkBool32 extendedDynamicState3LineRasterizationMode;
2449     VkBool32 extendedDynamicState3LineStippleEnable;
2450     VkBool32 extendedDynamicState3DepthClipNegativeOneToOne;
2451     VkBool32 extendedDynamicState3ViewportWScalingEnable;
2452     VkBool32 extendedDynamicState3ViewportSwizzle;
2453     VkBool32 extendedDynamicState3CoverageToColorEnable;
2454     VkBool32 extendedDynamicState3CoverageToColorLocation;
2455     VkBool32 extendedDynamicState3CoverageModulationMode;
2456     VkBool32 extendedDynamicState3CoverageModulationTableEnable;
2457     VkBool32 extendedDynamicState3CoverageModulationTable;
2458     VkBool32 extendedDynamicState3CoverageReductionMode;
2459     VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable;
2460     VkBool32 extendedDynamicState3ShadingRateImageEnable;
2461 } VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32;
2462
2463 typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV32
2464 {
2465     VkStructureType sType;
2466     PTR32 pNext;
2467     VkBool32 diagnosticsConfig;
2468 } VkPhysicalDeviceDiagnosticsConfigFeaturesNV32;
2469
2470 typedef struct VkDeviceDiagnosticsConfigCreateInfoNV32
2471 {
2472     VkStructureType sType;
2473     PTR32 pNext;
2474     VkDeviceDiagnosticsConfigFlagsNV flags;
2475 } VkDeviceDiagnosticsConfigCreateInfoNV32;
2476
2477 typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32
2478 {
2479     VkStructureType sType;
2480     PTR32 pNext;
2481     VkBool32 shaderZeroInitializeWorkgroupMemory;
2482 } VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32;
2483 typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR32;
2484
2485 typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32
2486 {
2487     VkStructureType sType;
2488     PTR32 pNext;
2489     VkBool32 shaderSubgroupUniformControlFlow;
2490 } VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32;
2491
2492 typedef struct VkPhysicalDeviceRobustness2FeaturesEXT32
2493 {
2494     VkStructureType sType;
2495     PTR32 pNext;
2496     VkBool32 robustBufferAccess2;
2497     VkBool32 robustImageAccess2;
2498     VkBool32 nullDescriptor;
2499 } VkPhysicalDeviceRobustness2FeaturesEXT32;
2500
2501 typedef struct VkPhysicalDeviceImageRobustnessFeatures32
2502 {
2503     VkStructureType sType;
2504     PTR32 pNext;
2505     VkBool32 robustImageAccess;
2506 } VkPhysicalDeviceImageRobustnessFeatures32;
2507 typedef VkPhysicalDeviceImageRobustnessFeatures32 VkPhysicalDeviceImageRobustnessFeaturesEXT32;
2508
2509 typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32
2510 {
2511     VkStructureType sType;
2512     PTR32 pNext;
2513     VkBool32 workgroupMemoryExplicitLayout;
2514     VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout;
2515     VkBool32 workgroupMemoryExplicitLayout8BitAccess;
2516     VkBool32 workgroupMemoryExplicitLayout16BitAccess;
2517 } VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32;
2518
2519 typedef struct VkPhysicalDevice4444FormatsFeaturesEXT32
2520 {
2521     VkStructureType sType;
2522     PTR32 pNext;
2523     VkBool32 formatA4R4G4B4;
2524     VkBool32 formatA4B4G4R4;
2525 } VkPhysicalDevice4444FormatsFeaturesEXT32;
2526
2527 typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32
2528 {
2529     VkStructureType sType;
2530     PTR32 pNext;
2531     VkBool32 subpassShading;
2532 } VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32;
2533
2534 typedef struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32
2535 {
2536     VkStructureType sType;
2537     PTR32 pNext;
2538     VkBool32 clustercullingShader;
2539     VkBool32 multiviewClusterCullingShader;
2540 } VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32;
2541
2542 typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32
2543 {
2544     VkStructureType sType;
2545     PTR32 pNext;
2546     VkBool32 shaderImageInt64Atomics;
2547     VkBool32 sparseImageInt64Atomics;
2548 } VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32;
2549
2550 typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR32
2551 {
2552     VkStructureType sType;
2553     PTR32 pNext;
2554     VkBool32 pipelineFragmentShadingRate;
2555     VkBool32 primitiveFragmentShadingRate;
2556     VkBool32 attachmentFragmentShadingRate;
2557 } VkPhysicalDeviceFragmentShadingRateFeaturesKHR32;
2558
2559 typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures32
2560 {
2561     VkStructureType sType;
2562     PTR32 pNext;
2563     VkBool32 shaderTerminateInvocation;
2564 } VkPhysicalDeviceShaderTerminateInvocationFeatures32;
2565 typedef VkPhysicalDeviceShaderTerminateInvocationFeatures32 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR32;
2566
2567 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32
2568 {
2569     VkStructureType sType;
2570     PTR32 pNext;
2571     VkBool32 fragmentShadingRateEnums;
2572     VkBool32 supersampleFragmentShadingRates;
2573     VkBool32 noInvocationFragmentShadingRates;
2574 } VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32;
2575
2576 typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32
2577 {
2578     VkStructureType sType;
2579     PTR32 pNext;
2580     VkBool32 image2DViewOf3D;
2581     VkBool32 sampler2DViewOf3D;
2582 } VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32;
2583
2584 typedef struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32
2585 {
2586     VkStructureType sType;
2587     PTR32 pNext;
2588     VkBool32 imageSlicedViewOf3D;
2589 } VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32;
2590
2591 typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32
2592 {
2593     VkStructureType sType;
2594     PTR32 pNext;
2595     VkBool32 attachmentFeedbackLoopDynamicState;
2596 } VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32;
2597
2598 typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32
2599 {
2600     VkStructureType sType;
2601     PTR32 pNext;
2602     VkBool32 mutableDescriptorType;
2603 } VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32;
2604 typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE32;
2605
2606 typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT32
2607 {
2608     VkStructureType sType;
2609     PTR32 pNext;
2610     VkBool32 depthClipControl;
2611 } VkPhysicalDeviceDepthClipControlFeaturesEXT32;
2612
2613 typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32
2614 {
2615     VkStructureType sType;
2616     PTR32 pNext;
2617     VkBool32 vertexInputDynamicState;
2618 } VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32;
2619
2620 typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT32
2621 {
2622     VkStructureType sType;
2623     PTR32 pNext;
2624     VkBool32 colorWriteEnable;
2625 } VkPhysicalDeviceColorWriteEnableFeaturesEXT32;
2626
2627 typedef struct VkPhysicalDeviceSynchronization2Features32
2628 {
2629     VkStructureType sType;
2630     PTR32 pNext;
2631     VkBool32 synchronization2;
2632 } VkPhysicalDeviceSynchronization2Features32;
2633 typedef VkPhysicalDeviceSynchronization2Features32 VkPhysicalDeviceSynchronization2FeaturesKHR32;
2634
2635 typedef struct VkPhysicalDeviceHostImageCopyFeaturesEXT32
2636 {
2637     VkStructureType sType;
2638     PTR32 pNext;
2639     VkBool32 hostImageCopy;
2640 } VkPhysicalDeviceHostImageCopyFeaturesEXT32;
2641
2642 typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32
2643 {
2644     VkStructureType sType;
2645     PTR32 pNext;
2646     VkBool32 primitivesGeneratedQuery;
2647     VkBool32 primitivesGeneratedQueryWithRasterizerDiscard;
2648     VkBool32 primitivesGeneratedQueryWithNonZeroStreams;
2649 } VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32;
2650
2651 typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT32
2652 {
2653     VkStructureType sType;
2654     PTR32 pNext;
2655     VkBool32 legacyDithering;
2656 } VkPhysicalDeviceLegacyDitheringFeaturesEXT32;
2657
2658 typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32
2659 {
2660     VkStructureType sType;
2661     PTR32 pNext;
2662     VkBool32 multisampledRenderToSingleSampled;
2663 } VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32;
2664
2665 typedef struct VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32
2666 {
2667     VkStructureType sType;
2668     PTR32 pNext;
2669     VkBool32 pipelineProtectedAccess;
2670 } VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32;
2671
2672 typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV32
2673 {
2674     VkStructureType sType;
2675     PTR32 pNext;
2676     VkBool32 inheritedViewportScissor2D;
2677 } VkPhysicalDeviceInheritedViewportScissorFeaturesNV32;
2678
2679 typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32
2680 {
2681     VkStructureType sType;
2682     PTR32 pNext;
2683     VkBool32 ycbcr2plane444Formats;
2684 } VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32;
2685
2686 typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT32
2687 {
2688     VkStructureType sType;
2689     PTR32 pNext;
2690     VkBool32 provokingVertexLast;
2691     VkBool32 transformFeedbackPreservesProvokingVertex;
2692 } VkPhysicalDeviceProvokingVertexFeaturesEXT32;
2693
2694 typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT32
2695 {
2696     VkStructureType sType;
2697     PTR32 pNext;
2698     VkBool32 descriptorBuffer;
2699     VkBool32 descriptorBufferCaptureReplay;
2700     VkBool32 descriptorBufferImageLayoutIgnored;
2701     VkBool32 descriptorBufferPushDescriptors;
2702 } VkPhysicalDeviceDescriptorBufferFeaturesEXT32;
2703
2704 typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures32
2705 {
2706     VkStructureType sType;
2707     PTR32 pNext;
2708     VkBool32 shaderIntegerDotProduct;
2709 } VkPhysicalDeviceShaderIntegerDotProductFeatures32;
2710 typedef VkPhysicalDeviceShaderIntegerDotProductFeatures32 VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR32;
2711
2712 typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32
2713 {
2714     VkStructureType sType;
2715     PTR32 pNext;
2716     VkBool32 fragmentShaderBarycentric;
2717 } VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32;
2718 typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV32;
2719
2720 typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32
2721 {
2722     VkStructureType sType;
2723     PTR32 pNext;
2724     VkBool32 rayTracingMotionBlur;
2725     VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect;
2726 } VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32;
2727
2728 typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32
2729 {
2730     VkStructureType sType;
2731     PTR32 pNext;
2732     VkBool32 formatRgba10x6WithoutYCbCrSampler;
2733 } VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32;
2734
2735 typedef struct VkPhysicalDeviceDynamicRenderingFeatures32
2736 {
2737     VkStructureType sType;
2738     PTR32 pNext;
2739     VkBool32 dynamicRendering;
2740 } VkPhysicalDeviceDynamicRenderingFeatures32;
2741 typedef VkPhysicalDeviceDynamicRenderingFeatures32 VkPhysicalDeviceDynamicRenderingFeaturesKHR32;
2742
2743 typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT32
2744 {
2745     VkStructureType sType;
2746     PTR32 pNext;
2747     VkBool32 minLod;
2748 } VkPhysicalDeviceImageViewMinLodFeaturesEXT32;
2749
2750 typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32
2751 {
2752     VkStructureType sType;
2753     PTR32 pNext;
2754     VkBool32 rasterizationOrderColorAttachmentAccess;
2755     VkBool32 rasterizationOrderDepthAttachmentAccess;
2756     VkBool32 rasterizationOrderStencilAttachmentAccess;
2757 } VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32;
2758 typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM32;
2759
2760 typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV32
2761 {
2762     VkStructureType sType;
2763     PTR32 pNext;
2764     VkBool32 linearColorAttachment;
2765 } VkPhysicalDeviceLinearColorAttachmentFeaturesNV32;
2766
2767 typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32
2768 {
2769     VkStructureType sType;
2770     PTR32 pNext;
2771     VkBool32 graphicsPipelineLibrary;
2772 } VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32;
2773
2774 typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32
2775 {
2776     VkStructureType sType;
2777     PTR32 pNext;
2778     VkBool32 descriptorSetHostMapping;
2779 } VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32;
2780
2781 typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32
2782 {
2783     VkStructureType sType;
2784     PTR32 pNext;
2785     VkBool32 shaderModuleIdentifier;
2786 } VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32;
2787
2788 typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT32
2789 {
2790     VkStructureType sType;
2791     PTR32 pNext;
2792     VkBool32 imageCompressionControl;
2793 } VkPhysicalDeviceImageCompressionControlFeaturesEXT32;
2794
2795 typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32
2796 {
2797     VkStructureType sType;
2798     PTR32 pNext;
2799     VkBool32 imageCompressionControlSwapchain;
2800 } VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32;
2801
2802 typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32
2803 {
2804     VkStructureType sType;
2805     PTR32 pNext;
2806     VkBool32 subpassMergeFeedback;
2807 } VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32;
2808
2809 typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT32
2810 {
2811     VkStructureType sType;
2812     PTR32 pNext;
2813     VkBool32 micromap;
2814     VkBool32 micromapCaptureReplay;
2815     VkBool32 micromapHostCommands;
2816 } VkPhysicalDeviceOpacityMicromapFeaturesEXT32;
2817
2818 typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT32
2819 {
2820     VkStructureType sType;
2821     PTR32 pNext;
2822     VkBool32 pipelinePropertiesIdentifier;
2823 } VkPhysicalDevicePipelinePropertiesFeaturesEXT32;
2824
2825 typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32
2826 {
2827     VkStructureType sType;
2828     PTR32 pNext;
2829     VkBool32 shaderEarlyAndLateFragmentTests;
2830 } VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32;
2831
2832 typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32
2833 {
2834     VkStructureType sType;
2835     PTR32 pNext;
2836     VkBool32 nonSeamlessCubeMap;
2837 } VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32;
2838
2839 typedef struct VkPhysicalDevicePipelineRobustnessFeaturesEXT32
2840 {
2841     VkStructureType sType;
2842     PTR32 pNext;
2843     VkBool32 pipelineRobustness;
2844 } VkPhysicalDevicePipelineRobustnessFeaturesEXT32;
2845
2846 typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM32
2847 {
2848     VkStructureType sType;
2849     PTR32 pNext;
2850     VkBool32 textureSampleWeighted;
2851     VkBool32 textureBoxFilter;
2852     VkBool32 textureBlockMatch;
2853 } VkPhysicalDeviceImageProcessingFeaturesQCOM32;
2854
2855 typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM32
2856 {
2857     VkStructureType sType;
2858     PTR32 pNext;
2859     VkBool32 tileProperties;
2860 } VkPhysicalDeviceTilePropertiesFeaturesQCOM32;
2861
2862 typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32
2863 {
2864     VkStructureType sType;
2865     PTR32 pNext;
2866     VkBool32 attachmentFeedbackLoopLayout;
2867 } VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32;
2868
2869 typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32
2870 {
2871     VkStructureType sType;
2872     PTR32 pNext;
2873     VkBool32 depthClampZeroOne;
2874 } VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32;
2875
2876 typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT32
2877 {
2878     VkStructureType sType;
2879     PTR32 pNext;
2880     VkBool32 reportAddressBinding;
2881 } VkPhysicalDeviceAddressBindingReportFeaturesEXT32;
2882
2883 typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV32
2884 {
2885     VkStructureType sType;
2886     PTR32 pNext;
2887     VkBool32 opticalFlow;
2888 } VkPhysicalDeviceOpticalFlowFeaturesNV32;
2889
2890 typedef struct VkPhysicalDeviceFaultFeaturesEXT32
2891 {
2892     VkStructureType sType;
2893     PTR32 pNext;
2894     VkBool32 deviceFault;
2895     VkBool32 deviceFaultVendorBinary;
2896 } VkPhysicalDeviceFaultFeaturesEXT32;
2897
2898 typedef struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32
2899 {
2900     VkStructureType sType;
2901     PTR32 pNext;
2902     VkBool32 pipelineLibraryGroupHandles;
2903 } VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32;
2904
2905 typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32
2906 {
2907     VkStructureType sType;
2908     PTR32 pNext;
2909     VkBool32 shaderCoreBuiltins;
2910 } VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32;
2911
2912 typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32
2913 {
2914     VkStructureType sType;
2915     PTR32 pNext;
2916     VkBool32 dynamicRenderingUnusedAttachments;
2917 } VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32;
2918
2919 typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32
2920 {
2921     VkStructureType sType;
2922     PTR32 pNext;
2923     VkBool32 swapchainMaintenance1;
2924 } VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32;
2925
2926 typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT32
2927 {
2928     VkStructureType sType;
2929     PTR32 pNext;
2930     VkBool32 depthBiasControl;
2931     VkBool32 leastRepresentableValueForceUnormRepresentation;
2932     VkBool32 floatRepresentation;
2933     VkBool32 depthBiasExact;
2934 } VkPhysicalDeviceDepthBiasControlFeaturesEXT32;
2935
2936 typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32
2937 {
2938     VkStructureType sType;
2939     PTR32 pNext;
2940     VkBool32 rayTracingInvocationReorder;
2941 } VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32;
2942
2943 typedef struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32
2944 {
2945     VkStructureType sType;
2946     PTR32 pNext;
2947     VkBool32 multiviewPerViewViewports;
2948 } VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32;
2949
2950 typedef struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32
2951 {
2952     VkStructureType sType;
2953     PTR32 pNext;
2954     VkBool32 rayTracingPositionFetch;
2955 } VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32;
2956
2957 typedef struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32
2958 {
2959     VkStructureType sType;
2960     PTR32 pNext;
2961     VkBool32 multiviewPerViewRenderAreas;
2962 } VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32;
2963
2964 typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT32
2965 {
2966     VkStructureType sType;
2967     PTR32 pNext;
2968     VkBool32 shaderObject;
2969 } VkPhysicalDeviceShaderObjectFeaturesEXT32;
2970
2971 typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT32
2972 {
2973     VkStructureType sType;
2974     PTR32 pNext;
2975     VkBool32 shaderTileImageColorReadAccess;
2976     VkBool32 shaderTileImageDepthReadAccess;
2977     VkBool32 shaderTileImageStencilReadAccess;
2978 } VkPhysicalDeviceShaderTileImageFeaturesEXT32;
2979
2980 typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR32
2981 {
2982     VkStructureType sType;
2983     PTR32 pNext;
2984     VkBool32 cooperativeMatrix;
2985     VkBool32 cooperativeMatrixRobustBufferAccess;
2986 } VkPhysicalDeviceCooperativeMatrixFeaturesKHR32;
2987
2988 typedef struct VkDeviceCreateInfo32
2989 {
2990     VkStructureType sType;
2991     PTR32 pNext;
2992     VkDeviceCreateFlags flags;
2993     uint32_t queueCreateInfoCount;
2994     PTR32 pQueueCreateInfos;
2995     uint32_t enabledLayerCount;
2996     PTR32 ppEnabledLayerNames;
2997     uint32_t enabledExtensionCount;
2998     PTR32 ppEnabledExtensionNames;
2999     PTR32 pEnabledFeatures;
3000 } VkDeviceCreateInfo32;
3001
3002 typedef struct VkEventCreateInfo32
3003 {
3004     VkStructureType sType;
3005     PTR32 pNext;
3006     VkEventCreateFlags flags;
3007 } VkEventCreateInfo32;
3008
3009 typedef struct VkExportFenceCreateInfo32
3010 {
3011     VkStructureType sType;
3012     PTR32 pNext;
3013     VkExternalFenceHandleTypeFlags handleTypes;
3014 } VkExportFenceCreateInfo32;
3015 typedef VkExportFenceCreateInfo32 VkExportFenceCreateInfoKHR32;
3016
3017 typedef struct VkFenceCreateInfo32
3018 {
3019     VkStructureType sType;
3020     PTR32 pNext;
3021     VkFenceCreateFlags flags;
3022 } VkFenceCreateInfo32;
3023
3024 typedef struct VkFramebufferAttachmentImageInfo32
3025 {
3026     VkStructureType sType;
3027     PTR32 pNext;
3028     VkImageCreateFlags flags;
3029     VkImageUsageFlags usage;
3030     uint32_t width;
3031     uint32_t height;
3032     uint32_t layerCount;
3033     uint32_t viewFormatCount;
3034     PTR32 pViewFormats;
3035 } VkFramebufferAttachmentImageInfo32;
3036 typedef VkFramebufferAttachmentImageInfo32 VkFramebufferAttachmentImageInfoKHR32;
3037
3038 typedef struct VkFramebufferAttachmentsCreateInfo32
3039 {
3040     VkStructureType sType;
3041     PTR32 pNext;
3042     uint32_t attachmentImageInfoCount;
3043     PTR32 pAttachmentImageInfos;
3044 } VkFramebufferAttachmentsCreateInfo32;
3045 typedef VkFramebufferAttachmentsCreateInfo32 VkFramebufferAttachmentsCreateInfoKHR32;
3046
3047 typedef struct VkFramebufferCreateInfo32
3048 {
3049     VkStructureType sType;
3050     PTR32 pNext;
3051     VkFramebufferCreateFlags flags;
3052     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
3053     uint32_t attachmentCount;
3054     PTR32 pAttachments;
3055     uint32_t width;
3056     uint32_t height;
3057     uint32_t layers;
3058 } VkFramebufferCreateInfo32;
3059
3060 typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT32
3061 {
3062     VkStructureType sType;
3063     PTR32 pNext;
3064     uint32_t vertexBindingDivisorCount;
3065     PTR32 pVertexBindingDivisors;
3066 } VkPipelineVertexInputDivisorStateCreateInfoEXT32;
3067
3068 typedef struct VkPipelineVertexInputStateCreateInfo32
3069 {
3070     VkStructureType sType;
3071     PTR32 pNext;
3072     VkPipelineVertexInputStateCreateFlags flags;
3073     uint32_t vertexBindingDescriptionCount;
3074     PTR32 pVertexBindingDescriptions;
3075     uint32_t vertexAttributeDescriptionCount;
3076     PTR32 pVertexAttributeDescriptions;
3077 } VkPipelineVertexInputStateCreateInfo32;
3078
3079 typedef struct VkPipelineTessellationDomainOriginStateCreateInfo32
3080 {
3081     VkStructureType sType;
3082     PTR32 pNext;
3083     VkTessellationDomainOrigin domainOrigin;
3084 } VkPipelineTessellationDomainOriginStateCreateInfo32;
3085 typedef VkPipelineTessellationDomainOriginStateCreateInfo32 VkPipelineTessellationDomainOriginStateCreateInfoKHR32;
3086
3087 typedef struct VkPipelineTessellationStateCreateInfo32
3088 {
3089     VkStructureType sType;
3090     PTR32 pNext;
3091     VkPipelineTessellationStateCreateFlags flags;
3092     uint32_t patchControlPoints;
3093 } VkPipelineTessellationStateCreateInfo32;
3094
3095 typedef struct VkGraphicsShaderGroupCreateInfoNV32
3096 {
3097     VkStructureType sType;
3098     PTR32 pNext;
3099     uint32_t stageCount;
3100     PTR32 pStages;
3101     PTR32 pVertexInputState;
3102     PTR32 pTessellationState;
3103 } VkGraphicsShaderGroupCreateInfoNV32;
3104
3105 typedef struct VkPipelineInputAssemblyStateCreateInfo32
3106 {
3107     VkStructureType sType;
3108     PTR32 pNext;
3109     VkPipelineInputAssemblyStateCreateFlags flags;
3110     VkPrimitiveTopology topology;
3111     VkBool32 primitiveRestartEnable;
3112 } VkPipelineInputAssemblyStateCreateInfo32;
3113
3114 typedef struct VkPipelineViewportWScalingStateCreateInfoNV32
3115 {
3116     VkStructureType sType;
3117     PTR32 pNext;
3118     VkBool32 viewportWScalingEnable;
3119     uint32_t viewportCount;
3120     PTR32 pViewportWScalings;
3121 } VkPipelineViewportWScalingStateCreateInfoNV32;
3122
3123 typedef struct VkPipelineViewportSwizzleStateCreateInfoNV32
3124 {
3125     VkStructureType sType;
3126     PTR32 pNext;
3127     VkPipelineViewportSwizzleStateCreateFlagsNV flags;
3128     uint32_t viewportCount;
3129     PTR32 pViewportSwizzles;
3130 } VkPipelineViewportSwizzleStateCreateInfoNV32;
3131
3132 typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV32
3133 {
3134     VkStructureType sType;
3135     PTR32 pNext;
3136     uint32_t exclusiveScissorCount;
3137     PTR32 pExclusiveScissors;
3138 } VkPipelineViewportExclusiveScissorStateCreateInfoNV32;
3139
3140 typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV32
3141 {
3142     VkStructureType sType;
3143     PTR32 pNext;
3144     VkBool32 shadingRateImageEnable;
3145     uint32_t viewportCount;
3146     PTR32 pShadingRatePalettes;
3147 } VkPipelineViewportShadingRateImageStateCreateInfoNV32;
3148
3149 typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32
3150 {
3151     VkStructureType sType;
3152     PTR32 pNext;
3153     VkCoarseSampleOrderTypeNV sampleOrderType;
3154     uint32_t customSampleOrderCount;
3155     PTR32 pCustomSampleOrders;
3156 } VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32;
3157
3158 typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT32
3159 {
3160     VkStructureType sType;
3161     PTR32 pNext;
3162     VkBool32 negativeOneToOne;
3163 } VkPipelineViewportDepthClipControlCreateInfoEXT32;
3164
3165 typedef struct VkPipelineViewportStateCreateInfo32
3166 {
3167     VkStructureType sType;
3168     PTR32 pNext;
3169     VkPipelineViewportStateCreateFlags flags;
3170     uint32_t viewportCount;
3171     PTR32 pViewports;
3172     uint32_t scissorCount;
3173     PTR32 pScissors;
3174 } VkPipelineViewportStateCreateInfo32;
3175
3176 typedef struct VkPipelineRasterizationStateRasterizationOrderAMD32
3177 {
3178     VkStructureType sType;
3179     PTR32 pNext;
3180     VkRasterizationOrderAMD rasterizationOrder;
3181 } VkPipelineRasterizationStateRasterizationOrderAMD32;
3182
3183 typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT32
3184 {
3185     VkStructureType sType;
3186     PTR32 pNext;
3187     VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
3188     VkConservativeRasterizationModeEXT conservativeRasterizationMode;
3189     float extraPrimitiveOverestimationSize;
3190 } VkPipelineRasterizationConservativeStateCreateInfoEXT32;
3191
3192 typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT32
3193 {
3194     VkStructureType sType;
3195     PTR32 pNext;
3196     VkPipelineRasterizationStateStreamCreateFlagsEXT flags;
3197     uint32_t rasterizationStream;
3198 } VkPipelineRasterizationStateStreamCreateInfoEXT32;
3199
3200 typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT32
3201 {
3202     VkStructureType sType;
3203     PTR32 pNext;
3204     VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags;
3205     VkBool32 depthClipEnable;
3206 } VkPipelineRasterizationDepthClipStateCreateInfoEXT32;
3207
3208 typedef struct VkPipelineRasterizationLineStateCreateInfoEXT32
3209 {
3210     VkStructureType sType;
3211     PTR32 pNext;
3212     VkLineRasterizationModeEXT lineRasterizationMode;
3213     VkBool32 stippledLineEnable;
3214     uint32_t lineStippleFactor;
3215     uint16_t lineStipplePattern;
3216 } VkPipelineRasterizationLineStateCreateInfoEXT32;
3217
3218 typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32
3219 {
3220     VkStructureType sType;
3221     PTR32 pNext;
3222     VkProvokingVertexModeEXT provokingVertexMode;
3223 } VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32;
3224
3225 typedef struct VkPipelineRasterizationStateCreateInfo32
3226 {
3227     VkStructureType sType;
3228     PTR32 pNext;
3229     VkPipelineRasterizationStateCreateFlags flags;
3230     VkBool32 depthClampEnable;
3231     VkBool32 rasterizerDiscardEnable;
3232     VkPolygonMode polygonMode;
3233     VkCullModeFlags cullMode;
3234     VkFrontFace frontFace;
3235     VkBool32 depthBiasEnable;
3236     float depthBiasConstantFactor;
3237     float depthBiasClamp;
3238     float depthBiasSlopeFactor;
3239     float lineWidth;
3240 } VkPipelineRasterizationStateCreateInfo32;
3241
3242 typedef struct VkPipelineCoverageToColorStateCreateInfoNV32
3243 {
3244     VkStructureType sType;
3245     PTR32 pNext;
3246     VkPipelineCoverageToColorStateCreateFlagsNV flags;
3247     VkBool32 coverageToColorEnable;
3248     uint32_t coverageToColorLocation;
3249 } VkPipelineCoverageToColorStateCreateInfoNV32;
3250
3251 typedef struct VkPipelineSampleLocationsStateCreateInfoEXT32
3252 {
3253     VkStructureType sType;
3254     PTR32 pNext;
3255     VkBool32 sampleLocationsEnable;
3256     VkSampleLocationsInfoEXT32 sampleLocationsInfo;
3257 } VkPipelineSampleLocationsStateCreateInfoEXT32;
3258
3259 typedef struct VkPipelineCoverageModulationStateCreateInfoNV32
3260 {
3261     VkStructureType sType;
3262     PTR32 pNext;
3263     VkPipelineCoverageModulationStateCreateFlagsNV flags;
3264     VkCoverageModulationModeNV coverageModulationMode;
3265     VkBool32 coverageModulationTableEnable;
3266     uint32_t coverageModulationTableCount;
3267     PTR32 pCoverageModulationTable;
3268 } VkPipelineCoverageModulationStateCreateInfoNV32;
3269
3270 typedef struct VkPipelineCoverageReductionStateCreateInfoNV32
3271 {
3272     VkStructureType sType;
3273     PTR32 pNext;
3274     VkPipelineCoverageReductionStateCreateFlagsNV flags;
3275     VkCoverageReductionModeNV coverageReductionMode;
3276 } VkPipelineCoverageReductionStateCreateInfoNV32;
3277
3278 typedef struct VkPipelineMultisampleStateCreateInfo32
3279 {
3280     VkStructureType sType;
3281     PTR32 pNext;
3282     VkPipelineMultisampleStateCreateFlags flags;
3283     VkSampleCountFlagBits rasterizationSamples;
3284     VkBool32 sampleShadingEnable;
3285     float minSampleShading;
3286     PTR32 pSampleMask;
3287     VkBool32 alphaToCoverageEnable;
3288     VkBool32 alphaToOneEnable;
3289 } VkPipelineMultisampleStateCreateInfo32;
3290
3291 typedef struct VkPipelineDepthStencilStateCreateInfo32
3292 {
3293     VkStructureType sType;
3294     PTR32 pNext;
3295     VkPipelineDepthStencilStateCreateFlags flags;
3296     VkBool32 depthTestEnable;
3297     VkBool32 depthWriteEnable;
3298     VkCompareOp depthCompareOp;
3299     VkBool32 depthBoundsTestEnable;
3300     VkBool32 stencilTestEnable;
3301     VkStencilOpState front;
3302     VkStencilOpState back;
3303     float minDepthBounds;
3304     float maxDepthBounds;
3305 } VkPipelineDepthStencilStateCreateInfo32;
3306
3307 typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT32
3308 {
3309     VkStructureType sType;
3310     PTR32 pNext;
3311     VkBool32 srcPremultiplied;
3312     VkBool32 dstPremultiplied;
3313     VkBlendOverlapEXT blendOverlap;
3314 } VkPipelineColorBlendAdvancedStateCreateInfoEXT32;
3315
3316 typedef struct VkPipelineColorWriteCreateInfoEXT32
3317 {
3318     VkStructureType sType;
3319     PTR32 pNext;
3320     uint32_t attachmentCount;
3321     PTR32 pColorWriteEnables;
3322 } VkPipelineColorWriteCreateInfoEXT32;
3323
3324 typedef struct VkPipelineColorBlendStateCreateInfo32
3325 {
3326     VkStructureType sType;
3327     PTR32 pNext;
3328     VkPipelineColorBlendStateCreateFlags flags;
3329     VkBool32 logicOpEnable;
3330     VkLogicOp logicOp;
3331     uint32_t attachmentCount;
3332     PTR32 pAttachments;
3333     float blendConstants[4];
3334 } VkPipelineColorBlendStateCreateInfo32;
3335
3336 typedef struct VkPipelineDynamicStateCreateInfo32
3337 {
3338     VkStructureType sType;
3339     PTR32 pNext;
3340     VkPipelineDynamicStateCreateFlags flags;
3341     uint32_t dynamicStateCount;
3342     PTR32 pDynamicStates;
3343 } VkPipelineDynamicStateCreateInfo32;
3344
3345 typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV32
3346 {
3347     VkStructureType sType;
3348     PTR32 pNext;
3349     uint32_t groupCount;
3350     PTR32 pGroups;
3351     uint32_t pipelineCount;
3352     PTR32 pPipelines;
3353 } VkGraphicsPipelineShaderGroupsCreateInfoNV32;
3354
3355 typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT32
3356 {
3357     VkStructureType sType;
3358     PTR32 pNext;
3359     VkPipelineDiscardRectangleStateCreateFlagsEXT flags;
3360     VkDiscardRectangleModeEXT discardRectangleMode;
3361     uint32_t discardRectangleCount;
3362     PTR32 pDiscardRectangles;
3363 } VkPipelineDiscardRectangleStateCreateInfoEXT32;
3364
3365 typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV32
3366 {
3367     VkStructureType sType;
3368     PTR32 pNext;
3369     VkBool32 representativeFragmentTestEnable;
3370 } VkPipelineRepresentativeFragmentTestStateCreateInfoNV32;
3371
3372 typedef struct VkPipelineLibraryCreateInfoKHR32
3373 {
3374     VkStructureType sType;
3375     PTR32 pNext;
3376     uint32_t libraryCount;
3377     PTR32 pLibraries;
3378 } VkPipelineLibraryCreateInfoKHR32;
3379
3380 typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR32
3381 {
3382     VkStructureType sType;
3383     PTR32 pNext;
3384     VkExtent2D fragmentSize;
3385     VkFragmentShadingRateCombinerOpKHR combinerOps[2];
3386 } VkPipelineFragmentShadingRateStateCreateInfoKHR32;
3387
3388 typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV32
3389 {
3390     VkStructureType sType;
3391     PTR32 pNext;
3392     VkFragmentShadingRateTypeNV shadingRateType;
3393     VkFragmentShadingRateNV shadingRate;
3394     VkFragmentShadingRateCombinerOpKHR combinerOps[2];
3395 } VkPipelineFragmentShadingRateEnumStateCreateInfoNV32;
3396
3397 typedef struct VkPipelineRenderingCreateInfo32
3398 {
3399     VkStructureType sType;
3400     PTR32 pNext;
3401     uint32_t viewMask;
3402     uint32_t colorAttachmentCount;
3403     PTR32 pColorAttachmentFormats;
3404     VkFormat depthAttachmentFormat;
3405     VkFormat stencilAttachmentFormat;
3406 } VkPipelineRenderingCreateInfo32;
3407 typedef VkPipelineRenderingCreateInfo32 VkPipelineRenderingCreateInfoKHR32;
3408
3409 typedef struct VkGraphicsPipelineLibraryCreateInfoEXT32
3410 {
3411     VkStructureType sType;
3412     PTR32 pNext;
3413     VkGraphicsPipelineLibraryFlagsEXT flags;
3414 } VkGraphicsPipelineLibraryCreateInfoEXT32;
3415
3416 typedef struct VkGraphicsPipelineCreateInfo32
3417 {
3418     VkStructureType sType;
3419     PTR32 pNext;
3420     VkPipelineCreateFlags flags;
3421     uint32_t stageCount;
3422     PTR32 pStages;
3423     PTR32 pVertexInputState;
3424     PTR32 pInputAssemblyState;
3425     PTR32 pTessellationState;
3426     PTR32 pViewportState;
3427     PTR32 pRasterizationState;
3428     PTR32 pMultisampleState;
3429     PTR32 pDepthStencilState;
3430     PTR32 pColorBlendState;
3431     PTR32 pDynamicState;
3432     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3433     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
3434     uint32_t subpass;
3435     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3436     int32_t basePipelineIndex;
3437 } VkGraphicsPipelineCreateInfo32;
3438
3439 typedef struct VkDedicatedAllocationImageCreateInfoNV32
3440 {
3441     VkStructureType sType;
3442     PTR32 pNext;
3443     VkBool32 dedicatedAllocation;
3444 } VkDedicatedAllocationImageCreateInfoNV32;
3445
3446 typedef struct VkExternalMemoryImageCreateInfo32
3447 {
3448     VkStructureType sType;
3449     PTR32 pNext;
3450     VkExternalMemoryHandleTypeFlags handleTypes;
3451 } VkExternalMemoryImageCreateInfo32;
3452 typedef VkExternalMemoryImageCreateInfo32 VkExternalMemoryImageCreateInfoKHR32;
3453
3454 typedef struct VkImageSwapchainCreateInfoKHR32
3455 {
3456     VkStructureType sType;
3457     PTR32 pNext;
3458     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
3459 } VkImageSwapchainCreateInfoKHR32;
3460
3461 typedef struct VkImageFormatListCreateInfo32
3462 {
3463     VkStructureType sType;
3464     PTR32 pNext;
3465     uint32_t viewFormatCount;
3466     PTR32 pViewFormats;
3467 } VkImageFormatListCreateInfo32;
3468 typedef VkImageFormatListCreateInfo32 VkImageFormatListCreateInfoKHR32;
3469
3470 typedef struct VkImageStencilUsageCreateInfo32
3471 {
3472     VkStructureType sType;
3473     PTR32 pNext;
3474     VkImageUsageFlags stencilUsage;
3475 } VkImageStencilUsageCreateInfo32;
3476 typedef VkImageStencilUsageCreateInfo32 VkImageStencilUsageCreateInfoEXT32;
3477
3478 typedef struct VkImageCompressionControlEXT32
3479 {
3480     VkStructureType sType;
3481     PTR32 pNext;
3482     VkImageCompressionFlagsEXT flags;
3483     uint32_t compressionControlPlaneCount;
3484     PTR32 pFixedRateFlags;
3485 } VkImageCompressionControlEXT32;
3486
3487 typedef struct VkOpticalFlowImageFormatInfoNV32
3488 {
3489     VkStructureType sType;
3490     PTR32 pNext;
3491     VkOpticalFlowUsageFlagsNV usage;
3492 } VkOpticalFlowImageFormatInfoNV32;
3493
3494 typedef struct VkImageCreateInfo32
3495 {
3496     VkStructureType sType;
3497     PTR32 pNext;
3498     VkImageCreateFlags flags;
3499     VkImageType imageType;
3500     VkFormat format;
3501     VkExtent3D extent;
3502     uint32_t mipLevels;
3503     uint32_t arrayLayers;
3504     VkSampleCountFlagBits samples;
3505     VkImageTiling tiling;
3506     VkImageUsageFlags usage;
3507     VkSharingMode sharingMode;
3508     uint32_t queueFamilyIndexCount;
3509     PTR32 pQueueFamilyIndices;
3510     VkImageLayout initialLayout;
3511 } VkImageCreateInfo32;
3512
3513 typedef struct VkImageViewUsageCreateInfo32
3514 {
3515     VkStructureType sType;
3516     PTR32 pNext;
3517     VkImageUsageFlags usage;
3518 } VkImageViewUsageCreateInfo32;
3519 typedef VkImageViewUsageCreateInfo32 VkImageViewUsageCreateInfoKHR32;
3520
3521 typedef struct VkImageViewSlicedCreateInfoEXT32
3522 {
3523     VkStructureType sType;
3524     PTR32 pNext;
3525     uint32_t sliceOffset;
3526     uint32_t sliceCount;
3527 } VkImageViewSlicedCreateInfoEXT32;
3528
3529 typedef struct VkSamplerYcbcrConversionInfo32
3530 {
3531     VkStructureType sType;
3532     PTR32 pNext;
3533     VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) conversion;
3534 } VkSamplerYcbcrConversionInfo32;
3535 typedef VkSamplerYcbcrConversionInfo32 VkSamplerYcbcrConversionInfoKHR32;
3536
3537 typedef struct VkImageViewASTCDecodeModeEXT32
3538 {
3539     VkStructureType sType;
3540     PTR32 pNext;
3541     VkFormat decodeMode;
3542 } VkImageViewASTCDecodeModeEXT32;
3543
3544 typedef struct VkImageViewMinLodCreateInfoEXT32
3545 {
3546     VkStructureType sType;
3547     PTR32 pNext;
3548     float minLod;
3549 } VkImageViewMinLodCreateInfoEXT32;
3550
3551 typedef struct VkImageViewSampleWeightCreateInfoQCOM32
3552 {
3553     VkStructureType sType;
3554     PTR32 pNext;
3555     VkOffset2D filterCenter;
3556     VkExtent2D filterSize;
3557     uint32_t numPhases;
3558 } VkImageViewSampleWeightCreateInfoQCOM32;
3559
3560 typedef struct VkImageViewCreateInfo32
3561 {
3562     VkStructureType sType;
3563     PTR32 pNext;
3564     VkImageViewCreateFlags flags;
3565     VkImage DECLSPEC_ALIGN(8) image;
3566     VkImageViewType viewType;
3567     VkFormat format;
3568     VkComponentMapping components;
3569     VkImageSubresourceRange subresourceRange;
3570 } VkImageViewCreateInfo32;
3571
3572 typedef struct VkIndirectCommandsLayoutTokenNV32
3573 {
3574     VkStructureType sType;
3575     PTR32 pNext;
3576     VkIndirectCommandsTokenTypeNV tokenType;
3577     uint32_t stream;
3578     uint32_t offset;
3579     uint32_t vertexBindingUnit;
3580     VkBool32 vertexDynamicStride;
3581     VkPipelineLayout DECLSPEC_ALIGN(8) pushconstantPipelineLayout;
3582     VkShaderStageFlags pushconstantShaderStageFlags;
3583     uint32_t pushconstantOffset;
3584     uint32_t pushconstantSize;
3585     VkIndirectStateFlagsNV indirectStateFlags;
3586     uint32_t indexTypeCount;
3587     PTR32 pIndexTypes;
3588     PTR32 pIndexTypeValues;
3589 } VkIndirectCommandsLayoutTokenNV32;
3590
3591 typedef struct VkIndirectCommandsLayoutCreateInfoNV32
3592 {
3593     VkStructureType sType;
3594     PTR32 pNext;
3595     VkIndirectCommandsLayoutUsageFlagsNV flags;
3596     VkPipelineBindPoint pipelineBindPoint;
3597     uint32_t tokenCount;
3598     PTR32 pTokens;
3599     uint32_t streamCount;
3600     PTR32 pStreamStrides;
3601 } VkIndirectCommandsLayoutCreateInfoNV32;
3602
3603 typedef struct VkApplicationInfo32
3604 {
3605     VkStructureType sType;
3606     PTR32 pNext;
3607     PTR32 pApplicationName;
3608     uint32_t applicationVersion;
3609     PTR32 pEngineName;
3610     uint32_t engineVersion;
3611     uint32_t apiVersion;
3612 } VkApplicationInfo32;
3613
3614 typedef struct VkValidationFlagsEXT32
3615 {
3616     VkStructureType sType;
3617     PTR32 pNext;
3618     uint32_t disabledValidationCheckCount;
3619     PTR32 pDisabledValidationChecks;
3620 } VkValidationFlagsEXT32;
3621
3622 typedef struct VkValidationFeaturesEXT32
3623 {
3624     VkStructureType sType;
3625     PTR32 pNext;
3626     uint32_t enabledValidationFeatureCount;
3627     PTR32 pEnabledValidationFeatures;
3628     uint32_t disabledValidationFeatureCount;
3629     PTR32 pDisabledValidationFeatures;
3630 } VkValidationFeaturesEXT32;
3631
3632 typedef struct VkInstanceCreateInfo32
3633 {
3634     VkStructureType sType;
3635     PTR32 pNext;
3636     VkInstanceCreateFlags flags;
3637     PTR32 pApplicationInfo;
3638     uint32_t enabledLayerCount;
3639     PTR32 ppEnabledLayerNames;
3640     uint32_t enabledExtensionCount;
3641     PTR32 ppEnabledExtensionNames;
3642 } VkInstanceCreateInfo32;
3643
3644 typedef struct VkMicromapCreateInfoEXT32
3645 {
3646     VkStructureType sType;
3647     PTR32 pNext;
3648     VkMicromapCreateFlagsEXT createFlags;
3649     VkBuffer DECLSPEC_ALIGN(8) buffer;
3650     VkDeviceSize DECLSPEC_ALIGN(8) offset;
3651     VkDeviceSize DECLSPEC_ALIGN(8) size;
3652     VkMicromapTypeEXT type;
3653     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
3654 } VkMicromapCreateInfoEXT32;
3655
3656 typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV32
3657 {
3658     VkStructureType sType;
3659     PTR32 pNext;
3660     uint32_t id;
3661     uint32_t size;
3662     PTR32 pPrivateData;
3663 } VkOpticalFlowSessionCreatePrivateDataInfoNV32;
3664
3665 typedef struct VkOpticalFlowSessionCreateInfoNV32
3666 {
3667     VkStructureType sType;
3668     PTR32 pNext;
3669     uint32_t width;
3670     uint32_t height;
3671     VkFormat imageFormat;
3672     VkFormat flowVectorFormat;
3673     VkFormat costFormat;
3674     VkOpticalFlowGridSizeFlagsNV outputGridSize;
3675     VkOpticalFlowGridSizeFlagsNV hintGridSize;
3676     VkOpticalFlowPerformanceLevelNV performanceLevel;
3677     VkOpticalFlowSessionCreateFlagsNV flags;
3678 } VkOpticalFlowSessionCreateInfoNV32;
3679
3680 typedef struct VkPipelineCacheCreateInfo32
3681 {
3682     VkStructureType sType;
3683     PTR32 pNext;
3684     VkPipelineCacheCreateFlags flags;
3685     PTR32 initialDataSize;
3686     PTR32 pInitialData;
3687 } VkPipelineCacheCreateInfo32;
3688
3689 typedef struct VkPipelineLayoutCreateInfo32
3690 {
3691     VkStructureType sType;
3692     PTR32 pNext;
3693     VkPipelineLayoutCreateFlags flags;
3694     uint32_t setLayoutCount;
3695     PTR32 pSetLayouts;
3696     uint32_t pushConstantRangeCount;
3697     PTR32 pPushConstantRanges;
3698 } VkPipelineLayoutCreateInfo32;
3699
3700 typedef struct VkPrivateDataSlotCreateInfo32
3701 {
3702     VkStructureType sType;
3703     PTR32 pNext;
3704     VkPrivateDataSlotCreateFlags flags;
3705 } VkPrivateDataSlotCreateInfo32;
3706 typedef VkPrivateDataSlotCreateInfo32 VkPrivateDataSlotCreateInfoEXT32;
3707
3708 typedef struct VkQueryPoolPerformanceCreateInfoKHR32
3709 {
3710     VkStructureType sType;
3711     PTR32 pNext;
3712     uint32_t queueFamilyIndex;
3713     uint32_t counterIndexCount;
3714     PTR32 pCounterIndices;
3715 } VkQueryPoolPerformanceCreateInfoKHR32;
3716
3717 typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL32
3718 {
3719     VkStructureType sType;
3720     PTR32 pNext;
3721     VkQueryPoolSamplingModeINTEL performanceCountersSampling;
3722 } VkQueryPoolPerformanceQueryCreateInfoINTEL32;
3723 typedef VkQueryPoolPerformanceQueryCreateInfoINTEL32 VkQueryPoolCreateInfoINTEL32;
3724
3725 typedef struct VkQueryPoolCreateInfo32
3726 {
3727     VkStructureType sType;
3728     PTR32 pNext;
3729     VkQueryPoolCreateFlags flags;
3730     VkQueryType queryType;
3731     uint32_t queryCount;
3732     VkQueryPipelineStatisticFlags pipelineStatistics;
3733 } VkQueryPoolCreateInfo32;
3734
3735 typedef struct VkRayTracingShaderGroupCreateInfoKHR32
3736 {
3737     VkStructureType sType;
3738     PTR32 pNext;
3739     VkRayTracingShaderGroupTypeKHR type;
3740     uint32_t generalShader;
3741     uint32_t closestHitShader;
3742     uint32_t anyHitShader;
3743     uint32_t intersectionShader;
3744     PTR32 pShaderGroupCaptureReplayHandle;
3745 } VkRayTracingShaderGroupCreateInfoKHR32;
3746
3747 typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR32
3748 {
3749     VkStructureType sType;
3750     PTR32 pNext;
3751     uint32_t maxPipelineRayPayloadSize;
3752     uint32_t maxPipelineRayHitAttributeSize;
3753 } VkRayTracingPipelineInterfaceCreateInfoKHR32;
3754
3755 typedef struct VkRayTracingPipelineCreateInfoKHR32
3756 {
3757     VkStructureType sType;
3758     PTR32 pNext;
3759     VkPipelineCreateFlags flags;
3760     uint32_t stageCount;
3761     PTR32 pStages;
3762     uint32_t groupCount;
3763     PTR32 pGroups;
3764     uint32_t maxPipelineRayRecursionDepth;
3765     PTR32 pLibraryInfo;
3766     PTR32 pLibraryInterface;
3767     PTR32 pDynamicState;
3768     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3769     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3770     int32_t basePipelineIndex;
3771 } VkRayTracingPipelineCreateInfoKHR32;
3772
3773 typedef struct VkRayTracingShaderGroupCreateInfoNV32
3774 {
3775     VkStructureType sType;
3776     PTR32 pNext;
3777     VkRayTracingShaderGroupTypeKHR type;
3778     uint32_t generalShader;
3779     uint32_t closestHitShader;
3780     uint32_t anyHitShader;
3781     uint32_t intersectionShader;
3782 } VkRayTracingShaderGroupCreateInfoNV32;
3783
3784 typedef struct VkRayTracingPipelineCreateInfoNV32
3785 {
3786     VkStructureType sType;
3787     PTR32 pNext;
3788     VkPipelineCreateFlags flags;
3789     uint32_t stageCount;
3790     PTR32 pStages;
3791     uint32_t groupCount;
3792     PTR32 pGroups;
3793     uint32_t maxRecursionDepth;
3794     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3795     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3796     int32_t basePipelineIndex;
3797 } VkRayTracingPipelineCreateInfoNV32;
3798
3799 typedef struct VkSubpassDescription32
3800 {
3801     VkSubpassDescriptionFlags flags;
3802     VkPipelineBindPoint pipelineBindPoint;
3803     uint32_t inputAttachmentCount;
3804     PTR32 pInputAttachments;
3805     uint32_t colorAttachmentCount;
3806     PTR32 pColorAttachments;
3807     PTR32 pResolveAttachments;
3808     PTR32 pDepthStencilAttachment;
3809     uint32_t preserveAttachmentCount;
3810     PTR32 pPreserveAttachments;
3811 } VkSubpassDescription32;
3812
3813 typedef struct VkRenderPassMultiviewCreateInfo32
3814 {
3815     VkStructureType sType;
3816     PTR32 pNext;
3817     uint32_t subpassCount;
3818     PTR32 pViewMasks;
3819     uint32_t dependencyCount;
3820     PTR32 pViewOffsets;
3821     uint32_t correlationMaskCount;
3822     PTR32 pCorrelationMasks;
3823 } VkRenderPassMultiviewCreateInfo32;
3824 typedef VkRenderPassMultiviewCreateInfo32 VkRenderPassMultiviewCreateInfoKHR32;
3825
3826 typedef struct VkRenderPassInputAttachmentAspectCreateInfo32
3827 {
3828     VkStructureType sType;
3829     PTR32 pNext;
3830     uint32_t aspectReferenceCount;
3831     PTR32 pAspectReferences;
3832 } VkRenderPassInputAttachmentAspectCreateInfo32;
3833 typedef VkRenderPassInputAttachmentAspectCreateInfo32 VkRenderPassInputAttachmentAspectCreateInfoKHR32;
3834
3835 typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT32
3836 {
3837     VkStructureType sType;
3838     PTR32 pNext;
3839     VkAttachmentReference fragmentDensityMapAttachment;
3840 } VkRenderPassFragmentDensityMapCreateInfoEXT32;
3841
3842 typedef struct VkRenderPassCreateInfo32
3843 {
3844     VkStructureType sType;
3845     PTR32 pNext;
3846     VkRenderPassCreateFlags flags;
3847     uint32_t attachmentCount;
3848     PTR32 pAttachments;
3849     uint32_t subpassCount;
3850     PTR32 pSubpasses;
3851     uint32_t dependencyCount;
3852     PTR32 pDependencies;
3853 } VkRenderPassCreateInfo32;
3854
3855 typedef struct VkAttachmentDescriptionStencilLayout32
3856 {
3857     VkStructureType sType;
3858     PTR32 pNext;
3859     VkImageLayout stencilInitialLayout;
3860     VkImageLayout stencilFinalLayout;
3861 } VkAttachmentDescriptionStencilLayout32;
3862 typedef VkAttachmentDescriptionStencilLayout32 VkAttachmentDescriptionStencilLayoutKHR32;
3863
3864 typedef struct VkAttachmentDescription232
3865 {
3866     VkStructureType sType;
3867     PTR32 pNext;
3868     VkAttachmentDescriptionFlags flags;
3869     VkFormat format;
3870     VkSampleCountFlagBits samples;
3871     VkAttachmentLoadOp loadOp;
3872     VkAttachmentStoreOp storeOp;
3873     VkAttachmentLoadOp stencilLoadOp;
3874     VkAttachmentStoreOp stencilStoreOp;
3875     VkImageLayout initialLayout;
3876     VkImageLayout finalLayout;
3877 } VkAttachmentDescription232;
3878 typedef VkAttachmentDescription232 VkAttachmentDescription2KHR32;
3879
3880 typedef struct VkAttachmentReferenceStencilLayout32
3881 {
3882     VkStructureType sType;
3883     PTR32 pNext;
3884     VkImageLayout stencilLayout;
3885 } VkAttachmentReferenceStencilLayout32;
3886 typedef VkAttachmentReferenceStencilLayout32 VkAttachmentReferenceStencilLayoutKHR32;
3887
3888 typedef struct VkAttachmentReference232
3889 {
3890     VkStructureType sType;
3891     PTR32 pNext;
3892     uint32_t attachment;
3893     VkImageLayout layout;
3894     VkImageAspectFlags aspectMask;
3895 } VkAttachmentReference232;
3896 typedef VkAttachmentReference232 VkAttachmentReference2KHR32;
3897
3898 typedef struct VkSubpassDescriptionDepthStencilResolve32
3899 {
3900     VkStructureType sType;
3901     PTR32 pNext;
3902     VkResolveModeFlagBits depthResolveMode;
3903     VkResolveModeFlagBits stencilResolveMode;
3904     PTR32 pDepthStencilResolveAttachment;
3905 } VkSubpassDescriptionDepthStencilResolve32;
3906 typedef VkSubpassDescriptionDepthStencilResolve32 VkSubpassDescriptionDepthStencilResolveKHR32;
3907
3908 typedef struct VkFragmentShadingRateAttachmentInfoKHR32
3909 {
3910     VkStructureType sType;
3911     PTR32 pNext;
3912     PTR32 pFragmentShadingRateAttachment;
3913     VkExtent2D shadingRateAttachmentTexelSize;
3914 } VkFragmentShadingRateAttachmentInfoKHR32;
3915
3916 typedef struct VkRenderPassCreationControlEXT32
3917 {
3918     VkStructureType sType;
3919     PTR32 pNext;
3920     VkBool32 disallowMerging;
3921 } VkRenderPassCreationControlEXT32;
3922
3923 typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT32
3924 {
3925     VkStructureType sType;
3926     PTR32 pNext;
3927     PTR32 pSubpassFeedback;
3928 } VkRenderPassSubpassFeedbackCreateInfoEXT32;
3929
3930 typedef struct VkSubpassDescription232
3931 {
3932     VkStructureType sType;
3933     PTR32 pNext;
3934     VkSubpassDescriptionFlags flags;
3935     VkPipelineBindPoint pipelineBindPoint;
3936     uint32_t viewMask;
3937     uint32_t inputAttachmentCount;
3938     PTR32 pInputAttachments;
3939     uint32_t colorAttachmentCount;
3940     PTR32 pColorAttachments;
3941     PTR32 pResolveAttachments;
3942     PTR32 pDepthStencilAttachment;
3943     uint32_t preserveAttachmentCount;
3944     PTR32 pPreserveAttachments;
3945 } VkSubpassDescription232;
3946 typedef VkSubpassDescription232 VkSubpassDescription2KHR32;
3947
3948 typedef struct VkSubpassDependency232
3949 {
3950     VkStructureType sType;
3951     PTR32 pNext;
3952     uint32_t srcSubpass;
3953     uint32_t dstSubpass;
3954     VkPipelineStageFlags srcStageMask;
3955     VkPipelineStageFlags dstStageMask;
3956     VkAccessFlags srcAccessMask;
3957     VkAccessFlags dstAccessMask;
3958     VkDependencyFlags dependencyFlags;
3959     int32_t viewOffset;
3960 } VkSubpassDependency232;
3961 typedef VkSubpassDependency232 VkSubpassDependency2KHR32;
3962
3963 typedef struct VkRenderPassCreationFeedbackCreateInfoEXT32
3964 {
3965     VkStructureType sType;
3966     PTR32 pNext;
3967     PTR32 pRenderPassFeedback;
3968 } VkRenderPassCreationFeedbackCreateInfoEXT32;
3969
3970 typedef struct VkRenderPassCreateInfo232
3971 {
3972     VkStructureType sType;
3973     PTR32 pNext;
3974     VkRenderPassCreateFlags flags;
3975     uint32_t attachmentCount;
3976     PTR32 pAttachments;
3977     uint32_t subpassCount;
3978     PTR32 pSubpasses;
3979     uint32_t dependencyCount;
3980     PTR32 pDependencies;
3981     uint32_t correlatedViewMaskCount;
3982     PTR32 pCorrelatedViewMasks;
3983 } VkRenderPassCreateInfo232;
3984 typedef VkRenderPassCreateInfo232 VkRenderPassCreateInfo2KHR32;
3985
3986 typedef struct VkSamplerReductionModeCreateInfo32
3987 {
3988     VkStructureType sType;
3989     PTR32 pNext;
3990     VkSamplerReductionMode reductionMode;
3991 } VkSamplerReductionModeCreateInfo32;
3992 typedef VkSamplerReductionModeCreateInfo32 VkSamplerReductionModeCreateInfoEXT32;
3993
3994 typedef struct VkSamplerCustomBorderColorCreateInfoEXT32
3995 {
3996     VkStructureType sType;
3997     PTR32 pNext;
3998     VkClearColorValue customBorderColor;
3999     VkFormat format;
4000 } VkSamplerCustomBorderColorCreateInfoEXT32;
4001
4002 typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT32
4003 {
4004     VkStructureType sType;
4005     PTR32 pNext;
4006     VkComponentMapping components;
4007     VkBool32 srgb;
4008 } VkSamplerBorderColorComponentMappingCreateInfoEXT32;
4009
4010 typedef struct VkSamplerCreateInfo32
4011 {
4012     VkStructureType sType;
4013     PTR32 pNext;
4014     VkSamplerCreateFlags flags;
4015     VkFilter magFilter;
4016     VkFilter minFilter;
4017     VkSamplerMipmapMode mipmapMode;
4018     VkSamplerAddressMode addressModeU;
4019     VkSamplerAddressMode addressModeV;
4020     VkSamplerAddressMode addressModeW;
4021     float mipLodBias;
4022     VkBool32 anisotropyEnable;
4023     float maxAnisotropy;
4024     VkBool32 compareEnable;
4025     VkCompareOp compareOp;
4026     float minLod;
4027     float maxLod;
4028     VkBorderColor borderColor;
4029     VkBool32 unnormalizedCoordinates;
4030 } VkSamplerCreateInfo32;
4031
4032 typedef struct VkSamplerYcbcrConversionCreateInfo32
4033 {
4034     VkStructureType sType;
4035     PTR32 pNext;
4036     VkFormat format;
4037     VkSamplerYcbcrModelConversion ycbcrModel;
4038     VkSamplerYcbcrRange ycbcrRange;
4039     VkComponentMapping components;
4040     VkChromaLocation xChromaOffset;
4041     VkChromaLocation yChromaOffset;
4042     VkFilter chromaFilter;
4043     VkBool32 forceExplicitReconstruction;
4044 } VkSamplerYcbcrConversionCreateInfo32;
4045 typedef VkSamplerYcbcrConversionCreateInfo32 VkSamplerYcbcrConversionCreateInfoKHR32;
4046
4047 typedef struct VkExportSemaphoreCreateInfo32
4048 {
4049     VkStructureType sType;
4050     PTR32 pNext;
4051     VkExternalSemaphoreHandleTypeFlags handleTypes;
4052 } VkExportSemaphoreCreateInfo32;
4053 typedef VkExportSemaphoreCreateInfo32 VkExportSemaphoreCreateInfoKHR32;
4054
4055 typedef struct VkSemaphoreTypeCreateInfo32
4056 {
4057     VkStructureType sType;
4058     PTR32 pNext;
4059     VkSemaphoreType semaphoreType;
4060     uint64_t DECLSPEC_ALIGN(8) initialValue;
4061 } VkSemaphoreTypeCreateInfo32;
4062 typedef VkSemaphoreTypeCreateInfo32 VkSemaphoreTypeCreateInfoKHR32;
4063
4064 typedef struct VkQueryLowLatencySupportNV32
4065 {
4066     VkStructureType sType;
4067     PTR32 pNext;
4068     PTR32 pQueriedLowLatencyData;
4069 } VkQueryLowLatencySupportNV32;
4070
4071 typedef struct VkSemaphoreCreateInfo32
4072 {
4073     VkStructureType sType;
4074     PTR32 pNext;
4075     VkSemaphoreCreateFlags flags;
4076 } VkSemaphoreCreateInfo32;
4077
4078 typedef struct VkShaderCreateInfoEXT32
4079 {
4080     VkStructureType sType;
4081     PTR32 pNext;
4082     VkShaderCreateFlagsEXT flags;
4083     VkShaderStageFlagBits stage;
4084     VkShaderStageFlags nextStage;
4085     VkShaderCodeTypeEXT codeType;
4086     PTR32 codeSize;
4087     PTR32 pCode;
4088     PTR32 pName;
4089     uint32_t setLayoutCount;
4090     PTR32 pSetLayouts;
4091     uint32_t pushConstantRangeCount;
4092     PTR32 pPushConstantRanges;
4093     PTR32 pSpecializationInfo;
4094 } VkShaderCreateInfoEXT32;
4095
4096 typedef struct VkDeviceGroupSwapchainCreateInfoKHR32
4097 {
4098     VkStructureType sType;
4099     PTR32 pNext;
4100     VkDeviceGroupPresentModeFlagsKHR modes;
4101 } VkDeviceGroupSwapchainCreateInfoKHR32;
4102
4103 typedef struct VkSwapchainPresentBarrierCreateInfoNV32
4104 {
4105     VkStructureType sType;
4106     PTR32 pNext;
4107     VkBool32 presentBarrierEnable;
4108 } VkSwapchainPresentBarrierCreateInfoNV32;
4109
4110 typedef struct VkSwapchainPresentModesCreateInfoEXT32
4111 {
4112     VkStructureType sType;
4113     PTR32 pNext;
4114     uint32_t presentModeCount;
4115     PTR32 pPresentModes;
4116 } VkSwapchainPresentModesCreateInfoEXT32;
4117
4118 typedef struct VkSwapchainPresentScalingCreateInfoEXT32
4119 {
4120     VkStructureType sType;
4121     PTR32 pNext;
4122     VkPresentScalingFlagsEXT scalingBehavior;
4123     VkPresentGravityFlagsEXT presentGravityX;
4124     VkPresentGravityFlagsEXT presentGravityY;
4125 } VkSwapchainPresentScalingCreateInfoEXT32;
4126
4127 typedef struct VkSwapchainCreateInfoKHR32
4128 {
4129     VkStructureType sType;
4130     PTR32 pNext;
4131     VkSwapchainCreateFlagsKHR flags;
4132     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
4133     uint32_t minImageCount;
4134     VkFormat imageFormat;
4135     VkColorSpaceKHR imageColorSpace;
4136     VkExtent2D imageExtent;
4137     uint32_t imageArrayLayers;
4138     VkImageUsageFlags imageUsage;
4139     VkSharingMode imageSharingMode;
4140     uint32_t queueFamilyIndexCount;
4141     PTR32 pQueueFamilyIndices;
4142     VkSurfaceTransformFlagBitsKHR preTransform;
4143     VkCompositeAlphaFlagBitsKHR compositeAlpha;
4144     VkPresentModeKHR presentMode;
4145     VkBool32 clipped;
4146     VkSwapchainKHR DECLSPEC_ALIGN(8) oldSwapchain;
4147 } VkSwapchainCreateInfoKHR32;
4148
4149 typedef struct VkValidationCacheCreateInfoEXT32
4150 {
4151     VkStructureType sType;
4152     PTR32 pNext;
4153     VkValidationCacheCreateFlagsEXT flags;
4154     PTR32 initialDataSize;
4155     PTR32 pInitialData;
4156 } VkValidationCacheCreateInfoEXT32;
4157
4158 typedef struct VkWin32SurfaceCreateInfoKHR32
4159 {
4160     VkStructureType sType;
4161     PTR32 pNext;
4162     VkWin32SurfaceCreateFlagsKHR flags;
4163     PTR32 hinstance;
4164     PTR32 hwnd;
4165 } VkWin32SurfaceCreateInfoKHR32;
4166
4167 typedef struct VkDebugMarkerObjectNameInfoEXT32
4168 {
4169     VkStructureType sType;
4170     PTR32 pNext;
4171     VkDebugReportObjectTypeEXT objectType;
4172     uint64_t DECLSPEC_ALIGN(8) object;
4173     PTR32 pObjectName;
4174 } VkDebugMarkerObjectNameInfoEXT32;
4175
4176 typedef struct VkDebugMarkerObjectTagInfoEXT32
4177 {
4178     VkStructureType sType;
4179     PTR32 pNext;
4180     VkDebugReportObjectTypeEXT objectType;
4181     uint64_t DECLSPEC_ALIGN(8) object;
4182     uint64_t DECLSPEC_ALIGN(8) tagName;
4183     PTR32 tagSize;
4184     PTR32 pTag;
4185 } VkDebugMarkerObjectTagInfoEXT32;
4186
4187 typedef struct VkPhysicalDeviceGroupProperties32
4188 {
4189     VkStructureType sType;
4190     PTR32 pNext;
4191     uint32_t physicalDeviceCount;
4192     PTR32 physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
4193     VkBool32 subsetAllocation;
4194 } VkPhysicalDeviceGroupProperties32;
4195 typedef VkPhysicalDeviceGroupProperties32 VkPhysicalDeviceGroupPropertiesKHR32;
4196
4197 typedef struct VkPerformanceCounterKHR32
4198 {
4199     VkStructureType sType;
4200     PTR32 pNext;
4201     VkPerformanceCounterUnitKHR unit;
4202     VkPerformanceCounterScopeKHR scope;
4203     VkPerformanceCounterStorageKHR storage;
4204     uint8_t uuid[VK_UUID_SIZE];
4205 } VkPerformanceCounterKHR32;
4206
4207 typedef struct VkPerformanceCounterDescriptionKHR32
4208 {
4209     VkStructureType sType;
4210     PTR32 pNext;
4211     VkPerformanceCounterDescriptionFlagsKHR flags;
4212     char name[VK_MAX_DESCRIPTION_SIZE];
4213     char category[VK_MAX_DESCRIPTION_SIZE];
4214     char description[VK_MAX_DESCRIPTION_SIZE];
4215 } VkPerformanceCounterDescriptionKHR32;
4216
4217 typedef struct VkMappedMemoryRange32
4218 {
4219     VkStructureType sType;
4220     PTR32 pNext;
4221     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
4222     VkDeviceSize DECLSPEC_ALIGN(8) offset;
4223     VkDeviceSize DECLSPEC_ALIGN(8) size;
4224 } VkMappedMemoryRange32;
4225
4226 typedef struct VkAccelerationStructureBuildSizesInfoKHR32
4227 {
4228     VkStructureType sType;
4229     PTR32 pNext;
4230     VkDeviceSize DECLSPEC_ALIGN(8) accelerationStructureSize;
4231     VkDeviceSize DECLSPEC_ALIGN(8) updateScratchSize;
4232     VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
4233 } VkAccelerationStructureBuildSizesInfoKHR32;
4234
4235 typedef struct VkAccelerationStructureDeviceAddressInfoKHR32
4236 {
4237     VkStructureType sType;
4238     PTR32 pNext;
4239     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
4240 } VkAccelerationStructureDeviceAddressInfoKHR32;
4241
4242 typedef struct VkAccelerationStructureMemoryRequirementsInfoNV32
4243 {
4244     VkStructureType sType;
4245     PTR32 pNext;
4246     VkAccelerationStructureMemoryRequirementsTypeNV type;
4247     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
4248 } VkAccelerationStructureMemoryRequirementsInfoNV32;
4249
4250 typedef struct VkMemoryRequirements32
4251 {
4252     VkDeviceSize DECLSPEC_ALIGN(8) size;
4253     VkDeviceSize DECLSPEC_ALIGN(8) alignment;
4254     uint32_t memoryTypeBits;
4255 } VkMemoryRequirements32;
4256
4257
4258 typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT32
4259 {
4260     VkStructureType sType;
4261     PTR32 pNext;
4262     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
4263     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructureNV;
4264 } VkAccelerationStructureCaptureDescriptorDataInfoEXT32;
4265
4266 typedef struct VkBufferDeviceAddressInfo32
4267 {
4268     VkStructureType sType;
4269     PTR32 pNext;
4270     VkBuffer DECLSPEC_ALIGN(8) buffer;
4271 } VkBufferDeviceAddressInfo32;
4272 typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoKHR32;
4273 typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoEXT32;
4274
4275 typedef struct VkBufferMemoryRequirementsInfo232
4276 {
4277     VkStructureType sType;
4278     PTR32 pNext;
4279     VkBuffer DECLSPEC_ALIGN(8) buffer;
4280 } VkBufferMemoryRequirementsInfo232;
4281 typedef VkBufferMemoryRequirementsInfo232 VkBufferMemoryRequirementsInfo2KHR32;
4282
4283 typedef struct VkMemoryDedicatedRequirements32
4284 {
4285     VkStructureType sType;
4286     PTR32 pNext;
4287     VkBool32 prefersDedicatedAllocation;
4288     VkBool32 requiresDedicatedAllocation;
4289 } VkMemoryDedicatedRequirements32;
4290 typedef VkMemoryDedicatedRequirements32 VkMemoryDedicatedRequirementsKHR32;
4291
4292 typedef struct VkMemoryRequirements232
4293 {
4294     VkStructureType sType;
4295     PTR32 pNext;
4296     VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
4297 } VkMemoryRequirements232;
4298 typedef VkMemoryRequirements232 VkMemoryRequirements2KHR32;
4299
4300 typedef struct VkBufferCaptureDescriptorDataInfoEXT32
4301 {
4302     VkStructureType sType;
4303     PTR32 pNext;
4304     VkBuffer DECLSPEC_ALIGN(8) buffer;
4305 } VkBufferCaptureDescriptorDataInfoEXT32;
4306
4307 typedef struct VkCalibratedTimestampInfoEXT32
4308 {
4309     VkStructureType sType;
4310     PTR32 pNext;
4311     VkTimeDomainEXT timeDomain;
4312 } VkCalibratedTimestampInfoEXT32;
4313
4314 typedef struct VkDescriptorAddressInfoEXT32
4315 {
4316     VkStructureType sType;
4317     PTR32 pNext;
4318     VkDeviceAddress DECLSPEC_ALIGN(8) address;
4319     VkDeviceSize DECLSPEC_ALIGN(8) range;
4320     VkFormat format;
4321 } VkDescriptorAddressInfoEXT32;
4322
4323 typedef union VkDescriptorDataEXT32
4324 {
4325     PTR32 pSampler;
4326     PTR32 pCombinedImageSampler;
4327     PTR32 pInputAttachmentImage;
4328     PTR32 pSampledImage;
4329     PTR32 pStorageImage;
4330     PTR32 pUniformTexelBuffer;
4331     PTR32 pStorageTexelBuffer;
4332     PTR32 pUniformBuffer;
4333     PTR32 pStorageBuffer;
4334     VkDeviceAddress DECLSPEC_ALIGN(8) accelerationStructure;
4335 } VkDescriptorDataEXT32;
4336
4337 typedef struct VkDescriptorGetInfoEXT32
4338 {
4339     VkStructureType sType;
4340     PTR32 pNext;
4341     VkDescriptorType type;
4342     VkDescriptorDataEXT32 DECLSPEC_ALIGN(8) data;
4343 } VkDescriptorGetInfoEXT32;
4344
4345 typedef struct VkDescriptorSetBindingReferenceVALVE32
4346 {
4347     VkStructureType sType;
4348     PTR32 pNext;
4349     VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
4350     uint32_t binding;
4351 } VkDescriptorSetBindingReferenceVALVE32;
4352
4353 typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE32
4354 {
4355     VkStructureType sType;
4356     PTR32 pNext;
4357     PTR32 descriptorOffset;
4358     uint32_t descriptorSize;
4359 } VkDescriptorSetLayoutHostMappingInfoVALVE32;
4360
4361 typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport32
4362 {
4363     VkStructureType sType;
4364     PTR32 pNext;
4365     uint32_t maxVariableDescriptorCount;
4366 } VkDescriptorSetVariableDescriptorCountLayoutSupport32;
4367 typedef VkDescriptorSetVariableDescriptorCountLayoutSupport32 VkDescriptorSetVariableDescriptorCountLayoutSupportEXT32;
4368
4369 typedef struct VkDescriptorSetLayoutSupport32
4370 {
4371     VkStructureType sType;
4372     PTR32 pNext;
4373     VkBool32 supported;
4374 } VkDescriptorSetLayoutSupport32;
4375 typedef VkDescriptorSetLayoutSupport32 VkDescriptorSetLayoutSupportKHR32;
4376
4377 typedef struct VkAccelerationStructureVersionInfoKHR32
4378 {
4379     VkStructureType sType;
4380     PTR32 pNext;
4381     PTR32 pVersionData;
4382 } VkAccelerationStructureVersionInfoKHR32;
4383
4384 typedef struct VkDeviceBufferMemoryRequirements32
4385 {
4386     VkStructureType sType;
4387     PTR32 pNext;
4388     PTR32 pCreateInfo;
4389 } VkDeviceBufferMemoryRequirements32;
4390 typedef VkDeviceBufferMemoryRequirements32 VkDeviceBufferMemoryRequirementsKHR32;
4391
4392 typedef struct VkDeviceFaultCountsEXT32
4393 {
4394     VkStructureType sType;
4395     PTR32 pNext;
4396     uint32_t addressInfoCount;
4397     uint32_t vendorInfoCount;
4398     VkDeviceSize DECLSPEC_ALIGN(8) vendorBinarySize;
4399 } VkDeviceFaultCountsEXT32;
4400
4401 typedef struct VkDeviceFaultAddressInfoEXT32
4402 {
4403     VkDeviceFaultAddressTypeEXT addressType;
4404     VkDeviceAddress DECLSPEC_ALIGN(8) reportedAddress;
4405     VkDeviceSize DECLSPEC_ALIGN(8) addressPrecision;
4406 } VkDeviceFaultAddressInfoEXT32;
4407
4408 typedef struct VkDeviceFaultVendorInfoEXT32
4409 {
4410     char description[VK_MAX_DESCRIPTION_SIZE];
4411     uint64_t DECLSPEC_ALIGN(8) vendorFaultCode;
4412     uint64_t DECLSPEC_ALIGN(8) vendorFaultData;
4413 } VkDeviceFaultVendorInfoEXT32;
4414
4415 typedef struct VkDeviceFaultInfoEXT32
4416 {
4417     VkStructureType sType;
4418     PTR32 pNext;
4419     char description[VK_MAX_DESCRIPTION_SIZE];
4420     PTR32 pAddressInfos;
4421     PTR32 pVendorInfos;
4422     PTR32 pVendorBinaryData;
4423 } VkDeviceFaultInfoEXT32;
4424
4425 typedef struct VkDeviceGroupPresentCapabilitiesKHR32
4426 {
4427     VkStructureType sType;
4428     PTR32 pNext;
4429     uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
4430     VkDeviceGroupPresentModeFlagsKHR modes;
4431 } VkDeviceGroupPresentCapabilitiesKHR32;
4432
4433 typedef struct VkDeviceImageMemoryRequirements32
4434 {
4435     VkStructureType sType;
4436     PTR32 pNext;
4437     PTR32 pCreateInfo;
4438     VkImageAspectFlagBits planeAspect;
4439 } VkDeviceImageMemoryRequirements32;
4440 typedef VkDeviceImageMemoryRequirements32 VkDeviceImageMemoryRequirementsKHR32;
4441
4442 typedef struct VkSparseImageMemoryRequirements32
4443 {
4444     VkSparseImageFormatProperties formatProperties;
4445     uint32_t imageMipTailFirstLod;
4446     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailSize;
4447     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailOffset;
4448     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailStride;
4449 } VkSparseImageMemoryRequirements32;
4450
4451 typedef struct VkSparseImageMemoryRequirements232
4452 {
4453     VkStructureType sType;
4454     PTR32 pNext;
4455     VkSparseImageMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
4456 } VkSparseImageMemoryRequirements232;
4457 typedef VkSparseImageMemoryRequirements232 VkSparseImageMemoryRequirements2KHR32;
4458
4459 typedef struct VkImageSubresource2KHR32
4460 {
4461     VkStructureType sType;
4462     PTR32 pNext;
4463     VkImageSubresource imageSubresource;
4464 } VkImageSubresource2KHR32;
4465 typedef VkImageSubresource2KHR32 VkImageSubresource2EXT32;
4466
4467 typedef struct VkDeviceImageSubresourceInfoKHR32
4468 {
4469     VkStructureType sType;
4470     PTR32 pNext;
4471     PTR32 pCreateInfo;
4472     PTR32 pSubresource;
4473 } VkDeviceImageSubresourceInfoKHR32;
4474
4475 typedef struct VkSubresourceLayout32
4476 {
4477     VkDeviceSize DECLSPEC_ALIGN(8) offset;
4478     VkDeviceSize DECLSPEC_ALIGN(8) size;
4479     VkDeviceSize DECLSPEC_ALIGN(8) rowPitch;
4480     VkDeviceSize DECLSPEC_ALIGN(8) arrayPitch;
4481     VkDeviceSize DECLSPEC_ALIGN(8) depthPitch;
4482 } VkSubresourceLayout32;
4483
4484 typedef struct VkSubresourceHostMemcpySizeEXT32
4485 {
4486     VkStructureType sType;
4487     PTR32 pNext;
4488     VkDeviceSize DECLSPEC_ALIGN(8) size;
4489 } VkSubresourceHostMemcpySizeEXT32;
4490
4491 typedef struct VkImageCompressionPropertiesEXT32
4492 {
4493     VkStructureType sType;
4494     PTR32 pNext;
4495     VkImageCompressionFlagsEXT imageCompressionFlags;
4496     VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags;
4497 } VkImageCompressionPropertiesEXT32;
4498
4499 typedef struct VkSubresourceLayout2KHR32
4500 {
4501     VkStructureType sType;
4502     PTR32 pNext;
4503     VkSubresourceLayout32 DECLSPEC_ALIGN(8) subresourceLayout;
4504 } VkSubresourceLayout2KHR32;
4505 typedef VkSubresourceLayout2KHR32 VkSubresourceLayout2EXT32;
4506
4507 typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo32
4508 {
4509     VkStructureType sType;
4510     PTR32 pNext;
4511     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
4512 } VkDeviceMemoryOpaqueCaptureAddressInfo32;
4513 typedef VkDeviceMemoryOpaqueCaptureAddressInfo32 VkDeviceMemoryOpaqueCaptureAddressInfoKHR32;
4514
4515 typedef struct VkMicromapVersionInfoEXT32
4516 {
4517     VkStructureType sType;
4518     PTR32 pNext;
4519     PTR32 pVersionData;
4520 } VkMicromapVersionInfoEXT32;
4521
4522 typedef struct VkDeviceQueueInfo232
4523 {
4524     VkStructureType sType;
4525     PTR32 pNext;
4526     VkDeviceQueueCreateFlags flags;
4527     uint32_t queueFamilyIndex;
4528     uint32_t queueIndex;
4529 } VkDeviceQueueInfo232;
4530
4531 typedef struct VkTilePropertiesQCOM32
4532 {
4533     VkStructureType sType;
4534     PTR32 pNext;
4535     VkExtent3D tileSize;
4536     VkExtent2D apronSize;
4537     VkOffset2D origin;
4538 } VkTilePropertiesQCOM32;
4539
4540 typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV32
4541 {
4542     VkStructureType sType;
4543     PTR32 pNext;
4544     VkPipelineBindPoint pipelineBindPoint;
4545     VkPipeline DECLSPEC_ALIGN(8) pipeline;
4546     VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
4547     uint32_t maxSequencesCount;
4548 } VkGeneratedCommandsMemoryRequirementsInfoNV32;
4549
4550 typedef struct VkImagePlaneMemoryRequirementsInfo32
4551 {
4552     VkStructureType sType;
4553     PTR32 pNext;
4554     VkImageAspectFlagBits planeAspect;
4555 } VkImagePlaneMemoryRequirementsInfo32;
4556 typedef VkImagePlaneMemoryRequirementsInfo32 VkImagePlaneMemoryRequirementsInfoKHR32;
4557
4558 typedef struct VkImageMemoryRequirementsInfo232
4559 {
4560     VkStructureType sType;
4561     PTR32 pNext;
4562     VkImage DECLSPEC_ALIGN(8) image;
4563 } VkImageMemoryRequirementsInfo232;
4564 typedef VkImageMemoryRequirementsInfo232 VkImageMemoryRequirementsInfo2KHR32;
4565
4566 typedef struct VkImageCaptureDescriptorDataInfoEXT32
4567 {
4568     VkStructureType sType;
4569     PTR32 pNext;
4570     VkImage DECLSPEC_ALIGN(8) image;
4571 } VkImageCaptureDescriptorDataInfoEXT32;
4572
4573 typedef struct VkImageSparseMemoryRequirementsInfo232
4574 {
4575     VkStructureType sType;
4576     PTR32 pNext;
4577     VkImage DECLSPEC_ALIGN(8) image;
4578 } VkImageSparseMemoryRequirementsInfo232;
4579 typedef VkImageSparseMemoryRequirementsInfo232 VkImageSparseMemoryRequirementsInfo2KHR32;
4580
4581 typedef struct VkImageViewAddressPropertiesNVX32
4582 {
4583     VkStructureType sType;
4584     PTR32 pNext;
4585     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
4586     VkDeviceSize DECLSPEC_ALIGN(8) size;
4587 } VkImageViewAddressPropertiesNVX32;
4588
4589 typedef struct VkImageViewHandleInfoNVX32
4590 {
4591     VkStructureType sType;
4592     PTR32 pNext;
4593     VkImageView DECLSPEC_ALIGN(8) imageView;
4594     VkDescriptorType descriptorType;
4595     VkSampler DECLSPEC_ALIGN(8) sampler;
4596 } VkImageViewHandleInfoNVX32;
4597
4598 typedef struct VkImageViewCaptureDescriptorDataInfoEXT32
4599 {
4600     VkStructureType sType;
4601     PTR32 pNext;
4602     VkImageView DECLSPEC_ALIGN(8) imageView;
4603 } VkImageViewCaptureDescriptorDataInfoEXT32;
4604
4605 typedef struct VkMemoryHostPointerPropertiesEXT32
4606 {
4607     VkStructureType sType;
4608     PTR32 pNext;
4609     uint32_t memoryTypeBits;
4610 } VkMemoryHostPointerPropertiesEXT32;
4611
4612 typedef struct VkMicromapBuildSizesInfoEXT32
4613 {
4614     VkStructureType sType;
4615     PTR32 pNext;
4616     VkDeviceSize DECLSPEC_ALIGN(8) micromapSize;
4617     VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
4618     VkBool32 discardable;
4619 } VkMicromapBuildSizesInfoEXT32;
4620
4621 typedef union VkPerformanceValueDataINTEL32
4622 {
4623     uint32_t value32;
4624     uint64_t DECLSPEC_ALIGN(8) value64;
4625     float valueFloat;
4626     VkBool32 valueBool;
4627     PTR32 valueString;
4628 } VkPerformanceValueDataINTEL32;
4629
4630 typedef struct VkPerformanceValueINTEL32
4631 {
4632     VkPerformanceValueTypeINTEL type;
4633     VkPerformanceValueDataINTEL32 DECLSPEC_ALIGN(8) data;
4634 } VkPerformanceValueINTEL32;
4635
4636 typedef struct VkCooperativeMatrixPropertiesKHR32
4637 {
4638     VkStructureType sType;
4639     PTR32 pNext;
4640     uint32_t MSize;
4641     uint32_t NSize;
4642     uint32_t KSize;
4643     VkComponentTypeKHR AType;
4644     VkComponentTypeKHR BType;
4645     VkComponentTypeKHR CType;
4646     VkComponentTypeKHR ResultType;
4647     VkBool32 saturatingAccumulation;
4648     VkScopeKHR scope;
4649 } VkCooperativeMatrixPropertiesKHR32;
4650
4651 typedef struct VkCooperativeMatrixPropertiesNV32
4652 {
4653     VkStructureType sType;
4654     PTR32 pNext;
4655     uint32_t MSize;
4656     uint32_t NSize;
4657     uint32_t KSize;
4658     VkComponentTypeNV AType;
4659     VkComponentTypeNV BType;
4660     VkComponentTypeNV CType;
4661     VkComponentTypeNV DType;
4662     VkScopeNV scope;
4663 } VkCooperativeMatrixPropertiesNV32;
4664
4665 typedef struct VkPhysicalDeviceExternalBufferInfo32
4666 {
4667     VkStructureType sType;
4668     PTR32 pNext;
4669     VkBufferCreateFlags flags;
4670     VkBufferUsageFlags usage;
4671     VkExternalMemoryHandleTypeFlagBits handleType;
4672 } VkPhysicalDeviceExternalBufferInfo32;
4673 typedef VkPhysicalDeviceExternalBufferInfo32 VkPhysicalDeviceExternalBufferInfoKHR32;
4674
4675 typedef struct VkExternalBufferProperties32
4676 {
4677     VkStructureType sType;
4678     PTR32 pNext;
4679     VkExternalMemoryProperties externalMemoryProperties;
4680 } VkExternalBufferProperties32;
4681 typedef VkExternalBufferProperties32 VkExternalBufferPropertiesKHR32;
4682
4683 typedef struct VkPhysicalDeviceExternalFenceInfo32
4684 {
4685     VkStructureType sType;
4686     PTR32 pNext;
4687     VkExternalFenceHandleTypeFlagBits handleType;
4688 } VkPhysicalDeviceExternalFenceInfo32;
4689 typedef VkPhysicalDeviceExternalFenceInfo32 VkPhysicalDeviceExternalFenceInfoKHR32;
4690
4691 typedef struct VkExternalFenceProperties32
4692 {
4693     VkStructureType sType;
4694     PTR32 pNext;
4695     VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
4696     VkExternalFenceHandleTypeFlags compatibleHandleTypes;
4697     VkExternalFenceFeatureFlags externalFenceFeatures;
4698 } VkExternalFenceProperties32;
4699 typedef VkExternalFenceProperties32 VkExternalFencePropertiesKHR32;
4700
4701 typedef struct VkPhysicalDeviceExternalSemaphoreInfo32
4702 {
4703     VkStructureType sType;
4704     PTR32 pNext;
4705     VkExternalSemaphoreHandleTypeFlagBits handleType;
4706 } VkPhysicalDeviceExternalSemaphoreInfo32;
4707 typedef VkPhysicalDeviceExternalSemaphoreInfo32 VkPhysicalDeviceExternalSemaphoreInfoKHR32;
4708
4709 typedef struct VkExternalSemaphoreProperties32
4710 {
4711     VkStructureType sType;
4712     PTR32 pNext;
4713     VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
4714     VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
4715     VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
4716 } VkExternalSemaphoreProperties32;
4717 typedef VkExternalSemaphoreProperties32 VkExternalSemaphorePropertiesKHR32;
4718
4719 typedef struct VkSubpassResolvePerformanceQueryEXT32
4720 {
4721     VkStructureType sType;
4722     PTR32 pNext;
4723     VkBool32 optimal;
4724 } VkSubpassResolvePerformanceQueryEXT32;
4725
4726 typedef struct VkFormatProperties332
4727 {
4728     VkStructureType sType;
4729     PTR32 pNext;
4730     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingFeatures;
4731     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingFeatures;
4732     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) bufferFeatures;
4733 } VkFormatProperties332;
4734 typedef VkFormatProperties332 VkFormatProperties3KHR32;
4735
4736 typedef struct VkFormatProperties232
4737 {
4738     VkStructureType sType;
4739     PTR32 pNext;
4740     VkFormatProperties formatProperties;
4741 } VkFormatProperties232;
4742 typedef VkFormatProperties232 VkFormatProperties2KHR32;
4743
4744 typedef struct VkPhysicalDeviceFragmentShadingRateKHR32
4745 {
4746     VkStructureType sType;
4747     PTR32 pNext;
4748     VkSampleCountFlags sampleCounts;
4749     VkExtent2D fragmentSize;
4750 } VkPhysicalDeviceFragmentShadingRateKHR32;
4751
4752 typedef struct VkImageFormatProperties32
4753 {
4754     VkExtent3D maxExtent;
4755     uint32_t maxMipLevels;
4756     uint32_t maxArrayLayers;
4757     VkSampleCountFlags sampleCounts;
4758     VkDeviceSize DECLSPEC_ALIGN(8) maxResourceSize;
4759 } VkImageFormatProperties32;
4760
4761 typedef struct VkPhysicalDeviceExternalImageFormatInfo32
4762 {
4763     VkStructureType sType;
4764     PTR32 pNext;
4765     VkExternalMemoryHandleTypeFlagBits handleType;
4766 } VkPhysicalDeviceExternalImageFormatInfo32;
4767 typedef VkPhysicalDeviceExternalImageFormatInfo32 VkPhysicalDeviceExternalImageFormatInfoKHR32;
4768
4769 typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT32
4770 {
4771     VkStructureType sType;
4772     PTR32 pNext;
4773     VkImageViewType imageViewType;
4774 } VkPhysicalDeviceImageViewImageFormatInfoEXT32;
4775
4776 typedef struct VkPhysicalDeviceImageFormatInfo232
4777 {
4778     VkStructureType sType;
4779     PTR32 pNext;
4780     VkFormat format;
4781     VkImageType type;
4782     VkImageTiling tiling;
4783     VkImageUsageFlags usage;
4784     VkImageCreateFlags flags;
4785 } VkPhysicalDeviceImageFormatInfo232;
4786 typedef VkPhysicalDeviceImageFormatInfo232 VkPhysicalDeviceImageFormatInfo2KHR32;
4787
4788 typedef struct VkExternalImageFormatProperties32
4789 {
4790     VkStructureType sType;
4791     PTR32 pNext;
4792     VkExternalMemoryProperties externalMemoryProperties;
4793 } VkExternalImageFormatProperties32;
4794 typedef VkExternalImageFormatProperties32 VkExternalImageFormatPropertiesKHR32;
4795
4796 typedef struct VkSamplerYcbcrConversionImageFormatProperties32
4797 {
4798     VkStructureType sType;
4799     PTR32 pNext;
4800     uint32_t combinedImageSamplerDescriptorCount;
4801 } VkSamplerYcbcrConversionImageFormatProperties32;
4802 typedef VkSamplerYcbcrConversionImageFormatProperties32 VkSamplerYcbcrConversionImageFormatPropertiesKHR32;
4803
4804 typedef struct VkTextureLODGatherFormatPropertiesAMD32
4805 {
4806     VkStructureType sType;
4807     PTR32 pNext;
4808     VkBool32 supportsTextureGatherLODBiasAMD;
4809 } VkTextureLODGatherFormatPropertiesAMD32;
4810
4811 typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT32
4812 {
4813     VkStructureType sType;
4814     PTR32 pNext;
4815     VkBool32 filterCubic;
4816     VkBool32 filterCubicMinmax;
4817 } VkFilterCubicImageViewImageFormatPropertiesEXT32;
4818
4819 typedef struct VkHostImageCopyDevicePerformanceQueryEXT32
4820 {
4821     VkStructureType sType;
4822     PTR32 pNext;
4823     VkBool32 optimalDeviceAccess;
4824     VkBool32 identicalMemoryLayout;
4825 } VkHostImageCopyDevicePerformanceQueryEXT32;
4826
4827 typedef struct VkImageFormatProperties232
4828 {
4829     VkStructureType sType;
4830     PTR32 pNext;
4831     VkImageFormatProperties32 DECLSPEC_ALIGN(8) imageFormatProperties;
4832 } VkImageFormatProperties232;
4833 typedef VkImageFormatProperties232 VkImageFormatProperties2KHR32;
4834
4835 typedef struct VkMemoryHeap32
4836 {
4837     VkDeviceSize DECLSPEC_ALIGN(8) size;
4838     VkMemoryHeapFlags flags;
4839 } VkMemoryHeap32;
4840
4841 typedef struct VkPhysicalDeviceMemoryProperties32
4842 {
4843     uint32_t memoryTypeCount;
4844     VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
4845     uint32_t memoryHeapCount;
4846     VkMemoryHeap32 DECLSPEC_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS];
4847 } VkPhysicalDeviceMemoryProperties32;
4848
4849 typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT32
4850 {
4851     VkStructureType sType;
4852     PTR32 pNext;
4853     VkDeviceSize DECLSPEC_ALIGN(8) heapBudget[VK_MAX_MEMORY_HEAPS];
4854     VkDeviceSize DECLSPEC_ALIGN(8) heapUsage[VK_MAX_MEMORY_HEAPS];
4855 } VkPhysicalDeviceMemoryBudgetPropertiesEXT32;
4856
4857 typedef struct VkPhysicalDeviceMemoryProperties232
4858 {
4859     VkStructureType sType;
4860     PTR32 pNext;
4861     VkPhysicalDeviceMemoryProperties32 DECLSPEC_ALIGN(8) memoryProperties;
4862 } VkPhysicalDeviceMemoryProperties232;
4863 typedef VkPhysicalDeviceMemoryProperties232 VkPhysicalDeviceMemoryProperties2KHR32;
4864
4865 typedef struct VkMultisamplePropertiesEXT32
4866 {
4867     VkStructureType sType;
4868     PTR32 pNext;
4869     VkExtent2D maxSampleLocationGridSize;
4870 } VkMultisamplePropertiesEXT32;
4871
4872 typedef struct VkOpticalFlowImageFormatPropertiesNV32
4873 {
4874     VkStructureType sType;
4875     PTR32 pNext;
4876     VkFormat format;
4877 } VkOpticalFlowImageFormatPropertiesNV32;
4878
4879 typedef struct VkPhysicalDeviceLimits32
4880 {
4881     uint32_t maxImageDimension1D;
4882     uint32_t maxImageDimension2D;
4883     uint32_t maxImageDimension3D;
4884     uint32_t maxImageDimensionCube;
4885     uint32_t maxImageArrayLayers;
4886     uint32_t maxTexelBufferElements;
4887     uint32_t maxUniformBufferRange;
4888     uint32_t maxStorageBufferRange;
4889     uint32_t maxPushConstantsSize;
4890     uint32_t maxMemoryAllocationCount;
4891     uint32_t maxSamplerAllocationCount;
4892     VkDeviceSize DECLSPEC_ALIGN(8) bufferImageGranularity;
4893     VkDeviceSize DECLSPEC_ALIGN(8) sparseAddressSpaceSize;
4894     uint32_t maxBoundDescriptorSets;
4895     uint32_t maxPerStageDescriptorSamplers;
4896     uint32_t maxPerStageDescriptorUniformBuffers;
4897     uint32_t maxPerStageDescriptorStorageBuffers;
4898     uint32_t maxPerStageDescriptorSampledImages;
4899     uint32_t maxPerStageDescriptorStorageImages;
4900     uint32_t maxPerStageDescriptorInputAttachments;
4901     uint32_t maxPerStageResources;
4902     uint32_t maxDescriptorSetSamplers;
4903     uint32_t maxDescriptorSetUniformBuffers;
4904     uint32_t maxDescriptorSetUniformBuffersDynamic;
4905     uint32_t maxDescriptorSetStorageBuffers;
4906     uint32_t maxDescriptorSetStorageBuffersDynamic;
4907     uint32_t maxDescriptorSetSampledImages;
4908     uint32_t maxDescriptorSetStorageImages;
4909     uint32_t maxDescriptorSetInputAttachments;
4910     uint32_t maxVertexInputAttributes;
4911     uint32_t maxVertexInputBindings;
4912     uint32_t maxVertexInputAttributeOffset;
4913     uint32_t maxVertexInputBindingStride;
4914     uint32_t maxVertexOutputComponents;
4915     uint32_t maxTessellationGenerationLevel;
4916     uint32_t maxTessellationPatchSize;
4917     uint32_t maxTessellationControlPerVertexInputComponents;
4918     uint32_t maxTessellationControlPerVertexOutputComponents;
4919     uint32_t maxTessellationControlPerPatchOutputComponents;
4920     uint32_t maxTessellationControlTotalOutputComponents;
4921     uint32_t maxTessellationEvaluationInputComponents;
4922     uint32_t maxTessellationEvaluationOutputComponents;
4923     uint32_t maxGeometryShaderInvocations;
4924     uint32_t maxGeometryInputComponents;
4925     uint32_t maxGeometryOutputComponents;
4926     uint32_t maxGeometryOutputVertices;
4927     uint32_t maxGeometryTotalOutputComponents;
4928     uint32_t maxFragmentInputComponents;
4929     uint32_t maxFragmentOutputAttachments;
4930     uint32_t maxFragmentDualSrcAttachments;
4931     uint32_t maxFragmentCombinedOutputResources;
4932     uint32_t maxComputeSharedMemorySize;
4933     uint32_t maxComputeWorkGroupCount[3];
4934     uint32_t maxComputeWorkGroupInvocations;
4935     uint32_t maxComputeWorkGroupSize[3];
4936     uint32_t subPixelPrecisionBits;
4937     uint32_t subTexelPrecisionBits;
4938     uint32_t mipmapPrecisionBits;
4939     uint32_t maxDrawIndexedIndexValue;
4940     uint32_t maxDrawIndirectCount;
4941     float maxSamplerLodBias;
4942     float maxSamplerAnisotropy;
4943     uint32_t maxViewports;
4944     uint32_t maxViewportDimensions[2];
4945     float viewportBoundsRange[2];
4946     uint32_t viewportSubPixelBits;
4947     PTR32 minMemoryMapAlignment;
4948     VkDeviceSize DECLSPEC_ALIGN(8) minTexelBufferOffsetAlignment;
4949     VkDeviceSize DECLSPEC_ALIGN(8) minUniformBufferOffsetAlignment;
4950     VkDeviceSize DECLSPEC_ALIGN(8) minStorageBufferOffsetAlignment;
4951     int32_t minTexelOffset;
4952     uint32_t maxTexelOffset;
4953     int32_t minTexelGatherOffset;
4954     uint32_t maxTexelGatherOffset;
4955     float minInterpolationOffset;
4956     float maxInterpolationOffset;
4957     uint32_t subPixelInterpolationOffsetBits;
4958     uint32_t maxFramebufferWidth;
4959     uint32_t maxFramebufferHeight;
4960     uint32_t maxFramebufferLayers;
4961     VkSampleCountFlags framebufferColorSampleCounts;
4962     VkSampleCountFlags framebufferDepthSampleCounts;
4963     VkSampleCountFlags framebufferStencilSampleCounts;
4964     VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
4965     uint32_t maxColorAttachments;
4966     VkSampleCountFlags sampledImageColorSampleCounts;
4967     VkSampleCountFlags sampledImageIntegerSampleCounts;
4968     VkSampleCountFlags sampledImageDepthSampleCounts;
4969     VkSampleCountFlags sampledImageStencilSampleCounts;
4970     VkSampleCountFlags storageImageSampleCounts;
4971     uint32_t maxSampleMaskWords;
4972     VkBool32 timestampComputeAndGraphics;
4973     float timestampPeriod;
4974     uint32_t maxClipDistances;
4975     uint32_t maxCullDistances;
4976     uint32_t maxCombinedClipAndCullDistances;
4977     uint32_t discreteQueuePriorities;
4978     float pointSizeRange[2];
4979     float lineWidthRange[2];
4980     float pointSizeGranularity;
4981     float lineWidthGranularity;
4982     VkBool32 strictLines;
4983     VkBool32 standardSampleLocations;
4984     VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyOffsetAlignment;
4985     VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyRowPitchAlignment;
4986     VkDeviceSize DECLSPEC_ALIGN(8) nonCoherentAtomSize;
4987 } VkPhysicalDeviceLimits32;
4988
4989 typedef struct VkPhysicalDeviceProperties32
4990 {
4991     uint32_t apiVersion;
4992     uint32_t driverVersion;
4993     uint32_t vendorID;
4994     uint32_t deviceID;
4995     VkPhysicalDeviceType deviceType;
4996     char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
4997     uint8_t pipelineCacheUUID[VK_UUID_SIZE];
4998     VkPhysicalDeviceLimits32 DECLSPEC_ALIGN(8) limits;
4999     VkPhysicalDeviceSparseProperties sparseProperties;
5000 } VkPhysicalDeviceProperties32;
5001
5002 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32
5003 {
5004     VkStructureType sType;
5005     PTR32 pNext;
5006     uint32_t maxGraphicsShaderGroupCount;
5007     uint32_t maxIndirectSequenceCount;
5008     uint32_t maxIndirectCommandsTokenCount;
5009     uint32_t maxIndirectCommandsStreamCount;
5010     uint32_t maxIndirectCommandsTokenOffset;
5011     uint32_t maxIndirectCommandsStreamStride;
5012     uint32_t minSequencesCountBufferOffsetAlignment;
5013     uint32_t minSequencesIndexBufferOffsetAlignment;
5014     uint32_t minIndirectCommandsBufferOffsetAlignment;
5015 } VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32;
5016
5017 typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT32
5018 {
5019     VkStructureType sType;
5020     PTR32 pNext;
5021     uint32_t maxMultiDrawCount;
5022 } VkPhysicalDeviceMultiDrawPropertiesEXT32;
5023
5024 typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR32
5025 {
5026     VkStructureType sType;
5027     PTR32 pNext;
5028     uint32_t maxPushDescriptors;
5029 } VkPhysicalDevicePushDescriptorPropertiesKHR32;
5030
5031 typedef struct VkPhysicalDeviceDriverProperties32
5032 {
5033     VkStructureType sType;
5034     PTR32 pNext;
5035     VkDriverId driverID;
5036     char driverName[VK_MAX_DRIVER_NAME_SIZE];
5037     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
5038     VkConformanceVersion conformanceVersion;
5039 } VkPhysicalDeviceDriverProperties32;
5040 typedef VkPhysicalDeviceDriverProperties32 VkPhysicalDeviceDriverPropertiesKHR32;
5041
5042 typedef struct VkPhysicalDeviceIDProperties32
5043 {
5044     VkStructureType sType;
5045     PTR32 pNext;
5046     uint8_t deviceUUID[VK_UUID_SIZE];
5047     uint8_t driverUUID[VK_UUID_SIZE];
5048     uint8_t deviceLUID[VK_LUID_SIZE];
5049     uint32_t deviceNodeMask;
5050     VkBool32 deviceLUIDValid;
5051 } VkPhysicalDeviceIDProperties32;
5052 typedef VkPhysicalDeviceIDProperties32 VkPhysicalDeviceIDPropertiesKHR32;
5053
5054 typedef struct VkPhysicalDeviceMultiviewProperties32
5055 {
5056     VkStructureType sType;
5057     PTR32 pNext;
5058     uint32_t maxMultiviewViewCount;
5059     uint32_t maxMultiviewInstanceIndex;
5060 } VkPhysicalDeviceMultiviewProperties32;
5061 typedef VkPhysicalDeviceMultiviewProperties32 VkPhysicalDeviceMultiviewPropertiesKHR32;
5062
5063 typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT32
5064 {
5065     VkStructureType sType;
5066     PTR32 pNext;
5067     uint32_t maxDiscardRectangles;
5068 } VkPhysicalDeviceDiscardRectanglePropertiesEXT32;
5069
5070 typedef struct VkPhysicalDeviceSubgroupProperties32
5071 {
5072     VkStructureType sType;
5073     PTR32 pNext;
5074     uint32_t subgroupSize;
5075     VkShaderStageFlags supportedStages;
5076     VkSubgroupFeatureFlags supportedOperations;
5077     VkBool32 quadOperationsInAllStages;
5078 } VkPhysicalDeviceSubgroupProperties32;
5079
5080 typedef struct VkPhysicalDevicePointClippingProperties32
5081 {
5082     VkStructureType sType;
5083     PTR32 pNext;
5084     VkPointClippingBehavior pointClippingBehavior;
5085 } VkPhysicalDevicePointClippingProperties32;
5086 typedef VkPhysicalDevicePointClippingProperties32 VkPhysicalDevicePointClippingPropertiesKHR32;
5087
5088 typedef struct VkPhysicalDeviceProtectedMemoryProperties32
5089 {
5090     VkStructureType sType;
5091     PTR32 pNext;
5092     VkBool32 protectedNoFault;
5093 } VkPhysicalDeviceProtectedMemoryProperties32;
5094
5095 typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties32
5096 {
5097     VkStructureType sType;
5098     PTR32 pNext;
5099     VkBool32 filterMinmaxSingleComponentFormats;
5100     VkBool32 filterMinmaxImageComponentMapping;
5101 } VkPhysicalDeviceSamplerFilterMinmaxProperties32;
5102 typedef VkPhysicalDeviceSamplerFilterMinmaxProperties32 VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT32;
5103
5104 typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT32
5105 {
5106     VkStructureType sType;
5107     PTR32 pNext;
5108     VkSampleCountFlags sampleLocationSampleCounts;
5109     VkExtent2D maxSampleLocationGridSize;
5110     float sampleLocationCoordinateRange[2];
5111     uint32_t sampleLocationSubPixelBits;
5112     VkBool32 variableSampleLocations;
5113 } VkPhysicalDeviceSampleLocationsPropertiesEXT32;
5114
5115 typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32
5116 {
5117     VkStructureType sType;
5118     PTR32 pNext;
5119     uint32_t advancedBlendMaxColorAttachments;
5120     VkBool32 advancedBlendIndependentBlend;
5121     VkBool32 advancedBlendNonPremultipliedSrcColor;
5122     VkBool32 advancedBlendNonPremultipliedDstColor;
5123     VkBool32 advancedBlendCorrelatedOverlap;
5124     VkBool32 advancedBlendAllOperations;
5125 } VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32;
5126
5127 typedef struct VkPhysicalDeviceInlineUniformBlockProperties32
5128 {
5129     VkStructureType sType;
5130     PTR32 pNext;
5131     uint32_t maxInlineUniformBlockSize;
5132     uint32_t maxPerStageDescriptorInlineUniformBlocks;
5133     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
5134     uint32_t maxDescriptorSetInlineUniformBlocks;
5135     uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
5136 } VkPhysicalDeviceInlineUniformBlockProperties32;
5137 typedef VkPhysicalDeviceInlineUniformBlockProperties32 VkPhysicalDeviceInlineUniformBlockPropertiesEXT32;
5138
5139 typedef struct VkPhysicalDeviceMaintenance3Properties32
5140 {
5141     VkStructureType sType;
5142     PTR32 pNext;
5143     uint32_t maxPerSetDescriptors;
5144     VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
5145 } VkPhysicalDeviceMaintenance3Properties32;
5146 typedef VkPhysicalDeviceMaintenance3Properties32 VkPhysicalDeviceMaintenance3PropertiesKHR32;
5147
5148 typedef struct VkPhysicalDeviceMaintenance4Properties32
5149 {
5150     VkStructureType sType;
5151     PTR32 pNext;
5152     VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
5153 } VkPhysicalDeviceMaintenance4Properties32;
5154 typedef VkPhysicalDeviceMaintenance4Properties32 VkPhysicalDeviceMaintenance4PropertiesKHR32;
5155
5156 typedef struct VkPhysicalDeviceMaintenance5PropertiesKHR32
5157 {
5158     VkStructureType sType;
5159     PTR32 pNext;
5160     VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting;
5161     VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting;
5162     VkBool32 depthStencilSwizzleOneSupport;
5163     VkBool32 polygonModePointSize;
5164     VkBool32 nonStrictSinglePixelWideLinesUseParallelogram;
5165     VkBool32 nonStrictWideLinesUseParallelogram;
5166 } VkPhysicalDeviceMaintenance5PropertiesKHR32;
5167
5168 typedef struct VkPhysicalDeviceFloatControlsProperties32
5169 {
5170     VkStructureType sType;
5171     PTR32 pNext;
5172     VkShaderFloatControlsIndependence denormBehaviorIndependence;
5173     VkShaderFloatControlsIndependence roundingModeIndependence;
5174     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
5175     VkBool32 shaderSignedZeroInfNanPreserveFloat32;
5176     VkBool32 shaderSignedZeroInfNanPreserveFloat64;
5177     VkBool32 shaderDenormPreserveFloat16;
5178     VkBool32 shaderDenormPreserveFloat32;
5179     VkBool32 shaderDenormPreserveFloat64;
5180     VkBool32 shaderDenormFlushToZeroFloat16;
5181     VkBool32 shaderDenormFlushToZeroFloat32;
5182     VkBool32 shaderDenormFlushToZeroFloat64;
5183     VkBool32 shaderRoundingModeRTEFloat16;
5184     VkBool32 shaderRoundingModeRTEFloat32;
5185     VkBool32 shaderRoundingModeRTEFloat64;
5186     VkBool32 shaderRoundingModeRTZFloat16;
5187     VkBool32 shaderRoundingModeRTZFloat32;
5188     VkBool32 shaderRoundingModeRTZFloat64;
5189 } VkPhysicalDeviceFloatControlsProperties32;
5190 typedef VkPhysicalDeviceFloatControlsProperties32 VkPhysicalDeviceFloatControlsPropertiesKHR32;
5191
5192 typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT32
5193 {
5194     VkStructureType sType;
5195     PTR32 pNext;
5196     VkDeviceSize DECLSPEC_ALIGN(8) minImportedHostPointerAlignment;
5197 } VkPhysicalDeviceExternalMemoryHostPropertiesEXT32;
5198
5199 typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT32
5200 {
5201     VkStructureType sType;
5202     PTR32 pNext;
5203     float primitiveOverestimationSize;
5204     float maxExtraPrimitiveOverestimationSize;
5205     float extraPrimitiveOverestimationSizeGranularity;
5206     VkBool32 primitiveUnderestimation;
5207     VkBool32 conservativePointAndLineRasterization;
5208     VkBool32 degenerateTrianglesRasterized;
5209     VkBool32 degenerateLinesRasterized;
5210     VkBool32 fullyCoveredFragmentShaderInputVariable;
5211     VkBool32 conservativeRasterizationPostDepthCoverage;
5212 } VkPhysicalDeviceConservativeRasterizationPropertiesEXT32;
5213
5214 typedef struct VkPhysicalDeviceShaderCorePropertiesAMD32
5215 {
5216     VkStructureType sType;
5217     PTR32 pNext;
5218     uint32_t shaderEngineCount;
5219     uint32_t shaderArraysPerEngineCount;
5220     uint32_t computeUnitsPerShaderArray;
5221     uint32_t simdPerComputeUnit;
5222     uint32_t wavefrontsPerSimd;
5223     uint32_t wavefrontSize;
5224     uint32_t sgprsPerSimd;
5225     uint32_t minSgprAllocation;
5226     uint32_t maxSgprAllocation;
5227     uint32_t sgprAllocationGranularity;
5228     uint32_t vgprsPerSimd;
5229     uint32_t minVgprAllocation;
5230     uint32_t maxVgprAllocation;
5231     uint32_t vgprAllocationGranularity;
5232 } VkPhysicalDeviceShaderCorePropertiesAMD32;
5233
5234 typedef struct VkPhysicalDeviceShaderCoreProperties2AMD32
5235 {
5236     VkStructureType sType;
5237     PTR32 pNext;
5238     VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;
5239     uint32_t activeComputeUnitCount;
5240 } VkPhysicalDeviceShaderCoreProperties2AMD32;
5241
5242 typedef struct VkPhysicalDeviceDescriptorIndexingProperties32
5243 {
5244     VkStructureType sType;
5245     PTR32 pNext;
5246     uint32_t maxUpdateAfterBindDescriptorsInAllPools;
5247     VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
5248     VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
5249     VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
5250     VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
5251     VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
5252     VkBool32 robustBufferAccessUpdateAfterBind;
5253     VkBool32 quadDivergentImplicitLod;
5254     uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
5255     uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
5256     uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
5257     uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
5258     uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
5259     uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
5260     uint32_t maxPerStageUpdateAfterBindResources;
5261     uint32_t maxDescriptorSetUpdateAfterBindSamplers;
5262     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
5263     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
5264     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
5265     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
5266     uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
5267     uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
5268     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
5269 } VkPhysicalDeviceDescriptorIndexingProperties32;
5270 typedef VkPhysicalDeviceDescriptorIndexingProperties32 VkPhysicalDeviceDescriptorIndexingPropertiesEXT32;
5271
5272 typedef struct VkPhysicalDeviceTimelineSemaphoreProperties32
5273 {
5274     VkStructureType sType;
5275     PTR32 pNext;
5276     uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
5277 } VkPhysicalDeviceTimelineSemaphoreProperties32;
5278 typedef VkPhysicalDeviceTimelineSemaphoreProperties32 VkPhysicalDeviceTimelineSemaphorePropertiesKHR32;
5279
5280 typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32
5281 {
5282     VkStructureType sType;
5283     PTR32 pNext;
5284     uint32_t maxVertexAttribDivisor;
5285 } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32;
5286
5287 typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT32
5288 {
5289     VkStructureType sType;
5290     PTR32 pNext;
5291     uint32_t pciDomain;
5292     uint32_t pciBus;
5293     uint32_t pciDevice;
5294     uint32_t pciFunction;
5295 } VkPhysicalDevicePCIBusInfoPropertiesEXT32;
5296
5297 typedef struct VkPhysicalDeviceDepthStencilResolveProperties32
5298 {
5299     VkStructureType sType;
5300     PTR32 pNext;
5301     VkResolveModeFlags supportedDepthResolveModes;
5302     VkResolveModeFlags supportedStencilResolveModes;
5303     VkBool32 independentResolveNone;
5304     VkBool32 independentResolve;
5305 } VkPhysicalDeviceDepthStencilResolveProperties32;
5306 typedef VkPhysicalDeviceDepthStencilResolveProperties32 VkPhysicalDeviceDepthStencilResolvePropertiesKHR32;
5307
5308 typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT32
5309 {
5310     VkStructureType sType;
5311     PTR32 pNext;
5312     uint32_t maxTransformFeedbackStreams;
5313     uint32_t maxTransformFeedbackBuffers;
5314     VkDeviceSize DECLSPEC_ALIGN(8) maxTransformFeedbackBufferSize;
5315     uint32_t maxTransformFeedbackStreamDataSize;
5316     uint32_t maxTransformFeedbackBufferDataSize;
5317     uint32_t maxTransformFeedbackBufferDataStride;
5318     VkBool32 transformFeedbackQueries;
5319     VkBool32 transformFeedbackStreamsLinesTriangles;
5320     VkBool32 transformFeedbackRasterizationStreamSelect;
5321     VkBool32 transformFeedbackDraw;
5322 } VkPhysicalDeviceTransformFeedbackPropertiesEXT32;
5323
5324 typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32
5325 {
5326     VkStructureType sType;
5327     PTR32 pNext;
5328     VkQueueFlags supportedQueues;
5329 } VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32;
5330
5331 typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV32
5332 {
5333     VkStructureType sType;
5334     PTR32 pNext;
5335     VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethods;
5336     uint64_t DECLSPEC_ALIGN(8) maxDecompressionIndirectCount;
5337 } VkPhysicalDeviceMemoryDecompressionPropertiesNV32;
5338
5339 typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV32
5340 {
5341     VkStructureType sType;
5342     PTR32 pNext;
5343     VkExtent2D shadingRateTexelSize;
5344     uint32_t shadingRatePaletteSize;
5345     uint32_t shadingRateMaxCoarseSamples;
5346 } VkPhysicalDeviceShadingRateImagePropertiesNV32;
5347
5348 typedef struct VkPhysicalDeviceMeshShaderPropertiesNV32
5349 {
5350     VkStructureType sType;
5351     PTR32 pNext;
5352     uint32_t maxDrawMeshTasksCount;
5353     uint32_t maxTaskWorkGroupInvocations;
5354     uint32_t maxTaskWorkGroupSize[3];
5355     uint32_t maxTaskTotalMemorySize;
5356     uint32_t maxTaskOutputCount;
5357     uint32_t maxMeshWorkGroupInvocations;
5358     uint32_t maxMeshWorkGroupSize[3];
5359     uint32_t maxMeshTotalMemorySize;
5360     uint32_t maxMeshOutputVertices;
5361     uint32_t maxMeshOutputPrimitives;
5362     uint32_t maxMeshMultiviewViewCount;
5363     uint32_t meshOutputPerVertexGranularity;
5364     uint32_t meshOutputPerPrimitiveGranularity;
5365 } VkPhysicalDeviceMeshShaderPropertiesNV32;
5366
5367 typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT32
5368 {
5369     VkStructureType sType;
5370     PTR32 pNext;
5371     uint32_t maxTaskWorkGroupTotalCount;
5372     uint32_t maxTaskWorkGroupCount[3];
5373     uint32_t maxTaskWorkGroupInvocations;
5374     uint32_t maxTaskWorkGroupSize[3];
5375     uint32_t maxTaskPayloadSize;
5376     uint32_t maxTaskSharedMemorySize;
5377     uint32_t maxTaskPayloadAndSharedMemorySize;
5378     uint32_t maxMeshWorkGroupTotalCount;
5379     uint32_t maxMeshWorkGroupCount[3];
5380     uint32_t maxMeshWorkGroupInvocations;
5381     uint32_t maxMeshWorkGroupSize[3];
5382     uint32_t maxMeshSharedMemorySize;
5383     uint32_t maxMeshPayloadAndSharedMemorySize;
5384     uint32_t maxMeshOutputMemorySize;
5385     uint32_t maxMeshPayloadAndOutputMemorySize;
5386     uint32_t maxMeshOutputComponents;
5387     uint32_t maxMeshOutputVertices;
5388     uint32_t maxMeshOutputPrimitives;
5389     uint32_t maxMeshOutputLayers;
5390     uint32_t maxMeshMultiviewViewCount;
5391     uint32_t meshOutputPerVertexGranularity;
5392     uint32_t meshOutputPerPrimitiveGranularity;
5393     uint32_t maxPreferredTaskWorkGroupInvocations;
5394     uint32_t maxPreferredMeshWorkGroupInvocations;
5395     VkBool32 prefersLocalInvocationVertexOutput;
5396     VkBool32 prefersLocalInvocationPrimitiveOutput;
5397     VkBool32 prefersCompactVertexOutput;
5398     VkBool32 prefersCompactPrimitiveOutput;
5399 } VkPhysicalDeviceMeshShaderPropertiesEXT32;
5400
5401 typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR32
5402 {
5403     VkStructureType sType;
5404     PTR32 pNext;
5405     uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
5406     uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
5407     uint64_t DECLSPEC_ALIGN(8) maxPrimitiveCount;
5408     uint32_t maxPerStageDescriptorAccelerationStructures;
5409     uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
5410     uint32_t maxDescriptorSetAccelerationStructures;
5411     uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures;
5412     uint32_t minAccelerationStructureScratchOffsetAlignment;
5413 } VkPhysicalDeviceAccelerationStructurePropertiesKHR32;
5414
5415 typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR32
5416 {
5417     VkStructureType sType;
5418     PTR32 pNext;
5419     uint32_t shaderGroupHandleSize;
5420     uint32_t maxRayRecursionDepth;
5421     uint32_t maxShaderGroupStride;
5422     uint32_t shaderGroupBaseAlignment;
5423     uint32_t shaderGroupHandleCaptureReplaySize;
5424     uint32_t maxRayDispatchInvocationCount;
5425     uint32_t shaderGroupHandleAlignment;
5426     uint32_t maxRayHitAttributeSize;
5427 } VkPhysicalDeviceRayTracingPipelinePropertiesKHR32;
5428
5429 typedef struct VkPhysicalDeviceRayTracingPropertiesNV32
5430 {
5431     VkStructureType sType;
5432     PTR32 pNext;
5433     uint32_t shaderGroupHandleSize;
5434     uint32_t maxRecursionDepth;
5435     uint32_t maxShaderGroupStride;
5436     uint32_t shaderGroupBaseAlignment;
5437     uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
5438     uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
5439     uint64_t DECLSPEC_ALIGN(8) maxTriangleCount;
5440     uint32_t maxDescriptorSetAccelerationStructures;
5441 } VkPhysicalDeviceRayTracingPropertiesNV32;
5442
5443 typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT32
5444 {
5445     VkStructureType sType;
5446     PTR32 pNext;
5447     VkExtent2D minFragmentDensityTexelSize;
5448     VkExtent2D maxFragmentDensityTexelSize;
5449     VkBool32 fragmentDensityInvocations;
5450 } VkPhysicalDeviceFragmentDensityMapPropertiesEXT32;
5451
5452 typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32
5453 {
5454     VkStructureType sType;
5455     PTR32 pNext;
5456     VkBool32 subsampledLoads;
5457     VkBool32 subsampledCoarseReconstructionEarlyAccess;
5458     uint32_t maxSubsampledArrayLayers;
5459     uint32_t maxDescriptorSetSubsampledSamplers;
5460 } VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32;
5461
5462 typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32
5463 {
5464     VkStructureType sType;
5465     PTR32 pNext;
5466     VkExtent2D fragmentDensityOffsetGranularity;
5467 } VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32;
5468
5469 typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV32
5470 {
5471     VkStructureType sType;
5472     PTR32 pNext;
5473     VkShaderStageFlags cooperativeMatrixSupportedStages;
5474 } VkPhysicalDeviceCooperativeMatrixPropertiesNV32;
5475
5476 typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR32
5477 {
5478     VkStructureType sType;
5479     PTR32 pNext;
5480     VkBool32 allowCommandBufferQueryCopies;
5481 } VkPhysicalDevicePerformanceQueryPropertiesKHR32;
5482
5483 typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32
5484 {
5485     VkStructureType sType;
5486     PTR32 pNext;
5487     uint32_t shaderSMCount;
5488     uint32_t shaderWarpsPerSM;
5489 } VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32;
5490
5491 typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties32
5492 {
5493     VkStructureType sType;
5494     PTR32 pNext;
5495     VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
5496     VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
5497     VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
5498     VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
5499 } VkPhysicalDeviceTexelBufferAlignmentProperties32;
5500 typedef VkPhysicalDeviceTexelBufferAlignmentProperties32 VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT32;
5501
5502 typedef struct VkPhysicalDeviceSubgroupSizeControlProperties32
5503 {
5504     VkStructureType sType;
5505     PTR32 pNext;
5506     uint32_t minSubgroupSize;
5507     uint32_t maxSubgroupSize;
5508     uint32_t maxComputeWorkgroupSubgroups;
5509     VkShaderStageFlags requiredSubgroupSizeStages;
5510 } VkPhysicalDeviceSubgroupSizeControlProperties32;
5511 typedef VkPhysicalDeviceSubgroupSizeControlProperties32 VkPhysicalDeviceSubgroupSizeControlPropertiesEXT32;
5512
5513 typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32
5514 {
5515     VkStructureType sType;
5516     PTR32 pNext;
5517     uint32_t maxSubpassShadingWorkgroupSizeAspectRatio;
5518 } VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32;
5519
5520 typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32
5521 {
5522     VkStructureType sType;
5523     PTR32 pNext;
5524     uint32_t maxWorkGroupCount[3];
5525     uint32_t maxWorkGroupSize[3];
5526     uint32_t maxOutputClusterCount;
5527     VkDeviceSize DECLSPEC_ALIGN(8) indirectBufferOffsetAlignment;
5528 } VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32;
5529
5530 typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT32
5531 {
5532     VkStructureType sType;
5533     PTR32 pNext;
5534     uint32_t lineSubPixelPrecisionBits;
5535 } VkPhysicalDeviceLineRasterizationPropertiesEXT32;
5536
5537 typedef struct VkPhysicalDeviceVulkan11Properties32
5538 {
5539     VkStructureType sType;
5540     PTR32 pNext;
5541     uint8_t deviceUUID[VK_UUID_SIZE];
5542     uint8_t driverUUID[VK_UUID_SIZE];
5543     uint8_t deviceLUID[VK_LUID_SIZE];
5544     uint32_t deviceNodeMask;
5545     VkBool32 deviceLUIDValid;
5546     uint32_t subgroupSize;
5547     VkShaderStageFlags subgroupSupportedStages;
5548     VkSubgroupFeatureFlags subgroupSupportedOperations;
5549     VkBool32 subgroupQuadOperationsInAllStages;
5550     VkPointClippingBehavior pointClippingBehavior;
5551     uint32_t maxMultiviewViewCount;
5552     uint32_t maxMultiviewInstanceIndex;
5553     VkBool32 protectedNoFault;
5554     uint32_t maxPerSetDescriptors;
5555     VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
5556 } VkPhysicalDeviceVulkan11Properties32;
5557
5558 typedef struct VkPhysicalDeviceVulkan12Properties32
5559 {
5560     VkStructureType sType;
5561     PTR32 pNext;
5562     VkDriverId driverID;
5563     char driverName[VK_MAX_DRIVER_NAME_SIZE];
5564     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
5565     VkConformanceVersion conformanceVersion;
5566     VkShaderFloatControlsIndependence denormBehaviorIndependence;
5567     VkShaderFloatControlsIndependence roundingModeIndependence;
5568     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
5569     VkBool32 shaderSignedZeroInfNanPreserveFloat32;
5570     VkBool32 shaderSignedZeroInfNanPreserveFloat64;
5571     VkBool32 shaderDenormPreserveFloat16;
5572     VkBool32 shaderDenormPreserveFloat32;
5573     VkBool32 shaderDenormPreserveFloat64;
5574     VkBool32 shaderDenormFlushToZeroFloat16;
5575     VkBool32 shaderDenormFlushToZeroFloat32;
5576     VkBool32 shaderDenormFlushToZeroFloat64;
5577     VkBool32 shaderRoundingModeRTEFloat16;
5578     VkBool32 shaderRoundingModeRTEFloat32;
5579     VkBool32 shaderRoundingModeRTEFloat64;
5580     VkBool32 shaderRoundingModeRTZFloat16;
5581     VkBool32 shaderRoundingModeRTZFloat32;
5582     VkBool32 shaderRoundingModeRTZFloat64;
5583     uint32_t maxUpdateAfterBindDescriptorsInAllPools;
5584     VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
5585     VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
5586     VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
5587     VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
5588     VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
5589     VkBool32 robustBufferAccessUpdateAfterBind;
5590     VkBool32 quadDivergentImplicitLod;
5591     uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
5592     uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
5593     uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
5594     uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
5595     uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
5596     uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
5597     uint32_t maxPerStageUpdateAfterBindResources;
5598     uint32_t maxDescriptorSetUpdateAfterBindSamplers;
5599     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
5600     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
5601     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
5602     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
5603     uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
5604     uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
5605     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
5606     VkResolveModeFlags supportedDepthResolveModes;
5607     VkResolveModeFlags supportedStencilResolveModes;
5608     VkBool32 independentResolveNone;
5609     VkBool32 independentResolve;
5610     VkBool32 filterMinmaxSingleComponentFormats;
5611     VkBool32 filterMinmaxImageComponentMapping;
5612     uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
5613     VkSampleCountFlags framebufferIntegerColorSampleCounts;
5614 } VkPhysicalDeviceVulkan12Properties32;
5615
5616 typedef struct VkPhysicalDeviceVulkan13Properties32
5617 {
5618     VkStructureType sType;
5619     PTR32 pNext;
5620     uint32_t minSubgroupSize;
5621     uint32_t maxSubgroupSize;
5622     uint32_t maxComputeWorkgroupSubgroups;
5623     VkShaderStageFlags requiredSubgroupSizeStages;
5624     uint32_t maxInlineUniformBlockSize;
5625     uint32_t maxPerStageDescriptorInlineUniformBlocks;
5626     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
5627     uint32_t maxDescriptorSetInlineUniformBlocks;
5628     uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
5629     uint32_t maxInlineUniformTotalSize;
5630     VkBool32 integerDotProduct8BitUnsignedAccelerated;
5631     VkBool32 integerDotProduct8BitSignedAccelerated;
5632     VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
5633     VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
5634     VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
5635     VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
5636     VkBool32 integerDotProduct16BitUnsignedAccelerated;
5637     VkBool32 integerDotProduct16BitSignedAccelerated;
5638     VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
5639     VkBool32 integerDotProduct32BitUnsignedAccelerated;
5640     VkBool32 integerDotProduct32BitSignedAccelerated;
5641     VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
5642     VkBool32 integerDotProduct64BitUnsignedAccelerated;
5643     VkBool32 integerDotProduct64BitSignedAccelerated;
5644     VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
5645     VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
5646     VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
5647     VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
5648     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
5649     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
5650     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
5651     VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
5652     VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
5653     VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
5654     VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
5655     VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
5656     VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
5657     VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
5658     VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
5659     VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
5660     VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
5661     VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
5662     VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
5663     VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
5664     VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
5665 } VkPhysicalDeviceVulkan13Properties32;
5666
5667 typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT32
5668 {
5669     VkStructureType sType;
5670     PTR32 pNext;
5671     uint32_t maxCustomBorderColorSamplers;
5672 } VkPhysicalDeviceCustomBorderColorPropertiesEXT32;
5673
5674 typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32
5675 {
5676     VkStructureType sType;
5677     PTR32 pNext;
5678     VkBool32 dynamicPrimitiveTopologyUnrestricted;
5679 } VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32;
5680
5681 typedef struct VkPhysicalDeviceRobustness2PropertiesEXT32
5682 {
5683     VkStructureType sType;
5684     PTR32 pNext;
5685     VkDeviceSize DECLSPEC_ALIGN(8) robustStorageBufferAccessSizeAlignment;
5686     VkDeviceSize DECLSPEC_ALIGN(8) robustUniformBufferAccessSizeAlignment;
5687 } VkPhysicalDeviceRobustness2PropertiesEXT32;
5688
5689 typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR32
5690 {
5691     VkStructureType sType;
5692     PTR32 pNext;
5693     VkExtent2D minFragmentShadingRateAttachmentTexelSize;
5694     VkExtent2D maxFragmentShadingRateAttachmentTexelSize;
5695     uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
5696     VkBool32 primitiveFragmentShadingRateWithMultipleViewports;
5697     VkBool32 layeredShadingRateAttachments;
5698     VkBool32 fragmentShadingRateNonTrivialCombinerOps;
5699     VkExtent2D maxFragmentSize;
5700     uint32_t maxFragmentSizeAspectRatio;
5701     uint32_t maxFragmentShadingRateCoverageSamples;
5702     VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples;
5703     VkBool32 fragmentShadingRateWithShaderDepthStencilWrites;
5704     VkBool32 fragmentShadingRateWithSampleMask;
5705     VkBool32 fragmentShadingRateWithShaderSampleMask;
5706     VkBool32 fragmentShadingRateWithConservativeRasterization;
5707     VkBool32 fragmentShadingRateWithFragmentShaderInterlock;
5708     VkBool32 fragmentShadingRateWithCustomSampleLocations;
5709     VkBool32 fragmentShadingRateStrictMultiplyCombiner;
5710 } VkPhysicalDeviceFragmentShadingRatePropertiesKHR32;
5711
5712 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32
5713 {
5714     VkStructureType sType;
5715     PTR32 pNext;
5716     VkSampleCountFlagBits maxFragmentShadingRateInvocationCount;
5717 } VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32;
5718
5719 typedef struct VkPhysicalDeviceHostImageCopyPropertiesEXT32
5720 {
5721     VkStructureType sType;
5722     PTR32 pNext;
5723     uint32_t copySrcLayoutCount;
5724     PTR32 pCopySrcLayouts;
5725     uint32_t copyDstLayoutCount;
5726     PTR32 pCopyDstLayouts;
5727     uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE];
5728     VkBool32 identicalMemoryTypeRequirements;
5729 } VkPhysicalDeviceHostImageCopyPropertiesEXT32;
5730
5731 typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT32
5732 {
5733     VkStructureType sType;
5734     PTR32 pNext;
5735     VkBool32 provokingVertexModePerPipeline;
5736     VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex;
5737 } VkPhysicalDeviceProvokingVertexPropertiesEXT32;
5738
5739 typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT32
5740 {
5741     VkStructureType sType;
5742     PTR32 pNext;
5743     VkBool32 combinedImageSamplerDescriptorSingleArray;
5744     VkBool32 bufferlessPushDescriptors;
5745     VkBool32 allowSamplerImageViewPostSubmitCreation;
5746     VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferOffsetAlignment;
5747     uint32_t maxDescriptorBufferBindings;
5748     uint32_t maxResourceDescriptorBufferBindings;
5749     uint32_t maxSamplerDescriptorBufferBindings;
5750     uint32_t maxEmbeddedImmutableSamplerBindings;
5751     uint32_t maxEmbeddedImmutableSamplers;
5752     PTR32 bufferCaptureReplayDescriptorDataSize;
5753     PTR32 imageCaptureReplayDescriptorDataSize;
5754     PTR32 imageViewCaptureReplayDescriptorDataSize;
5755     PTR32 samplerCaptureReplayDescriptorDataSize;
5756     PTR32 accelerationStructureCaptureReplayDescriptorDataSize;
5757     PTR32 samplerDescriptorSize;
5758     PTR32 combinedImageSamplerDescriptorSize;
5759     PTR32 sampledImageDescriptorSize;
5760     PTR32 storageImageDescriptorSize;
5761     PTR32 uniformTexelBufferDescriptorSize;
5762     PTR32 robustUniformTexelBufferDescriptorSize;
5763     PTR32 storageTexelBufferDescriptorSize;
5764     PTR32 robustStorageTexelBufferDescriptorSize;
5765     PTR32 uniformBufferDescriptorSize;
5766     PTR32 robustUniformBufferDescriptorSize;
5767     PTR32 storageBufferDescriptorSize;
5768     PTR32 robustStorageBufferDescriptorSize;
5769     PTR32 inputAttachmentDescriptorSize;
5770     PTR32 accelerationStructureDescriptorSize;
5771     VkDeviceSize DECLSPEC_ALIGN(8) maxSamplerDescriptorBufferRange;
5772     VkDeviceSize DECLSPEC_ALIGN(8) maxResourceDescriptorBufferRange;
5773     VkDeviceSize DECLSPEC_ALIGN(8) samplerDescriptorBufferAddressSpaceSize;
5774     VkDeviceSize DECLSPEC_ALIGN(8) resourceDescriptorBufferAddressSpaceSize;
5775     VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferAddressSpaceSize;
5776 } VkPhysicalDeviceDescriptorBufferPropertiesEXT32;
5777
5778 typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32
5779 {
5780     VkStructureType sType;
5781     PTR32 pNext;
5782     PTR32 combinedImageSamplerDensityMapDescriptorSize;
5783 } VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32;
5784
5785 typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties32
5786 {
5787     VkStructureType sType;
5788     PTR32 pNext;
5789     VkBool32 integerDotProduct8BitUnsignedAccelerated;
5790     VkBool32 integerDotProduct8BitSignedAccelerated;
5791     VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
5792     VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
5793     VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
5794     VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
5795     VkBool32 integerDotProduct16BitUnsignedAccelerated;
5796     VkBool32 integerDotProduct16BitSignedAccelerated;
5797     VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
5798     VkBool32 integerDotProduct32BitUnsignedAccelerated;
5799     VkBool32 integerDotProduct32BitSignedAccelerated;
5800     VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
5801     VkBool32 integerDotProduct64BitUnsignedAccelerated;
5802     VkBool32 integerDotProduct64BitSignedAccelerated;
5803     VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
5804     VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
5805     VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
5806     VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
5807     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
5808     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
5809     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
5810     VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
5811     VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
5812     VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
5813     VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
5814     VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
5815     VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
5816     VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
5817     VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
5818     VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
5819 } VkPhysicalDeviceShaderIntegerDotProductProperties32;
5820 typedef VkPhysicalDeviceShaderIntegerDotProductProperties32 VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR32;
5821
5822 typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32
5823 {
5824     VkStructureType sType;
5825     PTR32 pNext;
5826     VkBool32 triStripVertexOrderIndependentOfProvokingVertex;
5827 } VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32;
5828
5829 typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32
5830 {
5831     VkStructureType sType;
5832     PTR32 pNext;
5833     VkBool32 graphicsPipelineLibraryFastLinking;
5834     VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration;
5835 } VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32;
5836
5837 typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32
5838 {
5839     VkStructureType sType;
5840     PTR32 pNext;
5841     uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE];
5842 } VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32;
5843
5844 typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT32
5845 {
5846     VkStructureType sType;
5847     PTR32 pNext;
5848     uint32_t maxOpacity2StateSubdivisionLevel;
5849     uint32_t maxOpacity4StateSubdivisionLevel;
5850 } VkPhysicalDeviceOpacityMicromapPropertiesEXT32;
5851
5852 typedef struct VkPhysicalDevicePipelineRobustnessPropertiesEXT32
5853 {
5854     VkStructureType sType;
5855     PTR32 pNext;
5856     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers;
5857     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers;
5858     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs;
5859     VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages;
5860 } VkPhysicalDevicePipelineRobustnessPropertiesEXT32;
5861
5862 typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM32
5863 {
5864     VkStructureType sType;
5865     PTR32 pNext;
5866     uint32_t maxWeightFilterPhases;
5867     VkExtent2D maxWeightFilterDimension;
5868     VkExtent2D maxBlockMatchRegion;
5869     VkExtent2D maxBoxFilterBlockSize;
5870 } VkPhysicalDeviceImageProcessingPropertiesQCOM32;
5871
5872 typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV32
5873 {
5874     VkStructureType sType;
5875     PTR32 pNext;
5876     VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes;
5877     VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes;
5878     VkBool32 hintSupported;
5879     VkBool32 costSupported;
5880     VkBool32 bidirectionalFlowSupported;
5881     VkBool32 globalFlowSupported;
5882     uint32_t minWidth;
5883     uint32_t minHeight;
5884     uint32_t maxWidth;
5885     uint32_t maxHeight;
5886     uint32_t maxNumRegionsOfInterest;
5887 } VkPhysicalDeviceOpticalFlowPropertiesNV32;
5888
5889 typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32
5890 {
5891     VkStructureType sType;
5892     PTR32 pNext;
5893     uint64_t DECLSPEC_ALIGN(8) shaderCoreMask;
5894     uint32_t shaderCoreCount;
5895     uint32_t shaderWarpsPerCore;
5896 } VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32;
5897
5898 typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32
5899 {
5900     VkStructureType sType;
5901     PTR32 pNext;
5902     VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint;
5903 } VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32;
5904
5905 typedef struct VkPhysicalDeviceShaderCorePropertiesARM32
5906 {
5907     VkStructureType sType;
5908     PTR32 pNext;
5909     uint32_t pixelRate;
5910     uint32_t texelRate;
5911     uint32_t fmaRate;
5912 } VkPhysicalDeviceShaderCorePropertiesARM32;
5913
5914 typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT32
5915 {
5916     VkStructureType sType;
5917     PTR32 pNext;
5918     uint8_t shaderBinaryUUID[VK_UUID_SIZE];
5919     uint32_t shaderBinaryVersion;
5920 } VkPhysicalDeviceShaderObjectPropertiesEXT32;
5921
5922 typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT32
5923 {
5924     VkStructureType sType;
5925     PTR32 pNext;
5926     VkBool32 shaderTileImageCoherentReadAccelerated;
5927     VkBool32 shaderTileImageReadSampleFromPixelRateInvocation;
5928     VkBool32 shaderTileImageReadFromHelperInvocation;
5929 } VkPhysicalDeviceShaderTileImagePropertiesEXT32;
5930
5931 typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR32
5932 {
5933     VkStructureType sType;
5934     PTR32 pNext;
5935     VkShaderStageFlags cooperativeMatrixSupportedStages;
5936 } VkPhysicalDeviceCooperativeMatrixPropertiesKHR32;
5937
5938 typedef struct VkPhysicalDeviceProperties232
5939 {
5940     VkStructureType sType;
5941     PTR32 pNext;
5942     VkPhysicalDeviceProperties32 DECLSPEC_ALIGN(8) properties;
5943 } VkPhysicalDeviceProperties232;
5944 typedef VkPhysicalDeviceProperties232 VkPhysicalDeviceProperties2KHR32;
5945
5946 typedef struct VkQueueFamilyGlobalPriorityPropertiesKHR32
5947 {
5948     VkStructureType sType;
5949     PTR32 pNext;
5950     uint32_t priorityCount;
5951     VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR];
5952 } VkQueueFamilyGlobalPriorityPropertiesKHR32;
5953 typedef VkQueueFamilyGlobalPriorityPropertiesKHR32 VkQueueFamilyGlobalPriorityPropertiesEXT32;
5954
5955 typedef struct VkQueueFamilyCheckpointPropertiesNV32
5956 {
5957     VkStructureType sType;
5958     PTR32 pNext;
5959     VkPipelineStageFlags checkpointExecutionStageMask;
5960 } VkQueueFamilyCheckpointPropertiesNV32;
5961
5962 typedef struct VkQueueFamilyCheckpointProperties2NV32
5963 {
5964     VkStructureType sType;
5965     PTR32 pNext;
5966     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) checkpointExecutionStageMask;
5967 } VkQueueFamilyCheckpointProperties2NV32;
5968
5969 typedef struct VkQueueFamilyProperties232
5970 {
5971     VkStructureType sType;
5972     PTR32 pNext;
5973     VkQueueFamilyProperties queueFamilyProperties;
5974 } VkQueueFamilyProperties232;
5975 typedef VkQueueFamilyProperties232 VkQueueFamilyProperties2KHR32;
5976
5977 typedef struct VkPhysicalDeviceSparseImageFormatInfo232
5978 {
5979     VkStructureType sType;
5980     PTR32 pNext;
5981     VkFormat format;
5982     VkImageType type;
5983     VkSampleCountFlagBits samples;
5984     VkImageUsageFlags usage;
5985     VkImageTiling tiling;
5986 } VkPhysicalDeviceSparseImageFormatInfo232;
5987 typedef VkPhysicalDeviceSparseImageFormatInfo232 VkPhysicalDeviceSparseImageFormatInfo2KHR32;
5988
5989 typedef struct VkSparseImageFormatProperties232
5990 {
5991     VkStructureType sType;
5992     PTR32 pNext;
5993     VkSparseImageFormatProperties properties;
5994 } VkSparseImageFormatProperties232;
5995 typedef VkSparseImageFormatProperties232 VkSparseImageFormatProperties2KHR32;
5996
5997 typedef struct VkFramebufferMixedSamplesCombinationNV32
5998 {
5999     VkStructureType sType;
6000     PTR32 pNext;
6001     VkCoverageReductionModeNV coverageReductionMode;
6002     VkSampleCountFlagBits rasterizationSamples;
6003     VkSampleCountFlags depthStencilSamples;
6004     VkSampleCountFlags colorSamples;
6005 } VkFramebufferMixedSamplesCombinationNV32;
6006
6007 typedef struct VkSurfacePresentModeEXT32
6008 {
6009     VkStructureType sType;
6010     PTR32 pNext;
6011     VkPresentModeKHR presentMode;
6012 } VkSurfacePresentModeEXT32;
6013
6014 typedef struct VkPhysicalDeviceSurfaceInfo2KHR32
6015 {
6016     VkStructureType sType;
6017     PTR32 pNext;
6018     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
6019 } VkPhysicalDeviceSurfaceInfo2KHR32;
6020
6021 typedef struct VkSurfaceCapabilitiesPresentBarrierNV32
6022 {
6023     VkStructureType sType;
6024     PTR32 pNext;
6025     VkBool32 presentBarrierSupported;
6026 } VkSurfaceCapabilitiesPresentBarrierNV32;
6027
6028 typedef struct VkSurfacePresentScalingCapabilitiesEXT32
6029 {
6030     VkStructureType sType;
6031     PTR32 pNext;
6032     VkPresentScalingFlagsEXT supportedPresentScaling;
6033     VkPresentGravityFlagsEXT supportedPresentGravityX;
6034     VkPresentGravityFlagsEXT supportedPresentGravityY;
6035     VkExtent2D minScaledImageExtent;
6036     VkExtent2D maxScaledImageExtent;
6037 } VkSurfacePresentScalingCapabilitiesEXT32;
6038
6039 typedef struct VkSurfacePresentModeCompatibilityEXT32
6040 {
6041     VkStructureType sType;
6042     PTR32 pNext;
6043     uint32_t presentModeCount;
6044     PTR32 pPresentModes;
6045 } VkSurfacePresentModeCompatibilityEXT32;
6046
6047 typedef struct VkSurfaceCapabilities2KHR32
6048 {
6049     VkStructureType sType;
6050     PTR32 pNext;
6051     VkSurfaceCapabilitiesKHR surfaceCapabilities;
6052 } VkSurfaceCapabilities2KHR32;
6053
6054 typedef struct VkSurfaceFormat2KHR32
6055 {
6056     VkStructureType sType;
6057     PTR32 pNext;
6058     VkSurfaceFormatKHR surfaceFormat;
6059 } VkSurfaceFormat2KHR32;
6060
6061 typedef struct VkPhysicalDeviceToolProperties32
6062 {
6063     VkStructureType sType;
6064     PTR32 pNext;
6065     char name[VK_MAX_EXTENSION_NAME_SIZE];
6066     char version[VK_MAX_EXTENSION_NAME_SIZE];
6067     VkToolPurposeFlags purposes;
6068     char description[VK_MAX_DESCRIPTION_SIZE];
6069     char layer[VK_MAX_EXTENSION_NAME_SIZE];
6070 } VkPhysicalDeviceToolProperties32;
6071 typedef VkPhysicalDeviceToolProperties32 VkPhysicalDeviceToolPropertiesEXT32;
6072
6073 typedef struct VkPipelineExecutableInfoKHR32
6074 {
6075     VkStructureType sType;
6076     PTR32 pNext;
6077     VkPipeline DECLSPEC_ALIGN(8) pipeline;
6078     uint32_t executableIndex;
6079 } VkPipelineExecutableInfoKHR32;
6080
6081 typedef struct VkPipelineExecutableInternalRepresentationKHR32
6082 {
6083     VkStructureType sType;
6084     PTR32 pNext;
6085     char name[VK_MAX_DESCRIPTION_SIZE];
6086     char description[VK_MAX_DESCRIPTION_SIZE];
6087     VkBool32 isText;
6088     PTR32 dataSize;
6089     PTR32 pData;
6090 } VkPipelineExecutableInternalRepresentationKHR32;
6091
6092 typedef struct VkPipelineInfoKHR32
6093 {
6094     VkStructureType sType;
6095     PTR32 pNext;
6096     VkPipeline DECLSPEC_ALIGN(8) pipeline;
6097 } VkPipelineInfoKHR32;
6098 typedef VkPipelineInfoKHR32 VkPipelineInfoEXT32;
6099
6100 typedef struct VkPipelineExecutablePropertiesKHR32
6101 {
6102     VkStructureType sType;
6103     PTR32 pNext;
6104     VkShaderStageFlags stages;
6105     char name[VK_MAX_DESCRIPTION_SIZE];
6106     char description[VK_MAX_DESCRIPTION_SIZE];
6107     uint32_t subgroupSize;
6108 } VkPipelineExecutablePropertiesKHR32;
6109
6110 typedef union VkPipelineExecutableStatisticValueKHR32
6111 {
6112     VkBool32 b32;
6113     int64_t i64;
6114     uint64_t DECLSPEC_ALIGN(8) u64;
6115     double f64;
6116 } VkPipelineExecutableStatisticValueKHR32;
6117
6118 typedef struct VkPipelineExecutableStatisticKHR32
6119 {
6120     VkStructureType sType;
6121     PTR32 pNext;
6122     char name[VK_MAX_DESCRIPTION_SIZE];
6123     char description[VK_MAX_DESCRIPTION_SIZE];
6124     VkPipelineExecutableStatisticFormatKHR format;
6125     VkPipelineExecutableStatisticValueKHR32 DECLSPEC_ALIGN(8) value;
6126 } VkPipelineExecutableStatisticKHR32;
6127
6128 typedef struct VkPipelineIndirectDeviceAddressInfoNV32
6129 {
6130     VkStructureType sType;
6131     PTR32 pNext;
6132     VkPipelineBindPoint pipelineBindPoint;
6133     VkPipeline DECLSPEC_ALIGN(8) pipeline;
6134 } VkPipelineIndirectDeviceAddressInfoNV32;
6135
6136
6137 typedef struct VkCheckpointData2NV32
6138 {
6139     VkStructureType sType;
6140     PTR32 pNext;
6141     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
6142     PTR32 pCheckpointMarker;
6143 } VkCheckpointData2NV32;
6144
6145 typedef struct VkCheckpointDataNV32
6146 {
6147     VkStructureType sType;
6148     PTR32 pNext;
6149     VkPipelineStageFlagBits stage;
6150     PTR32 pCheckpointMarker;
6151 } VkCheckpointDataNV32;
6152
6153 typedef struct VkRenderingAreaInfoKHR32
6154 {
6155     VkStructureType sType;
6156     PTR32 pNext;
6157     uint32_t viewMask;
6158     uint32_t colorAttachmentCount;
6159     PTR32 pColorAttachmentFormats;
6160     VkFormat depthAttachmentFormat;
6161     VkFormat stencilAttachmentFormat;
6162 } VkRenderingAreaInfoKHR32;
6163
6164 typedef struct VkSamplerCaptureDescriptorDataInfoEXT32
6165 {
6166     VkStructureType sType;
6167     PTR32 pNext;
6168     VkSampler DECLSPEC_ALIGN(8) sampler;
6169 } VkSamplerCaptureDescriptorDataInfoEXT32;
6170
6171 typedef struct VkShaderModuleIdentifierEXT32
6172 {
6173     VkStructureType sType;
6174     PTR32 pNext;
6175     uint32_t identifierSize;
6176     uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT];
6177 } VkShaderModuleIdentifierEXT32;
6178
6179 typedef struct VkInitializePerformanceApiInfoINTEL32
6180 {
6181     VkStructureType sType;
6182     PTR32 pNext;
6183     PTR32 pUserData;
6184 } VkInitializePerformanceApiInfoINTEL32;
6185
6186 typedef struct VkMemoryMapInfoKHR32
6187 {
6188     VkStructureType sType;
6189     PTR32 pNext;
6190     VkMemoryMapFlags flags;
6191     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
6192     VkDeviceSize DECLSPEC_ALIGN(8) offset;
6193     VkDeviceSize DECLSPEC_ALIGN(8) size;
6194 } VkMemoryMapInfoKHR32;
6195
6196 typedef struct VkSparseMemoryBind32
6197 {
6198     VkDeviceSize DECLSPEC_ALIGN(8) resourceOffset;
6199     VkDeviceSize DECLSPEC_ALIGN(8) size;
6200     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
6201     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
6202     VkSparseMemoryBindFlags flags;
6203 } VkSparseMemoryBind32;
6204
6205 typedef struct VkSparseBufferMemoryBindInfo32
6206 {
6207     VkBuffer DECLSPEC_ALIGN(8) buffer;
6208     uint32_t bindCount;
6209     PTR32 pBinds;
6210 } VkSparseBufferMemoryBindInfo32;
6211
6212 typedef struct VkSparseImageOpaqueMemoryBindInfo32
6213 {
6214     VkImage DECLSPEC_ALIGN(8) image;
6215     uint32_t bindCount;
6216     PTR32 pBinds;
6217 } VkSparseImageOpaqueMemoryBindInfo32;
6218
6219 typedef struct VkSparseImageMemoryBind32
6220 {
6221     VkImageSubresource subresource;
6222     VkOffset3D offset;
6223     VkExtent3D extent;
6224     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
6225     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
6226     VkSparseMemoryBindFlags flags;
6227 } VkSparseImageMemoryBind32;
6228
6229 typedef struct VkSparseImageMemoryBindInfo32
6230 {
6231     VkImage DECLSPEC_ALIGN(8) image;
6232     uint32_t bindCount;
6233     PTR32 pBinds;
6234 } VkSparseImageMemoryBindInfo32;
6235
6236 typedef struct VkDeviceGroupBindSparseInfo32
6237 {
6238     VkStructureType sType;
6239     PTR32 pNext;
6240     uint32_t resourceDeviceIndex;
6241     uint32_t memoryDeviceIndex;
6242 } VkDeviceGroupBindSparseInfo32;
6243 typedef VkDeviceGroupBindSparseInfo32 VkDeviceGroupBindSparseInfoKHR32;
6244
6245 typedef struct VkTimelineSemaphoreSubmitInfo32
6246 {
6247     VkStructureType sType;
6248     PTR32 pNext;
6249     uint32_t waitSemaphoreValueCount;
6250     PTR32 pWaitSemaphoreValues;
6251     uint32_t signalSemaphoreValueCount;
6252     PTR32 pSignalSemaphoreValues;
6253 } VkTimelineSemaphoreSubmitInfo32;
6254 typedef VkTimelineSemaphoreSubmitInfo32 VkTimelineSemaphoreSubmitInfoKHR32;
6255
6256 typedef struct VkBindSparseInfo32
6257 {
6258     VkStructureType sType;
6259     PTR32 pNext;
6260     uint32_t waitSemaphoreCount;
6261     PTR32 pWaitSemaphores;
6262     uint32_t bufferBindCount;
6263     PTR32 pBufferBinds;
6264     uint32_t imageOpaqueBindCount;
6265     PTR32 pImageOpaqueBinds;
6266     uint32_t imageBindCount;
6267     PTR32 pImageBinds;
6268     uint32_t signalSemaphoreCount;
6269     PTR32 pSignalSemaphores;
6270 } VkBindSparseInfo32;
6271
6272 typedef struct VkPresentRegionKHR32
6273 {
6274     uint32_t rectangleCount;
6275     PTR32 pRectangles;
6276 } VkPresentRegionKHR32;
6277
6278 typedef struct VkPresentRegionsKHR32
6279 {
6280     VkStructureType sType;
6281     PTR32 pNext;
6282     uint32_t swapchainCount;
6283     PTR32 pRegions;
6284 } VkPresentRegionsKHR32;
6285
6286 typedef struct VkDeviceGroupPresentInfoKHR32
6287 {
6288     VkStructureType sType;
6289     PTR32 pNext;
6290     uint32_t swapchainCount;
6291     PTR32 pDeviceMasks;
6292     VkDeviceGroupPresentModeFlagBitsKHR mode;
6293 } VkDeviceGroupPresentInfoKHR32;
6294
6295 typedef struct VkPresentIdKHR32
6296 {
6297     VkStructureType sType;
6298     PTR32 pNext;
6299     uint32_t swapchainCount;
6300     PTR32 pPresentIds;
6301 } VkPresentIdKHR32;
6302
6303 typedef struct VkSwapchainPresentFenceInfoEXT32
6304 {
6305     VkStructureType sType;
6306     PTR32 pNext;
6307     uint32_t swapchainCount;
6308     PTR32 pFences;
6309 } VkSwapchainPresentFenceInfoEXT32;
6310
6311 typedef struct VkSwapchainPresentModeInfoEXT32
6312 {
6313     VkStructureType sType;
6314     PTR32 pNext;
6315     uint32_t swapchainCount;
6316     PTR32 pPresentModes;
6317 } VkSwapchainPresentModeInfoEXT32;
6318
6319 typedef struct VkPresentInfoKHR32
6320 {
6321     VkStructureType sType;
6322     PTR32 pNext;
6323     uint32_t waitSemaphoreCount;
6324     PTR32 pWaitSemaphores;
6325     uint32_t swapchainCount;
6326     PTR32 pSwapchains;
6327     PTR32 pImageIndices;
6328     PTR32 pResults;
6329 } VkPresentInfoKHR32;
6330
6331 typedef struct VkDeviceGroupSubmitInfo32
6332 {
6333     VkStructureType sType;
6334     PTR32 pNext;
6335     uint32_t waitSemaphoreCount;
6336     PTR32 pWaitSemaphoreDeviceIndices;
6337     uint32_t commandBufferCount;
6338     PTR32 pCommandBufferDeviceMasks;
6339     uint32_t signalSemaphoreCount;
6340     PTR32 pSignalSemaphoreDeviceIndices;
6341 } VkDeviceGroupSubmitInfo32;
6342 typedef VkDeviceGroupSubmitInfo32 VkDeviceGroupSubmitInfoKHR32;
6343
6344 typedef struct VkProtectedSubmitInfo32
6345 {
6346     VkStructureType sType;
6347     PTR32 pNext;
6348     VkBool32 protectedSubmit;
6349 } VkProtectedSubmitInfo32;
6350
6351 typedef struct VkPerformanceQuerySubmitInfoKHR32
6352 {
6353     VkStructureType sType;
6354     PTR32 pNext;
6355     uint32_t counterPassIndex;
6356 } VkPerformanceQuerySubmitInfoKHR32;
6357
6358 typedef struct VkSubmitInfo32
6359 {
6360     VkStructureType sType;
6361     PTR32 pNext;
6362     uint32_t waitSemaphoreCount;
6363     PTR32 pWaitSemaphores;
6364     PTR32 pWaitDstStageMask;
6365     uint32_t commandBufferCount;
6366     PTR32 pCommandBuffers;
6367     uint32_t signalSemaphoreCount;
6368     PTR32 pSignalSemaphores;
6369 } VkSubmitInfo32;
6370
6371 typedef struct VkSemaphoreSubmitInfo32
6372 {
6373     VkStructureType sType;
6374     PTR32 pNext;
6375     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
6376     uint64_t DECLSPEC_ALIGN(8) value;
6377     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
6378     uint32_t deviceIndex;
6379 } VkSemaphoreSubmitInfo32;
6380 typedef VkSemaphoreSubmitInfo32 VkSemaphoreSubmitInfoKHR32;
6381
6382 typedef struct VkCommandBufferSubmitInfo32
6383 {
6384     VkStructureType sType;
6385     PTR32 pNext;
6386     PTR32 commandBuffer;
6387     uint32_t deviceMask;
6388 } VkCommandBufferSubmitInfo32;
6389 typedef VkCommandBufferSubmitInfo32 VkCommandBufferSubmitInfoKHR32;
6390
6391 typedef struct VkSubmitInfo232
6392 {
6393     VkStructureType sType;
6394     PTR32 pNext;
6395     VkSubmitFlags flags;
6396     uint32_t waitSemaphoreInfoCount;
6397     PTR32 pWaitSemaphoreInfos;
6398     uint32_t commandBufferInfoCount;
6399     PTR32 pCommandBufferInfos;
6400     uint32_t signalSemaphoreInfoCount;
6401     PTR32 pSignalSemaphoreInfos;
6402 } VkSubmitInfo232;
6403 typedef VkSubmitInfo232 VkSubmitInfo2KHR32;
6404
6405 typedef struct VkReleaseSwapchainImagesInfoEXT32
6406 {
6407     VkStructureType sType;
6408     PTR32 pNext;
6409     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
6410     uint32_t imageIndexCount;
6411     PTR32 pImageIndices;
6412 } VkReleaseSwapchainImagesInfoEXT32;
6413
6414 typedef struct VkDebugUtilsObjectTagInfoEXT32
6415 {
6416     VkStructureType sType;
6417     PTR32 pNext;
6418     VkObjectType objectType;
6419     uint64_t DECLSPEC_ALIGN(8) objectHandle;
6420     uint64_t DECLSPEC_ALIGN(8) tagName;
6421     PTR32 tagSize;
6422     PTR32 pTag;
6423 } VkDebugUtilsObjectTagInfoEXT32;
6424
6425 typedef struct VkHdrMetadataEXT32
6426 {
6427     VkStructureType sType;
6428     PTR32 pNext;
6429     VkXYColorEXT displayPrimaryRed;
6430     VkXYColorEXT displayPrimaryGreen;
6431     VkXYColorEXT displayPrimaryBlue;
6432     VkXYColorEXT whitePoint;
6433     float maxLuminance;
6434     float minLuminance;
6435     float maxContentLightLevel;
6436     float maxFrameAverageLightLevel;
6437 } VkHdrMetadataEXT32;
6438
6439 typedef struct VkSemaphoreSignalInfo32
6440 {
6441     VkStructureType sType;
6442     PTR32 pNext;
6443     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
6444     uint64_t DECLSPEC_ALIGN(8) value;
6445 } VkSemaphoreSignalInfo32;
6446 typedef VkSemaphoreSignalInfo32 VkSemaphoreSignalInfoKHR32;
6447
6448 typedef struct VkDeviceAddressBindingCallbackDataEXT32
6449 {
6450     VkStructureType sType;
6451     PTR32 pNext;
6452     VkDeviceAddressBindingFlagsEXT flags;
6453     VkDeviceAddress DECLSPEC_ALIGN(8) baseAddress;
6454     VkDeviceSize DECLSPEC_ALIGN(8) size;
6455     VkDeviceAddressBindingTypeEXT bindingType;
6456 } VkDeviceAddressBindingCallbackDataEXT32;
6457
6458 typedef struct VkDebugUtilsMessengerCallbackDataEXT32
6459 {
6460     VkStructureType sType;
6461     PTR32 pNext;
6462     VkDebugUtilsMessengerCallbackDataFlagsEXT flags;
6463     PTR32 pMessageIdName;
6464     int32_t messageIdNumber;
6465     PTR32 pMessage;
6466     uint32_t queueLabelCount;
6467     PTR32 pQueueLabels;
6468     uint32_t cmdBufLabelCount;
6469     PTR32 pCmdBufLabels;
6470     uint32_t objectCount;
6471     PTR32 pObjects;
6472 } VkDebugUtilsMessengerCallbackDataEXT32;
6473
6474 typedef struct VkHostImageLayoutTransitionInfoEXT32
6475 {
6476     VkStructureType sType;
6477     PTR32 pNext;
6478     VkImage DECLSPEC_ALIGN(8) image;
6479     VkImageLayout oldLayout;
6480     VkImageLayout newLayout;
6481     VkImageSubresourceRange subresourceRange;
6482 } VkHostImageLayoutTransitionInfoEXT32;
6483
6484 typedef struct VkMemoryUnmapInfoKHR32
6485 {
6486     VkStructureType sType;
6487     PTR32 pNext;
6488     VkMemoryUnmapFlagsKHR flags;
6489     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
6490 } VkMemoryUnmapInfoKHR32;
6491
6492 typedef struct VkCopyDescriptorSet32
6493 {
6494     VkStructureType sType;
6495     PTR32 pNext;
6496     VkDescriptorSet DECLSPEC_ALIGN(8) srcSet;
6497     uint32_t srcBinding;
6498     uint32_t srcArrayElement;
6499     VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
6500     uint32_t dstBinding;
6501     uint32_t dstArrayElement;
6502     uint32_t descriptorCount;
6503 } VkCopyDescriptorSet32;
6504
6505 typedef struct VkSemaphoreWaitInfo32
6506 {
6507     VkStructureType sType;
6508     PTR32 pNext;
6509     VkSemaphoreWaitFlags flags;
6510     uint32_t semaphoreCount;
6511     PTR32 pSemaphores;
6512     PTR32 pValues;
6513 } VkSemaphoreWaitInfo32;
6514 typedef VkSemaphoreWaitInfo32 VkSemaphoreWaitInfoKHR32;
6515
6516 static uint64_t wine_vk_unwrap_handle(uint32_t type, uint64_t handle)
6517 {
6518     switch(type)
6519     {
6520     case VK_OBJECT_TYPE_COMMAND_BUFFER:
6521         return (uint64_t) (uintptr_t) wine_cmd_buffer_from_handle(((VkCommandBuffer) (uintptr_t) handle))->command_buffer;
6522     case VK_OBJECT_TYPE_COMMAND_POOL:
6523         return (uint64_t) wine_cmd_pool_from_handle(handle)->command_pool;
6524     case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
6525         return (uint64_t) wine_debug_report_callback_from_handle(handle)->debug_callback;
6526     case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
6527         return (uint64_t) wine_debug_utils_messenger_from_handle(handle)->debug_messenger;
6528     case VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR:
6529         return (uint64_t) wine_deferred_operation_from_handle(handle)->deferred_operation;
6530     case VK_OBJECT_TYPE_DEVICE:
6531         return (uint64_t) (uintptr_t) wine_device_from_handle(((VkDevice) (uintptr_t) handle))->device;
6532     case VK_OBJECT_TYPE_DEVICE_MEMORY:
6533         return (uint64_t) wine_device_memory_from_handle(handle)->memory;
6534     case VK_OBJECT_TYPE_INSTANCE:
6535         return (uint64_t) (uintptr_t) wine_instance_from_handle(((VkInstance) (uintptr_t) handle))->instance;
6536     case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
6537         return (uint64_t) (uintptr_t) wine_phys_dev_from_handle(((VkPhysicalDevice) (uintptr_t) handle))->phys_dev;
6538     case VK_OBJECT_TYPE_QUEUE:
6539         return (uint64_t) (uintptr_t) wine_queue_from_handle(((VkQueue) (uintptr_t) handle))->queue;
6540     case VK_OBJECT_TYPE_SURFACE_KHR:
6541         return (uint64_t) wine_surface_from_handle(handle)->surface;
6542     default:
6543        return handle;
6544     }
6545 }
6546
6547 static inline void convert_VkAcquireNextImageInfoKHR_win32_to_host(const VkAcquireNextImageInfoKHR32 *in, VkAcquireNextImageInfoKHR *out)
6548 {
6549     if (!in) return;
6550
6551     out->sType = in->sType;
6552     out->pNext = NULL;
6553     out->swapchain = in->swapchain;
6554     out->timeout = in->timeout;
6555     out->semaphore = in->semaphore;
6556     out->fence = in->fence;
6557     out->deviceMask = in->deviceMask;
6558     if (in->pNext)
6559         FIXME("Unexpected pNext\n");
6560 }
6561
6562 static inline void convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host(const VkPerformanceConfigurationAcquireInfoINTEL32 *in, VkPerformanceConfigurationAcquireInfoINTEL *out)
6563 {
6564     if (!in) return;
6565
6566     out->sType = in->sType;
6567     out->pNext = NULL;
6568     out->type = in->type;
6569     if (in->pNext)
6570         FIXME("Unexpected pNext\n");
6571 }
6572
6573 static inline void convert_VkAcquireProfilingLockInfoKHR_win32_to_host(const VkAcquireProfilingLockInfoKHR32 *in, VkAcquireProfilingLockInfoKHR *out)
6574 {
6575     if (!in) return;
6576
6577     out->sType = in->sType;
6578     out->pNext = NULL;
6579     out->flags = in->flags;
6580     out->timeout = in->timeout;
6581     if (in->pNext)
6582         FIXME("Unexpected pNext\n");
6583 }
6584
6585 static inline void convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(const VkCommandBufferAllocateInfo32 *in, VkCommandBufferAllocateInfo *out)
6586 {
6587     if (!in) return;
6588
6589     out->sType = in->sType;
6590     out->pNext = NULL;
6591     out->commandPool = in->commandPool;
6592     out->level = in->level;
6593     out->commandBufferCount = in->commandBufferCount;
6594     if (in->pNext)
6595         FIXME("Unexpected pNext\n");
6596 }
6597
6598 static inline VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_unwrapped_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
6599 {
6600     VkCommandBuffer *out;
6601     unsigned int i;
6602
6603     if (!in || !count) return NULL;
6604
6605     out = conversion_context_alloc(ctx, count * sizeof(*out));
6606     for (i = 0; i < count; i++)
6607     {
6608         out[i] = UlongToPtr(in[i]);
6609     }
6610
6611     return out;
6612 }
6613
6614 static inline void convert_VkDescriptorSetAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetAllocateInfo32 *in, VkDescriptorSetAllocateInfo *out)
6615 {
6616     const VkBaseInStructure32 *in_header;
6617     VkBaseOutStructure *out_header = (void *)out;
6618
6619     if (!in) return;
6620
6621     out->sType = in->sType;
6622     out->pNext = NULL;
6623     out->descriptorPool = in->descriptorPool;
6624     out->descriptorSetCount = in->descriptorSetCount;
6625     out->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in->pSetLayouts);
6626
6627     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6628     {
6629         switch (in_header->sType)
6630         {
6631         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
6632         {
6633             VkDescriptorSetVariableDescriptorCountAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6634             const VkDescriptorSetVariableDescriptorCountAllocateInfo32 *in_ext = (const VkDescriptorSetVariableDescriptorCountAllocateInfo32 *)in_header;
6635             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
6636             out_ext->pNext = NULL;
6637             out_ext->descriptorSetCount = in_ext->descriptorSetCount;
6638             out_ext->pDescriptorCounts = (const uint32_t *)UlongToPtr(in_ext->pDescriptorCounts);
6639             out_header->pNext = (void *)out_ext;
6640             out_header = (void *)out_ext;
6641             break;
6642         }
6643         default:
6644             FIXME("Unhandled sType %u.\n", in_header->sType);
6645             break;
6646         }
6647     }
6648 }
6649
6650 static inline void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryAllocateInfo32 *in, VkMemoryAllocateInfo *out)
6651 {
6652     const VkBaseInStructure32 *in_header;
6653     VkBaseOutStructure *out_header = (void *)out;
6654
6655     if (!in) return;
6656
6657     out->sType = in->sType;
6658     out->pNext = NULL;
6659     out->allocationSize = in->allocationSize;
6660     out->memoryTypeIndex = in->memoryTypeIndex;
6661
6662     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6663     {
6664         switch (in_header->sType)
6665         {
6666         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
6667         {
6668             VkDedicatedAllocationMemoryAllocateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6669             const VkDedicatedAllocationMemoryAllocateInfoNV32 *in_ext = (const VkDedicatedAllocationMemoryAllocateInfoNV32 *)in_header;
6670             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV;
6671             out_ext->pNext = NULL;
6672             out_ext->image = in_ext->image;
6673             out_ext->buffer = in_ext->buffer;
6674             out_header->pNext = (void *)out_ext;
6675             out_header = (void *)out_ext;
6676             break;
6677         }
6678         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
6679         {
6680             VkExportMemoryAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6681             const VkExportMemoryAllocateInfo32 *in_ext = (const VkExportMemoryAllocateInfo32 *)in_header;
6682             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
6683             out_ext->pNext = NULL;
6684             out_ext->handleTypes = in_ext->handleTypes;
6685             out_header->pNext = (void *)out_ext;
6686             out_header = (void *)out_ext;
6687             break;
6688         }
6689         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
6690         {
6691             VkImportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6692             const VkImportMemoryWin32HandleInfoKHR32 *in_ext = (const VkImportMemoryWin32HandleInfoKHR32 *)in_header;
6693             out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
6694             out_ext->pNext = NULL;
6695             out_ext->handleType = in_ext->handleType;
6696             out_ext->handle = in_ext->handle;
6697             out_ext->name = in_ext->name;
6698             out_header->pNext = (void *)out_ext;
6699             out_header = (void *)out_ext;
6700             break;
6701         }
6702         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
6703         {
6704             VkExportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6705             const VkExportMemoryWin32HandleInfoKHR32 *in_ext = (const VkExportMemoryWin32HandleInfoKHR32 *)in_header;
6706             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
6707             out_ext->pNext = NULL;
6708             out_ext->pAttributes = (const SECURITY_ATTRIBUTES *)UlongToPtr(in_ext->pAttributes);
6709             out_ext->dwAccess = in_ext->dwAccess;
6710             out_ext->name = in_ext->name;
6711             out_header->pNext = (void *)out_ext;
6712             out_header = (void *)out_ext;
6713             break;
6714         }
6715         case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
6716         {
6717             VkMemoryAllocateFlagsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6718             const VkMemoryAllocateFlagsInfo32 *in_ext = (const VkMemoryAllocateFlagsInfo32 *)in_header;
6719             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO;
6720             out_ext->pNext = NULL;
6721             out_ext->flags = in_ext->flags;
6722             out_ext->deviceMask = in_ext->deviceMask;
6723             out_header->pNext = (void *)out_ext;
6724             out_header = (void *)out_ext;
6725             break;
6726         }
6727         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
6728         {
6729             VkMemoryDedicatedAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6730             const VkMemoryDedicatedAllocateInfo32 *in_ext = (const VkMemoryDedicatedAllocateInfo32 *)in_header;
6731             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
6732             out_ext->pNext = NULL;
6733             out_ext->image = in_ext->image;
6734             out_ext->buffer = in_ext->buffer;
6735             out_header->pNext = (void *)out_ext;
6736             out_header = (void *)out_ext;
6737             break;
6738         }
6739         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
6740         {
6741             VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6742             const VkImportMemoryHostPointerInfoEXT32 *in_ext = (const VkImportMemoryHostPointerInfoEXT32 *)in_header;
6743             out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT;
6744             out_ext->pNext = NULL;
6745             out_ext->handleType = in_ext->handleType;
6746             out_ext->pHostPointer = (void *)UlongToPtr(in_ext->pHostPointer);
6747             out_header->pNext = (void *)out_ext;
6748             out_header = (void *)out_ext;
6749             break;
6750         }
6751         case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
6752         {
6753             VkMemoryPriorityAllocateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6754             const VkMemoryPriorityAllocateInfoEXT32 *in_ext = (const VkMemoryPriorityAllocateInfoEXT32 *)in_header;
6755             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT;
6756             out_ext->pNext = NULL;
6757             out_ext->priority = in_ext->priority;
6758             out_header->pNext = (void *)out_ext;
6759             out_header = (void *)out_ext;
6760             break;
6761         }
6762         case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
6763         {
6764             VkMemoryOpaqueCaptureAddressAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6765             const VkMemoryOpaqueCaptureAddressAllocateInfo32 *in_ext = (const VkMemoryOpaqueCaptureAddressAllocateInfo32 *)in_header;
6766             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
6767             out_ext->pNext = NULL;
6768             out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress;
6769             out_header->pNext = (void *)out_ext;
6770             out_header = (void *)out_ext;
6771             break;
6772         }
6773         default:
6774             FIXME("Unhandled sType %u.\n", in_header->sType);
6775             break;
6776         }
6777     }
6778 }
6779
6780 static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, VkCommandBufferInheritanceInfo *out)
6781 {
6782     const VkBaseInStructure32 *in_header;
6783     VkBaseOutStructure *out_header = (void *)out;
6784
6785     if (!in) return;
6786
6787     out->sType = in->sType;
6788     out->pNext = NULL;
6789     out->renderPass = in->renderPass;
6790     out->subpass = in->subpass;
6791     out->framebuffer = in->framebuffer;
6792     out->occlusionQueryEnable = in->occlusionQueryEnable;
6793     out->queryFlags = in->queryFlags;
6794     out->pipelineStatistics = in->pipelineStatistics;
6795
6796     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6797     {
6798         switch (in_header->sType)
6799         {
6800         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
6801         {
6802             VkCommandBufferInheritanceConditionalRenderingInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6803             const VkCommandBufferInheritanceConditionalRenderingInfoEXT32 *in_ext = (const VkCommandBufferInheritanceConditionalRenderingInfoEXT32 *)in_header;
6804             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT;
6805             out_ext->pNext = NULL;
6806             out_ext->conditionalRenderingEnable = in_ext->conditionalRenderingEnable;
6807             out_header->pNext = (void *)out_ext;
6808             out_header = (void *)out_ext;
6809             break;
6810         }
6811         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
6812         {
6813             VkCommandBufferInheritanceRenderPassTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6814             const VkCommandBufferInheritanceRenderPassTransformInfoQCOM32 *in_ext = (const VkCommandBufferInheritanceRenderPassTransformInfoQCOM32 *)in_header;
6815             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM;
6816             out_ext->pNext = NULL;
6817             out_ext->transform = in_ext->transform;
6818             out_ext->renderArea = in_ext->renderArea;
6819             out_header->pNext = (void *)out_ext;
6820             out_header = (void *)out_ext;
6821             break;
6822         }
6823         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
6824         {
6825             VkCommandBufferInheritanceViewportScissorInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6826             const VkCommandBufferInheritanceViewportScissorInfoNV32 *in_ext = (const VkCommandBufferInheritanceViewportScissorInfoNV32 *)in_header;
6827             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV;
6828             out_ext->pNext = NULL;
6829             out_ext->viewportScissor2D = in_ext->viewportScissor2D;
6830             out_ext->viewportDepthCount = in_ext->viewportDepthCount;
6831             out_ext->pViewportDepths = (const VkViewport *)UlongToPtr(in_ext->pViewportDepths);
6832             out_header->pNext = (void *)out_ext;
6833             out_header = (void *)out_ext;
6834             break;
6835         }
6836         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
6837         {
6838             VkCommandBufferInheritanceRenderingInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6839             const VkCommandBufferInheritanceRenderingInfo32 *in_ext = (const VkCommandBufferInheritanceRenderingInfo32 *)in_header;
6840             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
6841             out_ext->pNext = NULL;
6842             out_ext->flags = in_ext->flags;
6843             out_ext->viewMask = in_ext->viewMask;
6844             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
6845             out_ext->pColorAttachmentFormats = (const VkFormat *)UlongToPtr(in_ext->pColorAttachmentFormats);
6846             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
6847             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
6848             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
6849             out_header->pNext = (void *)out_ext;
6850             out_header = (void *)out_ext;
6851             break;
6852         }
6853         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
6854         {
6855             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6856             const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header;
6857             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
6858             out_ext->pNext = NULL;
6859             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
6860             out_ext->pColorAttachmentSamples = (const VkSampleCountFlagBits *)UlongToPtr(in_ext->pColorAttachmentSamples);
6861             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
6862             out_header->pNext = (void *)out_ext;
6863             out_header = (void *)out_ext;
6864             break;
6865         }
6866         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
6867         {
6868             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6869             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
6870             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
6871             out_ext->pNext = NULL;
6872             out_ext->perViewAttributes = in_ext->perViewAttributes;
6873             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
6874             out_header->pNext = (void *)out_ext;
6875             out_header = (void *)out_ext;
6876             break;
6877         }
6878         default:
6879             FIXME("Unhandled sType %u.\n", in_header->sType);
6880             break;
6881         }
6882     }
6883 }
6884
6885 static inline const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInheritanceInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, uint32_t count)
6886 {
6887     VkCommandBufferInheritanceInfo *out;
6888     unsigned int i;
6889
6890     if (!in || !count) return NULL;
6891
6892     out = conversion_context_alloc(ctx, count * sizeof(*out));
6893     for (i = 0; i < count; i++)
6894     {
6895         convert_VkCommandBufferInheritanceInfo_win32_to_host(ctx, &in[i], &out[i]);
6896     }
6897
6898     return out;
6899 }
6900
6901 static inline void convert_VkCommandBufferBeginInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferBeginInfo32 *in, VkCommandBufferBeginInfo *out)
6902 {
6903     const VkBaseInStructure32 *in_header;
6904     VkBaseOutStructure *out_header = (void *)out;
6905
6906     if (!in) return;
6907
6908     out->sType = in->sType;
6909     out->pNext = NULL;
6910     out->flags = in->flags;
6911     out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win32_to_host(ctx, (const VkCommandBufferInheritanceInfo32 *)UlongToPtr(in->pInheritanceInfo), 1);
6912
6913     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6914     {
6915         switch (in_header->sType)
6916         {
6917         case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
6918         {
6919             VkDeviceGroupCommandBufferBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6920             const VkDeviceGroupCommandBufferBeginInfo32 *in_ext = (const VkDeviceGroupCommandBufferBeginInfo32 *)in_header;
6921             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
6922             out_ext->pNext = NULL;
6923             out_ext->deviceMask = in_ext->deviceMask;
6924             out_header->pNext = (void *)out_ext;
6925             out_header = (void *)out_ext;
6926             break;
6927         }
6928         default:
6929             FIXME("Unhandled sType %u.\n", in_header->sType);
6930             break;
6931         }
6932     }
6933 }
6934
6935 #ifdef _WIN64
6936 static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win64_to_host(const VkBindAccelerationStructureMemoryInfoNV *in, VkBindAccelerationStructureMemoryInfoNV *out)
6937 {
6938     if (!in) return;
6939
6940     out->sType = in->sType;
6941     out->pNext = in->pNext;
6942     out->accelerationStructure = in->accelerationStructure;
6943     out->memory = wine_device_memory_from_handle(in->memory)->memory;
6944     out->memoryOffset = in->memoryOffset;
6945     out->deviceIndexCount = in->deviceIndexCount;
6946     out->pDeviceIndices = in->pDeviceIndices;
6947 }
6948 #endif /* _WIN64 */
6949
6950 static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(const VkBindAccelerationStructureMemoryInfoNV32 *in, VkBindAccelerationStructureMemoryInfoNV *out)
6951 {
6952     if (!in) return;
6953
6954     out->sType = in->sType;
6955     out->pNext = NULL;
6956     out->accelerationStructure = in->accelerationStructure;
6957     out->memory = wine_device_memory_from_handle(in->memory)->memory;
6958     out->memoryOffset = in->memoryOffset;
6959     out->deviceIndexCount = in->deviceIndexCount;
6960     out->pDeviceIndices = (const uint32_t *)UlongToPtr(in->pDeviceIndices);
6961     if (in->pNext)
6962         FIXME("Unexpected pNext\n");
6963 }
6964
6965 #ifdef _WIN64
6966 static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV *in, uint32_t count)
6967 {
6968     VkBindAccelerationStructureMemoryInfoNV *out;
6969     unsigned int i;
6970
6971     if (!in || !count) return NULL;
6972
6973     out = conversion_context_alloc(ctx, count * sizeof(*out));
6974     for (i = 0; i < count; i++)
6975     {
6976         convert_VkBindAccelerationStructureMemoryInfoNV_win64_to_host(&in[i], &out[i]);
6977     }
6978
6979     return out;
6980 }
6981 #endif /* _WIN64 */
6982
6983 static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV32 *in, uint32_t count)
6984 {
6985     VkBindAccelerationStructureMemoryInfoNV *out;
6986     unsigned int i;
6987
6988     if (!in || !count) return NULL;
6989
6990     out = conversion_context_alloc(ctx, count * sizeof(*out));
6991     for (i = 0; i < count; i++)
6992     {
6993         convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(&in[i], &out[i]);
6994     }
6995
6996     return out;
6997 }
6998
6999 #ifdef _WIN64
7000 static inline void convert_VkBindBufferMemoryInfo_win64_to_host(const VkBindBufferMemoryInfo *in, VkBindBufferMemoryInfo *out)
7001 {
7002     if (!in) return;
7003
7004     out->sType = in->sType;
7005     out->pNext = in->pNext;
7006     out->buffer = in->buffer;
7007     out->memory = wine_device_memory_from_handle(in->memory)->memory;
7008     out->memoryOffset = in->memoryOffset;
7009 }
7010 #endif /* _WIN64 */
7011
7012 static inline void convert_VkBindBufferMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, VkBindBufferMemoryInfo *out)
7013 {
7014     const VkBaseInStructure32 *in_header;
7015     VkBaseOutStructure *out_header = (void *)out;
7016
7017     if (!in) return;
7018
7019     out->sType = in->sType;
7020     out->pNext = NULL;
7021     out->buffer = in->buffer;
7022     out->memory = wine_device_memory_from_handle(in->memory)->memory;
7023     out->memoryOffset = in->memoryOffset;
7024
7025     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7026     {
7027         switch (in_header->sType)
7028         {
7029         case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
7030         {
7031             VkBindBufferMemoryDeviceGroupInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7032             const VkBindBufferMemoryDeviceGroupInfo32 *in_ext = (const VkBindBufferMemoryDeviceGroupInfo32 *)in_header;
7033             out_ext->sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
7034             out_ext->pNext = NULL;
7035             out_ext->deviceIndexCount = in_ext->deviceIndexCount;
7036             out_ext->pDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pDeviceIndices);
7037             out_header->pNext = (void *)out_ext;
7038             out_header = (void *)out_ext;
7039             break;
7040         }
7041         default:
7042             FIXME("Unhandled sType %u.\n", in_header->sType);
7043             break;
7044         }
7045     }
7046 }
7047
7048 #ifdef _WIN64
7049 static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo *in, uint32_t count)
7050 {
7051     VkBindBufferMemoryInfo *out;
7052     unsigned int i;
7053
7054     if (!in || !count) return NULL;
7055
7056     out = conversion_context_alloc(ctx, count * sizeof(*out));
7057     for (i = 0; i < count; i++)
7058     {
7059         convert_VkBindBufferMemoryInfo_win64_to_host(&in[i], &out[i]);
7060     }
7061
7062     return out;
7063 }
7064 #endif /* _WIN64 */
7065
7066 static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, uint32_t count)
7067 {
7068     VkBindBufferMemoryInfo *out;
7069     unsigned int i;
7070
7071     if (!in || !count) return NULL;
7072
7073     out = conversion_context_alloc(ctx, count * sizeof(*out));
7074     for (i = 0; i < count; i++)
7075     {
7076         convert_VkBindBufferMemoryInfo_win32_to_host(ctx, &in[i], &out[i]);
7077     }
7078
7079     return out;
7080 }
7081
7082 #ifdef _WIN64
7083 static inline void convert_VkBindImageMemoryInfo_win64_to_host(const VkBindImageMemoryInfo *in, VkBindImageMemoryInfo *out)
7084 {
7085     if (!in) return;
7086
7087     out->sType = in->sType;
7088     out->pNext = in->pNext;
7089     out->image = in->image;
7090     out->memory = wine_device_memory_from_handle(in->memory)->memory;
7091     out->memoryOffset = in->memoryOffset;
7092 }
7093 #endif /* _WIN64 */
7094
7095 static inline void convert_VkBindImageMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, VkBindImageMemoryInfo *out)
7096 {
7097     const VkBaseInStructure32 *in_header;
7098     VkBaseOutStructure *out_header = (void *)out;
7099
7100     if (!in) return;
7101
7102     out->sType = in->sType;
7103     out->pNext = NULL;
7104     out->image = in->image;
7105     out->memory = wine_device_memory_from_handle(in->memory)->memory;
7106     out->memoryOffset = in->memoryOffset;
7107
7108     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7109     {
7110         switch (in_header->sType)
7111         {
7112         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
7113         {
7114             VkBindImageMemoryDeviceGroupInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7115             const VkBindImageMemoryDeviceGroupInfo32 *in_ext = (const VkBindImageMemoryDeviceGroupInfo32 *)in_header;
7116             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
7117             out_ext->pNext = NULL;
7118             out_ext->deviceIndexCount = in_ext->deviceIndexCount;
7119             out_ext->pDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pDeviceIndices);
7120             out_ext->splitInstanceBindRegionCount = in_ext->splitInstanceBindRegionCount;
7121             out_ext->pSplitInstanceBindRegions = (const VkRect2D *)UlongToPtr(in_ext->pSplitInstanceBindRegions);
7122             out_header->pNext = (void *)out_ext;
7123             out_header = (void *)out_ext;
7124             break;
7125         }
7126         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
7127         {
7128             VkBindImageMemorySwapchainInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7129             const VkBindImageMemorySwapchainInfoKHR32 *in_ext = (const VkBindImageMemorySwapchainInfoKHR32 *)in_header;
7130             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR;
7131             out_ext->pNext = NULL;
7132             out_ext->swapchain = in_ext->swapchain;
7133             out_ext->imageIndex = in_ext->imageIndex;
7134             out_header->pNext = (void *)out_ext;
7135             out_header = (void *)out_ext;
7136             break;
7137         }
7138         case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
7139         {
7140             VkBindImagePlaneMemoryInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7141             const VkBindImagePlaneMemoryInfo32 *in_ext = (const VkBindImagePlaneMemoryInfo32 *)in_header;
7142             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO;
7143             out_ext->pNext = NULL;
7144             out_ext->planeAspect = in_ext->planeAspect;
7145             out_header->pNext = (void *)out_ext;
7146             out_header = (void *)out_ext;
7147             break;
7148         }
7149         default:
7150             FIXME("Unhandled sType %u.\n", in_header->sType);
7151             break;
7152         }
7153     }
7154 }
7155
7156 #ifdef _WIN64
7157 static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo *in, uint32_t count)
7158 {
7159     VkBindImageMemoryInfo *out;
7160     unsigned int i;
7161
7162     if (!in || !count) return NULL;
7163
7164     out = conversion_context_alloc(ctx, count * sizeof(*out));
7165     for (i = 0; i < count; i++)
7166     {
7167         convert_VkBindImageMemoryInfo_win64_to_host(&in[i], &out[i]);
7168     }
7169
7170     return out;
7171 }
7172 #endif /* _WIN64 */
7173
7174 static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, uint32_t count)
7175 {
7176     VkBindImageMemoryInfo *out;
7177     unsigned int i;
7178
7179     if (!in || !count) return NULL;
7180
7181     out = conversion_context_alloc(ctx, count * sizeof(*out));
7182     for (i = 0; i < count; i++)
7183     {
7184         convert_VkBindImageMemoryInfo_win32_to_host(ctx, &in[i], &out[i]);
7185     }
7186
7187     return out;
7188 }
7189
7190 static inline const VkMicromapUsageEXT * const*convert_VkMicromapUsageEXT_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
7191 {
7192     VkMicromapUsageEXT **out;
7193     unsigned int i;
7194
7195     if (!in || !count) return NULL;
7196
7197     out = conversion_context_alloc(ctx, count * sizeof(*out));
7198     for (i = 0; i < count; i++)
7199     {
7200         out[i] = UlongToPtr(in[i]);
7201     }
7202
7203     return (void *)out;
7204 }
7205
7206 static inline void convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryTrianglesDataKHR32 *in, VkAccelerationStructureGeometryTrianglesDataKHR *out)
7207 {
7208     const VkBaseInStructure32 *in_header;
7209     VkBaseOutStructure *out_header = (void *)out;
7210
7211     if (!in) return;
7212
7213     out->sType = in->sType;
7214     out->pNext = NULL;
7215     out->vertexFormat = in->vertexFormat;
7216     out->vertexData = in->vertexData;
7217     out->vertexStride = in->vertexStride;
7218     out->maxVertex = in->maxVertex;
7219     out->indexType = in->indexType;
7220     out->indexData = in->indexData;
7221     out->transformData = in->transformData;
7222
7223     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7224     {
7225         switch (in_header->sType)
7226         {
7227         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
7228         {
7229             VkAccelerationStructureGeometryMotionTrianglesDataNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7230             const VkAccelerationStructureGeometryMotionTrianglesDataNV32 *in_ext = (const VkAccelerationStructureGeometryMotionTrianglesDataNV32 *)in_header;
7231             out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV;
7232             out_ext->pNext = NULL;
7233             out_ext->vertexData = in_ext->vertexData;
7234             out_header->pNext = (void *)out_ext;
7235             out_header = (void *)out_ext;
7236             break;
7237         }
7238         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
7239         {
7240             VkAccelerationStructureTrianglesOpacityMicromapEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7241             const VkAccelerationStructureTrianglesOpacityMicromapEXT32 *in_ext = (const VkAccelerationStructureTrianglesOpacityMicromapEXT32 *)in_header;
7242             out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT;
7243             out_ext->pNext = NULL;
7244             out_ext->indexType = in_ext->indexType;
7245             out_ext->indexBuffer = in_ext->indexBuffer;
7246             out_ext->indexStride = in_ext->indexStride;
7247             out_ext->baseTriangle = in_ext->baseTriangle;
7248             out_ext->usageCountsCount = in_ext->usageCountsCount;
7249             out_ext->pUsageCounts = (const VkMicromapUsageEXT *)UlongToPtr(in_ext->pUsageCounts);
7250             out_ext->ppUsageCounts = convert_VkMicromapUsageEXT_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->ppUsageCounts), in_ext->usageCountsCount);
7251             out_ext->micromap = in_ext->micromap;
7252             out_header->pNext = (void *)out_ext;
7253             out_header = (void *)out_ext;
7254             break;
7255         }
7256         default:
7257             FIXME("Unhandled sType %u.\n", in_header->sType);
7258             break;
7259         }
7260     }
7261 }
7262
7263 static inline void convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_host(const VkAccelerationStructureGeometryAabbsDataKHR32 *in, VkAccelerationStructureGeometryAabbsDataKHR *out)
7264 {
7265     if (!in) return;
7266
7267     out->sType = in->sType;
7268     out->pNext = NULL;
7269     out->data = in->data;
7270     out->stride = in->stride;
7271     if (in->pNext)
7272         FIXME("Unexpected pNext\n");
7273 }
7274
7275 static inline void convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(const VkAccelerationStructureGeometryInstancesDataKHR32 *in, VkAccelerationStructureGeometryInstancesDataKHR *out)
7276 {
7277     if (!in) return;
7278
7279     out->sType = in->sType;
7280     out->pNext = NULL;
7281     out->arrayOfPointers = in->arrayOfPointers;
7282     out->data = in->data;
7283     if (in->pNext)
7284         FIXME("Unexpected pNext\n");
7285 }
7286
7287 static inline void convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryDataKHR32 *in, VkAccelerationStructureGeometryDataKHR *out, VkFlags selector)
7288 {
7289     if (!in) return;
7290
7291     if (selector == VK_GEOMETRY_TYPE_TRIANGLES_KHR)
7292         convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_host(ctx, &in->triangles, &out->triangles);
7293     if (selector == VK_GEOMETRY_TYPE_AABBS_KHR)
7294         convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_host(&in->aabbs, &out->aabbs);
7295     if (selector == VK_GEOMETRY_TYPE_INSTANCES_KHR)
7296         convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(&in->instances, &out->instances);
7297 }
7298
7299 static inline void convert_VkAccelerationStructureGeometryKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, VkAccelerationStructureGeometryKHR *out)
7300 {
7301     if (!in) return;
7302
7303     out->sType = in->sType;
7304     out->pNext = NULL;
7305     out->geometryType = in->geometryType;
7306     convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(ctx, &in->geometry, &out->geometry, in->geometryType);
7307     out->flags = in->flags;
7308     if (in->pNext)
7309         FIXME("Unexpected pNext\n");
7310 }
7311
7312 static inline const VkAccelerationStructureGeometryKHR *convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, uint32_t count)
7313 {
7314     VkAccelerationStructureGeometryKHR *out;
7315     unsigned int i;
7316
7317     if (!in || !count) return NULL;
7318
7319     out = conversion_context_alloc(ctx, count * sizeof(*out));
7320     for (i = 0; i < count; i++)
7321     {
7322         convert_VkAccelerationStructureGeometryKHR_win32_to_host(ctx, &in[i], &out[i]);
7323     }
7324
7325     return out;
7326 }
7327
7328 static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
7329 {
7330     VkAccelerationStructureGeometryKHR **out;
7331     unsigned int i;
7332
7333     if (!in || !count) return NULL;
7334
7335     out = conversion_context_alloc(ctx, count * sizeof(*out));
7336     for (i = 0; i < count; i++)
7337     {
7338         if (in[i])
7339         {
7340             out[i] = conversion_context_alloc(ctx, sizeof(*out[i]));
7341             convert_VkAccelerationStructureGeometryKHR_win32_to_host(ctx, (VkAccelerationStructureGeometryKHR32 *)UlongToPtr(in[i]), out[i]);
7342         }
7343         else
7344             out[i] = NULL;
7345     }
7346
7347     return (void *)out;
7348 }
7349
7350 static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, VkAccelerationStructureBuildGeometryInfoKHR *out)
7351 {
7352     if (!in) return;
7353
7354     out->sType = in->sType;
7355     out->pNext = NULL;
7356     out->type = in->type;
7357     out->flags = in->flags;
7358     out->mode = in->mode;
7359     out->srcAccelerationStructure = in->srcAccelerationStructure;
7360     out->dstAccelerationStructure = in->dstAccelerationStructure;
7361     out->geometryCount = in->geometryCount;
7362     out->pGeometries = convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(ctx, (const VkAccelerationStructureGeometryKHR32 *)UlongToPtr(in->pGeometries), in->geometryCount);
7363     out->ppGeometries = convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppGeometries), in->geometryCount);
7364     out->scratchData = in->scratchData;
7365     if (in->pNext)
7366         FIXME("Unexpected pNext\n");
7367 }
7368
7369 static inline const VkAccelerationStructureBuildGeometryInfoKHR *convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, uint32_t count)
7370 {
7371     VkAccelerationStructureBuildGeometryInfoKHR *out;
7372     unsigned int i;
7373
7374     if (!in || !count) return NULL;
7375
7376     out = conversion_context_alloc(ctx, count * sizeof(*out));
7377     for (i = 0; i < count; i++)
7378     {
7379         convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
7380     }
7381
7382     return out;
7383 }
7384
7385 static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, VkMicromapBuildInfoEXT *out)
7386 {
7387     if (!in) return;
7388
7389     out->sType = in->sType;
7390     out->pNext = NULL;
7391     out->type = in->type;
7392     out->flags = in->flags;
7393     out->mode = in->mode;
7394     out->dstMicromap = in->dstMicromap;
7395     out->usageCountsCount = in->usageCountsCount;
7396     out->pUsageCounts = (const VkMicromapUsageEXT *)UlongToPtr(in->pUsageCounts);
7397     out->ppUsageCounts = convert_VkMicromapUsageEXT_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppUsageCounts), in->usageCountsCount);
7398     out->data = in->data;
7399     out->scratchData = in->scratchData;
7400     out->triangleArray = in->triangleArray;
7401     out->triangleArrayStride = in->triangleArrayStride;
7402     if (in->pNext)
7403         FIXME("Unexpected pNext\n");
7404 }
7405
7406 static inline const VkMicromapBuildInfoEXT *convert_VkMicromapBuildInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, uint32_t count)
7407 {
7408     VkMicromapBuildInfoEXT *out;
7409     unsigned int i;
7410
7411     if (!in || !count) return NULL;
7412
7413     out = conversion_context_alloc(ctx, count * sizeof(*out));
7414     for (i = 0; i < count; i++)
7415     {
7416         convert_VkMicromapBuildInfoEXT_win32_to_host(ctx, &in[i], &out[i]);
7417     }
7418
7419     return out;
7420 }
7421
7422 static inline void convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(const VkConditionalRenderingBeginInfoEXT32 *in, VkConditionalRenderingBeginInfoEXT *out)
7423 {
7424     if (!in) return;
7425
7426     out->sType = in->sType;
7427     out->pNext = NULL;
7428     out->buffer = in->buffer;
7429     out->offset = in->offset;
7430     out->flags = in->flags;
7431     if (in->pNext)
7432         FIXME("Unexpected pNext\n");
7433 }
7434
7435 static inline void convert_VkDebugUtilsLabelEXT_win32_to_host(const VkDebugUtilsLabelEXT32 *in, VkDebugUtilsLabelEXT *out)
7436 {
7437     if (!in) return;
7438
7439     out->sType = in->sType;
7440     out->pNext = NULL;
7441     out->pLabelName = (const char *)UlongToPtr(in->pLabelName);
7442     memcpy(out->color, in->color, 4 * sizeof(float));
7443     if (in->pNext)
7444         FIXME("Unexpected pNext\n");
7445 }
7446
7447 static inline void convert_VkSampleLocationsInfoEXT_win32_to_host(const VkSampleLocationsInfoEXT32 *in, VkSampleLocationsInfoEXT *out)
7448 {
7449     if (!in) return;
7450
7451     out->sType = in->sType;
7452     out->pNext = NULL;
7453     out->sampleLocationsPerPixel = in->sampleLocationsPerPixel;
7454     out->sampleLocationGridSize = in->sampleLocationGridSize;
7455     out->sampleLocationsCount = in->sampleLocationsCount;
7456     out->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in->pSampleLocations);
7457     if (in->pNext)
7458         FIXME("Unexpected pNext\n");
7459 }
7460
7461 static inline void convert_VkAttachmentSampleLocationsEXT_win32_to_host(const VkAttachmentSampleLocationsEXT32 *in, VkAttachmentSampleLocationsEXT *out)
7462 {
7463     if (!in) return;
7464
7465     out->attachmentIndex = in->attachmentIndex;
7466     convert_VkSampleLocationsInfoEXT_win32_to_host(&in->sampleLocationsInfo, &out->sampleLocationsInfo);
7467 }
7468
7469 static inline const VkAttachmentSampleLocationsEXT *convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentSampleLocationsEXT32 *in, uint32_t count)
7470 {
7471     VkAttachmentSampleLocationsEXT *out;
7472     unsigned int i;
7473
7474     if (!in || !count) return NULL;
7475
7476     out = conversion_context_alloc(ctx, count * sizeof(*out));
7477     for (i = 0; i < count; i++)
7478     {
7479         convert_VkAttachmentSampleLocationsEXT_win32_to_host(&in[i], &out[i]);
7480     }
7481
7482     return out;
7483 }
7484
7485 static inline void convert_VkSubpassSampleLocationsEXT_win32_to_host(const VkSubpassSampleLocationsEXT32 *in, VkSubpassSampleLocationsEXT *out)
7486 {
7487     if (!in) return;
7488
7489     out->subpassIndex = in->subpassIndex;
7490     convert_VkSampleLocationsInfoEXT_win32_to_host(&in->sampleLocationsInfo, &out->sampleLocationsInfo);
7491 }
7492
7493 static inline const VkSubpassSampleLocationsEXT *convert_VkSubpassSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkSubpassSampleLocationsEXT32 *in, uint32_t count)
7494 {
7495     VkSubpassSampleLocationsEXT *out;
7496     unsigned int i;
7497
7498     if (!in || !count) return NULL;
7499
7500     out = conversion_context_alloc(ctx, count * sizeof(*out));
7501     for (i = 0; i < count; i++)
7502     {
7503         convert_VkSubpassSampleLocationsEXT_win32_to_host(&in[i], &out[i]);
7504     }
7505
7506     return out;
7507 }
7508
7509 static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassBeginInfo32 *in, VkRenderPassBeginInfo *out)
7510 {
7511     const VkBaseInStructure32 *in_header;
7512     VkBaseOutStructure *out_header = (void *)out;
7513
7514     if (!in) return;
7515
7516     out->sType = in->sType;
7517     out->pNext = NULL;
7518     out->renderPass = in->renderPass;
7519     out->framebuffer = in->framebuffer;
7520     out->renderArea = in->renderArea;
7521     out->clearValueCount = in->clearValueCount;
7522     out->pClearValues = (const VkClearValue *)UlongToPtr(in->pClearValues);
7523
7524     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7525     {
7526         switch (in_header->sType)
7527         {
7528         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
7529         {
7530             VkDeviceGroupRenderPassBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7531             const VkDeviceGroupRenderPassBeginInfo32 *in_ext = (const VkDeviceGroupRenderPassBeginInfo32 *)in_header;
7532             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
7533             out_ext->pNext = NULL;
7534             out_ext->deviceMask = in_ext->deviceMask;
7535             out_ext->deviceRenderAreaCount = in_ext->deviceRenderAreaCount;
7536             out_ext->pDeviceRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pDeviceRenderAreas);
7537             out_header->pNext = (void *)out_ext;
7538             out_header = (void *)out_ext;
7539             break;
7540         }
7541         case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
7542         {
7543             VkRenderPassSampleLocationsBeginInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7544             const VkRenderPassSampleLocationsBeginInfoEXT32 *in_ext = (const VkRenderPassSampleLocationsBeginInfoEXT32 *)in_header;
7545             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT;
7546             out_ext->pNext = NULL;
7547             out_ext->attachmentInitialSampleLocationsCount = in_ext->attachmentInitialSampleLocationsCount;
7548             out_ext->pAttachmentInitialSampleLocations = convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(ctx, (const VkAttachmentSampleLocationsEXT32 *)UlongToPtr(in_ext->pAttachmentInitialSampleLocations), in_ext->attachmentInitialSampleLocationsCount);
7549             out_ext->postSubpassSampleLocationsCount = in_ext->postSubpassSampleLocationsCount;
7550             out_ext->pPostSubpassSampleLocations = convert_VkSubpassSampleLocationsEXT_array_win32_to_host(ctx, (const VkSubpassSampleLocationsEXT32 *)UlongToPtr(in_ext->pPostSubpassSampleLocations), in_ext->postSubpassSampleLocationsCount);
7551             out_header->pNext = (void *)out_ext;
7552             out_header = (void *)out_ext;
7553             break;
7554         }
7555         case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
7556         {
7557             VkRenderPassAttachmentBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7558             const VkRenderPassAttachmentBeginInfo32 *in_ext = (const VkRenderPassAttachmentBeginInfo32 *)in_header;
7559             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO;
7560             out_ext->pNext = NULL;
7561             out_ext->attachmentCount = in_ext->attachmentCount;
7562             out_ext->pAttachments = (const VkImageView *)UlongToPtr(in_ext->pAttachments);
7563             out_header->pNext = (void *)out_ext;
7564             out_header = (void *)out_ext;
7565             break;
7566         }
7567         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
7568         {
7569             VkRenderPassTransformBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7570             const VkRenderPassTransformBeginInfoQCOM32 *in_ext = (const VkRenderPassTransformBeginInfoQCOM32 *)in_header;
7571             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM;
7572             out_ext->pNext = NULL;
7573             out_ext->transform = in_ext->transform;
7574             out_header->pNext = (void *)out_ext;
7575             out_header = (void *)out_ext;
7576             break;
7577         }
7578         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
7579         {
7580             VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7581             const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *in_ext = (const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *)in_header;
7582             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM;
7583             out_ext->pNext = NULL;
7584             out_ext->perViewRenderAreaCount = in_ext->perViewRenderAreaCount;
7585             out_ext->pPerViewRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pPerViewRenderAreas);
7586             out_header->pNext = (void *)out_ext;
7587             out_header = (void *)out_ext;
7588             break;
7589         }
7590         default:
7591             FIXME("Unhandled sType %u.\n", in_header->sType);
7592             break;
7593         }
7594     }
7595 }
7596
7597 static inline void convert_VkSubpassBeginInfo_win32_to_host(const VkSubpassBeginInfo32 *in, VkSubpassBeginInfo *out)
7598 {
7599     if (!in) return;
7600
7601     out->sType = in->sType;
7602     out->pNext = NULL;
7603     out->contents = in->contents;
7604     if (in->pNext)
7605         FIXME("Unexpected pNext\n");
7606 }
7607
7608 static inline void convert_VkRenderingAttachmentInfo_win32_to_host(const VkRenderingAttachmentInfo32 *in, VkRenderingAttachmentInfo *out)
7609 {
7610     if (!in) return;
7611
7612     out->sType = in->sType;
7613     out->pNext = NULL;
7614     out->imageView = in->imageView;
7615     out->imageLayout = in->imageLayout;
7616     out->resolveMode = in->resolveMode;
7617     out->resolveImageView = in->resolveImageView;
7618     out->resolveImageLayout = in->resolveImageLayout;
7619     out->loadOp = in->loadOp;
7620     out->storeOp = in->storeOp;
7621     out->clearValue = in->clearValue;
7622     if (in->pNext)
7623         FIXME("Unexpected pNext\n");
7624 }
7625
7626 static inline const VkRenderingAttachmentInfo *convert_VkRenderingAttachmentInfo_array_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, uint32_t count)
7627 {
7628     VkRenderingAttachmentInfo *out;
7629     unsigned int i;
7630
7631     if (!in || !count) return NULL;
7632
7633     out = conversion_context_alloc(ctx, count * sizeof(*out));
7634     for (i = 0; i < count; i++)
7635     {
7636         convert_VkRenderingAttachmentInfo_win32_to_host(&in[i], &out[i]);
7637     }
7638
7639     return out;
7640 }
7641
7642 static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingInfo32 *in, VkRenderingInfo *out)
7643 {
7644     const VkBaseInStructure32 *in_header;
7645     VkBaseOutStructure *out_header = (void *)out;
7646
7647     if (!in) return;
7648
7649     out->sType = in->sType;
7650     out->pNext = NULL;
7651     out->flags = in->flags;
7652     out->renderArea = in->renderArea;
7653     out->layerCount = in->layerCount;
7654     out->viewMask = in->viewMask;
7655     out->colorAttachmentCount = in->colorAttachmentCount;
7656     out->pColorAttachments = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pColorAttachments), in->colorAttachmentCount);
7657     out->pDepthAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pDepthAttachment), 1);
7658     out->pStencilAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pStencilAttachment), 1);
7659
7660     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7661     {
7662         switch (in_header->sType)
7663         {
7664         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
7665         {
7666             VkDeviceGroupRenderPassBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7667             const VkDeviceGroupRenderPassBeginInfo32 *in_ext = (const VkDeviceGroupRenderPassBeginInfo32 *)in_header;
7668             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
7669             out_ext->pNext = NULL;
7670             out_ext->deviceMask = in_ext->deviceMask;
7671             out_ext->deviceRenderAreaCount = in_ext->deviceRenderAreaCount;
7672             out_ext->pDeviceRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pDeviceRenderAreas);
7673             out_header->pNext = (void *)out_ext;
7674             out_header = (void *)out_ext;
7675             break;
7676         }
7677         case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
7678         {
7679             VkMultisampledRenderToSingleSampledInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7680             const VkMultisampledRenderToSingleSampledInfoEXT32 *in_ext = (const VkMultisampledRenderToSingleSampledInfoEXT32 *)in_header;
7681             out_ext->sType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
7682             out_ext->pNext = NULL;
7683             out_ext->multisampledRenderToSingleSampledEnable = in_ext->multisampledRenderToSingleSampledEnable;
7684             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
7685             out_header->pNext = (void *)out_ext;
7686             out_header = (void *)out_ext;
7687             break;
7688         }
7689         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
7690         {
7691             VkRenderingFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7692             const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *)in_header;
7693             out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
7694             out_ext->pNext = NULL;
7695             out_ext->imageView = in_ext->imageView;
7696             out_ext->imageLayout = in_ext->imageLayout;
7697             out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize;
7698             out_header->pNext = (void *)out_ext;
7699             out_header = (void *)out_ext;
7700             break;
7701         }
7702         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
7703         {
7704             VkRenderingFragmentDensityMapAttachmentInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7705             const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *in_ext = (const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *)in_header;
7706             out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT;
7707             out_ext->pNext = NULL;
7708             out_ext->imageView = in_ext->imageView;
7709             out_ext->imageLayout = in_ext->imageLayout;
7710             out_header->pNext = (void *)out_ext;
7711             out_header = (void *)out_ext;
7712             break;
7713         }
7714         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
7715         {
7716             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7717             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
7718             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
7719             out_ext->pNext = NULL;
7720             out_ext->perViewAttributes = in_ext->perViewAttributes;
7721             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
7722             out_header->pNext = (void *)out_ext;
7723             out_header = (void *)out_ext;
7724             break;
7725         }
7726         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
7727         {
7728             VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7729             const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *in_ext = (const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *)in_header;
7730             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM;
7731             out_ext->pNext = NULL;
7732             out_ext->perViewRenderAreaCount = in_ext->perViewRenderAreaCount;
7733             out_ext->pPerViewRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pPerViewRenderAreas);
7734             out_header->pNext = (void *)out_ext;
7735             out_header = (void *)out_ext;
7736             break;
7737         }
7738         default:
7739             FIXME("Unhandled sType %u.\n", in_header->sType);
7740             break;
7741         }
7742     }
7743 }
7744
7745 static inline void convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, VkDescriptorBufferBindingInfoEXT *out)
7746 {
7747     const VkBaseInStructure32 *in_header;
7748     VkBaseOutStructure *out_header = (void *)out;
7749
7750     if (!in) return;
7751
7752     out->sType = in->sType;
7753     out->pNext = NULL;
7754     out->address = in->address;
7755     out->usage = in->usage;
7756
7757     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7758     {
7759         switch (in_header->sType)
7760         {
7761         case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
7762         {
7763             VkBufferUsageFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7764             const VkBufferUsageFlags2CreateInfoKHR32 *in_ext = (const VkBufferUsageFlags2CreateInfoKHR32 *)in_header;
7765             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR;
7766             out_ext->pNext = NULL;
7767             out_ext->usage = in_ext->usage;
7768             out_header->pNext = (void *)out_ext;
7769             out_header = (void *)out_ext;
7770             break;
7771         }
7772         case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
7773         {
7774             VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7775             const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32 *in_ext = (const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32 *)in_header;
7776             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT;
7777             out_ext->pNext = NULL;
7778             out_ext->buffer = in_ext->buffer;
7779             out_header->pNext = (void *)out_ext;
7780             out_header = (void *)out_ext;
7781             break;
7782         }
7783         default:
7784             FIXME("Unhandled sType %u.\n", in_header->sType);
7785             break;
7786         }
7787     }
7788 }
7789
7790 static inline const VkDescriptorBufferBindingInfoEXT *convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, uint32_t count)
7791 {
7792     VkDescriptorBufferBindingInfoEXT *out;
7793     unsigned int i;
7794
7795     if (!in || !count) return NULL;
7796
7797     out = conversion_context_alloc(ctx, count * sizeof(*out));
7798     for (i = 0; i < count; i++)
7799     {
7800         convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(ctx, &in[i], &out[i]);
7801     }
7802
7803     return out;
7804 }
7805
7806 static inline void convert_VkImageBlit2_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, VkImageBlit2 *out)
7807 {
7808     const VkBaseInStructure32 *in_header;
7809     VkBaseOutStructure *out_header = (void *)out;
7810
7811     if (!in) return;
7812
7813     out->sType = in->sType;
7814     out->pNext = NULL;
7815     out->srcSubresource = in->srcSubresource;
7816     memcpy(out->srcOffsets, in->srcOffsets, 2 * sizeof(VkOffset3D));
7817     out->dstSubresource = in->dstSubresource;
7818     memcpy(out->dstOffsets, in->dstOffsets, 2 * sizeof(VkOffset3D));
7819
7820     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7821     {
7822         switch (in_header->sType)
7823         {
7824         case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
7825         {
7826             VkCopyCommandTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7827             const VkCopyCommandTransformInfoQCOM32 *in_ext = (const VkCopyCommandTransformInfoQCOM32 *)in_header;
7828             out_ext->sType = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM;
7829             out_ext->pNext = NULL;
7830             out_ext->transform = in_ext->transform;
7831             out_header->pNext = (void *)out_ext;
7832             out_header = (void *)out_ext;
7833             break;
7834         }
7835         default:
7836             FIXME("Unhandled sType %u.\n", in_header->sType);
7837             break;
7838         }
7839     }
7840 }
7841
7842 static inline const VkImageBlit2 *convert_VkImageBlit2_array_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, uint32_t count)
7843 {
7844     VkImageBlit2 *out;
7845     unsigned int i;
7846
7847     if (!in || !count) return NULL;
7848
7849     out = conversion_context_alloc(ctx, count * sizeof(*out));
7850     for (i = 0; i < count; i++)
7851     {
7852         convert_VkImageBlit2_win32_to_host(ctx, &in[i], &out[i]);
7853     }
7854
7855     return out;
7856 }
7857
7858 static inline void convert_VkBlitImageInfo2_win32_to_host(struct conversion_context *ctx, const VkBlitImageInfo232 *in, VkBlitImageInfo2 *out)
7859 {
7860     if (!in) return;
7861
7862     out->sType = in->sType;
7863     out->pNext = NULL;
7864     out->srcImage = in->srcImage;
7865     out->srcImageLayout = in->srcImageLayout;
7866     out->dstImage = in->dstImage;
7867     out->dstImageLayout = in->dstImageLayout;
7868     out->regionCount = in->regionCount;
7869     out->pRegions = convert_VkImageBlit2_array_win32_to_host(ctx, (const VkImageBlit232 *)UlongToPtr(in->pRegions), in->regionCount);
7870     out->filter = in->filter;
7871     if (in->pNext)
7872         FIXME("Unexpected pNext\n");
7873 }
7874
7875 static inline void convert_VkGeometryTrianglesNV_win32_to_host(const VkGeometryTrianglesNV32 *in, VkGeometryTrianglesNV *out)
7876 {
7877     if (!in) return;
7878
7879     out->sType = in->sType;
7880     out->pNext = NULL;
7881     out->vertexData = in->vertexData;
7882     out->vertexOffset = in->vertexOffset;
7883     out->vertexCount = in->vertexCount;
7884     out->vertexStride = in->vertexStride;
7885     out->vertexFormat = in->vertexFormat;
7886     out->indexData = in->indexData;
7887     out->indexOffset = in->indexOffset;
7888     out->indexCount = in->indexCount;
7889     out->indexType = in->indexType;
7890     out->transformData = in->transformData;
7891     out->transformOffset = in->transformOffset;
7892     if (in->pNext)
7893         FIXME("Unexpected pNext\n");
7894 }
7895
7896 static inline void convert_VkGeometryAABBNV_win32_to_host(const VkGeometryAABBNV32 *in, VkGeometryAABBNV *out)
7897 {
7898     if (!in) return;
7899
7900     out->sType = in->sType;
7901     out->pNext = NULL;
7902     out->aabbData = in->aabbData;
7903     out->numAABBs = in->numAABBs;
7904     out->stride = in->stride;
7905     out->offset = in->offset;
7906     if (in->pNext)
7907         FIXME("Unexpected pNext\n");
7908 }
7909
7910 static inline void convert_VkGeometryDataNV_win32_to_host(const VkGeometryDataNV32 *in, VkGeometryDataNV *out)
7911 {
7912     if (!in) return;
7913
7914     convert_VkGeometryTrianglesNV_win32_to_host(&in->triangles, &out->triangles);
7915     convert_VkGeometryAABBNV_win32_to_host(&in->aabbs, &out->aabbs);
7916 }
7917
7918 static inline void convert_VkGeometryNV_win32_to_host(const VkGeometryNV32 *in, VkGeometryNV *out)
7919 {
7920     if (!in) return;
7921
7922     out->sType = in->sType;
7923     out->pNext = NULL;
7924     out->geometryType = in->geometryType;
7925     convert_VkGeometryDataNV_win32_to_host(&in->geometry, &out->geometry);
7926     out->flags = in->flags;
7927     if (in->pNext)
7928         FIXME("Unexpected pNext\n");
7929 }
7930
7931 static inline const VkGeometryNV *convert_VkGeometryNV_array_win32_to_host(struct conversion_context *ctx, const VkGeometryNV32 *in, uint32_t count)
7932 {
7933     VkGeometryNV *out;
7934     unsigned int i;
7935
7936     if (!in || !count) return NULL;
7937
7938     out = conversion_context_alloc(ctx, count * sizeof(*out));
7939     for (i = 0; i < count; i++)
7940     {
7941         convert_VkGeometryNV_win32_to_host(&in[i], &out[i]);
7942     }
7943
7944     return out;
7945 }
7946
7947 static inline void convert_VkAccelerationStructureInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureInfoNV32 *in, VkAccelerationStructureInfoNV *out)
7948 {
7949     if (!in) return;
7950
7951     out->sType = in->sType;
7952     out->pNext = NULL;
7953     out->type = in->type;
7954     out->flags = in->flags;
7955     out->instanceCount = in->instanceCount;
7956     out->geometryCount = in->geometryCount;
7957     out->pGeometries = convert_VkGeometryNV_array_win32_to_host(ctx, (const VkGeometryNV32 *)UlongToPtr(in->pGeometries), in->geometryCount);
7958     if (in->pNext)
7959         FIXME("Unexpected pNext\n");
7960 }
7961
7962 static inline void convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(const VkCopyAccelerationStructureInfoKHR32 *in, VkCopyAccelerationStructureInfoKHR *out)
7963 {
7964     if (!in) return;
7965
7966     out->sType = in->sType;
7967     out->pNext = NULL;
7968     out->src = in->src;
7969     out->dst = in->dst;
7970     out->mode = in->mode;
7971     if (in->pNext)
7972         FIXME("Unexpected pNext\n");
7973 }
7974
7975 static inline void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(const VkCopyAccelerationStructureToMemoryInfoKHR32 *in, VkCopyAccelerationStructureToMemoryInfoKHR *out)
7976 {
7977     if (!in) return;
7978
7979     out->sType = in->sType;
7980     out->pNext = NULL;
7981     out->src = in->src;
7982     out->dst = in->dst;
7983     out->mode = in->mode;
7984     if (in->pNext)
7985         FIXME("Unexpected pNext\n");
7986 }
7987
7988 static inline void convert_VkBufferCopy_win32_to_host(const VkBufferCopy32 *in, VkBufferCopy *out)
7989 {
7990     if (!in) return;
7991
7992     out->srcOffset = in->srcOffset;
7993     out->dstOffset = in->dstOffset;
7994     out->size = in->size;
7995 }
7996
7997 static inline const VkBufferCopy *convert_VkBufferCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy32 *in, uint32_t count)
7998 {
7999     VkBufferCopy *out;
8000     unsigned int i;
8001
8002     if (!in || !count) return NULL;
8003
8004     out = conversion_context_alloc(ctx, count * sizeof(*out));
8005     for (i = 0; i < count; i++)
8006     {
8007         convert_VkBufferCopy_win32_to_host(&in[i], &out[i]);
8008     }
8009
8010     return out;
8011 }
8012
8013 static inline void convert_VkBufferCopy2_win32_to_host(const VkBufferCopy232 *in, VkBufferCopy2 *out)
8014 {
8015     if (!in) return;
8016
8017     out->sType = in->sType;
8018     out->pNext = NULL;
8019     out->srcOffset = in->srcOffset;
8020     out->dstOffset = in->dstOffset;
8021     out->size = in->size;
8022     if (in->pNext)
8023         FIXME("Unexpected pNext\n");
8024 }
8025
8026 static inline const VkBufferCopy2 *convert_VkBufferCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy232 *in, uint32_t count)
8027 {
8028     VkBufferCopy2 *out;
8029     unsigned int i;
8030
8031     if (!in || !count) return NULL;
8032
8033     out = conversion_context_alloc(ctx, count * sizeof(*out));
8034     for (i = 0; i < count; i++)
8035     {
8036         convert_VkBufferCopy2_win32_to_host(&in[i], &out[i]);
8037     }
8038
8039     return out;
8040 }
8041
8042 static inline void convert_VkCopyBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferInfo232 *in, VkCopyBufferInfo2 *out)
8043 {
8044     if (!in) return;
8045
8046     out->sType = in->sType;
8047     out->pNext = NULL;
8048     out->srcBuffer = in->srcBuffer;
8049     out->dstBuffer = in->dstBuffer;
8050     out->regionCount = in->regionCount;
8051     out->pRegions = convert_VkBufferCopy2_array_win32_to_host(ctx, (const VkBufferCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
8052     if (in->pNext)
8053         FIXME("Unexpected pNext\n");
8054 }
8055
8056 static inline void convert_VkBufferImageCopy_win32_to_host(const VkBufferImageCopy32 *in, VkBufferImageCopy *out)
8057 {
8058     if (!in) return;
8059
8060     out->bufferOffset = in->bufferOffset;
8061     out->bufferRowLength = in->bufferRowLength;
8062     out->bufferImageHeight = in->bufferImageHeight;
8063     out->imageSubresource = in->imageSubresource;
8064     out->imageOffset = in->imageOffset;
8065     out->imageExtent = in->imageExtent;
8066 }
8067
8068 static inline const VkBufferImageCopy *convert_VkBufferImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy32 *in, uint32_t count)
8069 {
8070     VkBufferImageCopy *out;
8071     unsigned int i;
8072
8073     if (!in || !count) return NULL;
8074
8075     out = conversion_context_alloc(ctx, count * sizeof(*out));
8076     for (i = 0; i < count; i++)
8077     {
8078         convert_VkBufferImageCopy_win32_to_host(&in[i], &out[i]);
8079     }
8080
8081     return out;
8082 }
8083
8084 static inline void convert_VkBufferImageCopy2_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, VkBufferImageCopy2 *out)
8085 {
8086     const VkBaseInStructure32 *in_header;
8087     VkBaseOutStructure *out_header = (void *)out;
8088
8089     if (!in) return;
8090
8091     out->sType = in->sType;
8092     out->pNext = NULL;
8093     out->bufferOffset = in->bufferOffset;
8094     out->bufferRowLength = in->bufferRowLength;
8095     out->bufferImageHeight = in->bufferImageHeight;
8096     out->imageSubresource = in->imageSubresource;
8097     out->imageOffset = in->imageOffset;
8098     out->imageExtent = in->imageExtent;
8099
8100     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8101     {
8102         switch (in_header->sType)
8103         {
8104         case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
8105         {
8106             VkCopyCommandTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8107             const VkCopyCommandTransformInfoQCOM32 *in_ext = (const VkCopyCommandTransformInfoQCOM32 *)in_header;
8108             out_ext->sType = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM;
8109             out_ext->pNext = NULL;
8110             out_ext->transform = in_ext->transform;
8111             out_header->pNext = (void *)out_ext;
8112             out_header = (void *)out_ext;
8113             break;
8114         }
8115         default:
8116             FIXME("Unhandled sType %u.\n", in_header->sType);
8117             break;
8118         }
8119     }
8120 }
8121
8122 static inline const VkBufferImageCopy2 *convert_VkBufferImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, uint32_t count)
8123 {
8124     VkBufferImageCopy2 *out;
8125     unsigned int i;
8126
8127     if (!in || !count) return NULL;
8128
8129     out = conversion_context_alloc(ctx, count * sizeof(*out));
8130     for (i = 0; i < count; i++)
8131     {
8132         convert_VkBufferImageCopy2_win32_to_host(ctx, &in[i], &out[i]);
8133     }
8134
8135     return out;
8136 }
8137
8138 static inline void convert_VkCopyBufferToImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferToImageInfo232 *in, VkCopyBufferToImageInfo2 *out)
8139 {
8140     if (!in) return;
8141
8142     out->sType = in->sType;
8143     out->pNext = NULL;
8144     out->srcBuffer = in->srcBuffer;
8145     out->dstImage = in->dstImage;
8146     out->dstImageLayout = in->dstImageLayout;
8147     out->regionCount = in->regionCount;
8148     out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, (const VkBufferImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
8149     if (in->pNext)
8150         FIXME("Unexpected pNext\n");
8151 }
8152
8153 static inline void convert_VkImageCopy2_win32_to_host(const VkImageCopy232 *in, VkImageCopy2 *out)
8154 {
8155     if (!in) return;
8156
8157     out->sType = in->sType;
8158     out->pNext = NULL;
8159     out->srcSubresource = in->srcSubresource;
8160     out->srcOffset = in->srcOffset;
8161     out->dstSubresource = in->dstSubresource;
8162     out->dstOffset = in->dstOffset;
8163     out->extent = in->extent;
8164     if (in->pNext)
8165         FIXME("Unexpected pNext\n");
8166 }
8167
8168 static inline const VkImageCopy2 *convert_VkImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkImageCopy232 *in, uint32_t count)
8169 {
8170     VkImageCopy2 *out;
8171     unsigned int i;
8172
8173     if (!in || !count) return NULL;
8174
8175     out = conversion_context_alloc(ctx, count * sizeof(*out));
8176     for (i = 0; i < count; i++)
8177     {
8178         convert_VkImageCopy2_win32_to_host(&in[i], &out[i]);
8179     }
8180
8181     return out;
8182 }
8183
8184 static inline void convert_VkCopyImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageInfo232 *in, VkCopyImageInfo2 *out)
8185 {
8186     if (!in) return;
8187
8188     out->sType = in->sType;
8189     out->pNext = NULL;
8190     out->srcImage = in->srcImage;
8191     out->srcImageLayout = in->srcImageLayout;
8192     out->dstImage = in->dstImage;
8193     out->dstImageLayout = in->dstImageLayout;
8194     out->regionCount = in->regionCount;
8195     out->pRegions = convert_VkImageCopy2_array_win32_to_host(ctx, (const VkImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
8196     if (in->pNext)
8197         FIXME("Unexpected pNext\n");
8198 }
8199
8200 static inline void convert_VkCopyImageToBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageToBufferInfo232 *in, VkCopyImageToBufferInfo2 *out)
8201 {
8202     if (!in) return;
8203
8204     out->sType = in->sType;
8205     out->pNext = NULL;
8206     out->srcImage = in->srcImage;
8207     out->srcImageLayout = in->srcImageLayout;
8208     out->dstBuffer = in->dstBuffer;
8209     out->regionCount = in->regionCount;
8210     out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, (const VkBufferImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
8211     if (in->pNext)
8212         FIXME("Unexpected pNext\n");
8213 }
8214
8215 static inline void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(const VkCopyMemoryToAccelerationStructureInfoKHR32 *in, VkCopyMemoryToAccelerationStructureInfoKHR *out)
8216 {
8217     if (!in) return;
8218
8219     out->sType = in->sType;
8220     out->pNext = NULL;
8221     out->src = in->src;
8222     out->dst = in->dst;
8223     out->mode = in->mode;
8224     if (in->pNext)
8225         FIXME("Unexpected pNext\n");
8226 }
8227
8228 static inline void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkCopyMemoryToMicromapInfoEXT32 *in, VkCopyMemoryToMicromapInfoEXT *out)
8229 {
8230     if (!in) return;
8231
8232     out->sType = in->sType;
8233     out->pNext = NULL;
8234     out->src = in->src;
8235     out->dst = in->dst;
8236     out->mode = in->mode;
8237     if (in->pNext)
8238         FIXME("Unexpected pNext\n");
8239 }
8240
8241 static inline void convert_VkCopyMicromapInfoEXT_win32_to_host(const VkCopyMicromapInfoEXT32 *in, VkCopyMicromapInfoEXT *out)
8242 {
8243     if (!in) return;
8244
8245     out->sType = in->sType;
8246     out->pNext = NULL;
8247     out->src = in->src;
8248     out->dst = in->dst;
8249     out->mode = in->mode;
8250     if (in->pNext)
8251         FIXME("Unexpected pNext\n");
8252 }
8253
8254 static inline void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkCopyMicromapToMemoryInfoEXT32 *in, VkCopyMicromapToMemoryInfoEXT *out)
8255 {
8256     if (!in) return;
8257
8258     out->sType = in->sType;
8259     out->pNext = NULL;
8260     out->src = in->src;
8261     out->dst = in->dst;
8262     out->mode = in->mode;
8263     if (in->pNext)
8264         FIXME("Unexpected pNext\n");
8265 }
8266
8267 static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoNVX32 *in, VkCuLaunchInfoNVX *out)
8268 {
8269     if (!in) return;
8270
8271     out->sType = in->sType;
8272     out->pNext = NULL;
8273     out->function = in->function;
8274     out->gridDimX = in->gridDimX;
8275     out->gridDimY = in->gridDimY;
8276     out->gridDimZ = in->gridDimZ;
8277     out->blockDimX = in->blockDimX;
8278     out->blockDimY = in->blockDimY;
8279     out->blockDimZ = in->blockDimZ;
8280     out->sharedMemBytes = in->sharedMemBytes;
8281     out->paramCount = in->paramCount;
8282     out->pParams = (const void * const *)UlongToPtr(in->pParams);
8283     out->extraCount = in->extraCount;
8284     out->pExtras = (const void * const *)UlongToPtr(in->pExtras);
8285     if (in->pNext)
8286         FIXME("Unexpected pNext\n");
8287 }
8288
8289 static inline void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebugMarkerMarkerInfoEXT32 *in, VkDebugMarkerMarkerInfoEXT *out)
8290 {
8291     if (!in) return;
8292
8293     out->sType = in->sType;
8294     out->pNext = NULL;
8295     out->pMarkerName = (const char *)UlongToPtr(in->pMarkerName);
8296     memcpy(out->color, in->color, 4 * sizeof(float));
8297     if (in->pNext)
8298         FIXME("Unexpected pNext\n");
8299 }
8300
8301 static inline void convert_VkDecompressMemoryRegionNV_win32_to_host(const VkDecompressMemoryRegionNV32 *in, VkDecompressMemoryRegionNV *out)
8302 {
8303     if (!in) return;
8304
8305     out->srcAddress = in->srcAddress;
8306     out->dstAddress = in->dstAddress;
8307     out->compressedSize = in->compressedSize;
8308     out->decompressedSize = in->decompressedSize;
8309     out->decompressionMethod = in->decompressionMethod;
8310 }
8311
8312 static inline const VkDecompressMemoryRegionNV *convert_VkDecompressMemoryRegionNV_array_win32_to_host(struct conversion_context *ctx, const VkDecompressMemoryRegionNV32 *in, uint32_t count)
8313 {
8314     VkDecompressMemoryRegionNV *out;
8315     unsigned int i;
8316
8317     if (!in || !count) return NULL;
8318
8319     out = conversion_context_alloc(ctx, count * sizeof(*out));
8320     for (i = 0; i < count; i++)
8321     {
8322         convert_VkDecompressMemoryRegionNV_win32_to_host(&in[i], &out[i]);
8323     }
8324
8325     return out;
8326 }
8327
8328 static inline void convert_VkSubpassEndInfo_win32_to_host(struct conversion_context *ctx, const VkSubpassEndInfo32 *in, VkSubpassEndInfo *out)
8329 {
8330     const VkBaseInStructure32 *in_header;
8331     VkBaseOutStructure *out_header = (void *)out;
8332
8333     if (!in) return;
8334
8335     out->sType = in->sType;
8336     out->pNext = NULL;
8337
8338     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8339     {
8340         switch (in_header->sType)
8341         {
8342         case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
8343         {
8344             VkSubpassFragmentDensityMapOffsetEndInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8345             const VkSubpassFragmentDensityMapOffsetEndInfoQCOM32 *in_ext = (const VkSubpassFragmentDensityMapOffsetEndInfoQCOM32 *)in_header;
8346             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM;
8347             out_ext->pNext = NULL;
8348             out_ext->fragmentDensityOffsetCount = in_ext->fragmentDensityOffsetCount;
8349             out_ext->pFragmentDensityOffsets = (const VkOffset2D *)UlongToPtr(in_ext->pFragmentDensityOffsets);
8350             out_header->pNext = (void *)out_ext;
8351             out_header = (void *)out_ext;
8352             break;
8353         }
8354         default:
8355             FIXME("Unhandled sType %u.\n", in_header->sType);
8356             break;
8357         }
8358     }
8359 }
8360
8361 #ifdef _WIN64
8362 static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win64_to_host(struct conversion_context *ctx, const VkCommandBuffer *in, uint32_t count)
8363 {
8364     VkCommandBuffer *out;
8365     unsigned int i;
8366
8367     if (!in || !count) return NULL;
8368
8369     out = conversion_context_alloc(ctx, count * sizeof(*out));
8370     for (i = 0; i < count; i++)
8371     {
8372         out[i] = wine_cmd_buffer_from_handle(in[i])->command_buffer;
8373     }
8374
8375     return out;
8376 }
8377 #endif /* _WIN64 */
8378
8379 static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
8380 {
8381     VkCommandBuffer *out;
8382     unsigned int i;
8383
8384     if (!in || !count) return NULL;
8385
8386     out = conversion_context_alloc(ctx, count * sizeof(*out));
8387     for (i = 0; i < count; i++)
8388     {
8389         out[i] = wine_cmd_buffer_from_handle(UlongToPtr(in[i]))->command_buffer;
8390     }
8391
8392     return out;
8393 }
8394
8395 static inline void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndirectCommandsStreamNV32 *in, VkIndirectCommandsStreamNV *out)
8396 {
8397     if (!in) return;
8398
8399     out->buffer = in->buffer;
8400     out->offset = in->offset;
8401 }
8402
8403 static inline const VkIndirectCommandsStreamNV *convert_VkIndirectCommandsStreamNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsStreamNV32 *in, uint32_t count)
8404 {
8405     VkIndirectCommandsStreamNV *out;
8406     unsigned int i;
8407
8408     if (!in || !count) return NULL;
8409
8410     out = conversion_context_alloc(ctx, count * sizeof(*out));
8411     for (i = 0; i < count; i++)
8412     {
8413         convert_VkIndirectCommandsStreamNV_win32_to_host(&in[i], &out[i]);
8414     }
8415
8416     return out;
8417 }
8418
8419 static inline void convert_VkGeneratedCommandsInfoNV_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoNV32 *in, VkGeneratedCommandsInfoNV *out)
8420 {
8421     if (!in) return;
8422
8423     out->sType = in->sType;
8424     out->pNext = NULL;
8425     out->pipelineBindPoint = in->pipelineBindPoint;
8426     out->pipeline = in->pipeline;
8427     out->indirectCommandsLayout = in->indirectCommandsLayout;
8428     out->streamCount = in->streamCount;
8429     out->pStreams = convert_VkIndirectCommandsStreamNV_array_win32_to_host(ctx, (const VkIndirectCommandsStreamNV32 *)UlongToPtr(in->pStreams), in->streamCount);
8430     out->sequencesCount = in->sequencesCount;
8431     out->preprocessBuffer = in->preprocessBuffer;
8432     out->preprocessOffset = in->preprocessOffset;
8433     out->preprocessSize = in->preprocessSize;
8434     out->sequencesCountBuffer = in->sequencesCountBuffer;
8435     out->sequencesCountOffset = in->sequencesCountOffset;
8436     out->sequencesIndexBuffer = in->sequencesIndexBuffer;
8437     out->sequencesIndexOffset = in->sequencesIndexOffset;
8438     if (in->pNext)
8439         FIXME("Unexpected pNext\n");
8440 }
8441
8442 static inline void convert_VkOpticalFlowExecuteInfoNV_win32_to_host(const VkOpticalFlowExecuteInfoNV32 *in, VkOpticalFlowExecuteInfoNV *out)
8443 {
8444     if (!in) return;
8445
8446     out->sType = in->sType;
8447     out->pNext = NULL;
8448     out->flags = in->flags;
8449     out->regionCount = in->regionCount;
8450     out->pRegions = (const VkRect2D *)UlongToPtr(in->pRegions);
8451     if (in->pNext)
8452         FIXME("Unexpected pNext\n");
8453 }
8454
8455 static inline void convert_VkMemoryBarrier_win32_to_host(const VkMemoryBarrier32 *in, VkMemoryBarrier *out)
8456 {
8457     if (!in) return;
8458
8459     out->sType = in->sType;
8460     out->pNext = NULL;
8461     out->srcAccessMask = in->srcAccessMask;
8462     out->dstAccessMask = in->dstAccessMask;
8463     if (in->pNext)
8464         FIXME("Unexpected pNext\n");
8465 }
8466
8467 static inline const VkMemoryBarrier *convert_VkMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier32 *in, uint32_t count)
8468 {
8469     VkMemoryBarrier *out;
8470     unsigned int i;
8471
8472     if (!in || !count) return NULL;
8473
8474     out = conversion_context_alloc(ctx, count * sizeof(*out));
8475     for (i = 0; i < count; i++)
8476     {
8477         convert_VkMemoryBarrier_win32_to_host(&in[i], &out[i]);
8478     }
8479
8480     return out;
8481 }
8482
8483 static inline void convert_VkBufferMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, VkBufferMemoryBarrier *out)
8484 {
8485     const VkBaseInStructure32 *in_header;
8486     VkBaseOutStructure *out_header = (void *)out;
8487
8488     if (!in) return;
8489
8490     out->sType = in->sType;
8491     out->pNext = NULL;
8492     out->srcAccessMask = in->srcAccessMask;
8493     out->dstAccessMask = in->dstAccessMask;
8494     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
8495     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
8496     out->buffer = in->buffer;
8497     out->offset = in->offset;
8498     out->size = in->size;
8499
8500     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8501     {
8502         switch (in_header->sType)
8503         {
8504         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
8505         {
8506             VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8507             const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header;
8508             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
8509             out_ext->pNext = NULL;
8510             out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory;
8511             out_header->pNext = (void *)out_ext;
8512             out_header = (void *)out_ext;
8513             break;
8514         }
8515         default:
8516             FIXME("Unhandled sType %u.\n", in_header->sType);
8517             break;
8518         }
8519     }
8520 }
8521
8522 static inline const VkBufferMemoryBarrier *convert_VkBufferMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, uint32_t count)
8523 {
8524     VkBufferMemoryBarrier *out;
8525     unsigned int i;
8526
8527     if (!in || !count) return NULL;
8528
8529     out = conversion_context_alloc(ctx, count * sizeof(*out));
8530     for (i = 0; i < count; i++)
8531     {
8532         convert_VkBufferMemoryBarrier_win32_to_host(ctx, &in[i], &out[i]);
8533     }
8534
8535     return out;
8536 }
8537
8538 static inline void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, VkImageMemoryBarrier *out)
8539 {
8540     const VkBaseInStructure32 *in_header;
8541     VkBaseOutStructure *out_header = (void *)out;
8542
8543     if (!in) return;
8544
8545     out->sType = in->sType;
8546     out->pNext = NULL;
8547     out->srcAccessMask = in->srcAccessMask;
8548     out->dstAccessMask = in->dstAccessMask;
8549     out->oldLayout = in->oldLayout;
8550     out->newLayout = in->newLayout;
8551     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
8552     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
8553     out->image = in->image;
8554     out->subresourceRange = in->subresourceRange;
8555
8556     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8557     {
8558         switch (in_header->sType)
8559         {
8560         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
8561         {
8562             VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8563             const VkSampleLocationsInfoEXT32 *in_ext = (const VkSampleLocationsInfoEXT32 *)in_header;
8564             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT;
8565             out_ext->pNext = NULL;
8566             out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel;
8567             out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize;
8568             out_ext->sampleLocationsCount = in_ext->sampleLocationsCount;
8569             out_ext->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in_ext->pSampleLocations);
8570             out_header->pNext = (void *)out_ext;
8571             out_header = (void *)out_ext;
8572             break;
8573         }
8574         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
8575         {
8576             VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8577             const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header;
8578             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
8579             out_ext->pNext = NULL;
8580             out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory;
8581             out_header->pNext = (void *)out_ext;
8582             out_header = (void *)out_ext;
8583             break;
8584         }
8585         default:
8586             FIXME("Unhandled sType %u.\n", in_header->sType);
8587             break;
8588         }
8589     }
8590 }
8591
8592 static inline const VkImageMemoryBarrier *convert_VkImageMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, uint32_t count)
8593 {
8594     VkImageMemoryBarrier *out;
8595     unsigned int i;
8596
8597     if (!in || !count) return NULL;
8598
8599     out = conversion_context_alloc(ctx, count * sizeof(*out));
8600     for (i = 0; i < count; i++)
8601     {
8602         convert_VkImageMemoryBarrier_win32_to_host(ctx, &in[i], &out[i]);
8603     }
8604
8605     return out;
8606 }
8607
8608 static inline void convert_VkMemoryBarrier2_win32_to_host(const VkMemoryBarrier232 *in, VkMemoryBarrier2 *out)
8609 {
8610     if (!in) return;
8611
8612     out->sType = in->sType;
8613     out->pNext = NULL;
8614     out->srcStageMask = in->srcStageMask;
8615     out->srcAccessMask = in->srcAccessMask;
8616     out->dstStageMask = in->dstStageMask;
8617     out->dstAccessMask = in->dstAccessMask;
8618     if (in->pNext)
8619         FIXME("Unexpected pNext\n");
8620 }
8621
8622 static inline const VkMemoryBarrier2 *convert_VkMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier232 *in, uint32_t count)
8623 {
8624     VkMemoryBarrier2 *out;
8625     unsigned int i;
8626
8627     if (!in || !count) return NULL;
8628
8629     out = conversion_context_alloc(ctx, count * sizeof(*out));
8630     for (i = 0; i < count; i++)
8631     {
8632         convert_VkMemoryBarrier2_win32_to_host(&in[i], &out[i]);
8633     }
8634
8635     return out;
8636 }
8637
8638 static inline void convert_VkBufferMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, VkBufferMemoryBarrier2 *out)
8639 {
8640     const VkBaseInStructure32 *in_header;
8641     VkBaseOutStructure *out_header = (void *)out;
8642
8643     if (!in) return;
8644
8645     out->sType = in->sType;
8646     out->pNext = NULL;
8647     out->srcStageMask = in->srcStageMask;
8648     out->srcAccessMask = in->srcAccessMask;
8649     out->dstStageMask = in->dstStageMask;
8650     out->dstAccessMask = in->dstAccessMask;
8651     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
8652     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
8653     out->buffer = in->buffer;
8654     out->offset = in->offset;
8655     out->size = in->size;
8656
8657     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8658     {
8659         switch (in_header->sType)
8660         {
8661         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
8662         {
8663             VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8664             const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header;
8665             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
8666             out_ext->pNext = NULL;
8667             out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory;
8668             out_header->pNext = (void *)out_ext;
8669             out_header = (void *)out_ext;
8670             break;
8671         }
8672         default:
8673             FIXME("Unhandled sType %u.\n", in_header->sType);
8674             break;
8675         }
8676     }
8677 }
8678
8679 static inline const VkBufferMemoryBarrier2 *convert_VkBufferMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, uint32_t count)
8680 {
8681     VkBufferMemoryBarrier2 *out;
8682     unsigned int i;
8683
8684     if (!in || !count) return NULL;
8685
8686     out = conversion_context_alloc(ctx, count * sizeof(*out));
8687     for (i = 0; i < count; i++)
8688     {
8689         convert_VkBufferMemoryBarrier2_win32_to_host(ctx, &in[i], &out[i]);
8690     }
8691
8692     return out;
8693 }
8694
8695 static inline void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, VkImageMemoryBarrier2 *out)
8696 {
8697     const VkBaseInStructure32 *in_header;
8698     VkBaseOutStructure *out_header = (void *)out;
8699
8700     if (!in) return;
8701
8702     out->sType = in->sType;
8703     out->pNext = NULL;
8704     out->srcStageMask = in->srcStageMask;
8705     out->srcAccessMask = in->srcAccessMask;
8706     out->dstStageMask = in->dstStageMask;
8707     out->dstAccessMask = in->dstAccessMask;
8708     out->oldLayout = in->oldLayout;
8709     out->newLayout = in->newLayout;
8710     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
8711     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
8712     out->image = in->image;
8713     out->subresourceRange = in->subresourceRange;
8714
8715     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8716     {
8717         switch (in_header->sType)
8718         {
8719         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
8720         {
8721             VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8722             const VkSampleLocationsInfoEXT32 *in_ext = (const VkSampleLocationsInfoEXT32 *)in_header;
8723             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT;
8724             out_ext->pNext = NULL;
8725             out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel;
8726             out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize;
8727             out_ext->sampleLocationsCount = in_ext->sampleLocationsCount;
8728             out_ext->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in_ext->pSampleLocations);
8729             out_header->pNext = (void *)out_ext;
8730             out_header = (void *)out_ext;
8731             break;
8732         }
8733         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
8734         {
8735             VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8736             const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header;
8737             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
8738             out_ext->pNext = NULL;
8739             out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory;
8740             out_header->pNext = (void *)out_ext;
8741             out_header = (void *)out_ext;
8742             break;
8743         }
8744         default:
8745             FIXME("Unhandled sType %u.\n", in_header->sType);
8746             break;
8747         }
8748     }
8749 }
8750
8751 static inline const VkImageMemoryBarrier2 *convert_VkImageMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, uint32_t count)
8752 {
8753     VkImageMemoryBarrier2 *out;
8754     unsigned int i;
8755
8756     if (!in || !count) return NULL;
8757
8758     out = conversion_context_alloc(ctx, count * sizeof(*out));
8759     for (i = 0; i < count; i++)
8760     {
8761         convert_VkImageMemoryBarrier2_win32_to_host(ctx, &in[i], &out[i]);
8762     }
8763
8764     return out;
8765 }
8766
8767 static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, VkDependencyInfo *out)
8768 {
8769     if (!in) return;
8770
8771     out->sType = in->sType;
8772     out->pNext = NULL;
8773     out->dependencyFlags = in->dependencyFlags;
8774     out->memoryBarrierCount = in->memoryBarrierCount;
8775     out->pMemoryBarriers = convert_VkMemoryBarrier2_array_win32_to_host(ctx, (const VkMemoryBarrier232 *)UlongToPtr(in->pMemoryBarriers), in->memoryBarrierCount);
8776     out->bufferMemoryBarrierCount = in->bufferMemoryBarrierCount;
8777     out->pBufferMemoryBarriers = convert_VkBufferMemoryBarrier2_array_win32_to_host(ctx, (const VkBufferMemoryBarrier232 *)UlongToPtr(in->pBufferMemoryBarriers), in->bufferMemoryBarrierCount);
8778     out->imageMemoryBarrierCount = in->imageMemoryBarrierCount;
8779     out->pImageMemoryBarriers = convert_VkImageMemoryBarrier2_array_win32_to_host(ctx, (const VkImageMemoryBarrier232 *)UlongToPtr(in->pImageMemoryBarriers), in->imageMemoryBarrierCount);
8780     if (in->pNext)
8781         FIXME("Unexpected pNext\n");
8782 }
8783
8784 static inline void convert_VkDescriptorImageInfo_win32_to_host(const VkDescriptorImageInfo32 *in, VkDescriptorImageInfo *out)
8785 {
8786     if (!in) return;
8787
8788     out->sampler = in->sampler;
8789     out->imageView = in->imageView;
8790     out->imageLayout = in->imageLayout;
8791 }
8792
8793 static inline const VkDescriptorImageInfo *convert_VkDescriptorImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorImageInfo32 *in, uint32_t count)
8794 {
8795     VkDescriptorImageInfo *out;
8796     unsigned int i;
8797
8798     if (!in || !count) return NULL;
8799
8800     out = conversion_context_alloc(ctx, count * sizeof(*out));
8801     for (i = 0; i < count; i++)
8802     {
8803         convert_VkDescriptorImageInfo_win32_to_host(&in[i], &out[i]);
8804     }
8805
8806     return out;
8807 }
8808
8809 static inline void convert_VkDescriptorBufferInfo_win32_to_host(const VkDescriptorBufferInfo32 *in, VkDescriptorBufferInfo *out)
8810 {
8811     if (!in) return;
8812
8813     out->buffer = in->buffer;
8814     out->offset = in->offset;
8815     out->range = in->range;
8816 }
8817
8818 static inline const VkDescriptorBufferInfo *convert_VkDescriptorBufferInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferInfo32 *in, uint32_t count)
8819 {
8820     VkDescriptorBufferInfo *out;
8821     unsigned int i;
8822
8823     if (!in || !count) return NULL;
8824
8825     out = conversion_context_alloc(ctx, count * sizeof(*out));
8826     for (i = 0; i < count; i++)
8827     {
8828         convert_VkDescriptorBufferInfo_win32_to_host(&in[i], &out[i]);
8829     }
8830
8831     return out;
8832 }
8833
8834 static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, VkWriteDescriptorSet *out)
8835 {
8836     const VkBaseInStructure32 *in_header;
8837     VkBaseOutStructure *out_header = (void *)out;
8838
8839     if (!in) return;
8840
8841     out->sType = in->sType;
8842     out->pNext = NULL;
8843     out->dstSet = in->dstSet;
8844     out->dstBinding = in->dstBinding;
8845     out->dstArrayElement = in->dstArrayElement;
8846     out->descriptorCount = in->descriptorCount;
8847     out->descriptorType = in->descriptorType;
8848     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);
8849     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);
8850     out->pTexelBufferView = (const VkBufferView *)UlongToPtr(in->pTexelBufferView);
8851
8852     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8853     {
8854         switch (in_header->sType)
8855         {
8856         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
8857         {
8858             VkWriteDescriptorSetInlineUniformBlock *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8859             const VkWriteDescriptorSetInlineUniformBlock32 *in_ext = (const VkWriteDescriptorSetInlineUniformBlock32 *)in_header;
8860             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
8861             out_ext->pNext = NULL;
8862             out_ext->dataSize = in_ext->dataSize;
8863             out_ext->pData = (const void *)UlongToPtr(in_ext->pData);
8864             out_header->pNext = (void *)out_ext;
8865             out_header = (void *)out_ext;
8866             break;
8867         }
8868         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
8869         {
8870             VkWriteDescriptorSetAccelerationStructureKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8871             const VkWriteDescriptorSetAccelerationStructureKHR32 *in_ext = (const VkWriteDescriptorSetAccelerationStructureKHR32 *)in_header;
8872             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR;
8873             out_ext->pNext = NULL;
8874             out_ext->accelerationStructureCount = in_ext->accelerationStructureCount;
8875             out_ext->pAccelerationStructures = (const VkAccelerationStructureKHR *)UlongToPtr(in_ext->pAccelerationStructures);
8876             out_header->pNext = (void *)out_ext;
8877             out_header = (void *)out_ext;
8878             break;
8879         }
8880         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
8881         {
8882             VkWriteDescriptorSetAccelerationStructureNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8883             const VkWriteDescriptorSetAccelerationStructureNV32 *in_ext = (const VkWriteDescriptorSetAccelerationStructureNV32 *)in_header;
8884             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV;
8885             out_ext->pNext = NULL;
8886             out_ext->accelerationStructureCount = in_ext->accelerationStructureCount;
8887             out_ext->pAccelerationStructures = (const VkAccelerationStructureNV *)UlongToPtr(in_ext->pAccelerationStructures);
8888             out_header->pNext = (void *)out_ext;
8889             out_header = (void *)out_ext;
8890             break;
8891         }
8892         default:
8893             FIXME("Unhandled sType %u.\n", in_header->sType);
8894             break;
8895         }
8896     }
8897 }
8898
8899 static inline const VkWriteDescriptorSet *convert_VkWriteDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, uint32_t count)
8900 {
8901     VkWriteDescriptorSet *out;
8902     unsigned int i;
8903
8904     if (!in || !count) return NULL;
8905
8906     out = conversion_context_alloc(ctx, count * sizeof(*out));
8907     for (i = 0; i < count; i++)
8908     {
8909         convert_VkWriteDescriptorSet_win32_to_host(ctx, &in[i], &out[i]);
8910     }
8911
8912     return out;
8913 }
8914
8915 static inline void convert_VkImageResolve2_win32_to_host(const VkImageResolve232 *in, VkImageResolve2 *out)
8916 {
8917     if (!in) return;
8918
8919     out->sType = in->sType;
8920     out->pNext = NULL;
8921     out->srcSubresource = in->srcSubresource;
8922     out->srcOffset = in->srcOffset;
8923     out->dstSubresource = in->dstSubresource;
8924     out->dstOffset = in->dstOffset;
8925     out->extent = in->extent;
8926     if (in->pNext)
8927         FIXME("Unexpected pNext\n");
8928 }
8929
8930 static inline const VkImageResolve2 *convert_VkImageResolve2_array_win32_to_host(struct conversion_context *ctx, const VkImageResolve232 *in, uint32_t count)
8931 {
8932     VkImageResolve2 *out;
8933     unsigned int i;
8934
8935     if (!in || !count) return NULL;
8936
8937     out = conversion_context_alloc(ctx, count * sizeof(*out));
8938     for (i = 0; i < count; i++)
8939     {
8940         convert_VkImageResolve2_win32_to_host(&in[i], &out[i]);
8941     }
8942
8943     return out;
8944 }
8945
8946 static inline void convert_VkResolveImageInfo2_win32_to_host(struct conversion_context *ctx, const VkResolveImageInfo232 *in, VkResolveImageInfo2 *out)
8947 {
8948     if (!in) return;
8949
8950     out->sType = in->sType;
8951     out->pNext = NULL;
8952     out->srcImage = in->srcImage;
8953     out->srcImageLayout = in->srcImageLayout;
8954     out->dstImage = in->dstImage;
8955     out->dstImageLayout = in->dstImageLayout;
8956     out->regionCount = in->regionCount;
8957     out->pRegions = convert_VkImageResolve2_array_win32_to_host(ctx, (const VkImageResolve232 *)UlongToPtr(in->pRegions), in->regionCount);
8958     if (in->pNext)
8959         FIXME("Unexpected pNext\n");
8960 }
8961
8962 static inline void convert_VkCoarseSampleOrderCustomNV_win32_to_host(const VkCoarseSampleOrderCustomNV32 *in, VkCoarseSampleOrderCustomNV *out)
8963 {
8964     if (!in) return;
8965
8966     out->shadingRate = in->shadingRate;
8967     out->sampleCount = in->sampleCount;
8968     out->sampleLocationCount = in->sampleLocationCount;
8969     out->pSampleLocations = (const VkCoarseSampleLocationNV *)UlongToPtr(in->pSampleLocations);
8970 }
8971
8972 static inline const VkCoarseSampleOrderCustomNV *convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(struct conversion_context *ctx, const VkCoarseSampleOrderCustomNV32 *in, uint32_t count)
8973 {
8974     VkCoarseSampleOrderCustomNV *out;
8975     unsigned int i;
8976
8977     if (!in || !count) return NULL;
8978
8979     out = conversion_context_alloc(ctx, count * sizeof(*out));
8980     for (i = 0; i < count; i++)
8981     {
8982         convert_VkCoarseSampleOrderCustomNV_win32_to_host(&in[i], &out[i]);
8983     }
8984
8985     return out;
8986 }
8987
8988 static inline void convert_VkDepthBiasInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDepthBiasInfoEXT32 *in, VkDepthBiasInfoEXT *out)
8989 {
8990     const VkBaseInStructure32 *in_header;
8991     VkBaseOutStructure *out_header = (void *)out;
8992
8993     if (!in) return;
8994
8995     out->sType = in->sType;
8996     out->pNext = NULL;
8997     out->depthBiasConstantFactor = in->depthBiasConstantFactor;
8998     out->depthBiasClamp = in->depthBiasClamp;
8999     out->depthBiasSlopeFactor = in->depthBiasSlopeFactor;
9000
9001     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9002     {
9003         switch (in_header->sType)
9004         {
9005         case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
9006         {
9007             VkDepthBiasRepresentationInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9008             const VkDepthBiasRepresentationInfoEXT32 *in_ext = (const VkDepthBiasRepresentationInfoEXT32 *)in_header;
9009             out_ext->sType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT;
9010             out_ext->pNext = NULL;
9011             out_ext->depthBiasRepresentation = in_ext->depthBiasRepresentation;
9012             out_ext->depthBiasExact = in_ext->depthBiasExact;
9013             out_header->pNext = (void *)out_ext;
9014             out_header = (void *)out_ext;
9015             break;
9016         }
9017         default:
9018             FIXME("Unhandled sType %u.\n", in_header->sType);
9019             break;
9020         }
9021     }
9022 }
9023
9024 static inline void convert_VkPerformanceMarkerInfoINTEL_win32_to_host(const VkPerformanceMarkerInfoINTEL32 *in, VkPerformanceMarkerInfoINTEL *out)
9025 {
9026     if (!in) return;
9027
9028     out->sType = in->sType;
9029     out->pNext = NULL;
9030     out->marker = in->marker;
9031     if (in->pNext)
9032         FIXME("Unexpected pNext\n");
9033 }
9034
9035 static inline void convert_VkPerformanceOverrideInfoINTEL_win32_to_host(const VkPerformanceOverrideInfoINTEL32 *in, VkPerformanceOverrideInfoINTEL *out)
9036 {
9037     if (!in) return;
9038
9039     out->sType = in->sType;
9040     out->pNext = NULL;
9041     out->type = in->type;
9042     out->enable = in->enable;
9043     out->parameter = in->parameter;
9044     if (in->pNext)
9045         FIXME("Unexpected pNext\n");
9046 }
9047
9048 static inline void convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(const VkPerformanceStreamMarkerInfoINTEL32 *in, VkPerformanceStreamMarkerInfoINTEL *out)
9049 {
9050     if (!in) return;
9051
9052     out->sType = in->sType;
9053     out->pNext = NULL;
9054     out->marker = in->marker;
9055     if (in->pNext)
9056         FIXME("Unexpected pNext\n");
9057 }
9058
9059 static inline void convert_VkVertexInputBindingDescription2EXT_win32_to_host(const VkVertexInputBindingDescription2EXT32 *in, VkVertexInputBindingDescription2EXT *out)
9060 {
9061     if (!in) return;
9062
9063     out->sType = in->sType;
9064     out->pNext = NULL;
9065     out->binding = in->binding;
9066     out->stride = in->stride;
9067     out->inputRate = in->inputRate;
9068     out->divisor = in->divisor;
9069     if (in->pNext)
9070         FIXME("Unexpected pNext\n");
9071 }
9072
9073 static inline const VkVertexInputBindingDescription2EXT *convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputBindingDescription2EXT32 *in, uint32_t count)
9074 {
9075     VkVertexInputBindingDescription2EXT *out;
9076     unsigned int i;
9077
9078     if (!in || !count) return NULL;
9079
9080     out = conversion_context_alloc(ctx, count * sizeof(*out));
9081     for (i = 0; i < count; i++)
9082     {
9083         convert_VkVertexInputBindingDescription2EXT_win32_to_host(&in[i], &out[i]);
9084     }
9085
9086     return out;
9087 }
9088
9089 static inline void convert_VkVertexInputAttributeDescription2EXT_win32_to_host(const VkVertexInputAttributeDescription2EXT32 *in, VkVertexInputAttributeDescription2EXT *out)
9090 {
9091     if (!in) return;
9092
9093     out->sType = in->sType;
9094     out->pNext = NULL;
9095     out->location = in->location;
9096     out->binding = in->binding;
9097     out->format = in->format;
9098     out->offset = in->offset;
9099     if (in->pNext)
9100         FIXME("Unexpected pNext\n");
9101 }
9102
9103 static inline const VkVertexInputAttributeDescription2EXT *convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputAttributeDescription2EXT32 *in, uint32_t count)
9104 {
9105     VkVertexInputAttributeDescription2EXT *out;
9106     unsigned int i;
9107
9108     if (!in || !count) return NULL;
9109
9110     out = conversion_context_alloc(ctx, count * sizeof(*out));
9111     for (i = 0; i < count; i++)
9112     {
9113         convert_VkVertexInputAttributeDescription2EXT_win32_to_host(&in[i], &out[i]);
9114     }
9115
9116     return out;
9117 }
9118
9119 static inline void convert_VkShadingRatePaletteNV_win32_to_host(const VkShadingRatePaletteNV32 *in, VkShadingRatePaletteNV *out)
9120 {
9121     if (!in) return;
9122
9123     out->shadingRatePaletteEntryCount = in->shadingRatePaletteEntryCount;
9124     out->pShadingRatePaletteEntries = (const VkShadingRatePaletteEntryNV *)UlongToPtr(in->pShadingRatePaletteEntries);
9125 }
9126
9127 static inline const VkShadingRatePaletteNV *convert_VkShadingRatePaletteNV_array_win32_to_host(struct conversion_context *ctx, const VkShadingRatePaletteNV32 *in, uint32_t count)
9128 {
9129     VkShadingRatePaletteNV *out;
9130     unsigned int i;
9131
9132     if (!in || !count) return NULL;
9133
9134     out = conversion_context_alloc(ctx, count * sizeof(*out));
9135     for (i = 0; i < count; i++)
9136     {
9137         convert_VkShadingRatePaletteNV_win32_to_host(&in[i], &out[i]);
9138     }
9139
9140     return out;
9141 }
9142
9143 static inline void convert_VkStridedDeviceAddressRegionKHR_win32_to_host(const VkStridedDeviceAddressRegionKHR32 *in, VkStridedDeviceAddressRegionKHR *out)
9144 {
9145     if (!in) return;
9146
9147     out->deviceAddress = in->deviceAddress;
9148     out->stride = in->stride;
9149     out->size = in->size;
9150 }
9151
9152 static inline const VkDependencyInfo *convert_VkDependencyInfo_array_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, uint32_t count)
9153 {
9154     VkDependencyInfo *out;
9155     unsigned int i;
9156
9157     if (!in || !count) return NULL;
9158
9159     out = conversion_context_alloc(ctx, count * sizeof(*out));
9160     for (i = 0; i < count; i++)
9161     {
9162         convert_VkDependencyInfo_win32_to_host(ctx, &in[i], &out[i]);
9163     }
9164
9165     return out;
9166 }
9167
9168 static inline void convert_VkCopyImageToImageInfoEXT_win32_to_host(struct conversion_context *ctx, const VkCopyImageToImageInfoEXT32 *in, VkCopyImageToImageInfoEXT *out)
9169 {
9170     if (!in) return;
9171
9172     out->sType = in->sType;
9173     out->pNext = NULL;
9174     out->flags = in->flags;
9175     out->srcImage = in->srcImage;
9176     out->srcImageLayout = in->srcImageLayout;
9177     out->dstImage = in->dstImage;
9178     out->dstImageLayout = in->dstImageLayout;
9179     out->regionCount = in->regionCount;
9180     out->pRegions = convert_VkImageCopy2_array_win32_to_host(ctx, (const VkImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
9181     if (in->pNext)
9182         FIXME("Unexpected pNext\n");
9183 }
9184
9185 static inline void convert_VkImageToMemoryCopyEXT_win32_to_host(const VkImageToMemoryCopyEXT32 *in, VkImageToMemoryCopyEXT *out)
9186 {
9187     if (!in) return;
9188
9189     out->sType = in->sType;
9190     out->pNext = NULL;
9191     out->pHostPointer = (void *)UlongToPtr(in->pHostPointer);
9192     out->memoryRowLength = in->memoryRowLength;
9193     out->memoryImageHeight = in->memoryImageHeight;
9194     out->imageSubresource = in->imageSubresource;
9195     out->imageOffset = in->imageOffset;
9196     out->imageExtent = in->imageExtent;
9197     if (in->pNext)
9198         FIXME("Unexpected pNext\n");
9199 }
9200
9201 static inline const VkImageToMemoryCopyEXT *convert_VkImageToMemoryCopyEXT_array_win32_to_host(struct conversion_context *ctx, const VkImageToMemoryCopyEXT32 *in, uint32_t count)
9202 {
9203     VkImageToMemoryCopyEXT *out;
9204     unsigned int i;
9205
9206     if (!in || !count) return NULL;
9207
9208     out = conversion_context_alloc(ctx, count * sizeof(*out));
9209     for (i = 0; i < count; i++)
9210     {
9211         convert_VkImageToMemoryCopyEXT_win32_to_host(&in[i], &out[i]);
9212     }
9213
9214     return out;
9215 }
9216
9217 static inline void convert_VkCopyImageToMemoryInfoEXT_win32_to_host(struct conversion_context *ctx, const VkCopyImageToMemoryInfoEXT32 *in, VkCopyImageToMemoryInfoEXT *out)
9218 {
9219     if (!in) return;
9220
9221     out->sType = in->sType;
9222     out->pNext = NULL;
9223     out->flags = in->flags;
9224     out->srcImage = in->srcImage;
9225     out->srcImageLayout = in->srcImageLayout;
9226     out->regionCount = in->regionCount;
9227     out->pRegions = convert_VkImageToMemoryCopyEXT_array_win32_to_host(ctx, (const VkImageToMemoryCopyEXT32 *)UlongToPtr(in->pRegions), in->regionCount);
9228     if (in->pNext)
9229         FIXME("Unexpected pNext\n");
9230 }
9231
9232 static inline void convert_VkMemoryToImageCopyEXT_win32_to_host(const VkMemoryToImageCopyEXT32 *in, VkMemoryToImageCopyEXT *out)
9233 {
9234     if (!in) return;
9235
9236     out->sType = in->sType;
9237     out->pNext = NULL;
9238     out->pHostPointer = (const void *)UlongToPtr(in->pHostPointer);
9239     out->memoryRowLength = in->memoryRowLength;
9240     out->memoryImageHeight = in->memoryImageHeight;
9241     out->imageSubresource = in->imageSubresource;
9242     out->imageOffset = in->imageOffset;
9243     out->imageExtent = in->imageExtent;
9244     if (in->pNext)
9245         FIXME("Unexpected pNext\n");
9246 }
9247
9248 static inline const VkMemoryToImageCopyEXT *convert_VkMemoryToImageCopyEXT_array_win32_to_host(struct conversion_context *ctx, const VkMemoryToImageCopyEXT32 *in, uint32_t count)
9249 {
9250     VkMemoryToImageCopyEXT *out;
9251     unsigned int i;
9252
9253     if (!in || !count) return NULL;
9254
9255     out = conversion_context_alloc(ctx, count * sizeof(*out));
9256     for (i = 0; i < count; i++)
9257     {
9258         convert_VkMemoryToImageCopyEXT_win32_to_host(&in[i], &out[i]);
9259     }
9260
9261     return out;
9262 }
9263
9264 static inline void convert_VkCopyMemoryToImageInfoEXT_win32_to_host(struct conversion_context *ctx, const VkCopyMemoryToImageInfoEXT32 *in, VkCopyMemoryToImageInfoEXT *out)
9265 {
9266     if (!in) return;
9267
9268     out->sType = in->sType;
9269     out->pNext = NULL;
9270     out->flags = in->flags;
9271     out->dstImage = in->dstImage;
9272     out->dstImageLayout = in->dstImageLayout;
9273     out->regionCount = in->regionCount;
9274     out->pRegions = convert_VkMemoryToImageCopyEXT_array_win32_to_host(ctx, (const VkMemoryToImageCopyEXT32 *)UlongToPtr(in->pRegions), in->regionCount);
9275     if (in->pNext)
9276         FIXME("Unexpected pNext\n");
9277 }
9278
9279 static inline void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoKHR32 *in, VkAccelerationStructureCreateInfoKHR *out)
9280 {
9281     const VkBaseInStructure32 *in_header;
9282     VkBaseOutStructure *out_header = (void *)out;
9283
9284     if (!in) return;
9285
9286     out->sType = in->sType;
9287     out->pNext = NULL;
9288     out->createFlags = in->createFlags;
9289     out->buffer = in->buffer;
9290     out->offset = in->offset;
9291     out->size = in->size;
9292     out->type = in->type;
9293     out->deviceAddress = in->deviceAddress;
9294
9295     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9296     {
9297         switch (in_header->sType)
9298         {
9299         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
9300         {
9301             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9302             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
9303             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
9304             out_ext->pNext = NULL;
9305             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
9306             out_header->pNext = (void *)out_ext;
9307             out_header = (void *)out_ext;
9308             break;
9309         }
9310         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
9311         {
9312             VkAccelerationStructureMotionInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9313             const VkAccelerationStructureMotionInfoNV32 *in_ext = (const VkAccelerationStructureMotionInfoNV32 *)in_header;
9314             out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV;
9315             out_ext->pNext = NULL;
9316             out_ext->maxInstances = in_ext->maxInstances;
9317             out_ext->flags = in_ext->flags;
9318             out_header->pNext = (void *)out_ext;
9319             out_header = (void *)out_ext;
9320             break;
9321         }
9322         default:
9323             FIXME("Unhandled sType %u.\n", in_header->sType);
9324             break;
9325         }
9326     }
9327 }
9328
9329 static inline void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoNV32 *in, VkAccelerationStructureCreateInfoNV *out)
9330 {
9331     const VkBaseInStructure32 *in_header;
9332     VkBaseOutStructure *out_header = (void *)out;
9333
9334     if (!in) return;
9335
9336     out->sType = in->sType;
9337     out->pNext = NULL;
9338     out->compactedSize = in->compactedSize;
9339     convert_VkAccelerationStructureInfoNV_win32_to_host(ctx, &in->info, &out->info);
9340
9341     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9342     {
9343         switch (in_header->sType)
9344         {
9345         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
9346         {
9347             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9348             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
9349             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
9350             out_ext->pNext = NULL;
9351             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
9352             out_header->pNext = (void *)out_ext;
9353             out_header = (void *)out_ext;
9354             break;
9355         }
9356         default:
9357             FIXME("Unhandled sType %u.\n", in_header->sType);
9358             break;
9359         }
9360     }
9361 }
9362
9363 static inline void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, VkBufferCreateInfo *out)
9364 {
9365     const VkBaseInStructure32 *in_header;
9366     VkBaseOutStructure *out_header = (void *)out;
9367
9368     if (!in) return;
9369
9370     out->sType = in->sType;
9371     out->pNext = NULL;
9372     out->flags = in->flags;
9373     out->size = in->size;
9374     out->usage = in->usage;
9375     out->sharingMode = in->sharingMode;
9376     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
9377     out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);
9378
9379     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9380     {
9381         switch (in_header->sType)
9382         {
9383         case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
9384         {
9385             VkBufferUsageFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9386             const VkBufferUsageFlags2CreateInfoKHR32 *in_ext = (const VkBufferUsageFlags2CreateInfoKHR32 *)in_header;
9387             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR;
9388             out_ext->pNext = NULL;
9389             out_ext->usage = in_ext->usage;
9390             out_header->pNext = (void *)out_ext;
9391             out_header = (void *)out_ext;
9392             break;
9393         }
9394         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
9395         {
9396             VkDedicatedAllocationBufferCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9397             const VkDedicatedAllocationBufferCreateInfoNV32 *in_ext = (const VkDedicatedAllocationBufferCreateInfoNV32 *)in_header;
9398             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV;
9399             out_ext->pNext = NULL;
9400             out_ext->dedicatedAllocation = in_ext->dedicatedAllocation;
9401             out_header->pNext = (void *)out_ext;
9402             out_header = (void *)out_ext;
9403             break;
9404         }
9405         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
9406         {
9407             VkExternalMemoryBufferCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9408             const VkExternalMemoryBufferCreateInfo32 *in_ext = (const VkExternalMemoryBufferCreateInfo32 *)in_header;
9409             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
9410             out_ext->pNext = NULL;
9411             out_ext->handleTypes = in_ext->handleTypes;
9412             out_header->pNext = (void *)out_ext;
9413             out_header = (void *)out_ext;
9414             break;
9415         }
9416         case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
9417         {
9418             VkBufferOpaqueCaptureAddressCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9419             const VkBufferOpaqueCaptureAddressCreateInfo32 *in_ext = (const VkBufferOpaqueCaptureAddressCreateInfo32 *)in_header;
9420             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
9421             out_ext->pNext = NULL;
9422             out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress;
9423             out_header->pNext = (void *)out_ext;
9424             out_header = (void *)out_ext;
9425             break;
9426         }
9427         case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
9428         {
9429             VkBufferDeviceAddressCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9430             const VkBufferDeviceAddressCreateInfoEXT32 *in_ext = (const VkBufferDeviceAddressCreateInfoEXT32 *)in_header;
9431             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT;
9432             out_ext->pNext = NULL;
9433             out_ext->deviceAddress = in_ext->deviceAddress;
9434             out_header->pNext = (void *)out_ext;
9435             out_header = (void *)out_ext;
9436             break;
9437         }
9438         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
9439         {
9440             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9441             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
9442             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
9443             out_ext->pNext = NULL;
9444             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
9445             out_header->pNext = (void *)out_ext;
9446             out_header = (void *)out_ext;
9447             break;
9448         }
9449         default:
9450             FIXME("Unhandled sType %u.\n", in_header->sType);
9451             break;
9452         }
9453     }
9454 }
9455
9456 static inline void convert_VkBufferViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferViewCreateInfo32 *in, VkBufferViewCreateInfo *out)
9457 {
9458     const VkBaseInStructure32 *in_header;
9459     VkBaseOutStructure *out_header = (void *)out;
9460
9461     if (!in) return;
9462
9463     out->sType = in->sType;
9464     out->pNext = NULL;
9465     out->flags = in->flags;
9466     out->buffer = in->buffer;
9467     out->format = in->format;
9468     out->offset = in->offset;
9469     out->range = in->range;
9470
9471     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9472     {
9473         switch (in_header->sType)
9474         {
9475         case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
9476         {
9477             VkBufferUsageFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9478             const VkBufferUsageFlags2CreateInfoKHR32 *in_ext = (const VkBufferUsageFlags2CreateInfoKHR32 *)in_header;
9479             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR;
9480             out_ext->pNext = NULL;
9481             out_ext->usage = in_ext->usage;
9482             out_header->pNext = (void *)out_ext;
9483             out_header = (void *)out_ext;
9484             break;
9485         }
9486         default:
9487             FIXME("Unhandled sType %u.\n", in_header->sType);
9488             break;
9489         }
9490     }
9491 }
9492
9493 static inline void convert_VkCommandPoolCreateInfo_win32_to_host(const VkCommandPoolCreateInfo32 *in, VkCommandPoolCreateInfo *out)
9494 {
9495     if (!in) return;
9496
9497     out->sType = in->sType;
9498     out->pNext = NULL;
9499     out->flags = in->flags;
9500     out->queueFamilyIndex = in->queueFamilyIndex;
9501     if (in->pNext)
9502         FIXME("Unexpected pNext\n");
9503 }
9504
9505 static inline void convert_VkPipelineCreationFeedback_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out)
9506 {
9507     if (!in) return;
9508
9509     out->flags = in->flags;
9510     out->duration = in->duration;
9511 }
9512
9513 static inline VkPipelineCreationFeedback *convert_VkPipelineCreationFeedback_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreationFeedback32 *in, uint32_t count)
9514 {
9515     VkPipelineCreationFeedback *out;
9516     if (!in || !count) return NULL;
9517
9518     out = conversion_context_alloc(ctx, count * sizeof(*out));
9519
9520     return out;
9521 }
9522
9523 static inline void convert_VkPipelineCreationFeedback_array_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out, uint32_t count)
9524 {
9525     unsigned int i;
9526
9527     if (!in) return;
9528
9529     for (i = 0; i < count; i++)
9530     {
9531         convert_VkPipelineCreationFeedback_host_to_win32(&in[i], &out[i]);
9532     }
9533 }
9534
9535 static inline void convert_VkSpecializationMapEntry_win32_to_host(const VkSpecializationMapEntry32 *in, VkSpecializationMapEntry *out)
9536 {
9537     if (!in) return;
9538
9539     out->constantID = in->constantID;
9540     out->offset = in->offset;
9541     out->size = in->size;
9542 }
9543
9544 static inline const VkSpecializationMapEntry *convert_VkSpecializationMapEntry_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationMapEntry32 *in, uint32_t count)
9545 {
9546     VkSpecializationMapEntry *out;
9547     unsigned int i;
9548
9549     if (!in || !count) return NULL;
9550
9551     out = conversion_context_alloc(ctx, count * sizeof(*out));
9552     for (i = 0; i < count; i++)
9553     {
9554         convert_VkSpecializationMapEntry_win32_to_host(&in[i], &out[i]);
9555     }
9556
9557     return out;
9558 }
9559
9560 static inline void convert_VkSpecializationInfo_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, VkSpecializationInfo *out)
9561 {
9562     if (!in) return;
9563
9564     out->mapEntryCount = in->mapEntryCount;
9565     out->pMapEntries = convert_VkSpecializationMapEntry_array_win32_to_host(ctx, (const VkSpecializationMapEntry32 *)UlongToPtr(in->pMapEntries), in->mapEntryCount);
9566     out->dataSize = in->dataSize;
9567     out->pData = (const void *)UlongToPtr(in->pData);
9568 }
9569
9570 static inline const VkSpecializationInfo *convert_VkSpecializationInfo_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, uint32_t count)
9571 {
9572     VkSpecializationInfo *out;
9573     unsigned int i;
9574
9575     if (!in || !count) return NULL;
9576
9577     out = conversion_context_alloc(ctx, count * sizeof(*out));
9578     for (i = 0; i < count; i++)
9579     {
9580         convert_VkSpecializationInfo_win32_to_host(ctx, &in[i], &out[i]);
9581     }
9582
9583     return out;
9584 }
9585
9586 #ifdef _WIN64
9587 static inline void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo *out)
9588 {
9589     const VkBaseInStructure *in_header;
9590     VkBaseOutStructure *out_header = (void *)out;
9591
9592     if (!in) return;
9593
9594     out->sType = in->sType;
9595     out->pNext = NULL;
9596     out->flags = in->flags;
9597     out->stage = in->stage;
9598     out->module = in->module;
9599     out->pName = in->pName;
9600     out->pSpecializationInfo = in->pSpecializationInfo;
9601
9602     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
9603     {
9604         switch (in_header->sType)
9605         {
9606         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
9607         {
9608             VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9609             const VkShaderModuleCreateInfo *in_ext = (const VkShaderModuleCreateInfo *)in_header;
9610             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
9611             out_ext->pNext = NULL;
9612             out_ext->flags = in_ext->flags;
9613             out_ext->codeSize = in_ext->codeSize;
9614             out_ext->pCode = in_ext->pCode;
9615             out_header->pNext = (void *)out_ext;
9616             out_header = (void *)out_ext;
9617             break;
9618         }
9619         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
9620         {
9621             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9622             const VkShaderModuleValidationCacheCreateInfoEXT *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT *)in_header;
9623             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
9624             out_ext->pNext = NULL;
9625             out_ext->validationCache = in_ext->validationCache;
9626             out_header->pNext = (void *)out_ext;
9627             out_header = (void *)out_ext;
9628             break;
9629         }
9630         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
9631         {
9632             VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9633             const VkDebugUtilsObjectNameInfoEXT *in_ext = (const VkDebugUtilsObjectNameInfoEXT *)in_header;
9634             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
9635             out_ext->pNext = NULL;
9636             out_ext->objectType = in_ext->objectType;
9637             out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
9638             out_ext->pObjectName = in_ext->pObjectName;
9639             out_header->pNext = (void *)out_ext;
9640             out_header = (void *)out_ext;
9641             break;
9642         }
9643         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
9644         {
9645             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9646             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)in_header;
9647             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
9648             out_ext->pNext = NULL;
9649             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
9650             out_header->pNext = (void *)out_ext;
9651             out_header = (void *)out_ext;
9652             break;
9653         }
9654         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
9655         {
9656             VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9657             const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *)in_header;
9658             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
9659             out_ext->pNext = NULL;
9660             out_ext->identifierSize = in_ext->identifierSize;
9661             out_ext->pIdentifier = in_ext->pIdentifier;
9662             out_header->pNext = (void *)out_ext;
9663             out_header = (void *)out_ext;
9664             break;
9665         }
9666         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
9667         {
9668             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9669             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
9670             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
9671             out_ext->pNext = NULL;
9672             out_ext->storageBuffers = in_ext->storageBuffers;
9673             out_ext->uniformBuffers = in_ext->uniformBuffers;
9674             out_ext->vertexInputs = in_ext->vertexInputs;
9675             out_ext->images = in_ext->images;
9676             out_header->pNext = (void *)out_ext;
9677             out_header = (void *)out_ext;
9678             break;
9679         }
9680         default:
9681             FIXME("Unhandled sType %u.\n", in_header->sType);
9682             break;
9683         }
9684     }
9685 }
9686 #endif /* _WIN64 */
9687
9688 static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, VkPipelineShaderStageCreateInfo *out)
9689 {
9690     const VkBaseInStructure32 *in_header;
9691     VkBaseOutStructure *out_header = (void *)out;
9692
9693     if (!in) return;
9694
9695     out->sType = in->sType;
9696     out->pNext = NULL;
9697     out->flags = in->flags;
9698     out->stage = in->stage;
9699     out->module = in->module;
9700     out->pName = (const char *)UlongToPtr(in->pName);
9701     out->pSpecializationInfo = convert_VkSpecializationInfo_array_win32_to_host(ctx, (const VkSpecializationInfo32 *)UlongToPtr(in->pSpecializationInfo), 1);
9702
9703     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9704     {
9705         switch (in_header->sType)
9706         {
9707         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
9708         {
9709             VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9710             const VkShaderModuleCreateInfo32 *in_ext = (const VkShaderModuleCreateInfo32 *)in_header;
9711             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
9712             out_ext->pNext = NULL;
9713             out_ext->flags = in_ext->flags;
9714             out_ext->codeSize = in_ext->codeSize;
9715             out_ext->pCode = (const uint32_t *)UlongToPtr(in_ext->pCode);
9716             out_header->pNext = (void *)out_ext;
9717             out_header = (void *)out_ext;
9718             break;
9719         }
9720         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
9721         {
9722             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9723             const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
9724             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
9725             out_ext->pNext = NULL;
9726             out_ext->validationCache = in_ext->validationCache;
9727             out_header->pNext = (void *)out_ext;
9728             out_header = (void *)out_ext;
9729             break;
9730         }
9731         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
9732         {
9733             VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9734             const VkDebugUtilsObjectNameInfoEXT32 *in_ext = (const VkDebugUtilsObjectNameInfoEXT32 *)in_header;
9735             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
9736             out_ext->pNext = NULL;
9737             out_ext->objectType = in_ext->objectType;
9738             out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
9739             out_ext->pObjectName = (const char *)UlongToPtr(in_ext->pObjectName);
9740             out_header->pNext = (void *)out_ext;
9741             out_header = (void *)out_ext;
9742             break;
9743         }
9744         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
9745         {
9746             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9747             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *)in_header;
9748             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
9749             out_ext->pNext = NULL;
9750             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
9751             out_header->pNext = (void *)out_ext;
9752             out_header = (void *)out_ext;
9753             break;
9754         }
9755         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
9756         {
9757             VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9758             const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *)in_header;
9759             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
9760             out_ext->pNext = NULL;
9761             out_ext->identifierSize = in_ext->identifierSize;
9762             out_ext->pIdentifier = (const uint8_t *)UlongToPtr(in_ext->pIdentifier);
9763             out_header->pNext = (void *)out_ext;
9764             out_header = (void *)out_ext;
9765             break;
9766         }
9767         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
9768         {
9769             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9770             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
9771             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
9772             out_ext->pNext = NULL;
9773             out_ext->storageBuffers = in_ext->storageBuffers;
9774             out_ext->uniformBuffers = in_ext->uniformBuffers;
9775             out_ext->vertexInputs = in_ext->vertexInputs;
9776             out_ext->images = in_ext->images;
9777             out_header->pNext = (void *)out_ext;
9778             out_header = (void *)out_ext;
9779             break;
9780         }
9781         default:
9782             FIXME("Unhandled sType %u.\n", in_header->sType);
9783             break;
9784         }
9785     }
9786 }
9787
9788 #ifdef _WIN64
9789 static inline void convert_VkComputePipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, VkComputePipelineCreateInfo *out)
9790 {
9791     if (!in) return;
9792
9793     out->sType = in->sType;
9794     out->pNext = in->pNext;
9795     out->flags = in->flags;
9796     convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in->stage, &out->stage);
9797     out->layout = in->layout;
9798     out->basePipelineHandle = in->basePipelineHandle;
9799     out->basePipelineIndex = in->basePipelineIndex;
9800 }
9801 #endif /* _WIN64 */
9802
9803 static inline void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, VkComputePipelineCreateInfo *out)
9804 {
9805     const VkBaseInStructure32 *in_header;
9806     VkBaseOutStructure *out_header = (void *)out;
9807
9808     if (!in) return;
9809
9810     out->sType = in->sType;
9811     out->pNext = NULL;
9812     out->flags = in->flags;
9813     convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in->stage, &out->stage);
9814     out->layout = in->layout;
9815     out->basePipelineHandle = in->basePipelineHandle;
9816     out->basePipelineIndex = in->basePipelineIndex;
9817
9818     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9819     {
9820         switch (in_header->sType)
9821         {
9822         case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
9823         {
9824             VkPipelineCreateFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9825             const VkPipelineCreateFlags2CreateInfoKHR32 *in_ext = (const VkPipelineCreateFlags2CreateInfoKHR32 *)in_header;
9826             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR;
9827             out_ext->pNext = NULL;
9828             out_ext->flags = in_ext->flags;
9829             out_header->pNext = (void *)out_ext;
9830             out_header = (void *)out_ext;
9831             break;
9832         }
9833         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
9834         {
9835             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9836             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
9837             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
9838             out_ext->pNext = NULL;
9839             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
9840             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
9841             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
9842             out_header->pNext = (void *)out_ext;
9843             out_header = (void *)out_ext;
9844             break;
9845         }
9846         case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
9847         {
9848             VkSubpassShadingPipelineCreateInfoHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9849             const VkSubpassShadingPipelineCreateInfoHUAWEI32 *in_ext = (const VkSubpassShadingPipelineCreateInfoHUAWEI32 *)in_header;
9850             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI;
9851             out_ext->pNext = NULL;
9852             out_ext->renderPass = in_ext->renderPass;
9853             out_ext->subpass = in_ext->subpass;
9854             out_header->pNext = (void *)out_ext;
9855             out_header = (void *)out_ext;
9856             break;
9857         }
9858         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
9859         {
9860             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9861             const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header;
9862             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
9863             out_ext->pNext = NULL;
9864             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
9865             out_header->pNext = (void *)out_ext;
9866             out_header = (void *)out_ext;
9867             break;
9868         }
9869         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
9870         {
9871             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9872             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
9873             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
9874             out_ext->pNext = NULL;
9875             out_ext->storageBuffers = in_ext->storageBuffers;
9876             out_ext->uniformBuffers = in_ext->uniformBuffers;
9877             out_ext->vertexInputs = in_ext->vertexInputs;
9878             out_ext->images = in_ext->images;
9879             out_header->pNext = (void *)out_ext;
9880             out_header = (void *)out_ext;
9881             break;
9882         }
9883         default:
9884             FIXME("Unhandled sType %u.\n", in_header->sType);
9885             break;
9886         }
9887     }
9888 }
9889
9890 static inline void convert_VkComputePipelineCreateInfo_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out)
9891 {
9892     const VkBaseInStructure *in_header;
9893     VkBaseOutStructure32 *out_header = (void *)out;
9894
9895     if (!in) return;
9896
9897
9898     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
9899     {
9900         switch (in_header->sType)
9901         {
9902         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
9903         {
9904             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
9905             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
9906             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
9907             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
9908             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
9909             out_header = (void *)out_ext;
9910             break;
9911         }
9912         default:
9913             break;
9914         }
9915     }
9916 }
9917
9918 #ifdef _WIN64
9919 static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, uint32_t count)
9920 {
9921     VkComputePipelineCreateInfo *out;
9922     unsigned int i;
9923
9924     if (!in || !count) return NULL;
9925
9926     out = conversion_context_alloc(ctx, count * sizeof(*out));
9927     for (i = 0; i < count; i++)
9928     {
9929         convert_VkComputePipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
9930     }
9931
9932     return out;
9933 }
9934 #endif /* _WIN64 */
9935
9936 static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, uint32_t count)
9937 {
9938     VkComputePipelineCreateInfo *out;
9939     unsigned int i;
9940
9941     if (!in || !count) return NULL;
9942
9943     out = conversion_context_alloc(ctx, count * sizeof(*out));
9944     for (i = 0; i < count; i++)
9945     {
9946         convert_VkComputePipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
9947     }
9948
9949     return out;
9950 }
9951
9952 static inline void convert_VkComputePipelineCreateInfo_array_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out, uint32_t count)
9953 {
9954     unsigned int i;
9955
9956     if (!in) return;
9957
9958     for (i = 0; i < count; i++)
9959     {
9960         convert_VkComputePipelineCreateInfo_host_to_win32(&in[i], &out[i]);
9961     }
9962 }
9963
9964 static inline void convert_VkCuFunctionCreateInfoNVX_win32_to_host(const VkCuFunctionCreateInfoNVX32 *in, VkCuFunctionCreateInfoNVX *out)
9965 {
9966     if (!in) return;
9967
9968     out->sType = in->sType;
9969     out->pNext = NULL;
9970     out->module = in->module;
9971     out->pName = (const char *)UlongToPtr(in->pName);
9972     if (in->pNext)
9973         FIXME("Unexpected pNext\n");
9974 }
9975
9976 static inline void convert_VkCuModuleCreateInfoNVX_win32_to_host(const VkCuModuleCreateInfoNVX32 *in, VkCuModuleCreateInfoNVX *out)
9977 {
9978     if (!in) return;
9979
9980     out->sType = in->sType;
9981     out->pNext = NULL;
9982     out->dataSize = in->dataSize;
9983     out->pData = (const void *)UlongToPtr(in->pData);
9984     if (in->pNext)
9985         FIXME("Unexpected pNext\n");
9986 }
9987
9988 static inline void convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(const VkDebugReportCallbackCreateInfoEXT32 *in, VkDebugReportCallbackCreateInfoEXT *out)
9989 {
9990     if (!in) return;
9991
9992     out->sType = in->sType;
9993     out->pNext = NULL;
9994     out->flags = in->flags;
9995     out->pfnCallback = in->pfnCallback;
9996     out->pUserData = (void *)UlongToPtr(in->pUserData);
9997     if (in->pNext)
9998         FIXME("Unexpected pNext\n");
9999 }
10000
10001 static inline void convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host(const VkDebugUtilsMessengerCreateInfoEXT32 *in, VkDebugUtilsMessengerCreateInfoEXT *out)
10002 {
10003     if (!in) return;
10004
10005     out->sType = in->sType;
10006     out->pNext = NULL;
10007     out->flags = in->flags;
10008     out->messageSeverity = in->messageSeverity;
10009     out->messageType = in->messageType;
10010     out->pfnUserCallback = in->pfnUserCallback;
10011     out->pUserData = (void *)UlongToPtr(in->pUserData);
10012     if (in->pNext)
10013         FIXME("Unexpected pNext\n");
10014 }
10015
10016 static inline void convert_VkMutableDescriptorTypeListEXT_win32_to_host(const VkMutableDescriptorTypeListEXT32 *in, VkMutableDescriptorTypeListEXT *out)
10017 {
10018     if (!in) return;
10019
10020     out->descriptorTypeCount = in->descriptorTypeCount;
10021     out->pDescriptorTypes = (const VkDescriptorType *)UlongToPtr(in->pDescriptorTypes);
10022 }
10023
10024 static inline const VkMutableDescriptorTypeListEXT *convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(struct conversion_context *ctx, const VkMutableDescriptorTypeListEXT32 *in, uint32_t count)
10025 {
10026     VkMutableDescriptorTypeListEXT *out;
10027     unsigned int i;
10028
10029     if (!in || !count) return NULL;
10030
10031     out = conversion_context_alloc(ctx, count * sizeof(*out));
10032     for (i = 0; i < count; i++)
10033     {
10034         convert_VkMutableDescriptorTypeListEXT_win32_to_host(&in[i], &out[i]);
10035     }
10036
10037     return out;
10038 }
10039
10040 static inline void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorPoolCreateInfo32 *in, VkDescriptorPoolCreateInfo *out)
10041 {
10042     const VkBaseInStructure32 *in_header;
10043     VkBaseOutStructure *out_header = (void *)out;
10044
10045     if (!in) return;
10046
10047     out->sType = in->sType;
10048     out->pNext = NULL;
10049     out->flags = in->flags;
10050     out->maxSets = in->maxSets;
10051     out->poolSizeCount = in->poolSizeCount;
10052     out->pPoolSizes = (const VkDescriptorPoolSize *)UlongToPtr(in->pPoolSizes);
10053
10054     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
10055     {
10056         switch (in_header->sType)
10057         {
10058         case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
10059         {
10060             VkDescriptorPoolInlineUniformBlockCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10061             const VkDescriptorPoolInlineUniformBlockCreateInfo32 *in_ext = (const VkDescriptorPoolInlineUniformBlockCreateInfo32 *)in_header;
10062             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
10063             out_ext->pNext = NULL;
10064             out_ext->maxInlineUniformBlockBindings = in_ext->maxInlineUniformBlockBindings;
10065             out_header->pNext = (void *)out_ext;
10066             out_header = (void *)out_ext;
10067             break;
10068         }
10069         case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
10070         {
10071             VkMutableDescriptorTypeCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10072             const VkMutableDescriptorTypeCreateInfoEXT32 *in_ext = (const VkMutableDescriptorTypeCreateInfoEXT32 *)in_header;
10073             out_ext->sType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
10074             out_ext->pNext = NULL;
10075             out_ext->mutableDescriptorTypeListCount = in_ext->mutableDescriptorTypeListCount;
10076             out_ext->pMutableDescriptorTypeLists = convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(ctx, (const VkMutableDescriptorTypeListEXT32 *)UlongToPtr(in_ext->pMutableDescriptorTypeLists), in_ext->mutableDescriptorTypeListCount);
10077             out_header->pNext = (void *)out_ext;
10078             out_header = (void *)out_ext;
10079             break;
10080         }
10081         default:
10082             FIXME("Unhandled sType %u.\n", in_header->sType);
10083             break;
10084         }
10085     }
10086 }
10087
10088 static inline void convert_VkDescriptorSetLayoutBinding_win32_to_host(const VkDescriptorSetLayoutBinding32 *in, VkDescriptorSetLayoutBinding *out)
10089 {
10090     if (!in) return;
10091
10092     out->binding = in->binding;
10093     out->descriptorType = in->descriptorType;
10094     out->descriptorCount = in->descriptorCount;
10095     out->stageFlags = in->stageFlags;
10096     out->pImmutableSamplers = (const VkSampler *)UlongToPtr(in->pImmutableSamplers);
10097 }
10098
10099 static inline const VkDescriptorSetLayoutBinding *convert_VkDescriptorSetLayoutBinding_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutBinding32 *in, uint32_t count)
10100 {
10101     VkDescriptorSetLayoutBinding *out;
10102     unsigned int i;
10103
10104     if (!in || !count) return NULL;
10105
10106     out = conversion_context_alloc(ctx, count * sizeof(*out));
10107     for (i = 0; i < count; i++)
10108     {
10109         convert_VkDescriptorSetLayoutBinding_win32_to_host(&in[i], &out[i]);
10110     }
10111
10112     return out;
10113 }
10114
10115 static inline void convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutCreateInfo32 *in, VkDescriptorSetLayoutCreateInfo *out)
10116 {
10117     const VkBaseInStructure32 *in_header;
10118     VkBaseOutStructure *out_header = (void *)out;
10119
10120     if (!in) return;
10121
10122     out->sType = in->sType;
10123     out->pNext = NULL;
10124     out->flags = in->flags;
10125     out->bindingCount = in->bindingCount;
10126     out->pBindings = convert_VkDescriptorSetLayoutBinding_array_win32_to_host(ctx, (const VkDescriptorSetLayoutBinding32 *)UlongToPtr(in->pBindings), in->bindingCount);
10127
10128     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
10129     {
10130         switch (in_header->sType)
10131         {
10132         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
10133         {
10134             VkDescriptorSetLayoutBindingFlagsCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10135             const VkDescriptorSetLayoutBindingFlagsCreateInfo32 *in_ext = (const VkDescriptorSetLayoutBindingFlagsCreateInfo32 *)in_header;
10136             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
10137             out_ext->pNext = NULL;
10138             out_ext->bindingCount = in_ext->bindingCount;
10139             out_ext->pBindingFlags = (const VkDescriptorBindingFlags *)UlongToPtr(in_ext->pBindingFlags);
10140             out_header->pNext = (void *)out_ext;
10141             out_header = (void *)out_ext;
10142             break;
10143         }
10144         case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
10145         {
10146             VkMutableDescriptorTypeCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10147             const VkMutableDescriptorTypeCreateInfoEXT32 *in_ext = (const VkMutableDescriptorTypeCreateInfoEXT32 *)in_header;
10148             out_ext->sType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
10149             out_ext->pNext = NULL;
10150             out_ext->mutableDescriptorTypeListCount = in_ext->mutableDescriptorTypeListCount;
10151             out_ext->pMutableDescriptorTypeLists = convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(ctx, (const VkMutableDescriptorTypeListEXT32 *)UlongToPtr(in_ext->pMutableDescriptorTypeLists), in_ext->mutableDescriptorTypeListCount);
10152             out_header->pNext = (void *)out_ext;
10153             out_header = (void *)out_ext;
10154             break;
10155         }
10156         default:
10157             FIXME("Unhandled sType %u.\n", in_header->sType);
10158             break;
10159         }
10160     }
10161 }
10162
10163 static inline void convert_VkDescriptorUpdateTemplateEntry_win32_to_host(const VkDescriptorUpdateTemplateEntry32 *in, VkDescriptorUpdateTemplateEntry *out)
10164 {
10165     if (!in) return;
10166
10167     out->dstBinding = in->dstBinding;
10168     out->dstArrayElement = in->dstArrayElement;
10169     out->descriptorCount = in->descriptorCount;
10170     out->descriptorType = in->descriptorType;
10171     out->offset = in->offset;
10172     out->stride = in->stride;
10173 }
10174
10175 static inline const VkDescriptorUpdateTemplateEntry *convert_VkDescriptorUpdateTemplateEntry_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateEntry32 *in, uint32_t count)
10176 {
10177     VkDescriptorUpdateTemplateEntry *out;
10178     unsigned int i;
10179
10180     if (!in || !count) return NULL;
10181
10182     out = conversion_context_alloc(ctx, count * sizeof(*out));
10183     for (i = 0; i < count; i++)
10184     {
10185         convert_VkDescriptorUpdateTemplateEntry_win32_to_host(&in[i], &out[i]);
10186     }
10187
10188     return out;
10189 }
10190
10191 static inline void convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateCreateInfo32 *in, VkDescriptorUpdateTemplateCreateInfo *out)
10192 {
10193     if (!in) return;
10194
10195     out->sType = in->sType;
10196     out->pNext = NULL;
10197     out->flags = in->flags;
10198     out->descriptorUpdateEntryCount = in->descriptorUpdateEntryCount;
10199     out->pDescriptorUpdateEntries = convert_VkDescriptorUpdateTemplateEntry_array_win32_to_host(ctx, (const VkDescriptorUpdateTemplateEntry32 *)UlongToPtr(in->pDescriptorUpdateEntries), in->descriptorUpdateEntryCount);
10200     out->templateType = in->templateType;
10201     out->descriptorSetLayout = in->descriptorSetLayout;
10202     out->pipelineBindPoint = in->pipelineBindPoint;
10203     out->pipelineLayout = in->pipelineLayout;
10204     out->set = in->set;
10205     if (in->pNext)
10206         FIXME("Unexpected pNext\n");
10207 }
10208
10209 #ifdef _WIN64
10210 static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win64_to_host(struct conversion_context *ctx, const VkPhysicalDevice *in, uint32_t count)
10211 {
10212     VkPhysicalDevice *out;
10213     unsigned int i;
10214
10215     if (!in || !count) return NULL;
10216
10217     out = conversion_context_alloc(ctx, count * sizeof(*out));
10218     for (i = 0; i < count; i++)
10219     {
10220         out[i] = wine_phys_dev_from_handle(in[i])->phys_dev;
10221     }
10222
10223     return out;
10224 }
10225 #endif /* _WIN64 */
10226
10227 static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
10228 {
10229     VkPhysicalDevice *out;
10230     unsigned int i;
10231
10232     if (!in || !count) return NULL;
10233
10234     out = conversion_context_alloc(ctx, count * sizeof(*out));
10235     for (i = 0; i < count; i++)
10236     {
10237         out[i] = wine_phys_dev_from_handle(UlongToPtr(in[i]))->phys_dev;
10238     }
10239
10240     return out;
10241 }
10242
10243 static inline void convert_VkDeviceQueueCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, VkDeviceQueueCreateInfo *out)
10244 {
10245     const VkBaseInStructure32 *in_header;
10246     VkBaseOutStructure *out_header = (void *)out;
10247
10248     if (!in) return;
10249
10250     out->sType = in->sType;
10251     out->pNext = NULL;
10252     out->flags = in->flags;
10253     out->queueFamilyIndex = in->queueFamilyIndex;
10254     out->queueCount = in->queueCount;
10255     out->pQueuePriorities = (const float *)UlongToPtr(in->pQueuePriorities);
10256
10257     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
10258     {
10259         switch (in_header->sType)
10260         {
10261         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
10262         {
10263             VkDeviceQueueGlobalPriorityCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10264             const VkDeviceQueueGlobalPriorityCreateInfoKHR32 *in_ext = (const VkDeviceQueueGlobalPriorityCreateInfoKHR32 *)in_header;
10265             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR;
10266             out_ext->pNext = NULL;
10267             out_ext->globalPriority = in_ext->globalPriority;
10268             out_header->pNext = (void *)out_ext;
10269             out_header = (void *)out_ext;
10270             break;
10271         }
10272         default:
10273             FIXME("Unhandled sType %u.\n", in_header->sType);
10274             break;
10275         }
10276     }
10277 }
10278
10279 static inline const VkDeviceQueueCreateInfo *convert_VkDeviceQueueCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, uint32_t count)
10280 {
10281     VkDeviceQueueCreateInfo *out;
10282     unsigned int i;
10283
10284     if (!in || !count) return NULL;
10285
10286     out = conversion_context_alloc(ctx, count * sizeof(*out));
10287     for (i = 0; i < count; i++)
10288     {
10289         convert_VkDeviceQueueCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
10290     }
10291
10292     return out;
10293 }
10294
10295 static inline const char * const*convert_char_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
10296 {
10297     char **out;
10298     unsigned int i;
10299
10300     if (!in || !count) return NULL;
10301
10302     out = conversion_context_alloc(ctx, count * sizeof(*out));
10303     for (i = 0; i < count; i++)
10304     {
10305         out[i] = UlongToPtr(in[i]);
10306     }
10307
10308     return (void *)out;
10309 }
10310
10311 #ifdef _WIN64
10312 static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo *in, VkDeviceCreateInfo *out)
10313 {
10314     const VkBaseInStructure *in_header;
10315     VkBaseOutStructure *out_header = (void *)out;
10316
10317     if (!in) return;
10318
10319     out->sType = in->sType;
10320     out->pNext = NULL;
10321     out->flags = in->flags;
10322     out->queueCreateInfoCount = in->queueCreateInfoCount;
10323     out->pQueueCreateInfos = in->pQueueCreateInfos;
10324     out->enabledLayerCount = in->enabledLayerCount;
10325     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
10326     out->enabledExtensionCount = in->enabledExtensionCount;
10327     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
10328     out->pEnabledFeatures = in->pEnabledFeatures;
10329
10330     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
10331     {
10332         switch (in_header->sType)
10333         {
10334         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
10335             break;
10336         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
10337         {
10338             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10339             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
10340             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
10341             out_ext->pNext = NULL;
10342             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
10343             out_header->pNext = (void *)out_ext;
10344             out_header = (void *)out_ext;
10345             break;
10346         }
10347         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
10348         {
10349             VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10350             const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *)in_header;
10351             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV;
10352             out_ext->pNext = NULL;
10353             out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute;
10354             out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines;
10355             out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay;
10356             out_header->pNext = (void *)out_ext;
10357             out_header = (void *)out_ext;
10358             break;
10359         }
10360         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
10361         {
10362             VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10363             const VkDevicePrivateDataCreateInfo *in_ext = (const VkDevicePrivateDataCreateInfo *)in_header;
10364             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
10365             out_ext->pNext = NULL;
10366             out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
10367             out_header->pNext = (void *)out_ext;
10368             out_header = (void *)out_ext;
10369             break;
10370         }
10371         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
10372         {
10373             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10374             const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
10375             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
10376             out_ext->pNext = NULL;
10377             out_ext->privateData = in_ext->privateData;
10378             out_header->pNext = (void *)out_ext;
10379             out_header = (void *)out_ext;
10380             break;
10381         }
10382         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
10383         {
10384             VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10385             const VkPhysicalDeviceFeatures2 *in_ext = (const VkPhysicalDeviceFeatures2 *)in_header;
10386             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
10387             out_ext->pNext = NULL;
10388             out_ext->features = in_ext->features;
10389             out_header->pNext = (void *)out_ext;
10390             out_header = (void *)out_ext;
10391             break;
10392         }
10393         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
10394         {
10395             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10396             const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
10397             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
10398             out_ext->pNext = NULL;
10399             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
10400             out_ext->variablePointers = in_ext->variablePointers;
10401             out_header->pNext = (void *)out_ext;
10402             out_header = (void *)out_ext;
10403             break;
10404         }
10405         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
10406         {
10407             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10408             const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
10409             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
10410             out_ext->pNext = NULL;
10411             out_ext->multiview = in_ext->multiview;
10412             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
10413             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
10414             out_header->pNext = (void *)out_ext;
10415             out_header = (void *)out_ext;
10416             break;
10417         }
10418         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
10419         {
10420             VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10421             const VkDeviceGroupDeviceCreateInfo *in_ext = (const VkDeviceGroupDeviceCreateInfo *)in_header;
10422             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
10423             out_ext->pNext = NULL;
10424             out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
10425             out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win64_to_host(ctx, in_ext->pPhysicalDevices, in_ext->physicalDeviceCount);
10426             out_header->pNext = (void *)out_ext;
10427             out_header = (void *)out_ext;
10428             break;
10429         }
10430         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
10431         {
10432             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10433             const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
10434             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
10435             out_ext->pNext = NULL;
10436             out_ext->presentId = in_ext->presentId;
10437             out_header->pNext = (void *)out_ext;
10438             out_header = (void *)out_ext;
10439             break;
10440         }
10441         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
10442         {
10443             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10444             const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
10445             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
10446             out_ext->pNext = NULL;
10447             out_ext->presentWait = in_ext->presentWait;
10448             out_header->pNext = (void *)out_ext;
10449             out_header = (void *)out_ext;
10450             break;
10451         }
10452         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
10453         {
10454             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10455             const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
10456             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
10457             out_ext->pNext = NULL;
10458             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
10459             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
10460             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
10461             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
10462             out_header->pNext = (void *)out_ext;
10463             out_header = (void *)out_ext;
10464             break;
10465         }
10466         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
10467         {
10468             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10469             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
10470             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
10471             out_ext->pNext = NULL;
10472             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
10473             out_header->pNext = (void *)out_ext;
10474             out_header = (void *)out_ext;
10475             break;
10476         }
10477         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
10478         {
10479             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10480             const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
10481             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
10482             out_ext->pNext = NULL;
10483             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
10484             out_header->pNext = (void *)out_ext;
10485             out_header = (void *)out_ext;
10486             break;
10487         }
10488         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
10489         {
10490             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10491             const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
10492             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
10493             out_ext->pNext = NULL;
10494             out_ext->protectedMemory = in_ext->protectedMemory;
10495             out_header->pNext = (void *)out_ext;
10496             out_header = (void *)out_ext;
10497             break;
10498         }
10499         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
10500         {
10501             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10502             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
10503             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
10504             out_ext->pNext = NULL;
10505             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
10506             out_header->pNext = (void *)out_ext;
10507             out_header = (void *)out_ext;
10508             break;
10509         }
10510         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
10511         {
10512             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10513             const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
10514             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
10515             out_ext->pNext = NULL;
10516             out_ext->multiDraw = in_ext->multiDraw;
10517             out_header->pNext = (void *)out_ext;
10518             out_header = (void *)out_ext;
10519             break;
10520         }
10521         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
10522         {
10523             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10524             const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
10525             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
10526             out_ext->pNext = NULL;
10527             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
10528             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
10529             out_header->pNext = (void *)out_ext;
10530             out_header = (void *)out_ext;
10531             break;
10532         }
10533         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
10534         {
10535             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10536             const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
10537             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
10538             out_ext->pNext = NULL;
10539             out_ext->maintenance4 = in_ext->maintenance4;
10540             out_header->pNext = (void *)out_ext;
10541             out_header = (void *)out_ext;
10542             break;
10543         }
10544         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
10545         {
10546             VkPhysicalDeviceMaintenance5FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10547             const VkPhysicalDeviceMaintenance5FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance5FeaturesKHR *)in_header;
10548             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR;
10549             out_ext->pNext = NULL;
10550             out_ext->maintenance5 = in_ext->maintenance5;
10551             out_header->pNext = (void *)out_ext;
10552             out_header = (void *)out_ext;
10553             break;
10554         }
10555         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
10556         {
10557             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10558             const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
10559             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
10560             out_ext->pNext = NULL;
10561             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
10562             out_header->pNext = (void *)out_ext;
10563             out_header = (void *)out_ext;
10564             break;
10565         }
10566         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
10567         {
10568             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10569             const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
10570             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
10571             out_ext->pNext = NULL;
10572             out_ext->shaderFloat16 = in_ext->shaderFloat16;
10573             out_ext->shaderInt8 = in_ext->shaderInt8;
10574             out_header->pNext = (void *)out_ext;
10575             out_header = (void *)out_ext;
10576             break;
10577         }
10578         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
10579         {
10580             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10581             const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
10582             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
10583             out_ext->pNext = NULL;
10584             out_ext->hostQueryReset = in_ext->hostQueryReset;
10585             out_header->pNext = (void *)out_ext;
10586             out_header = (void *)out_ext;
10587             break;
10588         }
10589         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
10590         {
10591             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10592             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *)in_header;
10593             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
10594             out_ext->pNext = NULL;
10595             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
10596             out_header->pNext = (void *)out_ext;
10597             out_header = (void *)out_ext;
10598             break;
10599         }
10600         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
10601         {
10602             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10603             const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
10604             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
10605             out_ext->pNext = NULL;
10606             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
10607             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
10608             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
10609             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
10610             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
10611             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
10612             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
10613             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
10614             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
10615             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
10616             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
10617             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
10618             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
10619             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
10620             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
10621             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
10622             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
10623             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
10624             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
10625             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
10626             out_header->pNext = (void *)out_ext;
10627             out_header = (void *)out_ext;
10628             break;
10629         }
10630         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
10631         {
10632             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10633             const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
10634             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
10635             out_ext->pNext = NULL;
10636             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
10637             out_header->pNext = (void *)out_ext;
10638             out_header = (void *)out_ext;
10639             break;
10640         }
10641         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
10642         {
10643             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10644             const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
10645             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
10646             out_ext->pNext = NULL;
10647             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
10648             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
10649             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
10650             out_header->pNext = (void *)out_ext;
10651             out_header = (void *)out_ext;
10652             break;
10653         }
10654         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
10655         {
10656             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10657             const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
10658             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
10659             out_ext->pNext = NULL;
10660             out_ext->conditionalRendering = in_ext->conditionalRendering;
10661             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
10662             out_header->pNext = (void *)out_ext;
10663             out_header = (void *)out_ext;
10664             break;
10665         }
10666         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
10667         {
10668             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10669             const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
10670             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
10671             out_ext->pNext = NULL;
10672             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
10673             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
10674             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
10675             out_header->pNext = (void *)out_ext;
10676             out_header = (void *)out_ext;
10677             break;
10678         }
10679         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
10680         {
10681             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10682             const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
10683             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
10684             out_ext->pNext = NULL;
10685             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
10686             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
10687             out_header->pNext = (void *)out_ext;
10688             out_header = (void *)out_ext;
10689             break;
10690         }
10691         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
10692         {
10693             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10694             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
10695             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
10696             out_ext->pNext = NULL;
10697             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
10698             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
10699             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
10700             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
10701             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
10702             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
10703             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
10704             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
10705             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
10706             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
10707             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
10708             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
10709             out_header->pNext = (void *)out_ext;
10710             out_header = (void *)out_ext;
10711             break;
10712         }
10713         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
10714         {
10715             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10716             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
10717             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
10718             out_ext->pNext = NULL;
10719             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
10720             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
10721             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
10722             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
10723             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
10724             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
10725             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
10726             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
10727             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
10728             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
10729             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
10730             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
10731             out_header->pNext = (void *)out_ext;
10732             out_header = (void *)out_ext;
10733             break;
10734         }
10735         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
10736         {
10737             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10738             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header;
10739             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
10740             out_ext->pNext = NULL;
10741             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
10742             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
10743             out_header->pNext = (void *)out_ext;
10744             out_header = (void *)out_ext;
10745             break;
10746         }
10747         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
10748         {
10749             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10750             const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
10751             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
10752             out_ext->pNext = NULL;
10753             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
10754             out_header->pNext = (void *)out_ext;
10755             out_header = (void *)out_ext;
10756             break;
10757         }
10758         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
10759         {
10760             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10761             const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
10762             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
10763             out_ext->pNext = NULL;
10764             out_ext->transformFeedback = in_ext->transformFeedback;
10765             out_ext->geometryStreams = in_ext->geometryStreams;
10766             out_header->pNext = (void *)out_ext;
10767             out_header = (void *)out_ext;
10768             break;
10769         }
10770         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
10771         {
10772             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10773             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
10774             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
10775             out_ext->pNext = NULL;
10776             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
10777             out_header->pNext = (void *)out_ext;
10778             out_header = (void *)out_ext;
10779             break;
10780         }
10781         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
10782         {
10783             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10784             const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
10785             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
10786             out_ext->pNext = NULL;
10787             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
10788             out_header->pNext = (void *)out_ext;
10789             out_header = (void *)out_ext;
10790             break;
10791         }
10792         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
10793         {
10794             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10795             const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
10796             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
10797             out_ext->pNext = NULL;
10798             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
10799             out_header->pNext = (void *)out_ext;
10800             out_header = (void *)out_ext;
10801             break;
10802         }
10803         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
10804         {
10805             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10806             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header;
10807             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
10808             out_ext->pNext = NULL;
10809             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
10810             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
10811             out_header->pNext = (void *)out_ext;
10812             out_header = (void *)out_ext;
10813             break;
10814         }
10815         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
10816         {
10817             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10818             const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
10819             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
10820             out_ext->pNext = NULL;
10821             out_ext->imageFootprint = in_ext->imageFootprint;
10822             out_header->pNext = (void *)out_ext;
10823             out_header = (void *)out_ext;
10824             break;
10825         }
10826         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
10827         {
10828             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10829             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
10830             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
10831             out_ext->pNext = NULL;
10832             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
10833             out_header->pNext = (void *)out_ext;
10834             out_header = (void *)out_ext;
10835             break;
10836         }
10837         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
10838         {
10839             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10840             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
10841             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
10842             out_ext->pNext = NULL;
10843             out_ext->indirectCopy = in_ext->indirectCopy;
10844             out_header->pNext = (void *)out_ext;
10845             out_header = (void *)out_ext;
10846             break;
10847         }
10848         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
10849         {
10850             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10851             const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
10852             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
10853             out_ext->pNext = NULL;
10854             out_ext->memoryDecompression = in_ext->memoryDecompression;
10855             out_header->pNext = (void *)out_ext;
10856             out_header = (void *)out_ext;
10857             break;
10858         }
10859         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
10860         {
10861             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10862             const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
10863             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
10864             out_ext->pNext = NULL;
10865             out_ext->shadingRateImage = in_ext->shadingRateImage;
10866             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
10867             out_header->pNext = (void *)out_ext;
10868             out_header = (void *)out_ext;
10869             break;
10870         }
10871         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
10872         {
10873             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10874             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
10875             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
10876             out_ext->pNext = NULL;
10877             out_ext->invocationMask = in_ext->invocationMask;
10878             out_header->pNext = (void *)out_ext;
10879             out_header = (void *)out_ext;
10880             break;
10881         }
10882         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
10883         {
10884             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10885             const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
10886             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
10887             out_ext->pNext = NULL;
10888             out_ext->taskShader = in_ext->taskShader;
10889             out_ext->meshShader = in_ext->meshShader;
10890             out_header->pNext = (void *)out_ext;
10891             out_header = (void *)out_ext;
10892             break;
10893         }
10894         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
10895         {
10896             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10897             const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
10898             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
10899             out_ext->pNext = NULL;
10900             out_ext->taskShader = in_ext->taskShader;
10901             out_ext->meshShader = in_ext->meshShader;
10902             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
10903             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
10904             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
10905             out_header->pNext = (void *)out_ext;
10906             out_header = (void *)out_ext;
10907             break;
10908         }
10909         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
10910         {
10911             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10912             const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
10913             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
10914             out_ext->pNext = NULL;
10915             out_ext->accelerationStructure = in_ext->accelerationStructure;
10916             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
10917             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
10918             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
10919             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
10920             out_header->pNext = (void *)out_ext;
10921             out_header = (void *)out_ext;
10922             break;
10923         }
10924         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
10925         {
10926             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10927             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
10928             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
10929             out_ext->pNext = NULL;
10930             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
10931             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
10932             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
10933             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
10934             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
10935             out_header->pNext = (void *)out_ext;
10936             out_header = (void *)out_ext;
10937             break;
10938         }
10939         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
10940         {
10941             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10942             const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
10943             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
10944             out_ext->pNext = NULL;
10945             out_ext->rayQuery = in_ext->rayQuery;
10946             out_header->pNext = (void *)out_ext;
10947             out_header = (void *)out_ext;
10948             break;
10949         }
10950         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
10951         {
10952             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10953             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
10954             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
10955             out_ext->pNext = NULL;
10956             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
10957             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
10958             out_header->pNext = (void *)out_ext;
10959             out_header = (void *)out_ext;
10960             break;
10961         }
10962         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
10963         {
10964             VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10965             const VkDeviceMemoryOverallocationCreateInfoAMD *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD *)in_header;
10966             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
10967             out_ext->pNext = NULL;
10968             out_ext->overallocationBehavior = in_ext->overallocationBehavior;
10969             out_header->pNext = (void *)out_ext;
10970             out_header = (void *)out_ext;
10971             break;
10972         }
10973         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
10974         {
10975             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10976             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
10977             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
10978             out_ext->pNext = NULL;
10979             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
10980             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
10981             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
10982             out_header->pNext = (void *)out_ext;
10983             out_header = (void *)out_ext;
10984             break;
10985         }
10986         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
10987         {
10988             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10989             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
10990             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
10991             out_ext->pNext = NULL;
10992             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
10993             out_header->pNext = (void *)out_ext;
10994             out_header = (void *)out_ext;
10995             break;
10996         }
10997         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
10998         {
10999             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11000             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *)in_header;
11001             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
11002             out_ext->pNext = NULL;
11003             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
11004             out_header->pNext = (void *)out_ext;
11005             out_header = (void *)out_ext;
11006             break;
11007         }
11008         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
11009         {
11010             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11011             const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
11012             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
11013             out_ext->pNext = NULL;
11014             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
11015             out_header->pNext = (void *)out_ext;
11016             out_header = (void *)out_ext;
11017             break;
11018         }
11019         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
11020         {
11021             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11022             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
11023             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
11024             out_ext->pNext = NULL;
11025             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
11026             out_header->pNext = (void *)out_ext;
11027             out_header = (void *)out_ext;
11028             break;
11029         }
11030         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
11031         {
11032             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11033             const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
11034             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
11035             out_ext->pNext = NULL;
11036             out_ext->depthClipEnable = in_ext->depthClipEnable;
11037             out_header->pNext = (void *)out_ext;
11038             out_header = (void *)out_ext;
11039             break;
11040         }
11041         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
11042         {
11043             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11044             const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
11045             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
11046             out_ext->pNext = NULL;
11047             out_ext->memoryPriority = in_ext->memoryPriority;
11048             out_header->pNext = (void *)out_ext;
11049             out_header = (void *)out_ext;
11050             break;
11051         }
11052         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
11053         {
11054             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11055             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
11056             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
11057             out_ext->pNext = NULL;
11058             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
11059             out_header->pNext = (void *)out_ext;
11060             out_header = (void *)out_ext;
11061             break;
11062         }
11063         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
11064         {
11065             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11066             const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
11067             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
11068             out_ext->pNext = NULL;
11069             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
11070             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
11071             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
11072             out_header->pNext = (void *)out_ext;
11073             out_header = (void *)out_ext;
11074             break;
11075         }
11076         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
11077         {
11078             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11079             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
11080             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
11081             out_ext->pNext = NULL;
11082             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
11083             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
11084             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
11085             out_header->pNext = (void *)out_ext;
11086             out_header = (void *)out_ext;
11087             break;
11088         }
11089         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
11090         {
11091             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11092             const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
11093             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
11094             out_ext->pNext = NULL;
11095             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
11096             out_header->pNext = (void *)out_ext;
11097             out_header = (void *)out_ext;
11098             break;
11099         }
11100         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
11101         {
11102             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11103             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
11104             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
11105             out_ext->pNext = NULL;
11106             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
11107             out_header->pNext = (void *)out_ext;
11108             out_header = (void *)out_ext;
11109             break;
11110         }
11111         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
11112         {
11113             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11114             const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
11115             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
11116             out_ext->pNext = NULL;
11117             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
11118             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
11119             out_header->pNext = (void *)out_ext;
11120             out_header = (void *)out_ext;
11121             break;
11122         }
11123         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
11124         {
11125             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11126             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
11127             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
11128             out_ext->pNext = NULL;
11129             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
11130             out_header->pNext = (void *)out_ext;
11131             out_header = (void *)out_ext;
11132             break;
11133         }
11134         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
11135         {
11136             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11137             const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
11138             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
11139             out_ext->pNext = NULL;
11140             out_ext->presentBarrier = in_ext->presentBarrier;
11141             out_header->pNext = (void *)out_ext;
11142             out_header = (void *)out_ext;
11143             break;
11144         }
11145         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
11146         {
11147             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11148             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
11149             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
11150             out_ext->pNext = NULL;
11151             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
11152             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
11153             out_header->pNext = (void *)out_ext;
11154             out_header = (void *)out_ext;
11155             break;
11156         }
11157         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR:
11158         {
11159             VkPerformanceQueryReservationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11160             const VkPerformanceQueryReservationInfoKHR *in_ext = (const VkPerformanceQueryReservationInfoKHR *)in_header;
11161             out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR;
11162             out_ext->pNext = NULL;
11163             out_ext->maxPerformanceQueriesPerPool = in_ext->maxPerformanceQueriesPerPool;
11164             out_header->pNext = (void *)out_ext;
11165             out_header = (void *)out_ext;
11166             break;
11167         }
11168         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
11169         {
11170             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11171             const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
11172             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
11173             out_ext->pNext = NULL;
11174             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
11175             out_header->pNext = (void *)out_ext;
11176             out_header = (void *)out_ext;
11177             break;
11178         }
11179         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
11180         {
11181             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11182             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
11183             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
11184             out_ext->pNext = NULL;
11185             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
11186             out_header->pNext = (void *)out_ext;
11187             out_header = (void *)out_ext;
11188             break;
11189         }
11190         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
11191         {
11192             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11193             const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
11194             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
11195             out_ext->pNext = NULL;
11196             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
11197             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
11198             out_header->pNext = (void *)out_ext;
11199             out_header = (void *)out_ext;
11200             break;
11201         }
11202         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
11203         {
11204             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11205             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header;
11206             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
11207             out_ext->pNext = NULL;
11208             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
11209             out_header->pNext = (void *)out_ext;
11210             out_header = (void *)out_ext;
11211             break;
11212         }
11213         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
11214         {
11215             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11216             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
11217             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
11218             out_ext->pNext = NULL;
11219             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
11220             out_header->pNext = (void *)out_ext;
11221             out_header = (void *)out_ext;
11222             break;
11223         }
11224         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
11225         {
11226             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11227             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
11228             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
11229             out_ext->pNext = NULL;
11230             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
11231             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
11232             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
11233             out_header->pNext = (void *)out_ext;
11234             out_header = (void *)out_ext;
11235             break;
11236         }
11237         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
11238         {
11239             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11240             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
11241             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
11242             out_ext->pNext = NULL;
11243             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
11244             out_header->pNext = (void *)out_ext;
11245             out_header = (void *)out_ext;
11246             break;
11247         }
11248         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
11249         {
11250             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11251             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
11252             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
11253             out_ext->pNext = NULL;
11254             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
11255             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
11256             out_header->pNext = (void *)out_ext;
11257             out_header = (void *)out_ext;
11258             break;
11259         }
11260         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
11261         {
11262             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11263             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
11264             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
11265             out_ext->pNext = NULL;
11266             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
11267             out_header->pNext = (void *)out_ext;
11268             out_header = (void *)out_ext;
11269             break;
11270         }
11271         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
11272         {
11273             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11274             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
11275             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
11276             out_ext->pNext = NULL;
11277             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
11278             out_header->pNext = (void *)out_ext;
11279             out_header = (void *)out_ext;
11280             break;
11281         }
11282         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
11283         {
11284             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11285             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
11286             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
11287             out_ext->pNext = NULL;
11288             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
11289             out_header->pNext = (void *)out_ext;
11290             out_header = (void *)out_ext;
11291             break;
11292         }
11293         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
11294         {
11295             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11296             const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
11297             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
11298             out_ext->pNext = NULL;
11299             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
11300             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
11301             out_header->pNext = (void *)out_ext;
11302             out_header = (void *)out_ext;
11303             break;
11304         }
11305         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
11306         {
11307             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11308             const VkPhysicalDeviceLineRasterizationFeaturesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header;
11309             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
11310             out_ext->pNext = NULL;
11311             out_ext->rectangularLines = in_ext->rectangularLines;
11312             out_ext->bresenhamLines = in_ext->bresenhamLines;
11313             out_ext->smoothLines = in_ext->smoothLines;
11314             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
11315             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
11316             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
11317             out_header->pNext = (void *)out_ext;
11318             out_header = (void *)out_ext;
11319             break;
11320         }
11321         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
11322         {
11323             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11324             const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
11325             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
11326             out_ext->pNext = NULL;
11327             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
11328             out_header->pNext = (void *)out_ext;
11329             out_header = (void *)out_ext;
11330             break;
11331         }
11332         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
11333         {
11334             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11335             const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
11336             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
11337             out_ext->pNext = NULL;
11338             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
11339             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
11340             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
11341             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
11342             out_ext->multiview = in_ext->multiview;
11343             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
11344             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
11345             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
11346             out_ext->variablePointers = in_ext->variablePointers;
11347             out_ext->protectedMemory = in_ext->protectedMemory;
11348             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
11349             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
11350             out_header->pNext = (void *)out_ext;
11351             out_header = (void *)out_ext;
11352             break;
11353         }
11354         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
11355         {
11356             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11357             const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
11358             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
11359             out_ext->pNext = NULL;
11360             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
11361             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
11362             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
11363             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
11364             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
11365             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
11366             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
11367             out_ext->shaderFloat16 = in_ext->shaderFloat16;
11368             out_ext->shaderInt8 = in_ext->shaderInt8;
11369             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
11370             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
11371             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
11372             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
11373             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
11374             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
11375             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
11376             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
11377             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
11378             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
11379             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
11380             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
11381             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
11382             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
11383             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
11384             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
11385             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
11386             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
11387             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
11388             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
11389             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
11390             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
11391             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
11392             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
11393             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
11394             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
11395             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
11396             out_ext->hostQueryReset = in_ext->hostQueryReset;
11397             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
11398             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
11399             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
11400             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
11401             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
11402             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
11403             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
11404             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
11405             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
11406             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
11407             out_header->pNext = (void *)out_ext;
11408             out_header = (void *)out_ext;
11409             break;
11410         }
11411         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
11412         {
11413             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11414             const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
11415             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
11416             out_ext->pNext = NULL;
11417             out_ext->robustImageAccess = in_ext->robustImageAccess;
11418             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
11419             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
11420             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
11421             out_ext->privateData = in_ext->privateData;
11422             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
11423             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
11424             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
11425             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
11426             out_ext->synchronization2 = in_ext->synchronization2;
11427             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
11428             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
11429             out_ext->dynamicRendering = in_ext->dynamicRendering;
11430             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
11431             out_ext->maintenance4 = in_ext->maintenance4;
11432             out_header->pNext = (void *)out_ext;
11433             out_header = (void *)out_ext;
11434             break;
11435         }
11436         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
11437         {
11438             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11439             const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
11440             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
11441             out_ext->pNext = NULL;
11442             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
11443             out_header->pNext = (void *)out_ext;
11444             out_header = (void *)out_ext;
11445             break;
11446         }
11447         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
11448         {
11449             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11450             const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
11451             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
11452             out_ext->pNext = NULL;
11453             out_ext->customBorderColors = in_ext->customBorderColors;
11454             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
11455             out_header->pNext = (void *)out_ext;
11456             out_header = (void *)out_ext;
11457             break;
11458         }
11459         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
11460         {
11461             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11462             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
11463             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
11464             out_ext->pNext = NULL;
11465             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
11466             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
11467             out_header->pNext = (void *)out_ext;
11468             out_header = (void *)out_ext;
11469             break;
11470         }
11471         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
11472         {
11473             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11474             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
11475             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
11476             out_ext->pNext = NULL;
11477             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
11478             out_header->pNext = (void *)out_ext;
11479             out_header = (void *)out_ext;
11480             break;
11481         }
11482         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
11483         {
11484             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11485             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
11486             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
11487             out_ext->pNext = NULL;
11488             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
11489             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
11490             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
11491             out_header->pNext = (void *)out_ext;
11492             out_header = (void *)out_ext;
11493             break;
11494         }
11495         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
11496         {
11497             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11498             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
11499             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
11500             out_ext->pNext = NULL;
11501             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
11502             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
11503             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
11504             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
11505             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
11506             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
11507             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
11508             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
11509             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
11510             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
11511             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
11512             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
11513             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
11514             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
11515             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
11516             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
11517             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
11518             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
11519             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
11520             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
11521             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
11522             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
11523             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
11524             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
11525             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
11526             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
11527             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
11528             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
11529             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
11530             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
11531             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
11532             out_header->pNext = (void *)out_ext;
11533             out_header = (void *)out_ext;
11534             break;
11535         }
11536         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
11537         {
11538             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11539             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
11540             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
11541             out_ext->pNext = NULL;
11542             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
11543             out_header->pNext = (void *)out_ext;
11544             out_header = (void *)out_ext;
11545             break;
11546         }
11547         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
11548         {
11549             VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11550             const VkDeviceDiagnosticsConfigCreateInfoNV *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV *)in_header;
11551             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
11552             out_ext->pNext = NULL;
11553             out_ext->flags = in_ext->flags;
11554             out_header->pNext = (void *)out_ext;
11555             out_header = (void *)out_ext;
11556             break;
11557         }
11558         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
11559         {
11560             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11561             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
11562             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
11563             out_ext->pNext = NULL;
11564             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
11565             out_header->pNext = (void *)out_ext;
11566             out_header = (void *)out_ext;
11567             break;
11568         }
11569         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
11570         {
11571             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11572             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
11573             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
11574             out_ext->pNext = NULL;
11575             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
11576             out_header->pNext = (void *)out_ext;
11577             out_header = (void *)out_ext;
11578             break;
11579         }
11580         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
11581         {
11582             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11583             const VkPhysicalDeviceRobustness2FeaturesEXT *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT *)in_header;
11584             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
11585             out_ext->pNext = NULL;
11586             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
11587             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
11588             out_ext->nullDescriptor = in_ext->nullDescriptor;
11589             out_header->pNext = (void *)out_ext;
11590             out_header = (void *)out_ext;
11591             break;
11592         }
11593         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
11594         {
11595             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11596             const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
11597             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
11598             out_ext->pNext = NULL;
11599             out_ext->robustImageAccess = in_ext->robustImageAccess;
11600             out_header->pNext = (void *)out_ext;
11601             out_header = (void *)out_ext;
11602             break;
11603         }
11604         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
11605         {
11606             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11607             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
11608             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
11609             out_ext->pNext = NULL;
11610             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
11611             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
11612             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
11613             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
11614             out_header->pNext = (void *)out_ext;
11615             out_header = (void *)out_ext;
11616             break;
11617         }
11618         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
11619         {
11620             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11621             const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
11622             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
11623             out_ext->pNext = NULL;
11624             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
11625             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
11626             out_header->pNext = (void *)out_ext;
11627             out_header = (void *)out_ext;
11628             break;
11629         }
11630         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
11631         {
11632             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11633             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
11634             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
11635             out_ext->pNext = NULL;
11636             out_ext->subpassShading = in_ext->subpassShading;
11637             out_header->pNext = (void *)out_ext;
11638             out_header = (void *)out_ext;
11639             break;
11640         }
11641         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
11642         {
11643             VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11644             const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *)in_header;
11645             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
11646             out_ext->pNext = NULL;
11647             out_ext->clustercullingShader = in_ext->clustercullingShader;
11648             out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
11649             out_header->pNext = (void *)out_ext;
11650             out_header = (void *)out_ext;
11651             break;
11652         }
11653         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
11654         {
11655             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11656             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
11657             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
11658             out_ext->pNext = NULL;
11659             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
11660             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
11661             out_header->pNext = (void *)out_ext;
11662             out_header = (void *)out_ext;
11663             break;
11664         }
11665         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
11666         {
11667             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11668             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
11669             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
11670             out_ext->pNext = NULL;
11671             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
11672             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
11673             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
11674             out_header->pNext = (void *)out_ext;
11675             out_header = (void *)out_ext;
11676             break;
11677         }
11678         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
11679         {
11680             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11681             const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
11682             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
11683             out_ext->pNext = NULL;
11684             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
11685             out_header->pNext = (void *)out_ext;
11686             out_header = (void *)out_ext;
11687             break;
11688         }
11689         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
11690         {
11691             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11692             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
11693             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
11694             out_ext->pNext = NULL;
11695             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
11696             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
11697             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
11698             out_header->pNext = (void *)out_ext;
11699             out_header = (void *)out_ext;
11700             break;
11701         }
11702         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
11703         {
11704             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11705             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
11706             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
11707             out_ext->pNext = NULL;
11708             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
11709             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
11710             out_header->pNext = (void *)out_ext;
11711             out_header = (void *)out_ext;
11712             break;
11713         }
11714         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
11715         {
11716             VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11717             const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)in_header;
11718             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
11719             out_ext->pNext = NULL;
11720             out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
11721             out_header->pNext = (void *)out_ext;
11722             out_header = (void *)out_ext;
11723             break;
11724         }
11725         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
11726         {
11727             VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11728             const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)in_header;
11729             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
11730             out_ext->pNext = NULL;
11731             out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
11732             out_header->pNext = (void *)out_ext;
11733             out_header = (void *)out_ext;
11734             break;
11735         }
11736         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
11737         {
11738             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11739             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
11740             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
11741             out_ext->pNext = NULL;
11742             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
11743             out_header->pNext = (void *)out_ext;
11744             out_header = (void *)out_ext;
11745             break;
11746         }
11747         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
11748         {
11749             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11750             const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
11751             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
11752             out_ext->pNext = NULL;
11753             out_ext->depthClipControl = in_ext->depthClipControl;
11754             out_header->pNext = (void *)out_ext;
11755             out_header = (void *)out_ext;
11756             break;
11757         }
11758         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
11759         {
11760             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11761             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
11762             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
11763             out_ext->pNext = NULL;
11764             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
11765             out_header->pNext = (void *)out_ext;
11766             out_header = (void *)out_ext;
11767             break;
11768         }
11769         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
11770         {
11771             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11772             const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
11773             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
11774             out_ext->pNext = NULL;
11775             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
11776             out_header->pNext = (void *)out_ext;
11777             out_header = (void *)out_ext;
11778             break;
11779         }
11780         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
11781         {
11782             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11783             const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
11784             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
11785             out_ext->pNext = NULL;
11786             out_ext->synchronization2 = in_ext->synchronization2;
11787             out_header->pNext = (void *)out_ext;
11788             out_header = (void *)out_ext;
11789             break;
11790         }
11791         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
11792         {
11793             VkPhysicalDeviceHostImageCopyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11794             const VkPhysicalDeviceHostImageCopyFeaturesEXT *in_ext = (const VkPhysicalDeviceHostImageCopyFeaturesEXT *)in_header;
11795             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT;
11796             out_ext->pNext = NULL;
11797             out_ext->hostImageCopy = in_ext->hostImageCopy;
11798             out_header->pNext = (void *)out_ext;
11799             out_header = (void *)out_ext;
11800             break;
11801         }
11802         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
11803         {
11804             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11805             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
11806             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
11807             out_ext->pNext = NULL;
11808             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
11809             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
11810             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
11811             out_header->pNext = (void *)out_ext;
11812             out_header = (void *)out_ext;
11813             break;
11814         }
11815         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
11816         {
11817             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11818             const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
11819             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
11820             out_ext->pNext = NULL;
11821             out_ext->legacyDithering = in_ext->legacyDithering;
11822             out_header->pNext = (void *)out_ext;
11823             out_header = (void *)out_ext;
11824             break;
11825         }
11826         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
11827         {
11828             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11829             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
11830             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
11831             out_ext->pNext = NULL;
11832             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
11833             out_header->pNext = (void *)out_ext;
11834             out_header = (void *)out_ext;
11835             break;
11836         }
11837         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
11838         {
11839             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11840             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)in_header;
11841             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
11842             out_ext->pNext = NULL;
11843             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
11844             out_header->pNext = (void *)out_ext;
11845             out_header = (void *)out_ext;
11846             break;
11847         }
11848         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
11849         {
11850             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11851             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
11852             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
11853             out_ext->pNext = NULL;
11854             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
11855             out_header->pNext = (void *)out_ext;
11856             out_header = (void *)out_ext;
11857             break;
11858         }
11859         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
11860         {
11861             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11862             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
11863             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
11864             out_ext->pNext = NULL;
11865             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
11866             out_header->pNext = (void *)out_ext;
11867             out_header = (void *)out_ext;
11868             break;
11869         }
11870         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
11871         {
11872             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11873             const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
11874             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
11875             out_ext->pNext = NULL;
11876             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
11877             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
11878             out_header->pNext = (void *)out_ext;
11879             out_header = (void *)out_ext;
11880             break;
11881         }
11882         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
11883         {
11884             VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11885             const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header;
11886             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
11887             out_ext->pNext = NULL;
11888             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
11889             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
11890             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
11891             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
11892             out_header->pNext = (void *)out_ext;
11893             out_header = (void *)out_ext;
11894             break;
11895         }
11896         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
11897         {
11898             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11899             const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
11900             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
11901             out_ext->pNext = NULL;
11902             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
11903             out_header->pNext = (void *)out_ext;
11904             out_header = (void *)out_ext;
11905             break;
11906         }
11907         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
11908         {
11909             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11910             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
11911             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
11912             out_ext->pNext = NULL;
11913             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
11914             out_header->pNext = (void *)out_ext;
11915             out_header = (void *)out_ext;
11916             break;
11917         }
11918         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
11919         {
11920             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11921             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
11922             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
11923             out_ext->pNext = NULL;
11924             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
11925             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
11926             out_header->pNext = (void *)out_ext;
11927             out_header = (void *)out_ext;
11928             break;
11929         }
11930         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
11931         {
11932             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11933             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
11934             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
11935             out_ext->pNext = NULL;
11936             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
11937             out_header->pNext = (void *)out_ext;
11938             out_header = (void *)out_ext;
11939             break;
11940         }
11941         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
11942         {
11943             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11944             const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
11945             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
11946             out_ext->pNext = NULL;
11947             out_ext->dynamicRendering = in_ext->dynamicRendering;
11948             out_header->pNext = (void *)out_ext;
11949             out_header = (void *)out_ext;
11950             break;
11951         }
11952         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
11953         {
11954             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11955             const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
11956             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
11957             out_ext->pNext = NULL;
11958             out_ext->minLod = in_ext->minLod;
11959             out_header->pNext = (void *)out_ext;
11960             out_header = (void *)out_ext;
11961             break;
11962         }
11963         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
11964         {
11965             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11966             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
11967             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
11968             out_ext->pNext = NULL;
11969             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
11970             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
11971             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
11972             out_header->pNext = (void *)out_ext;
11973             out_header = (void *)out_ext;
11974             break;
11975         }
11976         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
11977         {
11978             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11979             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
11980             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
11981             out_ext->pNext = NULL;
11982             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
11983             out_header->pNext = (void *)out_ext;
11984             out_header = (void *)out_ext;
11985             break;
11986         }
11987         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
11988         {
11989             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11990             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
11991             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
11992             out_ext->pNext = NULL;
11993             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
11994             out_header->pNext = (void *)out_ext;
11995             out_header = (void *)out_ext;
11996             break;
11997         }
11998         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
11999         {
12000             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12001             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
12002             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
12003             out_ext->pNext = NULL;
12004             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
12005             out_header->pNext = (void *)out_ext;
12006             out_header = (void *)out_ext;
12007             break;
12008         }
12009         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
12010         {
12011             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12012             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
12013             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
12014             out_ext->pNext = NULL;
12015             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
12016             out_header->pNext = (void *)out_ext;
12017             out_header = (void *)out_ext;
12018             break;
12019         }
12020         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
12021         {
12022             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12023             const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
12024             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
12025             out_ext->pNext = NULL;
12026             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
12027             out_header->pNext = (void *)out_ext;
12028             out_header = (void *)out_ext;
12029             break;
12030         }
12031         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
12032         {
12033             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12034             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
12035             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
12036             out_ext->pNext = NULL;
12037             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
12038             out_header->pNext = (void *)out_ext;
12039             out_header = (void *)out_ext;
12040             break;
12041         }
12042         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
12043         {
12044             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12045             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
12046             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
12047             out_ext->pNext = NULL;
12048             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
12049             out_header->pNext = (void *)out_ext;
12050             out_header = (void *)out_ext;
12051             break;
12052         }
12053         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
12054         {
12055             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12056             const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
12057             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
12058             out_ext->pNext = NULL;
12059             out_ext->micromap = in_ext->micromap;
12060             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
12061             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
12062             out_header->pNext = (void *)out_ext;
12063             out_header = (void *)out_ext;
12064             break;
12065         }
12066         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
12067         {
12068             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12069             const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
12070             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
12071             out_ext->pNext = NULL;
12072             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
12073             out_header->pNext = (void *)out_ext;
12074             out_header = (void *)out_ext;
12075             break;
12076         }
12077         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
12078         {
12079             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12080             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header;
12081             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
12082             out_ext->pNext = NULL;
12083             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
12084             out_header->pNext = (void *)out_ext;
12085             out_header = (void *)out_ext;
12086             break;
12087         }
12088         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
12089         {
12090             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12091             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
12092             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
12093             out_ext->pNext = NULL;
12094             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
12095             out_header->pNext = (void *)out_ext;
12096             out_header = (void *)out_ext;
12097             break;
12098         }
12099         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
12100         {
12101             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12102             const VkPhysicalDevicePipelineRobustnessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT *)in_header;
12103             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
12104             out_ext->pNext = NULL;
12105             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
12106             out_header->pNext = (void *)out_ext;
12107             out_header = (void *)out_ext;
12108             break;
12109         }
12110         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
12111         {
12112             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12113             const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
12114             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
12115             out_ext->pNext = NULL;
12116             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
12117             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
12118             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
12119             out_header->pNext = (void *)out_ext;
12120             out_header = (void *)out_ext;
12121             break;
12122         }
12123         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
12124         {
12125             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12126             const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
12127             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
12128             out_ext->pNext = NULL;
12129             out_ext->tileProperties = in_ext->tileProperties;
12130             out_header->pNext = (void *)out_ext;
12131             out_header = (void *)out_ext;
12132             break;
12133         }
12134         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
12135         {
12136             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12137             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
12138             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
12139             out_ext->pNext = NULL;
12140             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
12141             out_header->pNext = (void *)out_ext;
12142             out_header = (void *)out_ext;
12143             break;
12144         }
12145         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
12146         {
12147             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12148             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *)in_header;
12149             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
12150             out_ext->pNext = NULL;
12151             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
12152             out_header->pNext = (void *)out_ext;
12153             out_header = (void *)out_ext;
12154             break;
12155         }
12156         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
12157         {
12158             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12159             const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
12160             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
12161             out_ext->pNext = NULL;
12162             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
12163             out_header->pNext = (void *)out_ext;
12164             out_header = (void *)out_ext;
12165             break;
12166         }
12167         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
12168         {
12169             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12170             const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
12171             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
12172             out_ext->pNext = NULL;
12173             out_ext->opticalFlow = in_ext->opticalFlow;
12174             out_header->pNext = (void *)out_ext;
12175             out_header = (void *)out_ext;
12176             break;
12177         }
12178         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
12179         {
12180             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12181             const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
12182             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
12183             out_ext->pNext = NULL;
12184             out_ext->deviceFault = in_ext->deviceFault;
12185             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
12186             out_header->pNext = (void *)out_ext;
12187             out_header = (void *)out_ext;
12188             break;
12189         }
12190         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
12191         {
12192             VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12193             const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)in_header;
12194             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
12195             out_ext->pNext = NULL;
12196             out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
12197             out_header->pNext = (void *)out_ext;
12198             out_header = (void *)out_ext;
12199             break;
12200         }
12201         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
12202         {
12203             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12204             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
12205             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
12206             out_ext->pNext = NULL;
12207             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
12208             out_header->pNext = (void *)out_ext;
12209             out_header = (void *)out_ext;
12210             break;
12211         }
12212         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
12213         {
12214             VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12215             const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)in_header;
12216             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
12217             out_ext->pNext = NULL;
12218             out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
12219             out_header->pNext = (void *)out_ext;
12220             out_header = (void *)out_ext;
12221             break;
12222         }
12223         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
12224         {
12225             VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12226             const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *)in_header;
12227             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT;
12228             out_ext->pNext = NULL;
12229             out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
12230             out_header->pNext = (void *)out_ext;
12231             out_header = (void *)out_ext;
12232             break;
12233         }
12234         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
12235         {
12236             VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12237             const VkPhysicalDeviceDepthBiasControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT *)in_header;
12238             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
12239             out_ext->pNext = NULL;
12240             out_ext->depthBiasControl = in_ext->depthBiasControl;
12241             out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
12242             out_ext->floatRepresentation = in_ext->floatRepresentation;
12243             out_ext->depthBiasExact = in_ext->depthBiasExact;
12244             out_header->pNext = (void *)out_ext;
12245             out_header = (void *)out_ext;
12246             break;
12247         }
12248         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
12249         {
12250             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12251             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
12252             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
12253             out_ext->pNext = NULL;
12254             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
12255             out_header->pNext = (void *)out_ext;
12256             out_header = (void *)out_ext;
12257             break;
12258         }
12259         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
12260         {
12261             VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12262             const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *)in_header;
12263             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
12264             out_ext->pNext = NULL;
12265             out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
12266             out_header->pNext = (void *)out_ext;
12267             out_header = (void *)out_ext;
12268             break;
12269         }
12270         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
12271         {
12272             VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12273             const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)in_header;
12274             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
12275             out_ext->pNext = NULL;
12276             out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
12277             out_header->pNext = (void *)out_ext;
12278             out_header = (void *)out_ext;
12279             break;
12280         }
12281         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
12282         {
12283             VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12284             const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *)in_header;
12285             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
12286             out_ext->pNext = NULL;
12287             out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
12288             out_header->pNext = (void *)out_ext;
12289             out_header = (void *)out_ext;
12290             break;
12291         }
12292         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
12293         {
12294             VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12295             const VkPhysicalDeviceShaderObjectFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)in_header;
12296             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
12297             out_ext->pNext = NULL;
12298             out_ext->shaderObject = in_ext->shaderObject;
12299             out_header->pNext = (void *)out_ext;
12300             out_header = (void *)out_ext;
12301             break;
12302         }
12303         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
12304         {
12305             VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12306             const VkPhysicalDeviceShaderTileImageFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT *)in_header;
12307             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
12308             out_ext->pNext = NULL;
12309             out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
12310             out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
12311             out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
12312             out_header->pNext = (void *)out_ext;
12313             out_header = (void *)out_ext;
12314             break;
12315         }
12316         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
12317         {
12318             VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12319             const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)in_header;
12320             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
12321             out_ext->pNext = NULL;
12322             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
12323             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
12324             out_header->pNext = (void *)out_ext;
12325             out_header = (void *)out_ext;
12326             break;
12327         }
12328         default:
12329             FIXME("Unhandled sType %u.\n", in_header->sType);
12330             break;
12331         }
12332     }
12333 }
12334 #endif /* _WIN64 */
12335
12336 static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo32 *in, VkDeviceCreateInfo *out)
12337 {
12338     const VkBaseInStructure32 *in_header;
12339     VkBaseOutStructure *out_header = (void *)out;
12340
12341     if (!in) return;
12342
12343     out->sType = in->sType;
12344     out->pNext = NULL;
12345     out->flags = in->flags;
12346     out->queueCreateInfoCount = in->queueCreateInfoCount;
12347     out->pQueueCreateInfos = convert_VkDeviceQueueCreateInfo_array_win32_to_host(ctx, (const VkDeviceQueueCreateInfo32 *)UlongToPtr(in->pQueueCreateInfos), in->queueCreateInfoCount);
12348     out->enabledLayerCount = in->enabledLayerCount;
12349     out->ppEnabledLayerNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledLayerNames), in->enabledLayerCount);
12350     out->enabledExtensionCount = in->enabledExtensionCount;
12351     out->ppEnabledExtensionNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledExtensionNames), in->enabledExtensionCount);
12352     out->pEnabledFeatures = (const VkPhysicalDeviceFeatures *)UlongToPtr(in->pEnabledFeatures);
12353
12354     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
12355     {
12356         switch (in_header->sType)
12357         {
12358         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
12359             break;
12360         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
12361         {
12362             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12363             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header;
12364             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
12365             out_ext->pNext = NULL;
12366             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
12367             out_header->pNext = (void *)out_ext;
12368             out_header = (void *)out_ext;
12369             break;
12370         }
12371         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
12372         {
12373             VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12374             const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *)in_header;
12375             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV;
12376             out_ext->pNext = NULL;
12377             out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute;
12378             out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines;
12379             out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay;
12380             out_header->pNext = (void *)out_ext;
12381             out_header = (void *)out_ext;
12382             break;
12383         }
12384         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
12385         {
12386             VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12387             const VkDevicePrivateDataCreateInfo32 *in_ext = (const VkDevicePrivateDataCreateInfo32 *)in_header;
12388             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
12389             out_ext->pNext = NULL;
12390             out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
12391             out_header->pNext = (void *)out_ext;
12392             out_header = (void *)out_ext;
12393             break;
12394         }
12395         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
12396         {
12397             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12398             const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header;
12399             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
12400             out_ext->pNext = NULL;
12401             out_ext->privateData = in_ext->privateData;
12402             out_header->pNext = (void *)out_ext;
12403             out_header = (void *)out_ext;
12404             break;
12405         }
12406         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
12407         {
12408             VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12409             const VkPhysicalDeviceFeatures232 *in_ext = (const VkPhysicalDeviceFeatures232 *)in_header;
12410             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
12411             out_ext->pNext = NULL;
12412             out_ext->features = in_ext->features;
12413             out_header->pNext = (void *)out_ext;
12414             out_header = (void *)out_ext;
12415             break;
12416         }
12417         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
12418         {
12419             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12420             const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header;
12421             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
12422             out_ext->pNext = NULL;
12423             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
12424             out_ext->variablePointers = in_ext->variablePointers;
12425             out_header->pNext = (void *)out_ext;
12426             out_header = (void *)out_ext;
12427             break;
12428         }
12429         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
12430         {
12431             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12432             const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header;
12433             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
12434             out_ext->pNext = NULL;
12435             out_ext->multiview = in_ext->multiview;
12436             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
12437             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
12438             out_header->pNext = (void *)out_ext;
12439             out_header = (void *)out_ext;
12440             break;
12441         }
12442         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
12443         {
12444             VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12445             const VkDeviceGroupDeviceCreateInfo32 *in_ext = (const VkDeviceGroupDeviceCreateInfo32 *)in_header;
12446             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
12447             out_ext->pNext = NULL;
12448             out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
12449             out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->pPhysicalDevices), in_ext->physicalDeviceCount);
12450             out_header->pNext = (void *)out_ext;
12451             out_header = (void *)out_ext;
12452             break;
12453         }
12454         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
12455         {
12456             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12457             const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header;
12458             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
12459             out_ext->pNext = NULL;
12460             out_ext->presentId = in_ext->presentId;
12461             out_header->pNext = (void *)out_ext;
12462             out_header = (void *)out_ext;
12463             break;
12464         }
12465         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
12466         {
12467             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12468             const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header;
12469             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
12470             out_ext->pNext = NULL;
12471             out_ext->presentWait = in_ext->presentWait;
12472             out_header->pNext = (void *)out_ext;
12473             out_header = (void *)out_ext;
12474             break;
12475         }
12476         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
12477         {
12478             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12479             const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header;
12480             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
12481             out_ext->pNext = NULL;
12482             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
12483             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
12484             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
12485             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
12486             out_header->pNext = (void *)out_ext;
12487             out_header = (void *)out_ext;
12488             break;
12489         }
12490         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
12491         {
12492             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12493             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header;
12494             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
12495             out_ext->pNext = NULL;
12496             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
12497             out_header->pNext = (void *)out_ext;
12498             out_header = (void *)out_ext;
12499             break;
12500         }
12501         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
12502         {
12503             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12504             const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header;
12505             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
12506             out_ext->pNext = NULL;
12507             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
12508             out_header->pNext = (void *)out_ext;
12509             out_header = (void *)out_ext;
12510             break;
12511         }
12512         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
12513         {
12514             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12515             const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header;
12516             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
12517             out_ext->pNext = NULL;
12518             out_ext->protectedMemory = in_ext->protectedMemory;
12519             out_header->pNext = (void *)out_ext;
12520             out_header = (void *)out_ext;
12521             break;
12522         }
12523         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
12524         {
12525             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12526             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *)in_header;
12527             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
12528             out_ext->pNext = NULL;
12529             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
12530             out_header->pNext = (void *)out_ext;
12531             out_header = (void *)out_ext;
12532             break;
12533         }
12534         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
12535         {
12536             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12537             const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header;
12538             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
12539             out_ext->pNext = NULL;
12540             out_ext->multiDraw = in_ext->multiDraw;
12541             out_header->pNext = (void *)out_ext;
12542             out_header = (void *)out_ext;
12543             break;
12544         }
12545         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
12546         {
12547             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12548             const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header;
12549             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
12550             out_ext->pNext = NULL;
12551             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
12552             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
12553             out_header->pNext = (void *)out_ext;
12554             out_header = (void *)out_ext;
12555             break;
12556         }
12557         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
12558         {
12559             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12560             const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header;
12561             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
12562             out_ext->pNext = NULL;
12563             out_ext->maintenance4 = in_ext->maintenance4;
12564             out_header->pNext = (void *)out_ext;
12565             out_header = (void *)out_ext;
12566             break;
12567         }
12568         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
12569         {
12570             VkPhysicalDeviceMaintenance5FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12571             const VkPhysicalDeviceMaintenance5FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance5FeaturesKHR32 *)in_header;
12572             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR;
12573             out_ext->pNext = NULL;
12574             out_ext->maintenance5 = in_ext->maintenance5;
12575             out_header->pNext = (void *)out_ext;
12576             out_header = (void *)out_ext;
12577             break;
12578         }
12579         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
12580         {
12581             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12582             const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header;
12583             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
12584             out_ext->pNext = NULL;
12585             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
12586             out_header->pNext = (void *)out_ext;
12587             out_header = (void *)out_ext;
12588             break;
12589         }
12590         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
12591         {
12592             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12593             const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header;
12594             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
12595             out_ext->pNext = NULL;
12596             out_ext->shaderFloat16 = in_ext->shaderFloat16;
12597             out_ext->shaderInt8 = in_ext->shaderInt8;
12598             out_header->pNext = (void *)out_ext;
12599             out_header = (void *)out_ext;
12600             break;
12601         }
12602         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
12603         {
12604             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12605             const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header;
12606             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
12607             out_ext->pNext = NULL;
12608             out_ext->hostQueryReset = in_ext->hostQueryReset;
12609             out_header->pNext = (void *)out_ext;
12610             out_header = (void *)out_ext;
12611             break;
12612         }
12613         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
12614         {
12615             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12616             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *)in_header;
12617             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
12618             out_ext->pNext = NULL;
12619             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
12620             out_header->pNext = (void *)out_ext;
12621             out_header = (void *)out_ext;
12622             break;
12623         }
12624         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
12625         {
12626             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12627             const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header;
12628             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
12629             out_ext->pNext = NULL;
12630             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
12631             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
12632             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
12633             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
12634             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
12635             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
12636             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
12637             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
12638             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
12639             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
12640             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
12641             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
12642             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
12643             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
12644             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
12645             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
12646             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
12647             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
12648             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
12649             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
12650             out_header->pNext = (void *)out_ext;
12651             out_header = (void *)out_ext;
12652             break;
12653         }
12654         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
12655         {
12656             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12657             const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header;
12658             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
12659             out_ext->pNext = NULL;
12660             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
12661             out_header->pNext = (void *)out_ext;
12662             out_header = (void *)out_ext;
12663             break;
12664         }
12665         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
12666         {
12667             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12668             const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header;
12669             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
12670             out_ext->pNext = NULL;
12671             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
12672             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
12673             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
12674             out_header->pNext = (void *)out_ext;
12675             out_header = (void *)out_ext;
12676             break;
12677         }
12678         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
12679         {
12680             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12681             const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header;
12682             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
12683             out_ext->pNext = NULL;
12684             out_ext->conditionalRendering = in_ext->conditionalRendering;
12685             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
12686             out_header->pNext = (void *)out_ext;
12687             out_header = (void *)out_ext;
12688             break;
12689         }
12690         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
12691         {
12692             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12693             const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header;
12694             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
12695             out_ext->pNext = NULL;
12696             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
12697             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
12698             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
12699             out_header->pNext = (void *)out_ext;
12700             out_header = (void *)out_ext;
12701             break;
12702         }
12703         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
12704         {
12705             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12706             const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header;
12707             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
12708             out_ext->pNext = NULL;
12709             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
12710             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
12711             out_header->pNext = (void *)out_ext;
12712             out_header = (void *)out_ext;
12713             break;
12714         }
12715         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
12716         {
12717             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12718             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header;
12719             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
12720             out_ext->pNext = NULL;
12721             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
12722             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
12723             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
12724             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
12725             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
12726             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
12727             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
12728             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
12729             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
12730             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
12731             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
12732             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
12733             out_header->pNext = (void *)out_ext;
12734             out_header = (void *)out_ext;
12735             break;
12736         }
12737         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
12738         {
12739             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12740             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header;
12741             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
12742             out_ext->pNext = NULL;
12743             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
12744             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
12745             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
12746             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
12747             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
12748             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
12749             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
12750             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
12751             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
12752             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
12753             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
12754             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
12755             out_header->pNext = (void *)out_ext;
12756             out_header = (void *)out_ext;
12757             break;
12758         }
12759         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
12760         {
12761             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12762             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *)in_header;
12763             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
12764             out_ext->pNext = NULL;
12765             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
12766             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
12767             out_header->pNext = (void *)out_ext;
12768             out_header = (void *)out_ext;
12769             break;
12770         }
12771         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
12772         {
12773             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12774             const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header;
12775             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
12776             out_ext->pNext = NULL;
12777             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
12778             out_header->pNext = (void *)out_ext;
12779             out_header = (void *)out_ext;
12780             break;
12781         }
12782         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
12783         {
12784             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12785             const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header;
12786             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
12787             out_ext->pNext = NULL;
12788             out_ext->transformFeedback = in_ext->transformFeedback;
12789             out_ext->geometryStreams = in_ext->geometryStreams;
12790             out_header->pNext = (void *)out_ext;
12791             out_header = (void *)out_ext;
12792             break;
12793         }
12794         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
12795         {
12796             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12797             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header;
12798             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
12799             out_ext->pNext = NULL;
12800             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
12801             out_header->pNext = (void *)out_ext;
12802             out_header = (void *)out_ext;
12803             break;
12804         }
12805         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
12806         {
12807             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12808             const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header;
12809             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
12810             out_ext->pNext = NULL;
12811             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
12812             out_header->pNext = (void *)out_ext;
12813             out_header = (void *)out_ext;
12814             break;
12815         }
12816         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
12817         {
12818             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12819             const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header;
12820             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
12821             out_ext->pNext = NULL;
12822             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
12823             out_header->pNext = (void *)out_ext;
12824             out_header = (void *)out_ext;
12825             break;
12826         }
12827         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
12828         {
12829             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12830             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *)in_header;
12831             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
12832             out_ext->pNext = NULL;
12833             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
12834             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
12835             out_header->pNext = (void *)out_ext;
12836             out_header = (void *)out_ext;
12837             break;
12838         }
12839         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
12840         {
12841             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12842             const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header;
12843             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
12844             out_ext->pNext = NULL;
12845             out_ext->imageFootprint = in_ext->imageFootprint;
12846             out_header->pNext = (void *)out_ext;
12847             out_header = (void *)out_ext;
12848             break;
12849         }
12850         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
12851         {
12852             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12853             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header;
12854             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
12855             out_ext->pNext = NULL;
12856             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
12857             out_header->pNext = (void *)out_ext;
12858             out_header = (void *)out_ext;
12859             break;
12860         }
12861         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
12862         {
12863             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12864             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header;
12865             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
12866             out_ext->pNext = NULL;
12867             out_ext->indirectCopy = in_ext->indirectCopy;
12868             out_header->pNext = (void *)out_ext;
12869             out_header = (void *)out_ext;
12870             break;
12871         }
12872         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
12873         {
12874             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12875             const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header;
12876             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
12877             out_ext->pNext = NULL;
12878             out_ext->memoryDecompression = in_ext->memoryDecompression;
12879             out_header->pNext = (void *)out_ext;
12880             out_header = (void *)out_ext;
12881             break;
12882         }
12883         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
12884         {
12885             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12886             const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header;
12887             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
12888             out_ext->pNext = NULL;
12889             out_ext->shadingRateImage = in_ext->shadingRateImage;
12890             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
12891             out_header->pNext = (void *)out_ext;
12892             out_header = (void *)out_ext;
12893             break;
12894         }
12895         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
12896         {
12897             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12898             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header;
12899             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
12900             out_ext->pNext = NULL;
12901             out_ext->invocationMask = in_ext->invocationMask;
12902             out_header->pNext = (void *)out_ext;
12903             out_header = (void *)out_ext;
12904             break;
12905         }
12906         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
12907         {
12908             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12909             const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header;
12910             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
12911             out_ext->pNext = NULL;
12912             out_ext->taskShader = in_ext->taskShader;
12913             out_ext->meshShader = in_ext->meshShader;
12914             out_header->pNext = (void *)out_ext;
12915             out_header = (void *)out_ext;
12916             break;
12917         }
12918         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
12919         {
12920             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12921             const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header;
12922             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
12923             out_ext->pNext = NULL;
12924             out_ext->taskShader = in_ext->taskShader;
12925             out_ext->meshShader = in_ext->meshShader;
12926             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
12927             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
12928             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
12929             out_header->pNext = (void *)out_ext;
12930             out_header = (void *)out_ext;
12931             break;
12932         }
12933         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
12934         {
12935             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12936             const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header;
12937             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
12938             out_ext->pNext = NULL;
12939             out_ext->accelerationStructure = in_ext->accelerationStructure;
12940             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
12941             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
12942             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
12943             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
12944             out_header->pNext = (void *)out_ext;
12945             out_header = (void *)out_ext;
12946             break;
12947         }
12948         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
12949         {
12950             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12951             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header;
12952             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
12953             out_ext->pNext = NULL;
12954             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
12955             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
12956             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
12957             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
12958             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
12959             out_header->pNext = (void *)out_ext;
12960             out_header = (void *)out_ext;
12961             break;
12962         }
12963         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
12964         {
12965             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12966             const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header;
12967             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
12968             out_ext->pNext = NULL;
12969             out_ext->rayQuery = in_ext->rayQuery;
12970             out_header->pNext = (void *)out_ext;
12971             out_header = (void *)out_ext;
12972             break;
12973         }
12974         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
12975         {
12976             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12977             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header;
12978             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
12979             out_ext->pNext = NULL;
12980             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
12981             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
12982             out_header->pNext = (void *)out_ext;
12983             out_header = (void *)out_ext;
12984             break;
12985         }
12986         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
12987         {
12988             VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12989             const VkDeviceMemoryOverallocationCreateInfoAMD32 *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD32 *)in_header;
12990             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
12991             out_ext->pNext = NULL;
12992             out_ext->overallocationBehavior = in_ext->overallocationBehavior;
12993             out_header->pNext = (void *)out_ext;
12994             out_header = (void *)out_ext;
12995             break;
12996         }
12997         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
12998         {
12999             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13000             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header;
13001             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
13002             out_ext->pNext = NULL;
13003             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
13004             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
13005             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
13006             out_header->pNext = (void *)out_ext;
13007             out_header = (void *)out_ext;
13008             break;
13009         }
13010         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
13011         {
13012             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13013             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header;
13014             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
13015             out_ext->pNext = NULL;
13016             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
13017             out_header->pNext = (void *)out_ext;
13018             out_header = (void *)out_ext;
13019             break;
13020         }
13021         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
13022         {
13023             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13024             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *)in_header;
13025             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
13026             out_ext->pNext = NULL;
13027             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
13028             out_header->pNext = (void *)out_ext;
13029             out_header = (void *)out_ext;
13030             break;
13031         }
13032         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
13033         {
13034             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13035             const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header;
13036             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
13037             out_ext->pNext = NULL;
13038             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
13039             out_header->pNext = (void *)out_ext;
13040             out_header = (void *)out_ext;
13041             break;
13042         }
13043         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
13044         {
13045             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13046             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header;
13047             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
13048             out_ext->pNext = NULL;
13049             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
13050             out_header->pNext = (void *)out_ext;
13051             out_header = (void *)out_ext;
13052             break;
13053         }
13054         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
13055         {
13056             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13057             const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header;
13058             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
13059             out_ext->pNext = NULL;
13060             out_ext->depthClipEnable = in_ext->depthClipEnable;
13061             out_header->pNext = (void *)out_ext;
13062             out_header = (void *)out_ext;
13063             break;
13064         }
13065         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
13066         {
13067             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13068             const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header;
13069             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
13070             out_ext->pNext = NULL;
13071             out_ext->memoryPriority = in_ext->memoryPriority;
13072             out_header->pNext = (void *)out_ext;
13073             out_header = (void *)out_ext;
13074             break;
13075         }
13076         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
13077         {
13078             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13079             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header;
13080             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
13081             out_ext->pNext = NULL;
13082             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
13083             out_header->pNext = (void *)out_ext;
13084             out_header = (void *)out_ext;
13085             break;
13086         }
13087         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
13088         {
13089             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13090             const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header;
13091             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
13092             out_ext->pNext = NULL;
13093             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
13094             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
13095             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
13096             out_header->pNext = (void *)out_ext;
13097             out_header = (void *)out_ext;
13098             break;
13099         }
13100         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
13101         {
13102             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13103             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header;
13104             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
13105             out_ext->pNext = NULL;
13106             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
13107             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
13108             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
13109             out_header->pNext = (void *)out_ext;
13110             out_header = (void *)out_ext;
13111             break;
13112         }
13113         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
13114         {
13115             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13116             const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header;
13117             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
13118             out_ext->pNext = NULL;
13119             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
13120             out_header->pNext = (void *)out_ext;
13121             out_header = (void *)out_ext;
13122             break;
13123         }
13124         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
13125         {
13126             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13127             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header;
13128             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
13129             out_ext->pNext = NULL;
13130             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
13131             out_header->pNext = (void *)out_ext;
13132             out_header = (void *)out_ext;
13133             break;
13134         }
13135         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
13136         {
13137             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13138             const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header;
13139             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
13140             out_ext->pNext = NULL;
13141             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
13142             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
13143             out_header->pNext = (void *)out_ext;
13144             out_header = (void *)out_ext;
13145             break;
13146         }
13147         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
13148         {
13149             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13150             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header;
13151             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
13152             out_ext->pNext = NULL;
13153             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
13154             out_header->pNext = (void *)out_ext;
13155             out_header = (void *)out_ext;
13156             break;
13157         }
13158         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
13159         {
13160             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13161             const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header;
13162             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
13163             out_ext->pNext = NULL;
13164             out_ext->presentBarrier = in_ext->presentBarrier;
13165             out_header->pNext = (void *)out_ext;
13166             out_header = (void *)out_ext;
13167             break;
13168         }
13169         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
13170         {
13171             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13172             const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header;
13173             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
13174             out_ext->pNext = NULL;
13175             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
13176             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
13177             out_header->pNext = (void *)out_ext;
13178             out_header = (void *)out_ext;
13179             break;
13180         }
13181         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR:
13182         {
13183             VkPerformanceQueryReservationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13184             const VkPerformanceQueryReservationInfoKHR32 *in_ext = (const VkPerformanceQueryReservationInfoKHR32 *)in_header;
13185             out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR;
13186             out_ext->pNext = NULL;
13187             out_ext->maxPerformanceQueriesPerPool = in_ext->maxPerformanceQueriesPerPool;
13188             out_header->pNext = (void *)out_ext;
13189             out_header = (void *)out_ext;
13190             break;
13191         }
13192         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
13193         {
13194             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13195             const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header;
13196             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
13197             out_ext->pNext = NULL;
13198             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
13199             out_header->pNext = (void *)out_ext;
13200             out_header = (void *)out_ext;
13201             break;
13202         }
13203         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
13204         {
13205             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13206             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header;
13207             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
13208             out_ext->pNext = NULL;
13209             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
13210             out_header->pNext = (void *)out_ext;
13211             out_header = (void *)out_ext;
13212             break;
13213         }
13214         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
13215         {
13216             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13217             const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header;
13218             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
13219             out_ext->pNext = NULL;
13220             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
13221             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
13222             out_header->pNext = (void *)out_ext;
13223             out_header = (void *)out_ext;
13224             break;
13225         }
13226         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
13227         {
13228             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13229             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *)in_header;
13230             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
13231             out_ext->pNext = NULL;
13232             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
13233             out_header->pNext = (void *)out_ext;
13234             out_header = (void *)out_ext;
13235             break;
13236         }
13237         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
13238         {
13239             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13240             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header;
13241             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
13242             out_ext->pNext = NULL;
13243             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
13244             out_header->pNext = (void *)out_ext;
13245             out_header = (void *)out_ext;
13246             break;
13247         }
13248         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
13249         {
13250             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13251             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header;
13252             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
13253             out_ext->pNext = NULL;
13254             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
13255             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
13256             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
13257             out_header->pNext = (void *)out_ext;
13258             out_header = (void *)out_ext;
13259             break;
13260         }
13261         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
13262         {
13263             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13264             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header;
13265             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
13266             out_ext->pNext = NULL;
13267             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
13268             out_header->pNext = (void *)out_ext;
13269             out_header = (void *)out_ext;
13270             break;
13271         }
13272         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
13273         {
13274             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13275             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header;
13276             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
13277             out_ext->pNext = NULL;
13278             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
13279             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
13280             out_header->pNext = (void *)out_ext;
13281             out_header = (void *)out_ext;
13282             break;
13283         }
13284         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
13285         {
13286             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13287             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header;
13288             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
13289             out_ext->pNext = NULL;
13290             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
13291             out_header->pNext = (void *)out_ext;
13292             out_header = (void *)out_ext;
13293             break;
13294         }
13295         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
13296         {
13297             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13298             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header;
13299             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
13300             out_ext->pNext = NULL;
13301             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
13302             out_header->pNext = (void *)out_ext;
13303             out_header = (void *)out_ext;
13304             break;
13305         }
13306         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
13307         {
13308             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13309             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header;
13310             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
13311             out_ext->pNext = NULL;
13312             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
13313             out_header->pNext = (void *)out_ext;
13314             out_header = (void *)out_ext;
13315             break;
13316         }
13317         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
13318         {
13319             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13320             const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header;
13321             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
13322             out_ext->pNext = NULL;
13323             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
13324             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
13325             out_header->pNext = (void *)out_ext;
13326             out_header = (void *)out_ext;
13327             break;
13328         }
13329         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
13330         {
13331             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13332             const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *)in_header;
13333             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
13334             out_ext->pNext = NULL;
13335             out_ext->rectangularLines = in_ext->rectangularLines;
13336             out_ext->bresenhamLines = in_ext->bresenhamLines;
13337             out_ext->smoothLines = in_ext->smoothLines;
13338             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
13339             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
13340             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
13341             out_header->pNext = (void *)out_ext;
13342             out_header = (void *)out_ext;
13343             break;
13344         }
13345         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
13346         {
13347             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13348             const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header;
13349             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
13350             out_ext->pNext = NULL;
13351             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
13352             out_header->pNext = (void *)out_ext;
13353             out_header = (void *)out_ext;
13354             break;
13355         }
13356         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
13357         {
13358             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13359             const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header;
13360             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
13361             out_ext->pNext = NULL;
13362             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
13363             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
13364             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
13365             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
13366             out_ext->multiview = in_ext->multiview;
13367             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
13368             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
13369             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
13370             out_ext->variablePointers = in_ext->variablePointers;
13371             out_ext->protectedMemory = in_ext->protectedMemory;
13372             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
13373             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
13374             out_header->pNext = (void *)out_ext;
13375             out_header = (void *)out_ext;
13376             break;
13377         }
13378         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
13379         {
13380             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13381             const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header;
13382             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
13383             out_ext->pNext = NULL;
13384             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
13385             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
13386             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
13387             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
13388             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
13389             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
13390             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
13391             out_ext->shaderFloat16 = in_ext->shaderFloat16;
13392             out_ext->shaderInt8 = in_ext->shaderInt8;
13393             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
13394             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
13395             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
13396             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
13397             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
13398             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
13399             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
13400             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
13401             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
13402             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
13403             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
13404             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
13405             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
13406             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
13407             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
13408             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
13409             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
13410             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
13411             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
13412             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
13413             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
13414             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
13415             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
13416             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
13417             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
13418             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
13419             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
13420             out_ext->hostQueryReset = in_ext->hostQueryReset;
13421             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
13422             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
13423             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
13424             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
13425             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
13426             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
13427             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
13428             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
13429             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
13430             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
13431             out_header->pNext = (void *)out_ext;
13432             out_header = (void *)out_ext;
13433             break;
13434         }
13435         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
13436         {
13437             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13438             const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header;
13439             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
13440             out_ext->pNext = NULL;
13441             out_ext->robustImageAccess = in_ext->robustImageAccess;
13442             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
13443             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
13444             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
13445             out_ext->privateData = in_ext->privateData;
13446             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
13447             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
13448             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
13449             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
13450             out_ext->synchronization2 = in_ext->synchronization2;
13451             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
13452             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
13453             out_ext->dynamicRendering = in_ext->dynamicRendering;
13454             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
13455             out_ext->maintenance4 = in_ext->maintenance4;
13456             out_header->pNext = (void *)out_ext;
13457             out_header = (void *)out_ext;
13458             break;
13459         }
13460         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
13461         {
13462             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13463             const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header;
13464             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
13465             out_ext->pNext = NULL;
13466             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
13467             out_header->pNext = (void *)out_ext;
13468             out_header = (void *)out_ext;
13469             break;
13470         }
13471         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
13472         {
13473             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13474             const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header;
13475             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
13476             out_ext->pNext = NULL;
13477             out_ext->customBorderColors = in_ext->customBorderColors;
13478             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
13479             out_header->pNext = (void *)out_ext;
13480             out_header = (void *)out_ext;
13481             break;
13482         }
13483         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
13484         {
13485             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13486             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header;
13487             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
13488             out_ext->pNext = NULL;
13489             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
13490             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
13491             out_header->pNext = (void *)out_ext;
13492             out_header = (void *)out_ext;
13493             break;
13494         }
13495         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
13496         {
13497             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13498             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header;
13499             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
13500             out_ext->pNext = NULL;
13501             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
13502             out_header->pNext = (void *)out_ext;
13503             out_header = (void *)out_ext;
13504             break;
13505         }
13506         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
13507         {
13508             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13509             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header;
13510             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
13511             out_ext->pNext = NULL;
13512             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
13513             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
13514             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
13515             out_header->pNext = (void *)out_ext;
13516             out_header = (void *)out_ext;
13517             break;
13518         }
13519         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
13520         {
13521             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13522             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header;
13523             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
13524             out_ext->pNext = NULL;
13525             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
13526             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
13527             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
13528             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
13529             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
13530             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
13531             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
13532             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
13533             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
13534             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
13535             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
13536             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
13537             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
13538             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
13539             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
13540             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
13541             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
13542             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
13543             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
13544             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
13545             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
13546             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
13547             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
13548             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
13549             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
13550             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
13551             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
13552             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
13553             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
13554             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
13555             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
13556             out_header->pNext = (void *)out_ext;
13557             out_header = (void *)out_ext;
13558             break;
13559         }
13560         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
13561         {
13562             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13563             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header;
13564             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
13565             out_ext->pNext = NULL;
13566             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
13567             out_header->pNext = (void *)out_ext;
13568             out_header = (void *)out_ext;
13569             break;
13570         }
13571         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
13572         {
13573             VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13574             const VkDeviceDiagnosticsConfigCreateInfoNV32 *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV32 *)in_header;
13575             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
13576             out_ext->pNext = NULL;
13577             out_ext->flags = in_ext->flags;
13578             out_header->pNext = (void *)out_ext;
13579             out_header = (void *)out_ext;
13580             break;
13581         }
13582         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
13583         {
13584             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13585             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header;
13586             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
13587             out_ext->pNext = NULL;
13588             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
13589             out_header->pNext = (void *)out_ext;
13590             out_header = (void *)out_ext;
13591             break;
13592         }
13593         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
13594         {
13595             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13596             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header;
13597             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
13598             out_ext->pNext = NULL;
13599             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
13600             out_header->pNext = (void *)out_ext;
13601             out_header = (void *)out_ext;
13602             break;
13603         }
13604         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
13605         {
13606             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13607             const VkPhysicalDeviceRobustness2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT32 *)in_header;
13608             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
13609             out_ext->pNext = NULL;
13610             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
13611             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
13612             out_ext->nullDescriptor = in_ext->nullDescriptor;
13613             out_header->pNext = (void *)out_ext;
13614             out_header = (void *)out_ext;
13615             break;
13616         }
13617         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
13618         {
13619             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13620             const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header;
13621             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
13622             out_ext->pNext = NULL;
13623             out_ext->robustImageAccess = in_ext->robustImageAccess;
13624             out_header->pNext = (void *)out_ext;
13625             out_header = (void *)out_ext;
13626             break;
13627         }
13628         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
13629         {
13630             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13631             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header;
13632             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
13633             out_ext->pNext = NULL;
13634             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
13635             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
13636             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
13637             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
13638             out_header->pNext = (void *)out_ext;
13639             out_header = (void *)out_ext;
13640             break;
13641         }
13642         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
13643         {
13644             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13645             const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header;
13646             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
13647             out_ext->pNext = NULL;
13648             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
13649             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
13650             out_header->pNext = (void *)out_ext;
13651             out_header = (void *)out_ext;
13652             break;
13653         }
13654         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
13655         {
13656             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13657             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header;
13658             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
13659             out_ext->pNext = NULL;
13660             out_ext->subpassShading = in_ext->subpassShading;
13661             out_header->pNext = (void *)out_ext;
13662             out_header = (void *)out_ext;
13663             break;
13664         }
13665         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
13666         {
13667             VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13668             const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *)in_header;
13669             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
13670             out_ext->pNext = NULL;
13671             out_ext->clustercullingShader = in_ext->clustercullingShader;
13672             out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
13673             out_header->pNext = (void *)out_ext;
13674             out_header = (void *)out_ext;
13675             break;
13676         }
13677         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
13678         {
13679             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13680             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header;
13681             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
13682             out_ext->pNext = NULL;
13683             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
13684             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
13685             out_header->pNext = (void *)out_ext;
13686             out_header = (void *)out_ext;
13687             break;
13688         }
13689         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
13690         {
13691             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13692             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header;
13693             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
13694             out_ext->pNext = NULL;
13695             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
13696             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
13697             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
13698             out_header->pNext = (void *)out_ext;
13699             out_header = (void *)out_ext;
13700             break;
13701         }
13702         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
13703         {
13704             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13705             const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header;
13706             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
13707             out_ext->pNext = NULL;
13708             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
13709             out_header->pNext = (void *)out_ext;
13710             out_header = (void *)out_ext;
13711             break;
13712         }
13713         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
13714         {
13715             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13716             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header;
13717             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
13718             out_ext->pNext = NULL;
13719             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
13720             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
13721             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
13722             out_header->pNext = (void *)out_ext;
13723             out_header = (void *)out_ext;
13724             break;
13725         }
13726         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
13727         {
13728             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13729             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header;
13730             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
13731             out_ext->pNext = NULL;
13732             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
13733             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
13734             out_header->pNext = (void *)out_ext;
13735             out_header = (void *)out_ext;
13736             break;
13737         }
13738         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
13739         {
13740             VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13741             const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *)in_header;
13742             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
13743             out_ext->pNext = NULL;
13744             out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
13745             out_header->pNext = (void *)out_ext;
13746             out_header = (void *)out_ext;
13747             break;
13748         }
13749         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
13750         {
13751             VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13752             const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *)in_header;
13753             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
13754             out_ext->pNext = NULL;
13755             out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
13756             out_header->pNext = (void *)out_ext;
13757             out_header = (void *)out_ext;
13758             break;
13759         }
13760         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
13761         {
13762             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13763             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header;
13764             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
13765             out_ext->pNext = NULL;
13766             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
13767             out_header->pNext = (void *)out_ext;
13768             out_header = (void *)out_ext;
13769             break;
13770         }
13771         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
13772         {
13773             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13774             const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header;
13775             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
13776             out_ext->pNext = NULL;
13777             out_ext->depthClipControl = in_ext->depthClipControl;
13778             out_header->pNext = (void *)out_ext;
13779             out_header = (void *)out_ext;
13780             break;
13781         }
13782         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
13783         {
13784             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13785             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header;
13786             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
13787             out_ext->pNext = NULL;
13788             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
13789             out_header->pNext = (void *)out_ext;
13790             out_header = (void *)out_ext;
13791             break;
13792         }
13793         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
13794         {
13795             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13796             const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header;
13797             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
13798             out_ext->pNext = NULL;
13799             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
13800             out_header->pNext = (void *)out_ext;
13801             out_header = (void *)out_ext;
13802             break;
13803         }
13804         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
13805         {
13806             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13807             const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header;
13808             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
13809             out_ext->pNext = NULL;
13810             out_ext->synchronization2 = in_ext->synchronization2;
13811             out_header->pNext = (void *)out_ext;
13812             out_header = (void *)out_ext;
13813             break;
13814         }
13815         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
13816         {
13817             VkPhysicalDeviceHostImageCopyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13818             const VkPhysicalDeviceHostImageCopyFeaturesEXT32 *in_ext = (const VkPhysicalDeviceHostImageCopyFeaturesEXT32 *)in_header;
13819             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT;
13820             out_ext->pNext = NULL;
13821             out_ext->hostImageCopy = in_ext->hostImageCopy;
13822             out_header->pNext = (void *)out_ext;
13823             out_header = (void *)out_ext;
13824             break;
13825         }
13826         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
13827         {
13828             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13829             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header;
13830             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
13831             out_ext->pNext = NULL;
13832             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
13833             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
13834             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
13835             out_header->pNext = (void *)out_ext;
13836             out_header = (void *)out_ext;
13837             break;
13838         }
13839         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
13840         {
13841             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13842             const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header;
13843             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
13844             out_ext->pNext = NULL;
13845             out_ext->legacyDithering = in_ext->legacyDithering;
13846             out_header->pNext = (void *)out_ext;
13847             out_header = (void *)out_ext;
13848             break;
13849         }
13850         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
13851         {
13852             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13853             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header;
13854             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
13855             out_ext->pNext = NULL;
13856             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
13857             out_header->pNext = (void *)out_ext;
13858             out_header = (void *)out_ext;
13859             break;
13860         }
13861         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
13862         {
13863             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13864             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *)in_header;
13865             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
13866             out_ext->pNext = NULL;
13867             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
13868             out_header->pNext = (void *)out_ext;
13869             out_header = (void *)out_ext;
13870             break;
13871         }
13872         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
13873         {
13874             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13875             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header;
13876             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
13877             out_ext->pNext = NULL;
13878             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
13879             out_header->pNext = (void *)out_ext;
13880             out_header = (void *)out_ext;
13881             break;
13882         }
13883         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
13884         {
13885             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13886             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header;
13887             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
13888             out_ext->pNext = NULL;
13889             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
13890             out_header->pNext = (void *)out_ext;
13891             out_header = (void *)out_ext;
13892             break;
13893         }
13894         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
13895         {
13896             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13897             const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *)in_header;
13898             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
13899             out_ext->pNext = NULL;
13900             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
13901             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
13902             out_header->pNext = (void *)out_ext;
13903             out_header = (void *)out_ext;
13904             break;
13905         }
13906         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
13907         {
13908             VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13909             const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header;
13910             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
13911             out_ext->pNext = NULL;
13912             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
13913             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
13914             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
13915             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
13916             out_header->pNext = (void *)out_ext;
13917             out_header = (void *)out_ext;
13918             break;
13919         }
13920         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
13921         {
13922             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13923             const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header;
13924             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
13925             out_ext->pNext = NULL;
13926             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
13927             out_header->pNext = (void *)out_ext;
13928             out_header = (void *)out_ext;
13929             break;
13930         }
13931         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
13932         {
13933             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13934             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header;
13935             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
13936             out_ext->pNext = NULL;
13937             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
13938             out_header->pNext = (void *)out_ext;
13939             out_header = (void *)out_ext;
13940             break;
13941         }
13942         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
13943         {
13944             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13945             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header;
13946             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
13947             out_ext->pNext = NULL;
13948             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
13949             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
13950             out_header->pNext = (void *)out_ext;
13951             out_header = (void *)out_ext;
13952             break;
13953         }
13954         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
13955         {
13956             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13957             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header;
13958             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
13959             out_ext->pNext = NULL;
13960             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
13961             out_header->pNext = (void *)out_ext;
13962             out_header = (void *)out_ext;
13963             break;
13964         }
13965         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
13966         {
13967             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13968             const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header;
13969             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
13970             out_ext->pNext = NULL;
13971             out_ext->dynamicRendering = in_ext->dynamicRendering;
13972             out_header->pNext = (void *)out_ext;
13973             out_header = (void *)out_ext;
13974             break;
13975         }
13976         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
13977         {
13978             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13979             const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header;
13980             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
13981             out_ext->pNext = NULL;
13982             out_ext->minLod = in_ext->minLod;
13983             out_header->pNext = (void *)out_ext;
13984             out_header = (void *)out_ext;
13985             break;
13986         }
13987         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
13988         {
13989             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13990             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header;
13991             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
13992             out_ext->pNext = NULL;
13993             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
13994             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
13995             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
13996             out_header->pNext = (void *)out_ext;
13997             out_header = (void *)out_ext;
13998             break;
13999         }
14000         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
14001         {
14002             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14003             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header;
14004             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
14005             out_ext->pNext = NULL;
14006             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
14007             out_header->pNext = (void *)out_ext;
14008             out_header = (void *)out_ext;
14009             break;
14010         }
14011         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
14012         {
14013             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14014             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header;
14015             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
14016             out_ext->pNext = NULL;
14017             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
14018             out_header->pNext = (void *)out_ext;
14019             out_header = (void *)out_ext;
14020             break;
14021         }
14022         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
14023         {
14024             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14025             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header;
14026             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
14027             out_ext->pNext = NULL;
14028             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
14029             out_header->pNext = (void *)out_ext;
14030             out_header = (void *)out_ext;
14031             break;
14032         }
14033         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
14034         {
14035             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14036             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header;
14037             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
14038             out_ext->pNext = NULL;
14039             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
14040             out_header->pNext = (void *)out_ext;
14041             out_header = (void *)out_ext;
14042             break;
14043         }
14044         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
14045         {
14046             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14047             const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header;
14048             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
14049             out_ext->pNext = NULL;
14050             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
14051             out_header->pNext = (void *)out_ext;
14052             out_header = (void *)out_ext;
14053             break;
14054         }
14055         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
14056         {
14057             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14058             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header;
14059             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
14060             out_ext->pNext = NULL;
14061             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
14062             out_header->pNext = (void *)out_ext;
14063             out_header = (void *)out_ext;
14064             break;
14065         }
14066         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
14067         {
14068             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14069             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header;
14070             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
14071             out_ext->pNext = NULL;
14072             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
14073             out_header->pNext = (void *)out_ext;
14074             out_header = (void *)out_ext;
14075             break;
14076         }
14077         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
14078         {
14079             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14080             const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header;
14081             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
14082             out_ext->pNext = NULL;
14083             out_ext->micromap = in_ext->micromap;
14084             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
14085             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
14086             out_header->pNext = (void *)out_ext;
14087             out_header = (void *)out_ext;
14088             break;
14089         }
14090         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
14091         {
14092             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14093             const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header;
14094             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
14095             out_ext->pNext = NULL;
14096             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
14097             out_header->pNext = (void *)out_ext;
14098             out_header = (void *)out_ext;
14099             break;
14100         }
14101         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
14102         {
14103             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14104             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header;
14105             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
14106             out_ext->pNext = NULL;
14107             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
14108             out_header->pNext = (void *)out_ext;
14109             out_header = (void *)out_ext;
14110             break;
14111         }
14112         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
14113         {
14114             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14115             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header;
14116             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
14117             out_ext->pNext = NULL;
14118             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
14119             out_header->pNext = (void *)out_ext;
14120             out_header = (void *)out_ext;
14121             break;
14122         }
14123         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
14124         {
14125             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14126             const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *)in_header;
14127             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
14128             out_ext->pNext = NULL;
14129             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
14130             out_header->pNext = (void *)out_ext;
14131             out_header = (void *)out_ext;
14132             break;
14133         }
14134         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
14135         {
14136             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14137             const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header;
14138             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
14139             out_ext->pNext = NULL;
14140             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
14141             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
14142             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
14143             out_header->pNext = (void *)out_ext;
14144             out_header = (void *)out_ext;
14145             break;
14146         }
14147         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
14148         {
14149             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14150             const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header;
14151             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
14152             out_ext->pNext = NULL;
14153             out_ext->tileProperties = in_ext->tileProperties;
14154             out_header->pNext = (void *)out_ext;
14155             out_header = (void *)out_ext;
14156             break;
14157         }
14158         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
14159         {
14160             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14161             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header;
14162             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
14163             out_ext->pNext = NULL;
14164             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
14165             out_header->pNext = (void *)out_ext;
14166             out_header = (void *)out_ext;
14167             break;
14168         }
14169         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
14170         {
14171             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14172             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *)in_header;
14173             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
14174             out_ext->pNext = NULL;
14175             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
14176             out_header->pNext = (void *)out_ext;
14177             out_header = (void *)out_ext;
14178             break;
14179         }
14180         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
14181         {
14182             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14183             const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header;
14184             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
14185             out_ext->pNext = NULL;
14186             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
14187             out_header->pNext = (void *)out_ext;
14188             out_header = (void *)out_ext;
14189             break;
14190         }
14191         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
14192         {
14193             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14194             const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header;
14195             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
14196             out_ext->pNext = NULL;
14197             out_ext->opticalFlow = in_ext->opticalFlow;
14198             out_header->pNext = (void *)out_ext;
14199             out_header = (void *)out_ext;
14200             break;
14201         }
14202         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
14203         {
14204             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14205             const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header;
14206             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
14207             out_ext->pNext = NULL;
14208             out_ext->deviceFault = in_ext->deviceFault;
14209             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
14210             out_header->pNext = (void *)out_ext;
14211             out_header = (void *)out_ext;
14212             break;
14213         }
14214         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
14215         {
14216             VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14217             const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *)in_header;
14218             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
14219             out_ext->pNext = NULL;
14220             out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
14221             out_header->pNext = (void *)out_ext;
14222             out_header = (void *)out_ext;
14223             break;
14224         }
14225         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
14226         {
14227             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14228             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header;
14229             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
14230             out_ext->pNext = NULL;
14231             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
14232             out_header->pNext = (void *)out_ext;
14233             out_header = (void *)out_ext;
14234             break;
14235         }
14236         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
14237         {
14238             VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14239             const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *)in_header;
14240             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
14241             out_ext->pNext = NULL;
14242             out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
14243             out_header->pNext = (void *)out_ext;
14244             out_header = (void *)out_ext;
14245             break;
14246         }
14247         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
14248         {
14249             VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14250             const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *)in_header;
14251             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT;
14252             out_ext->pNext = NULL;
14253             out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
14254             out_header->pNext = (void *)out_ext;
14255             out_header = (void *)out_ext;
14256             break;
14257         }
14258         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
14259         {
14260             VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14261             const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *)in_header;
14262             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
14263             out_ext->pNext = NULL;
14264             out_ext->depthBiasControl = in_ext->depthBiasControl;
14265             out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
14266             out_ext->floatRepresentation = in_ext->floatRepresentation;
14267             out_ext->depthBiasExact = in_ext->depthBiasExact;
14268             out_header->pNext = (void *)out_ext;
14269             out_header = (void *)out_ext;
14270             break;
14271         }
14272         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
14273         {
14274             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14275             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header;
14276             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
14277             out_ext->pNext = NULL;
14278             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
14279             out_header->pNext = (void *)out_ext;
14280             out_header = (void *)out_ext;
14281             break;
14282         }
14283         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
14284         {
14285             VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14286             const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *)in_header;
14287             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
14288             out_ext->pNext = NULL;
14289             out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
14290             out_header->pNext = (void *)out_ext;
14291             out_header = (void *)out_ext;
14292             break;
14293         }
14294         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
14295         {
14296             VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14297             const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *)in_header;
14298             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
14299             out_ext->pNext = NULL;
14300             out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
14301             out_header->pNext = (void *)out_ext;
14302             out_header = (void *)out_ext;
14303             break;
14304         }
14305         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
14306         {
14307             VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14308             const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *)in_header;
14309             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
14310             out_ext->pNext = NULL;
14311             out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
14312             out_header->pNext = (void *)out_ext;
14313             out_header = (void *)out_ext;
14314             break;
14315         }
14316         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
14317         {
14318             VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14319             const VkPhysicalDeviceShaderObjectFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT32 *)in_header;
14320             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
14321             out_ext->pNext = NULL;
14322             out_ext->shaderObject = in_ext->shaderObject;
14323             out_header->pNext = (void *)out_ext;
14324             out_header = (void *)out_ext;
14325             break;
14326         }
14327         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
14328         {
14329             VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14330             const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *)in_header;
14331             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
14332             out_ext->pNext = NULL;
14333             out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
14334             out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
14335             out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
14336             out_header->pNext = (void *)out_ext;
14337             out_header = (void *)out_ext;
14338             break;
14339         }
14340         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
14341         {
14342             VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14343             const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *)in_header;
14344             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
14345             out_ext->pNext = NULL;
14346             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
14347             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
14348             out_header->pNext = (void *)out_ext;
14349             out_header = (void *)out_ext;
14350             break;
14351         }
14352         default:
14353             FIXME("Unhandled sType %u.\n", in_header->sType);
14354             break;
14355         }
14356     }
14357 }
14358
14359 static inline void convert_VkEventCreateInfo_win32_to_host(const VkEventCreateInfo32 *in, VkEventCreateInfo *out)
14360 {
14361     if (!in) return;
14362
14363     out->sType = in->sType;
14364     out->pNext = NULL;
14365     out->flags = in->flags;
14366     if (in->pNext)
14367         FIXME("Unexpected pNext\n");
14368 }
14369
14370 static inline void convert_VkFenceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFenceCreateInfo32 *in, VkFenceCreateInfo *out)
14371 {
14372     const VkBaseInStructure32 *in_header;
14373     VkBaseOutStructure *out_header = (void *)out;
14374
14375     if (!in) return;
14376
14377     out->sType = in->sType;
14378     out->pNext = NULL;
14379     out->flags = in->flags;
14380
14381     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14382     {
14383         switch (in_header->sType)
14384         {
14385         case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
14386         {
14387             VkExportFenceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14388             const VkExportFenceCreateInfo32 *in_ext = (const VkExportFenceCreateInfo32 *)in_header;
14389             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO;
14390             out_ext->pNext = NULL;
14391             out_ext->handleTypes = in_ext->handleTypes;
14392             out_header->pNext = (void *)out_ext;
14393             out_header = (void *)out_ext;
14394             break;
14395         }
14396         default:
14397             FIXME("Unhandled sType %u.\n", in_header->sType);
14398             break;
14399         }
14400     }
14401 }
14402
14403 static inline void convert_VkFramebufferAttachmentImageInfo_win32_to_host(const VkFramebufferAttachmentImageInfo32 *in, VkFramebufferAttachmentImageInfo *out)
14404 {
14405     if (!in) return;
14406
14407     out->sType = in->sType;
14408     out->pNext = NULL;
14409     out->flags = in->flags;
14410     out->usage = in->usage;
14411     out->width = in->width;
14412     out->height = in->height;
14413     out->layerCount = in->layerCount;
14414     out->viewFormatCount = in->viewFormatCount;
14415     out->pViewFormats = (const VkFormat *)UlongToPtr(in->pViewFormats);
14416     if (in->pNext)
14417         FIXME("Unexpected pNext\n");
14418 }
14419
14420 static inline const VkFramebufferAttachmentImageInfo *convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferAttachmentImageInfo32 *in, uint32_t count)
14421 {
14422     VkFramebufferAttachmentImageInfo *out;
14423     unsigned int i;
14424
14425     if (!in || !count) return NULL;
14426
14427     out = conversion_context_alloc(ctx, count * sizeof(*out));
14428     for (i = 0; i < count; i++)
14429     {
14430         convert_VkFramebufferAttachmentImageInfo_win32_to_host(&in[i], &out[i]);
14431     }
14432
14433     return out;
14434 }
14435
14436 static inline void convert_VkFramebufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFramebufferCreateInfo32 *in, VkFramebufferCreateInfo *out)
14437 {
14438     const VkBaseInStructure32 *in_header;
14439     VkBaseOutStructure *out_header = (void *)out;
14440
14441     if (!in) return;
14442
14443     out->sType = in->sType;
14444     out->pNext = NULL;
14445     out->flags = in->flags;
14446     out->renderPass = in->renderPass;
14447     out->attachmentCount = in->attachmentCount;
14448     out->pAttachments = (const VkImageView *)UlongToPtr(in->pAttachments);
14449     out->width = in->width;
14450     out->height = in->height;
14451     out->layers = in->layers;
14452
14453     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14454     {
14455         switch (in_header->sType)
14456         {
14457         case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
14458         {
14459             VkFramebufferAttachmentsCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14460             const VkFramebufferAttachmentsCreateInfo32 *in_ext = (const VkFramebufferAttachmentsCreateInfo32 *)in_header;
14461             out_ext->sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
14462             out_ext->pNext = NULL;
14463             out_ext->attachmentImageInfoCount = in_ext->attachmentImageInfoCount;
14464             out_ext->pAttachmentImageInfos = convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(ctx, (const VkFramebufferAttachmentImageInfo32 *)UlongToPtr(in_ext->pAttachmentImageInfos), in_ext->attachmentImageInfoCount);
14465             out_header->pNext = (void *)out_ext;
14466             out_header = (void *)out_ext;
14467             break;
14468         }
14469         default:
14470             FIXME("Unhandled sType %u.\n", in_header->sType);
14471             break;
14472         }
14473     }
14474 }
14475
14476 #ifdef _WIN64
14477 static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, uint32_t count)
14478 {
14479     VkPipelineShaderStageCreateInfo *out;
14480     unsigned int i;
14481
14482     if (!in || !count) return NULL;
14483
14484     out = conversion_context_alloc(ctx, count * sizeof(*out));
14485     for (i = 0; i < count; i++)
14486     {
14487         convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
14488     }
14489
14490     return out;
14491 }
14492 #endif /* _WIN64 */
14493
14494 static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, uint32_t count)
14495 {
14496     VkPipelineShaderStageCreateInfo *out;
14497     unsigned int i;
14498
14499     if (!in || !count) return NULL;
14500
14501     out = conversion_context_alloc(ctx, count * sizeof(*out));
14502     for (i = 0; i < count; i++)
14503     {
14504         convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14505     }
14506
14507     return out;
14508 }
14509
14510 static inline void convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, VkPipelineVertexInputStateCreateInfo *out)
14511 {
14512     const VkBaseInStructure32 *in_header;
14513     VkBaseOutStructure *out_header = (void *)out;
14514
14515     if (!in) return;
14516
14517     out->sType = in->sType;
14518     out->pNext = NULL;
14519     out->flags = in->flags;
14520     out->vertexBindingDescriptionCount = in->vertexBindingDescriptionCount;
14521     out->pVertexBindingDescriptions = (const VkVertexInputBindingDescription *)UlongToPtr(in->pVertexBindingDescriptions);
14522     out->vertexAttributeDescriptionCount = in->vertexAttributeDescriptionCount;
14523     out->pVertexAttributeDescriptions = (const VkVertexInputAttributeDescription *)UlongToPtr(in->pVertexAttributeDescriptions);
14524
14525     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14526     {
14527         switch (in_header->sType)
14528         {
14529         case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
14530         {
14531             VkPipelineVertexInputDivisorStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14532             const VkPipelineVertexInputDivisorStateCreateInfoEXT32 *in_ext = (const VkPipelineVertexInputDivisorStateCreateInfoEXT32 *)in_header;
14533             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT;
14534             out_ext->pNext = NULL;
14535             out_ext->vertexBindingDivisorCount = in_ext->vertexBindingDivisorCount;
14536             out_ext->pVertexBindingDivisors = (const VkVertexInputBindingDivisorDescriptionEXT *)UlongToPtr(in_ext->pVertexBindingDivisors);
14537             out_header->pNext = (void *)out_ext;
14538             out_header = (void *)out_ext;
14539             break;
14540         }
14541         default:
14542             FIXME("Unhandled sType %u.\n", in_header->sType);
14543             break;
14544         }
14545     }
14546 }
14547
14548 static inline const VkPipelineVertexInputStateCreateInfo *convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, uint32_t count)
14549 {
14550     VkPipelineVertexInputStateCreateInfo *out;
14551     unsigned int i;
14552
14553     if (!in || !count) return NULL;
14554
14555     out = conversion_context_alloc(ctx, count * sizeof(*out));
14556     for (i = 0; i < count; i++)
14557     {
14558         convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14559     }
14560
14561     return out;
14562 }
14563
14564 static inline void convert_VkPipelineTessellationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, VkPipelineTessellationStateCreateInfo *out)
14565 {
14566     const VkBaseInStructure32 *in_header;
14567     VkBaseOutStructure *out_header = (void *)out;
14568
14569     if (!in) return;
14570
14571     out->sType = in->sType;
14572     out->pNext = NULL;
14573     out->flags = in->flags;
14574     out->patchControlPoints = in->patchControlPoints;
14575
14576     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14577     {
14578         switch (in_header->sType)
14579         {
14580         case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
14581         {
14582             VkPipelineTessellationDomainOriginStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14583             const VkPipelineTessellationDomainOriginStateCreateInfo32 *in_ext = (const VkPipelineTessellationDomainOriginStateCreateInfo32 *)in_header;
14584             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
14585             out_ext->pNext = NULL;
14586             out_ext->domainOrigin = in_ext->domainOrigin;
14587             out_header->pNext = (void *)out_ext;
14588             out_header = (void *)out_ext;
14589             break;
14590         }
14591         default:
14592             FIXME("Unhandled sType %u.\n", in_header->sType);
14593             break;
14594         }
14595     }
14596 }
14597
14598 static inline const VkPipelineTessellationStateCreateInfo *convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, uint32_t count)
14599 {
14600     VkPipelineTessellationStateCreateInfo *out;
14601     unsigned int i;
14602
14603     if (!in || !count) return NULL;
14604
14605     out = conversion_context_alloc(ctx, count * sizeof(*out));
14606     for (i = 0; i < count; i++)
14607     {
14608         convert_VkPipelineTessellationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14609     }
14610
14611     return out;
14612 }
14613
14614 #ifdef _WIN64
14615 static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, VkGraphicsShaderGroupCreateInfoNV *out)
14616 {
14617     if (!in) return;
14618
14619     out->sType = in->sType;
14620     out->pNext = in->pNext;
14621     out->stageCount = in->stageCount;
14622     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
14623     out->pVertexInputState = in->pVertexInputState;
14624     out->pTessellationState = in->pTessellationState;
14625 }
14626 #endif /* _WIN64 */
14627
14628 static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, VkGraphicsShaderGroupCreateInfoNV *out)
14629 {
14630     if (!in) return;
14631
14632     out->sType = in->sType;
14633     out->pNext = NULL;
14634     out->stageCount = in->stageCount;
14635     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
14636     out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineVertexInputStateCreateInfo32 *)UlongToPtr(in->pVertexInputState), 1);
14637     out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineTessellationStateCreateInfo32 *)UlongToPtr(in->pTessellationState), 1);
14638     if (in->pNext)
14639         FIXME("Unexpected pNext\n");
14640 }
14641
14642 #ifdef _WIN64
14643 static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, uint32_t count)
14644 {
14645     VkGraphicsShaderGroupCreateInfoNV *out;
14646     unsigned int i;
14647
14648     if (!in || !count) return NULL;
14649
14650     out = conversion_context_alloc(ctx, count * sizeof(*out));
14651     for (i = 0; i < count; i++)
14652     {
14653         convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
14654     }
14655
14656     return out;
14657 }
14658 #endif /* _WIN64 */
14659
14660 static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, uint32_t count)
14661 {
14662     VkGraphicsShaderGroupCreateInfoNV *out;
14663     unsigned int i;
14664
14665     if (!in || !count) return NULL;
14666
14667     out = conversion_context_alloc(ctx, count * sizeof(*out));
14668     for (i = 0; i < count; i++)
14669     {
14670         convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
14671     }
14672
14673     return out;
14674 }
14675
14676 static inline void convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(const VkPipelineInputAssemblyStateCreateInfo32 *in, VkPipelineInputAssemblyStateCreateInfo *out)
14677 {
14678     if (!in) return;
14679
14680     out->sType = in->sType;
14681     out->pNext = NULL;
14682     out->flags = in->flags;
14683     out->topology = in->topology;
14684     out->primitiveRestartEnable = in->primitiveRestartEnable;
14685     if (in->pNext)
14686         FIXME("Unexpected pNext\n");
14687 }
14688
14689 static inline const VkPipelineInputAssemblyStateCreateInfo *convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineInputAssemblyStateCreateInfo32 *in, uint32_t count)
14690 {
14691     VkPipelineInputAssemblyStateCreateInfo *out;
14692     unsigned int i;
14693
14694     if (!in || !count) return NULL;
14695
14696     out = conversion_context_alloc(ctx, count * sizeof(*out));
14697     for (i = 0; i < count; i++)
14698     {
14699         convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(&in[i], &out[i]);
14700     }
14701
14702     return out;
14703 }
14704
14705 static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, VkPipelineViewportStateCreateInfo *out)
14706 {
14707     const VkBaseInStructure32 *in_header;
14708     VkBaseOutStructure *out_header = (void *)out;
14709
14710     if (!in) return;
14711
14712     out->sType = in->sType;
14713     out->pNext = NULL;
14714     out->flags = in->flags;
14715     out->viewportCount = in->viewportCount;
14716     out->pViewports = (const VkViewport *)UlongToPtr(in->pViewports);
14717     out->scissorCount = in->scissorCount;
14718     out->pScissors = (const VkRect2D *)UlongToPtr(in->pScissors);
14719
14720     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14721     {
14722         switch (in_header->sType)
14723         {
14724         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
14725         {
14726             VkPipelineViewportWScalingStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14727             const VkPipelineViewportWScalingStateCreateInfoNV32 *in_ext = (const VkPipelineViewportWScalingStateCreateInfoNV32 *)in_header;
14728             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV;
14729             out_ext->pNext = NULL;
14730             out_ext->viewportWScalingEnable = in_ext->viewportWScalingEnable;
14731             out_ext->viewportCount = in_ext->viewportCount;
14732             out_ext->pViewportWScalings = (const VkViewportWScalingNV *)UlongToPtr(in_ext->pViewportWScalings);
14733             out_header->pNext = (void *)out_ext;
14734             out_header = (void *)out_ext;
14735             break;
14736         }
14737         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
14738         {
14739             VkPipelineViewportSwizzleStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14740             const VkPipelineViewportSwizzleStateCreateInfoNV32 *in_ext = (const VkPipelineViewportSwizzleStateCreateInfoNV32 *)in_header;
14741             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV;
14742             out_ext->pNext = NULL;
14743             out_ext->flags = in_ext->flags;
14744             out_ext->viewportCount = in_ext->viewportCount;
14745             out_ext->pViewportSwizzles = (const VkViewportSwizzleNV *)UlongToPtr(in_ext->pViewportSwizzles);
14746             out_header->pNext = (void *)out_ext;
14747             out_header = (void *)out_ext;
14748             break;
14749         }
14750         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
14751         {
14752             VkPipelineViewportExclusiveScissorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14753             const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *in_ext = (const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *)in_header;
14754             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV;
14755             out_ext->pNext = NULL;
14756             out_ext->exclusiveScissorCount = in_ext->exclusiveScissorCount;
14757             out_ext->pExclusiveScissors = (const VkRect2D *)UlongToPtr(in_ext->pExclusiveScissors);
14758             out_header->pNext = (void *)out_ext;
14759             out_header = (void *)out_ext;
14760             break;
14761         }
14762         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
14763         {
14764             VkPipelineViewportShadingRateImageStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14765             const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *in_ext = (const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *)in_header;
14766             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV;
14767             out_ext->pNext = NULL;
14768             out_ext->shadingRateImageEnable = in_ext->shadingRateImageEnable;
14769             out_ext->viewportCount = in_ext->viewportCount;
14770             out_ext->pShadingRatePalettes = convert_VkShadingRatePaletteNV_array_win32_to_host(ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(in_ext->pShadingRatePalettes), in_ext->viewportCount);
14771             out_header->pNext = (void *)out_ext;
14772             out_header = (void *)out_ext;
14773             break;
14774         }
14775         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
14776         {
14777             VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14778             const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *in_ext = (const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *)in_header;
14779             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV;
14780             out_ext->pNext = NULL;
14781             out_ext->sampleOrderType = in_ext->sampleOrderType;
14782             out_ext->customSampleOrderCount = in_ext->customSampleOrderCount;
14783             out_ext->pCustomSampleOrders = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(in_ext->pCustomSampleOrders), in_ext->customSampleOrderCount);
14784             out_header->pNext = (void *)out_ext;
14785             out_header = (void *)out_ext;
14786             break;
14787         }
14788         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
14789         {
14790             VkPipelineViewportDepthClipControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14791             const VkPipelineViewportDepthClipControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClipControlCreateInfoEXT32 *)in_header;
14792             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT;
14793             out_ext->pNext = NULL;
14794             out_ext->negativeOneToOne = in_ext->negativeOneToOne;
14795             out_header->pNext = (void *)out_ext;
14796             out_header = (void *)out_ext;
14797             break;
14798         }
14799         default:
14800             FIXME("Unhandled sType %u.\n", in_header->sType);
14801             break;
14802         }
14803     }
14804 }
14805
14806 static inline const VkPipelineViewportStateCreateInfo *convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, uint32_t count)
14807 {
14808     VkPipelineViewportStateCreateInfo *out;
14809     unsigned int i;
14810
14811     if (!in || !count) return NULL;
14812
14813     out = conversion_context_alloc(ctx, count * sizeof(*out));
14814     for (i = 0; i < count; i++)
14815     {
14816         convert_VkPipelineViewportStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14817     }
14818
14819     return out;
14820 }
14821
14822 static inline void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, VkPipelineRasterizationStateCreateInfo *out)
14823 {
14824     const VkBaseInStructure32 *in_header;
14825     VkBaseOutStructure *out_header = (void *)out;
14826
14827     if (!in) return;
14828
14829     out->sType = in->sType;
14830     out->pNext = NULL;
14831     out->flags = in->flags;
14832     out->depthClampEnable = in->depthClampEnable;
14833     out->rasterizerDiscardEnable = in->rasterizerDiscardEnable;
14834     out->polygonMode = in->polygonMode;
14835     out->cullMode = in->cullMode;
14836     out->frontFace = in->frontFace;
14837     out->depthBiasEnable = in->depthBiasEnable;
14838     out->depthBiasConstantFactor = in->depthBiasConstantFactor;
14839     out->depthBiasClamp = in->depthBiasClamp;
14840     out->depthBiasSlopeFactor = in->depthBiasSlopeFactor;
14841     out->lineWidth = in->lineWidth;
14842
14843     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14844     {
14845         switch (in_header->sType)
14846         {
14847         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
14848         {
14849             VkPipelineRasterizationStateRasterizationOrderAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14850             const VkPipelineRasterizationStateRasterizationOrderAMD32 *in_ext = (const VkPipelineRasterizationStateRasterizationOrderAMD32 *)in_header;
14851             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD;
14852             out_ext->pNext = NULL;
14853             out_ext->rasterizationOrder = in_ext->rasterizationOrder;
14854             out_header->pNext = (void *)out_ext;
14855             out_header = (void *)out_ext;
14856             break;
14857         }
14858         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
14859         {
14860             VkPipelineRasterizationConservativeStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14861             const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *)in_header;
14862             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT;
14863             out_ext->pNext = NULL;
14864             out_ext->flags = in_ext->flags;
14865             out_ext->conservativeRasterizationMode = in_ext->conservativeRasterizationMode;
14866             out_ext->extraPrimitiveOverestimationSize = in_ext->extraPrimitiveOverestimationSize;
14867             out_header->pNext = (void *)out_ext;
14868             out_header = (void *)out_ext;
14869             break;
14870         }
14871         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
14872         {
14873             VkPipelineRasterizationStateStreamCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14874             const VkPipelineRasterizationStateStreamCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationStateStreamCreateInfoEXT32 *)in_header;
14875             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT;
14876             out_ext->pNext = NULL;
14877             out_ext->flags = in_ext->flags;
14878             out_ext->rasterizationStream = in_ext->rasterizationStream;
14879             out_header->pNext = (void *)out_ext;
14880             out_header = (void *)out_ext;
14881             break;
14882         }
14883         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
14884         {
14885             VkPipelineRasterizationDepthClipStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14886             const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *)in_header;
14887             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT;
14888             out_ext->pNext = NULL;
14889             out_ext->flags = in_ext->flags;
14890             out_ext->depthClipEnable = in_ext->depthClipEnable;
14891             out_header->pNext = (void *)out_ext;
14892             out_header = (void *)out_ext;
14893             break;
14894         }
14895         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
14896         {
14897             VkPipelineRasterizationLineStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14898             const VkPipelineRasterizationLineStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationLineStateCreateInfoEXT32 *)in_header;
14899             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT;
14900             out_ext->pNext = NULL;
14901             out_ext->lineRasterizationMode = in_ext->lineRasterizationMode;
14902             out_ext->stippledLineEnable = in_ext->stippledLineEnable;
14903             out_ext->lineStippleFactor = in_ext->lineStippleFactor;
14904             out_ext->lineStipplePattern = in_ext->lineStipplePattern;
14905             out_header->pNext = (void *)out_ext;
14906             out_header = (void *)out_ext;
14907             break;
14908         }
14909         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
14910         {
14911             VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14912             const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *)in_header;
14913             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT;
14914             out_ext->pNext = NULL;
14915             out_ext->provokingVertexMode = in_ext->provokingVertexMode;
14916             out_header->pNext = (void *)out_ext;
14917             out_header = (void *)out_ext;
14918             break;
14919         }
14920         case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
14921         {
14922             VkDepthBiasRepresentationInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14923             const VkDepthBiasRepresentationInfoEXT32 *in_ext = (const VkDepthBiasRepresentationInfoEXT32 *)in_header;
14924             out_ext->sType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT;
14925             out_ext->pNext = NULL;
14926             out_ext->depthBiasRepresentation = in_ext->depthBiasRepresentation;
14927             out_ext->depthBiasExact = in_ext->depthBiasExact;
14928             out_header->pNext = (void *)out_ext;
14929             out_header = (void *)out_ext;
14930             break;
14931         }
14932         default:
14933             FIXME("Unhandled sType %u.\n", in_header->sType);
14934             break;
14935         }
14936     }
14937 }
14938
14939 static inline const VkPipelineRasterizationStateCreateInfo *convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, uint32_t count)
14940 {
14941     VkPipelineRasterizationStateCreateInfo *out;
14942     unsigned int i;
14943
14944     if (!in || !count) return NULL;
14945
14946     out = conversion_context_alloc(ctx, count * sizeof(*out));
14947     for (i = 0; i < count; i++)
14948     {
14949         convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14950     }
14951
14952     return out;
14953 }
14954
14955 static inline void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, VkPipelineMultisampleStateCreateInfo *out)
14956 {
14957     const VkBaseInStructure32 *in_header;
14958     VkBaseOutStructure *out_header = (void *)out;
14959
14960     if (!in) return;
14961
14962     out->sType = in->sType;
14963     out->pNext = NULL;
14964     out->flags = in->flags;
14965     out->rasterizationSamples = in->rasterizationSamples;
14966     out->sampleShadingEnable = in->sampleShadingEnable;
14967     out->minSampleShading = in->minSampleShading;
14968     out->pSampleMask = (const VkSampleMask *)UlongToPtr(in->pSampleMask);
14969     out->alphaToCoverageEnable = in->alphaToCoverageEnable;
14970     out->alphaToOneEnable = in->alphaToOneEnable;
14971
14972     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14973     {
14974         switch (in_header->sType)
14975         {
14976         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
14977         {
14978             VkPipelineCoverageToColorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14979             const VkPipelineCoverageToColorStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageToColorStateCreateInfoNV32 *)in_header;
14980             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV;
14981             out_ext->pNext = NULL;
14982             out_ext->flags = in_ext->flags;
14983             out_ext->coverageToColorEnable = in_ext->coverageToColorEnable;
14984             out_ext->coverageToColorLocation = in_ext->coverageToColorLocation;
14985             out_header->pNext = (void *)out_ext;
14986             out_header = (void *)out_ext;
14987             break;
14988         }
14989         case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
14990         {
14991             VkPipelineSampleLocationsStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14992             const VkPipelineSampleLocationsStateCreateInfoEXT32 *in_ext = (const VkPipelineSampleLocationsStateCreateInfoEXT32 *)in_header;
14993             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT;
14994             out_ext->pNext = NULL;
14995             out_ext->sampleLocationsEnable = in_ext->sampleLocationsEnable;
14996             convert_VkSampleLocationsInfoEXT_win32_to_host(&in_ext->sampleLocationsInfo, &out_ext->sampleLocationsInfo);
14997             out_header->pNext = (void *)out_ext;
14998             out_header = (void *)out_ext;
14999             break;
15000         }
15001         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
15002         {
15003             VkPipelineCoverageModulationStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15004             const VkPipelineCoverageModulationStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageModulationStateCreateInfoNV32 *)in_header;
15005             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV;
15006             out_ext->pNext = NULL;
15007             out_ext->flags = in_ext->flags;
15008             out_ext->coverageModulationMode = in_ext->coverageModulationMode;
15009             out_ext->coverageModulationTableEnable = in_ext->coverageModulationTableEnable;
15010             out_ext->coverageModulationTableCount = in_ext->coverageModulationTableCount;
15011             out_ext->pCoverageModulationTable = (const float *)UlongToPtr(in_ext->pCoverageModulationTable);
15012             out_header->pNext = (void *)out_ext;
15013             out_header = (void *)out_ext;
15014             break;
15015         }
15016         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
15017         {
15018             VkPipelineCoverageReductionStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15019             const VkPipelineCoverageReductionStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageReductionStateCreateInfoNV32 *)in_header;
15020             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV;
15021             out_ext->pNext = NULL;
15022             out_ext->flags = in_ext->flags;
15023             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
15024             out_header->pNext = (void *)out_ext;
15025             out_header = (void *)out_ext;
15026             break;
15027         }
15028         default:
15029             FIXME("Unhandled sType %u.\n", in_header->sType);
15030             break;
15031         }
15032     }
15033 }
15034
15035 static inline const VkPipelineMultisampleStateCreateInfo *convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, uint32_t count)
15036 {
15037     VkPipelineMultisampleStateCreateInfo *out;
15038     unsigned int i;
15039
15040     if (!in || !count) return NULL;
15041
15042     out = conversion_context_alloc(ctx, count * sizeof(*out));
15043     for (i = 0; i < count; i++)
15044     {
15045         convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
15046     }
15047
15048     return out;
15049 }
15050
15051 static inline void convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(const VkPipelineDepthStencilStateCreateInfo32 *in, VkPipelineDepthStencilStateCreateInfo *out)
15052 {
15053     if (!in) return;
15054
15055     out->sType = in->sType;
15056     out->pNext = NULL;
15057     out->flags = in->flags;
15058     out->depthTestEnable = in->depthTestEnable;
15059     out->depthWriteEnable = in->depthWriteEnable;
15060     out->depthCompareOp = in->depthCompareOp;
15061     out->depthBoundsTestEnable = in->depthBoundsTestEnable;
15062     out->stencilTestEnable = in->stencilTestEnable;
15063     out->front = in->front;
15064     out->back = in->back;
15065     out->minDepthBounds = in->minDepthBounds;
15066     out->maxDepthBounds = in->maxDepthBounds;
15067     if (in->pNext)
15068         FIXME("Unexpected pNext\n");
15069 }
15070
15071 static inline const VkPipelineDepthStencilStateCreateInfo *convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDepthStencilStateCreateInfo32 *in, uint32_t count)
15072 {
15073     VkPipelineDepthStencilStateCreateInfo *out;
15074     unsigned int i;
15075
15076     if (!in || !count) return NULL;
15077
15078     out = conversion_context_alloc(ctx, count * sizeof(*out));
15079     for (i = 0; i < count; i++)
15080     {
15081         convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(&in[i], &out[i]);
15082     }
15083
15084     return out;
15085 }
15086
15087 static inline void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, VkPipelineColorBlendStateCreateInfo *out)
15088 {
15089     const VkBaseInStructure32 *in_header;
15090     VkBaseOutStructure *out_header = (void *)out;
15091
15092     if (!in) return;
15093
15094     out->sType = in->sType;
15095     out->pNext = NULL;
15096     out->flags = in->flags;
15097     out->logicOpEnable = in->logicOpEnable;
15098     out->logicOp = in->logicOp;
15099     out->attachmentCount = in->attachmentCount;
15100     out->pAttachments = (const VkPipelineColorBlendAttachmentState *)UlongToPtr(in->pAttachments);
15101     memcpy(out->blendConstants, in->blendConstants, 4 * sizeof(float));
15102
15103     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15104     {
15105         switch (in_header->sType)
15106         {
15107         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
15108         {
15109             VkPipelineColorBlendAdvancedStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15110             const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *in_ext = (const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *)in_header;
15111             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT;
15112             out_ext->pNext = NULL;
15113             out_ext->srcPremultiplied = in_ext->srcPremultiplied;
15114             out_ext->dstPremultiplied = in_ext->dstPremultiplied;
15115             out_ext->blendOverlap = in_ext->blendOverlap;
15116             out_header->pNext = (void *)out_ext;
15117             out_header = (void *)out_ext;
15118             break;
15119         }
15120         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
15121         {
15122             VkPipelineColorWriteCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15123             const VkPipelineColorWriteCreateInfoEXT32 *in_ext = (const VkPipelineColorWriteCreateInfoEXT32 *)in_header;
15124             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT;
15125             out_ext->pNext = NULL;
15126             out_ext->attachmentCount = in_ext->attachmentCount;
15127             out_ext->pColorWriteEnables = (const VkBool32 *)UlongToPtr(in_ext->pColorWriteEnables);
15128             out_header->pNext = (void *)out_ext;
15129             out_header = (void *)out_ext;
15130             break;
15131         }
15132         default:
15133             FIXME("Unhandled sType %u.\n", in_header->sType);
15134             break;
15135         }
15136     }
15137 }
15138
15139 static inline const VkPipelineColorBlendStateCreateInfo *convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, uint32_t count)
15140 {
15141     VkPipelineColorBlendStateCreateInfo *out;
15142     unsigned int i;
15143
15144     if (!in || !count) return NULL;
15145
15146     out = conversion_context_alloc(ctx, count * sizeof(*out));
15147     for (i = 0; i < count; i++)
15148     {
15149         convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
15150     }
15151
15152     return out;
15153 }
15154
15155 static inline void convert_VkPipelineDynamicStateCreateInfo_win32_to_host(const VkPipelineDynamicStateCreateInfo32 *in, VkPipelineDynamicStateCreateInfo *out)
15156 {
15157     if (!in) return;
15158
15159     out->sType = in->sType;
15160     out->pNext = NULL;
15161     out->flags = in->flags;
15162     out->dynamicStateCount = in->dynamicStateCount;
15163     out->pDynamicStates = (const VkDynamicState *)UlongToPtr(in->pDynamicStates);
15164     if (in->pNext)
15165         FIXME("Unexpected pNext\n");
15166 }
15167
15168 static inline const VkPipelineDynamicStateCreateInfo *convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDynamicStateCreateInfo32 *in, uint32_t count)
15169 {
15170     VkPipelineDynamicStateCreateInfo *out;
15171     unsigned int i;
15172
15173     if (!in || !count) return NULL;
15174
15175     out = conversion_context_alloc(ctx, count * sizeof(*out));
15176     for (i = 0; i < count; i++)
15177     {
15178         convert_VkPipelineDynamicStateCreateInfo_win32_to_host(&in[i], &out[i]);
15179     }
15180
15181     return out;
15182 }
15183
15184 #ifdef _WIN64
15185 static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, VkGraphicsPipelineCreateInfo *out)
15186 {
15187     const VkBaseInStructure *in_header;
15188     VkBaseOutStructure *out_header = (void *)out;
15189
15190     if (!in) return;
15191
15192     out->sType = in->sType;
15193     out->pNext = NULL;
15194     out->flags = in->flags;
15195     out->stageCount = in->stageCount;
15196     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
15197     out->pVertexInputState = in->pVertexInputState;
15198     out->pInputAssemblyState = in->pInputAssemblyState;
15199     out->pTessellationState = in->pTessellationState;
15200     out->pViewportState = in->pViewportState;
15201     out->pRasterizationState = in->pRasterizationState;
15202     out->pMultisampleState = in->pMultisampleState;
15203     out->pDepthStencilState = in->pDepthStencilState;
15204     out->pColorBlendState = in->pColorBlendState;
15205     out->pDynamicState = in->pDynamicState;
15206     out->layout = in->layout;
15207     out->renderPass = in->renderPass;
15208     out->subpass = in->subpass;
15209     out->basePipelineHandle = in->basePipelineHandle;
15210     out->basePipelineIndex = in->basePipelineIndex;
15211
15212     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
15213     {
15214         switch (in_header->sType)
15215         {
15216         case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
15217         {
15218             VkPipelineCreateFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15219             const VkPipelineCreateFlags2CreateInfoKHR *in_ext = (const VkPipelineCreateFlags2CreateInfoKHR *)in_header;
15220             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR;
15221             out_ext->pNext = NULL;
15222             out_ext->flags = in_ext->flags;
15223             out_header->pNext = (void *)out_ext;
15224             out_header = (void *)out_ext;
15225             break;
15226         }
15227         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
15228         {
15229             VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15230             const VkGraphicsPipelineShaderGroupsCreateInfoNV *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV *)in_header;
15231             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
15232             out_ext->pNext = NULL;
15233             out_ext->groupCount = in_ext->groupCount;
15234             out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(ctx, in_ext->pGroups, in_ext->groupCount);
15235             out_ext->pipelineCount = in_ext->pipelineCount;
15236             out_ext->pPipelines = in_ext->pPipelines;
15237             out_header->pNext = (void *)out_ext;
15238             out_header = (void *)out_ext;
15239             break;
15240         }
15241         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
15242         {
15243             VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15244             const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header;
15245             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
15246             out_ext->pNext = NULL;
15247             out_ext->flags = in_ext->flags;
15248             out_ext->discardRectangleMode = in_ext->discardRectangleMode;
15249             out_ext->discardRectangleCount = in_ext->discardRectangleCount;
15250             out_ext->pDiscardRectangles = in_ext->pDiscardRectangles;
15251             out_header->pNext = (void *)out_ext;
15252             out_header = (void *)out_ext;
15253             break;
15254         }
15255         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
15256         {
15257             VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15258             const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header;
15259             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
15260             out_ext->pNext = NULL;
15261             out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
15262             out_header->pNext = (void *)out_ext;
15263             out_header = (void *)out_ext;
15264             break;
15265         }
15266         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
15267         {
15268             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15269             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
15270             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
15271             out_ext->pNext = NULL;
15272             out_ext->pPipelineCreationFeedback = in_ext->pPipelineCreationFeedback;
15273             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
15274             out_ext->pPipelineStageCreationFeedbacks = in_ext->pPipelineStageCreationFeedbacks;
15275             out_header->pNext = (void *)out_ext;
15276             out_header = (void *)out_ext;
15277             break;
15278         }
15279         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
15280         {
15281             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15282             const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header;
15283             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
15284             out_ext->pNext = NULL;
15285             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
15286             out_header->pNext = (void *)out_ext;
15287             out_header = (void *)out_ext;
15288             break;
15289         }
15290         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
15291         {
15292             VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15293             const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header;
15294             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
15295             out_ext->pNext = NULL;
15296             out_ext->libraryCount = in_ext->libraryCount;
15297             out_ext->pLibraries = in_ext->pLibraries;
15298             out_header->pNext = (void *)out_ext;
15299             out_header = (void *)out_ext;
15300             break;
15301         }
15302         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
15303         {
15304             VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15305             const VkPipelineFragmentShadingRateStateCreateInfoKHR *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR *)in_header;
15306             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
15307             out_ext->pNext = NULL;
15308             out_ext->fragmentSize = in_ext->fragmentSize;
15309             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
15310             out_header->pNext = (void *)out_ext;
15311             out_header = (void *)out_ext;
15312             break;
15313         }
15314         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
15315         {
15316             VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15317             const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header;
15318             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
15319             out_ext->pNext = NULL;
15320             out_ext->shadingRateType = in_ext->shadingRateType;
15321             out_ext->shadingRate = in_ext->shadingRate;
15322             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
15323             out_header->pNext = (void *)out_ext;
15324             out_header = (void *)out_ext;
15325             break;
15326         }
15327         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
15328         {
15329             VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15330             const VkPipelineRenderingCreateInfo *in_ext = (const VkPipelineRenderingCreateInfo *)in_header;
15331             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
15332             out_ext->pNext = NULL;
15333             out_ext->viewMask = in_ext->viewMask;
15334             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
15335             out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats;
15336             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
15337             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
15338             out_header->pNext = (void *)out_ext;
15339             out_header = (void *)out_ext;
15340             break;
15341         }
15342         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
15343         {
15344             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15345             const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header;
15346             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
15347             out_ext->pNext = NULL;
15348             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
15349             out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
15350             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
15351             out_header->pNext = (void *)out_ext;
15352             out_header = (void *)out_ext;
15353             break;
15354         }
15355         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
15356         {
15357             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15358             const VkMultiviewPerViewAttributesInfoNVX *in_ext = (const VkMultiviewPerViewAttributesInfoNVX *)in_header;
15359             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
15360             out_ext->pNext = NULL;
15361             out_ext->perViewAttributes = in_ext->perViewAttributes;
15362             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
15363             out_header->pNext = (void *)out_ext;
15364             out_header = (void *)out_ext;
15365             break;
15366         }
15367         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
15368         {
15369             VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15370             const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header;
15371             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
15372             out_ext->pNext = NULL;
15373             out_ext->flags = in_ext->flags;
15374             out_header->pNext = (void *)out_ext;
15375             out_header = (void *)out_ext;
15376             break;
15377         }
15378         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
15379         {
15380             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15381             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
15382             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
15383             out_ext->pNext = NULL;
15384             out_ext->storageBuffers = in_ext->storageBuffers;
15385             out_ext->uniformBuffers = in_ext->uniformBuffers;
15386             out_ext->vertexInputs = in_ext->vertexInputs;
15387             out_ext->images = in_ext->images;
15388             out_header->pNext = (void *)out_ext;
15389             out_header = (void *)out_ext;
15390             break;
15391         }
15392         default:
15393             FIXME("Unhandled sType %u.\n", in_header->sType);
15394             break;
15395         }
15396     }
15397 }
15398 #endif /* _WIN64 */
15399
15400 static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, VkGraphicsPipelineCreateInfo *out)
15401 {
15402     const VkBaseInStructure32 *in_header;
15403     VkBaseOutStructure *out_header = (void *)out;
15404
15405     if (!in) return;
15406
15407     out->sType = in->sType;
15408     out->pNext = NULL;
15409     out->flags = in->flags;
15410     out->stageCount = in->stageCount;
15411     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
15412     out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineVertexInputStateCreateInfo32 *)UlongToPtr(in->pVertexInputState), 1);
15413     out->pInputAssemblyState = convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineInputAssemblyStateCreateInfo32 *)UlongToPtr(in->pInputAssemblyState), 1);
15414     out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineTessellationStateCreateInfo32 *)UlongToPtr(in->pTessellationState), 1);
15415     out->pViewportState = convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineViewportStateCreateInfo32 *)UlongToPtr(in->pViewportState), 1);
15416     out->pRasterizationState = convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineRasterizationStateCreateInfo32 *)UlongToPtr(in->pRasterizationState), 1);
15417     out->pMultisampleState = convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineMultisampleStateCreateInfo32 *)UlongToPtr(in->pMultisampleState), 1);
15418     out->pDepthStencilState = convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDepthStencilStateCreateInfo32 *)UlongToPtr(in->pDepthStencilState), 1);
15419     out->pColorBlendState = convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineColorBlendStateCreateInfo32 *)UlongToPtr(in->pColorBlendState), 1);
15420     out->pDynamicState = convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDynamicStateCreateInfo32 *)UlongToPtr(in->pDynamicState), 1);
15421     out->layout = in->layout;
15422     out->renderPass = in->renderPass;
15423     out->subpass = in->subpass;
15424     out->basePipelineHandle = in->basePipelineHandle;
15425     out->basePipelineIndex = in->basePipelineIndex;
15426
15427     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15428     {
15429         switch (in_header->sType)
15430         {
15431         case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
15432         {
15433             VkPipelineCreateFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15434             const VkPipelineCreateFlags2CreateInfoKHR32 *in_ext = (const VkPipelineCreateFlags2CreateInfoKHR32 *)in_header;
15435             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR;
15436             out_ext->pNext = NULL;
15437             out_ext->flags = in_ext->flags;
15438             out_header->pNext = (void *)out_ext;
15439             out_header = (void *)out_ext;
15440             break;
15441         }
15442         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
15443         {
15444             VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15445             const VkGraphicsPipelineShaderGroupsCreateInfoNV32 *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV32 *)in_header;
15446             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
15447             out_ext->pNext = NULL;
15448             out_ext->groupCount = in_ext->groupCount;
15449             out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(ctx, (const VkGraphicsShaderGroupCreateInfoNV32 *)UlongToPtr(in_ext->pGroups), in_ext->groupCount);
15450             out_ext->pipelineCount = in_ext->pipelineCount;
15451             out_ext->pPipelines = (const VkPipeline *)UlongToPtr(in_ext->pPipelines);
15452             out_header->pNext = (void *)out_ext;
15453             out_header = (void *)out_ext;
15454             break;
15455         }
15456         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
15457         {
15458             VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15459             const VkPipelineDiscardRectangleStateCreateInfoEXT32 *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT32 *)in_header;
15460             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
15461             out_ext->pNext = NULL;
15462             out_ext->flags = in_ext->flags;
15463             out_ext->discardRectangleMode = in_ext->discardRectangleMode;
15464             out_ext->discardRectangleCount = in_ext->discardRectangleCount;
15465             out_ext->pDiscardRectangles = (const VkRect2D *)UlongToPtr(in_ext->pDiscardRectangles);
15466             out_header->pNext = (void *)out_ext;
15467             out_header = (void *)out_ext;
15468             break;
15469         }
15470         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
15471         {
15472             VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15473             const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *)in_header;
15474             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
15475             out_ext->pNext = NULL;
15476             out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
15477             out_header->pNext = (void *)out_ext;
15478             out_header = (void *)out_ext;
15479             break;
15480         }
15481         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
15482         {
15483             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15484             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
15485             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
15486             out_ext->pNext = NULL;
15487             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
15488             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
15489             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
15490             out_header->pNext = (void *)out_ext;
15491             out_header = (void *)out_ext;
15492             break;
15493         }
15494         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
15495         {
15496             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15497             const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header;
15498             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
15499             out_ext->pNext = NULL;
15500             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
15501             out_header->pNext = (void *)out_ext;
15502             out_header = (void *)out_ext;
15503             break;
15504         }
15505         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
15506         {
15507             VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15508             const VkPipelineLibraryCreateInfoKHR32 *in_ext = (const VkPipelineLibraryCreateInfoKHR32 *)in_header;
15509             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
15510             out_ext->pNext = NULL;
15511             out_ext->libraryCount = in_ext->libraryCount;
15512             out_ext->pLibraries = (const VkPipeline *)UlongToPtr(in_ext->pLibraries);
15513             out_header->pNext = (void *)out_ext;
15514             out_header = (void *)out_ext;
15515             break;
15516         }
15517         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
15518         {
15519             VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15520             const VkPipelineFragmentShadingRateStateCreateInfoKHR32 *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR32 *)in_header;
15521             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
15522             out_ext->pNext = NULL;
15523             out_ext->fragmentSize = in_ext->fragmentSize;
15524             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
15525             out_header->pNext = (void *)out_ext;
15526             out_header = (void *)out_ext;
15527             break;
15528         }
15529         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
15530         {
15531             VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15532             const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *)in_header;
15533             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
15534             out_ext->pNext = NULL;
15535             out_ext->shadingRateType = in_ext->shadingRateType;
15536             out_ext->shadingRate = in_ext->shadingRate;
15537             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
15538             out_header->pNext = (void *)out_ext;
15539             out_header = (void *)out_ext;
15540             break;
15541         }
15542         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
15543         {
15544             VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15545             const VkPipelineRenderingCreateInfo32 *in_ext = (const VkPipelineRenderingCreateInfo32 *)in_header;
15546             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
15547             out_ext->pNext = NULL;
15548             out_ext->viewMask = in_ext->viewMask;
15549             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
15550             out_ext->pColorAttachmentFormats = (const VkFormat *)UlongToPtr(in_ext->pColorAttachmentFormats);
15551             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
15552             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
15553             out_header->pNext = (void *)out_ext;
15554             out_header = (void *)out_ext;
15555             break;
15556         }
15557         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
15558         {
15559             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15560             const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header;
15561             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
15562             out_ext->pNext = NULL;
15563             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
15564             out_ext->pColorAttachmentSamples = (const VkSampleCountFlagBits *)UlongToPtr(in_ext->pColorAttachmentSamples);
15565             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
15566             out_header->pNext = (void *)out_ext;
15567             out_header = (void *)out_ext;
15568             break;
15569         }
15570         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
15571         {
15572             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15573             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
15574             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
15575             out_ext->pNext = NULL;
15576             out_ext->perViewAttributes = in_ext->perViewAttributes;
15577             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
15578             out_header->pNext = (void *)out_ext;
15579             out_header = (void *)out_ext;
15580             break;
15581         }
15582         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
15583         {
15584             VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15585             const VkGraphicsPipelineLibraryCreateInfoEXT32 *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT32 *)in_header;
15586             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
15587             out_ext->pNext = NULL;
15588             out_ext->flags = in_ext->flags;
15589             out_header->pNext = (void *)out_ext;
15590             out_header = (void *)out_ext;
15591             break;
15592         }
15593         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
15594         {
15595             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15596             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
15597             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
15598             out_ext->pNext = NULL;
15599             out_ext->storageBuffers = in_ext->storageBuffers;
15600             out_ext->uniformBuffers = in_ext->uniformBuffers;
15601             out_ext->vertexInputs = in_ext->vertexInputs;
15602             out_ext->images = in_ext->images;
15603             out_header->pNext = (void *)out_ext;
15604             out_header = (void *)out_ext;
15605             break;
15606         }
15607         default:
15608             FIXME("Unhandled sType %u.\n", in_header->sType);
15609             break;
15610         }
15611     }
15612 }
15613
15614 static inline void convert_VkGraphicsPipelineCreateInfo_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out)
15615 {
15616     const VkBaseInStructure *in_header;
15617     VkBaseOutStructure32 *out_header = (void *)out;
15618
15619     if (!in) return;
15620
15621
15622     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
15623     {
15624         switch (in_header->sType)
15625         {
15626         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
15627         {
15628             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
15629             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
15630             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
15631             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
15632             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
15633             out_header = (void *)out_ext;
15634             break;
15635         }
15636         default:
15637             break;
15638         }
15639     }
15640 }
15641
15642 #ifdef _WIN64
15643 static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, uint32_t count)
15644 {
15645     VkGraphicsPipelineCreateInfo *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_VkGraphicsPipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
15654     }
15655
15656     return out;
15657 }
15658 #endif /* _WIN64 */
15659
15660 static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, uint32_t count)
15661 {
15662     VkGraphicsPipelineCreateInfo *out;
15663     unsigned int i;
15664
15665     if (!in || !count) return NULL;
15666
15667     out = conversion_context_alloc(ctx, count * sizeof(*out));
15668     for (i = 0; i < count; i++)
15669     {
15670         convert_VkGraphicsPipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
15671     }
15672
15673     return out;
15674 }
15675
15676 static inline void convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out, uint32_t count)
15677 {
15678     unsigned int i;
15679
15680     if (!in) return;
15681
15682     for (i = 0; i < count; i++)
15683     {
15684         convert_VkGraphicsPipelineCreateInfo_host_to_win32(&in[i], &out[i]);
15685     }
15686 }
15687
15688 static inline void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, VkImageCreateInfo *out)
15689 {
15690     const VkBaseInStructure32 *in_header;
15691     VkBaseOutStructure *out_header = (void *)out;
15692
15693     if (!in) return;
15694
15695     out->sType = in->sType;
15696     out->pNext = NULL;
15697     out->flags = in->flags;
15698     out->imageType = in->imageType;
15699     out->format = in->format;
15700     out->extent = in->extent;
15701     out->mipLevels = in->mipLevels;
15702     out->arrayLayers = in->arrayLayers;
15703     out->samples = in->samples;
15704     out->tiling = in->tiling;
15705     out->usage = in->usage;
15706     out->sharingMode = in->sharingMode;
15707     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
15708     out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);
15709     out->initialLayout = in->initialLayout;
15710
15711     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15712     {
15713         switch (in_header->sType)
15714         {
15715         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
15716         {
15717             VkDedicatedAllocationImageCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15718             const VkDedicatedAllocationImageCreateInfoNV32 *in_ext = (const VkDedicatedAllocationImageCreateInfoNV32 *)in_header;
15719             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV;
15720             out_ext->pNext = NULL;
15721             out_ext->dedicatedAllocation = in_ext->dedicatedAllocation;
15722             out_header->pNext = (void *)out_ext;
15723             out_header = (void *)out_ext;
15724             break;
15725         }
15726         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
15727         {
15728             VkExternalMemoryImageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15729             const VkExternalMemoryImageCreateInfo32 *in_ext = (const VkExternalMemoryImageCreateInfo32 *)in_header;
15730             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
15731             out_ext->pNext = NULL;
15732             out_ext->handleTypes = in_ext->handleTypes;
15733             out_header->pNext = (void *)out_ext;
15734             out_header = (void *)out_ext;
15735             break;
15736         }
15737         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
15738         {
15739             VkImageSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15740             const VkImageSwapchainCreateInfoKHR32 *in_ext = (const VkImageSwapchainCreateInfoKHR32 *)in_header;
15741             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR;
15742             out_ext->pNext = NULL;
15743             out_ext->swapchain = in_ext->swapchain;
15744             out_header->pNext = (void *)out_ext;
15745             out_header = (void *)out_ext;
15746             break;
15747         }
15748         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
15749         {
15750             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15751             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
15752             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
15753             out_ext->pNext = NULL;
15754             out_ext->viewFormatCount = in_ext->viewFormatCount;
15755             out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
15756             out_header->pNext = (void *)out_ext;
15757             out_header = (void *)out_ext;
15758             break;
15759         }
15760         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
15761         {
15762             VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15763             const VkImageStencilUsageCreateInfo32 *in_ext = (const VkImageStencilUsageCreateInfo32 *)in_header;
15764             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
15765             out_ext->pNext = NULL;
15766             out_ext->stencilUsage = in_ext->stencilUsage;
15767             out_header->pNext = (void *)out_ext;
15768             out_header = (void *)out_ext;
15769             break;
15770         }
15771         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
15772         {
15773             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15774             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
15775             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
15776             out_ext->pNext = NULL;
15777             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
15778             out_header->pNext = (void *)out_ext;
15779             out_header = (void *)out_ext;
15780             break;
15781         }
15782         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
15783         {
15784             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15785             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
15786             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
15787             out_ext->pNext = NULL;
15788             out_ext->flags = in_ext->flags;
15789             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
15790             out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
15791             out_header->pNext = (void *)out_ext;
15792             out_header = (void *)out_ext;
15793             break;
15794         }
15795         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
15796         {
15797             VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15798             const VkOpticalFlowImageFormatInfoNV32 *in_ext = (const VkOpticalFlowImageFormatInfoNV32 *)in_header;
15799             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
15800             out_ext->pNext = NULL;
15801             out_ext->usage = in_ext->usage;
15802             out_header->pNext = (void *)out_ext;
15803             out_header = (void *)out_ext;
15804             break;
15805         }
15806         default:
15807             FIXME("Unhandled sType %u.\n", in_header->sType);
15808             break;
15809         }
15810     }
15811 }
15812
15813 static inline void convert_VkImageViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageViewCreateInfo32 *in, VkImageViewCreateInfo *out)
15814 {
15815     const VkBaseInStructure32 *in_header;
15816     VkBaseOutStructure *out_header = (void *)out;
15817
15818     if (!in) return;
15819
15820     out->sType = in->sType;
15821     out->pNext = NULL;
15822     out->flags = in->flags;
15823     out->image = in->image;
15824     out->viewType = in->viewType;
15825     out->format = in->format;
15826     out->components = in->components;
15827     out->subresourceRange = in->subresourceRange;
15828
15829     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15830     {
15831         switch (in_header->sType)
15832         {
15833         case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
15834         {
15835             VkImageViewUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15836             const VkImageViewUsageCreateInfo32 *in_ext = (const VkImageViewUsageCreateInfo32 *)in_header;
15837             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
15838             out_ext->pNext = NULL;
15839             out_ext->usage = in_ext->usage;
15840             out_header->pNext = (void *)out_ext;
15841             out_header = (void *)out_ext;
15842             break;
15843         }
15844         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
15845         {
15846             VkImageViewSlicedCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15847             const VkImageViewSlicedCreateInfoEXT32 *in_ext = (const VkImageViewSlicedCreateInfoEXT32 *)in_header;
15848             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT;
15849             out_ext->pNext = NULL;
15850             out_ext->sliceOffset = in_ext->sliceOffset;
15851             out_ext->sliceCount = in_ext->sliceCount;
15852             out_header->pNext = (void *)out_ext;
15853             out_header = (void *)out_ext;
15854             break;
15855         }
15856         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
15857         {
15858             VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15859             const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
15860             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
15861             out_ext->pNext = NULL;
15862             out_ext->conversion = in_ext->conversion;
15863             out_header->pNext = (void *)out_ext;
15864             out_header = (void *)out_ext;
15865             break;
15866         }
15867         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
15868         {
15869             VkImageViewASTCDecodeModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15870             const VkImageViewASTCDecodeModeEXT32 *in_ext = (const VkImageViewASTCDecodeModeEXT32 *)in_header;
15871             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT;
15872             out_ext->pNext = NULL;
15873             out_ext->decodeMode = in_ext->decodeMode;
15874             out_header->pNext = (void *)out_ext;
15875             out_header = (void *)out_ext;
15876             break;
15877         }
15878         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
15879         {
15880             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15881             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
15882             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
15883             out_ext->pNext = NULL;
15884             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
15885             out_header->pNext = (void *)out_ext;
15886             out_header = (void *)out_ext;
15887             break;
15888         }
15889         case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
15890         {
15891             VkImageViewMinLodCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15892             const VkImageViewMinLodCreateInfoEXT32 *in_ext = (const VkImageViewMinLodCreateInfoEXT32 *)in_header;
15893             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT;
15894             out_ext->pNext = NULL;
15895             out_ext->minLod = in_ext->minLod;
15896             out_header->pNext = (void *)out_ext;
15897             out_header = (void *)out_ext;
15898             break;
15899         }
15900         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
15901         {
15902             VkImageViewSampleWeightCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15903             const VkImageViewSampleWeightCreateInfoQCOM32 *in_ext = (const VkImageViewSampleWeightCreateInfoQCOM32 *)in_header;
15904             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM;
15905             out_ext->pNext = NULL;
15906             out_ext->filterCenter = in_ext->filterCenter;
15907             out_ext->filterSize = in_ext->filterSize;
15908             out_ext->numPhases = in_ext->numPhases;
15909             out_header->pNext = (void *)out_ext;
15910             out_header = (void *)out_ext;
15911             break;
15912         }
15913         default:
15914             FIXME("Unhandled sType %u.\n", in_header->sType);
15915             break;
15916         }
15917     }
15918 }
15919
15920 static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const VkIndirectCommandsLayoutTokenNV32 *in, VkIndirectCommandsLayoutTokenNV *out)
15921 {
15922     if (!in) return;
15923
15924     out->sType = in->sType;
15925     out->pNext = NULL;
15926     out->tokenType = in->tokenType;
15927     out->stream = in->stream;
15928     out->offset = in->offset;
15929     out->vertexBindingUnit = in->vertexBindingUnit;
15930     out->vertexDynamicStride = in->vertexDynamicStride;
15931     out->pushconstantPipelineLayout = in->pushconstantPipelineLayout;
15932     out->pushconstantShaderStageFlags = in->pushconstantShaderStageFlags;
15933     out->pushconstantOffset = in->pushconstantOffset;
15934     out->pushconstantSize = in->pushconstantSize;
15935     out->indirectStateFlags = in->indirectStateFlags;
15936     out->indexTypeCount = in->indexTypeCount;
15937     out->pIndexTypes = (const VkIndexType *)UlongToPtr(in->pIndexTypes);
15938     out->pIndexTypeValues = (const uint32_t *)UlongToPtr(in->pIndexTypeValues);
15939     if (in->pNext)
15940         FIXME("Unexpected pNext\n");
15941 }
15942
15943 static inline const VkIndirectCommandsLayoutTokenNV *convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenNV32 *in, uint32_t count)
15944 {
15945     VkIndirectCommandsLayoutTokenNV *out;
15946     unsigned int i;
15947
15948     if (!in || !count) return NULL;
15949
15950     out = conversion_context_alloc(ctx, count * sizeof(*out));
15951     for (i = 0; i < count; i++)
15952     {
15953         convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(&in[i], &out[i]);
15954     }
15955
15956     return out;
15957 }
15958
15959 static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoNV32 *in, VkIndirectCommandsLayoutCreateInfoNV *out)
15960 {
15961     if (!in) return;
15962
15963     out->sType = in->sType;
15964     out->pNext = NULL;
15965     out->flags = in->flags;
15966     out->pipelineBindPoint = in->pipelineBindPoint;
15967     out->tokenCount = in->tokenCount;
15968     out->pTokens = convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(ctx, (const VkIndirectCommandsLayoutTokenNV32 *)UlongToPtr(in->pTokens), in->tokenCount);
15969     out->streamCount = in->streamCount;
15970     out->pStreamStrides = (const uint32_t *)UlongToPtr(in->pStreamStrides);
15971     if (in->pNext)
15972         FIXME("Unexpected pNext\n");
15973 }
15974
15975 static inline void convert_VkApplicationInfo_win32_to_host(const VkApplicationInfo32 *in, VkApplicationInfo *out)
15976 {
15977     if (!in) return;
15978
15979     out->sType = in->sType;
15980     out->pNext = NULL;
15981     out->pApplicationName = (const char *)UlongToPtr(in->pApplicationName);
15982     out->applicationVersion = in->applicationVersion;
15983     out->pEngineName = (const char *)UlongToPtr(in->pEngineName);
15984     out->engineVersion = in->engineVersion;
15985     out->apiVersion = in->apiVersion;
15986     if (in->pNext)
15987         FIXME("Unexpected pNext\n");
15988 }
15989
15990 static inline const VkApplicationInfo *convert_VkApplicationInfo_array_win32_to_host(struct conversion_context *ctx, const VkApplicationInfo32 *in, uint32_t count)
15991 {
15992     VkApplicationInfo *out;
15993     unsigned int i;
15994
15995     if (!in || !count) return NULL;
15996
15997     out = conversion_context_alloc(ctx, count * sizeof(*out));
15998     for (i = 0; i < count; i++)
15999     {
16000         convert_VkApplicationInfo_win32_to_host(&in[i], &out[i]);
16001     }
16002
16003     return out;
16004 }
16005
16006 #ifdef _WIN64
16007 static inline void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo *in, VkInstanceCreateInfo *out)
16008 {
16009     const VkBaseInStructure *in_header;
16010     VkBaseOutStructure *out_header = (void *)out;
16011
16012     if (!in) return;
16013
16014     out->sType = in->sType;
16015     out->pNext = NULL;
16016     out->flags = in->flags;
16017     out->pApplicationInfo = in->pApplicationInfo;
16018     out->enabledLayerCount = in->enabledLayerCount;
16019     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
16020     out->enabledExtensionCount = in->enabledExtensionCount;
16021     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
16022
16023     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
16024     {
16025         switch (in_header->sType)
16026         {
16027         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
16028             break;
16029         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
16030         {
16031             VkDebugReportCallbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16032             const VkDebugReportCallbackCreateInfoEXT *in_ext = (const VkDebugReportCallbackCreateInfoEXT *)in_header;
16033             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
16034             out_ext->pNext = NULL;
16035             out_ext->flags = in_ext->flags;
16036             out_ext->pfnCallback = in_ext->pfnCallback;
16037             out_ext->pUserData = in_ext->pUserData;
16038             out_header->pNext = (void *)out_ext;
16039             out_header = (void *)out_ext;
16040             break;
16041         }
16042         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
16043         {
16044             VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16045             const VkValidationFlagsEXT *in_ext = (const VkValidationFlagsEXT *)in_header;
16046             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
16047             out_ext->pNext = NULL;
16048             out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
16049             out_ext->pDisabledValidationChecks = in_ext->pDisabledValidationChecks;
16050             out_header->pNext = (void *)out_ext;
16051             out_header = (void *)out_ext;
16052             break;
16053         }
16054         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
16055         {
16056             VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16057             const VkValidationFeaturesEXT *in_ext = (const VkValidationFeaturesEXT *)in_header;
16058             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
16059             out_ext->pNext = NULL;
16060             out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount;
16061             out_ext->pEnabledValidationFeatures = in_ext->pEnabledValidationFeatures;
16062             out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount;
16063             out_ext->pDisabledValidationFeatures = in_ext->pDisabledValidationFeatures;
16064             out_header->pNext = (void *)out_ext;
16065             out_header = (void *)out_ext;
16066             break;
16067         }
16068         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
16069         {
16070             VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16071             const VkDebugUtilsMessengerCreateInfoEXT *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT *)in_header;
16072             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
16073             out_ext->pNext = NULL;
16074             out_ext->flags = in_ext->flags;
16075             out_ext->messageSeverity = in_ext->messageSeverity;
16076             out_ext->messageType = in_ext->messageType;
16077             out_ext->pfnUserCallback = in_ext->pfnUserCallback;
16078             out_ext->pUserData = in_ext->pUserData;
16079             out_header->pNext = (void *)out_ext;
16080             out_header = (void *)out_ext;
16081             break;
16082         }
16083         default:
16084             FIXME("Unhandled sType %u.\n", in_header->sType);
16085             break;
16086         }
16087     }
16088 }
16089 #endif /* _WIN64 */
16090
16091 static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo32 *in, VkInstanceCreateInfo *out)
16092 {
16093     const VkBaseInStructure32 *in_header;
16094     VkBaseOutStructure *out_header = (void *)out;
16095
16096     if (!in) return;
16097
16098     out->sType = in->sType;
16099     out->pNext = NULL;
16100     out->flags = in->flags;
16101     out->pApplicationInfo = convert_VkApplicationInfo_array_win32_to_host(ctx, (const VkApplicationInfo32 *)UlongToPtr(in->pApplicationInfo), 1);
16102     out->enabledLayerCount = in->enabledLayerCount;
16103     out->ppEnabledLayerNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledLayerNames), in->enabledLayerCount);
16104     out->enabledExtensionCount = in->enabledExtensionCount;
16105     out->ppEnabledExtensionNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledExtensionNames), in->enabledExtensionCount);
16106
16107     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16108     {
16109         switch (in_header->sType)
16110         {
16111         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
16112             break;
16113         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
16114         {
16115             VkDebugReportCallbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16116             const VkDebugReportCallbackCreateInfoEXT32 *in_ext = (const VkDebugReportCallbackCreateInfoEXT32 *)in_header;
16117             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
16118             out_ext->pNext = NULL;
16119             out_ext->flags = in_ext->flags;
16120             out_ext->pfnCallback = in_ext->pfnCallback;
16121             out_ext->pUserData = (void *)UlongToPtr(in_ext->pUserData);
16122             out_header->pNext = (void *)out_ext;
16123             out_header = (void *)out_ext;
16124             break;
16125         }
16126         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
16127         {
16128             VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16129             const VkValidationFlagsEXT32 *in_ext = (const VkValidationFlagsEXT32 *)in_header;
16130             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
16131             out_ext->pNext = NULL;
16132             out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
16133             out_ext->pDisabledValidationChecks = (const VkValidationCheckEXT *)UlongToPtr(in_ext->pDisabledValidationChecks);
16134             out_header->pNext = (void *)out_ext;
16135             out_header = (void *)out_ext;
16136             break;
16137         }
16138         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
16139         {
16140             VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16141             const VkValidationFeaturesEXT32 *in_ext = (const VkValidationFeaturesEXT32 *)in_header;
16142             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
16143             out_ext->pNext = NULL;
16144             out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount;
16145             out_ext->pEnabledValidationFeatures = (const VkValidationFeatureEnableEXT *)UlongToPtr(in_ext->pEnabledValidationFeatures);
16146             out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount;
16147             out_ext->pDisabledValidationFeatures = (const VkValidationFeatureDisableEXT *)UlongToPtr(in_ext->pDisabledValidationFeatures);
16148             out_header->pNext = (void *)out_ext;
16149             out_header = (void *)out_ext;
16150             break;
16151         }
16152         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
16153         {
16154             VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16155             const VkDebugUtilsMessengerCreateInfoEXT32 *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT32 *)in_header;
16156             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
16157             out_ext->pNext = NULL;
16158             out_ext->flags = in_ext->flags;
16159             out_ext->messageSeverity = in_ext->messageSeverity;
16160             out_ext->messageType = in_ext->messageType;
16161             out_ext->pfnUserCallback = in_ext->pfnUserCallback;
16162             out_ext->pUserData = (void *)UlongToPtr(in_ext->pUserData);
16163             out_header->pNext = (void *)out_ext;
16164             out_header = (void *)out_ext;
16165             break;
16166         }
16167         default:
16168             FIXME("Unhandled sType %u.\n", in_header->sType);
16169             break;
16170         }
16171     }
16172 }
16173
16174 static inline void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicromapCreateInfoEXT32 *in, VkMicromapCreateInfoEXT *out)
16175 {
16176     if (!in) return;
16177
16178     out->sType = in->sType;
16179     out->pNext = NULL;
16180     out->createFlags = in->createFlags;
16181     out->buffer = in->buffer;
16182     out->offset = in->offset;
16183     out->size = in->size;
16184     out->type = in->type;
16185     out->deviceAddress = in->deviceAddress;
16186     if (in->pNext)
16187         FIXME("Unexpected pNext\n");
16188 }
16189
16190 static inline void convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowSessionCreateInfoNV32 *in, VkOpticalFlowSessionCreateInfoNV *out)
16191 {
16192     const VkBaseInStructure32 *in_header;
16193     VkBaseOutStructure *out_header = (void *)out;
16194
16195     if (!in) return;
16196
16197     out->sType = in->sType;
16198     out->pNext = NULL;
16199     out->width = in->width;
16200     out->height = in->height;
16201     out->imageFormat = in->imageFormat;
16202     out->flowVectorFormat = in->flowVectorFormat;
16203     out->costFormat = in->costFormat;
16204     out->outputGridSize = in->outputGridSize;
16205     out->hintGridSize = in->hintGridSize;
16206     out->performanceLevel = in->performanceLevel;
16207     out->flags = in->flags;
16208
16209     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16210     {
16211         switch (in_header->sType)
16212         {
16213         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
16214         {
16215             VkOpticalFlowSessionCreatePrivateDataInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16216             const VkOpticalFlowSessionCreatePrivateDataInfoNV32 *in_ext = (const VkOpticalFlowSessionCreatePrivateDataInfoNV32 *)in_header;
16217             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV;
16218             out_ext->pNext = NULL;
16219             out_ext->id = in_ext->id;
16220             out_ext->size = in_ext->size;
16221             out_ext->pPrivateData = (const void *)UlongToPtr(in_ext->pPrivateData);
16222             out_header->pNext = (void *)out_ext;
16223             out_header = (void *)out_ext;
16224             break;
16225         }
16226         default:
16227             FIXME("Unhandled sType %u.\n", in_header->sType);
16228             break;
16229         }
16230     }
16231 }
16232
16233 static inline void convert_VkPipelineCacheCreateInfo_win32_to_host(const VkPipelineCacheCreateInfo32 *in, VkPipelineCacheCreateInfo *out)
16234 {
16235     if (!in) return;
16236
16237     out->sType = in->sType;
16238     out->pNext = NULL;
16239     out->flags = in->flags;
16240     out->initialDataSize = in->initialDataSize;
16241     out->pInitialData = (const void *)UlongToPtr(in->pInitialData);
16242     if (in->pNext)
16243         FIXME("Unexpected pNext\n");
16244 }
16245
16246 static inline void convert_VkPipelineLayoutCreateInfo_win32_to_host(const VkPipelineLayoutCreateInfo32 *in, VkPipelineLayoutCreateInfo *out)
16247 {
16248     if (!in) return;
16249
16250     out->sType = in->sType;
16251     out->pNext = NULL;
16252     out->flags = in->flags;
16253     out->setLayoutCount = in->setLayoutCount;
16254     out->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in->pSetLayouts);
16255     out->pushConstantRangeCount = in->pushConstantRangeCount;
16256     out->pPushConstantRanges = (const VkPushConstantRange *)UlongToPtr(in->pPushConstantRanges);
16257     if (in->pNext)
16258         FIXME("Unexpected pNext\n");
16259 }
16260
16261 static inline void convert_VkPrivateDataSlotCreateInfo_win32_to_host(const VkPrivateDataSlotCreateInfo32 *in, VkPrivateDataSlotCreateInfo *out)
16262 {
16263     if (!in) return;
16264
16265     out->sType = in->sType;
16266     out->pNext = NULL;
16267     out->flags = in->flags;
16268     if (in->pNext)
16269         FIXME("Unexpected pNext\n");
16270 }
16271
16272 static inline void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkQueryPoolCreateInfo32 *in, VkQueryPoolCreateInfo *out)
16273 {
16274     const VkBaseInStructure32 *in_header;
16275     VkBaseOutStructure *out_header = (void *)out;
16276
16277     if (!in) return;
16278
16279     out->sType = in->sType;
16280     out->pNext = NULL;
16281     out->flags = in->flags;
16282     out->queryType = in->queryType;
16283     out->queryCount = in->queryCount;
16284     out->pipelineStatistics = in->pipelineStatistics;
16285
16286     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16287     {
16288         switch (in_header->sType)
16289         {
16290         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
16291         {
16292             VkQueryPoolPerformanceCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16293             const VkQueryPoolPerformanceCreateInfoKHR32 *in_ext = (const VkQueryPoolPerformanceCreateInfoKHR32 *)in_header;
16294             out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR;
16295             out_ext->pNext = NULL;
16296             out_ext->queueFamilyIndex = in_ext->queueFamilyIndex;
16297             out_ext->counterIndexCount = in_ext->counterIndexCount;
16298             out_ext->pCounterIndices = (const uint32_t *)UlongToPtr(in_ext->pCounterIndices);
16299             out_header->pNext = (void *)out_ext;
16300             out_header = (void *)out_ext;
16301             break;
16302         }
16303         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
16304         {
16305             VkQueryPoolPerformanceQueryCreateInfoINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16306             const VkQueryPoolPerformanceQueryCreateInfoINTEL32 *in_ext = (const VkQueryPoolPerformanceQueryCreateInfoINTEL32 *)in_header;
16307             out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL;
16308             out_ext->pNext = NULL;
16309             out_ext->performanceCountersSampling = in_ext->performanceCountersSampling;
16310             out_header->pNext = (void *)out_ext;
16311             out_header = (void *)out_ext;
16312             break;
16313         }
16314         default:
16315             FIXME("Unhandled sType %u.\n", in_header->sType);
16316             break;
16317         }
16318     }
16319 }
16320
16321 static inline void convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(const VkRayTracingShaderGroupCreateInfoKHR32 *in, VkRayTracingShaderGroupCreateInfoKHR *out)
16322 {
16323     if (!in) return;
16324
16325     out->sType = in->sType;
16326     out->pNext = NULL;
16327     out->type = in->type;
16328     out->generalShader = in->generalShader;
16329     out->closestHitShader = in->closestHitShader;
16330     out->anyHitShader = in->anyHitShader;
16331     out->intersectionShader = in->intersectionShader;
16332     out->pShaderGroupCaptureReplayHandle = (const void *)UlongToPtr(in->pShaderGroupCaptureReplayHandle);
16333     if (in->pNext)
16334         FIXME("Unexpected pNext\n");
16335 }
16336
16337 static inline const VkRayTracingShaderGroupCreateInfoKHR *convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoKHR32 *in, uint32_t count)
16338 {
16339     VkRayTracingShaderGroupCreateInfoKHR *out;
16340     unsigned int i;
16341
16342     if (!in || !count) return NULL;
16343
16344     out = conversion_context_alloc(ctx, count * sizeof(*out));
16345     for (i = 0; i < count; i++)
16346     {
16347         convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(&in[i], &out[i]);
16348     }
16349
16350     return out;
16351 }
16352
16353 static inline void convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(const VkPipelineLibraryCreateInfoKHR32 *in, VkPipelineLibraryCreateInfoKHR *out)
16354 {
16355     if (!in) return;
16356
16357     out->sType = in->sType;
16358     out->pNext = NULL;
16359     out->libraryCount = in->libraryCount;
16360     out->pLibraries = (const VkPipeline *)UlongToPtr(in->pLibraries);
16361     if (in->pNext)
16362         FIXME("Unexpected pNext\n");
16363 }
16364
16365 static inline const VkPipelineLibraryCreateInfoKHR *convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineLibraryCreateInfoKHR32 *in, uint32_t count)
16366 {
16367     VkPipelineLibraryCreateInfoKHR *out;
16368     unsigned int i;
16369
16370     if (!in || !count) return NULL;
16371
16372     out = conversion_context_alloc(ctx, count * sizeof(*out));
16373     for (i = 0; i < count; i++)
16374     {
16375         convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(&in[i], &out[i]);
16376     }
16377
16378     return out;
16379 }
16380
16381 static inline void convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_host(const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, VkRayTracingPipelineInterfaceCreateInfoKHR *out)
16382 {
16383     if (!in) return;
16384
16385     out->sType = in->sType;
16386     out->pNext = NULL;
16387     out->maxPipelineRayPayloadSize = in->maxPipelineRayPayloadSize;
16388     out->maxPipelineRayHitAttributeSize = in->maxPipelineRayHitAttributeSize;
16389     if (in->pNext)
16390         FIXME("Unexpected pNext\n");
16391 }
16392
16393 static inline const VkRayTracingPipelineInterfaceCreateInfoKHR *convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, uint32_t count)
16394 {
16395     VkRayTracingPipelineInterfaceCreateInfoKHR *out;
16396     unsigned int i;
16397
16398     if (!in || !count) return NULL;
16399
16400     out = conversion_context_alloc(ctx, count * sizeof(*out));
16401     for (i = 0; i < count; i++)
16402     {
16403         convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_host(&in[i], &out[i]);
16404     }
16405
16406     return out;
16407 }
16408
16409 #ifdef _WIN64
16410 static inline void convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, VkRayTracingPipelineCreateInfoKHR *out)
16411 {
16412     if (!in) return;
16413
16414     out->sType = in->sType;
16415     out->pNext = in->pNext;
16416     out->flags = in->flags;
16417     out->stageCount = in->stageCount;
16418     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
16419     out->groupCount = in->groupCount;
16420     out->pGroups = in->pGroups;
16421     out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
16422     out->pLibraryInfo = in->pLibraryInfo;
16423     out->pLibraryInterface = in->pLibraryInterface;
16424     out->pDynamicState = in->pDynamicState;
16425     out->layout = in->layout;
16426     out->basePipelineHandle = in->basePipelineHandle;
16427     out->basePipelineIndex = in->basePipelineIndex;
16428 }
16429 #endif /* _WIN64 */
16430
16431 static inline void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, VkRayTracingPipelineCreateInfoKHR *out)
16432 {
16433     const VkBaseInStructure32 *in_header;
16434     VkBaseOutStructure *out_header = (void *)out;
16435
16436     if (!in) return;
16437
16438     out->sType = in->sType;
16439     out->pNext = NULL;
16440     out->flags = in->flags;
16441     out->stageCount = in->stageCount;
16442     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
16443     out->groupCount = in->groupCount;
16444     out->pGroups = convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(ctx, (const VkRayTracingShaderGroupCreateInfoKHR32 *)UlongToPtr(in->pGroups), in->groupCount);
16445     out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
16446     out->pLibraryInfo = convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(ctx, (const VkPipelineLibraryCreateInfoKHR32 *)UlongToPtr(in->pLibraryInfo), 1);
16447     out->pLibraryInterface = convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(ctx, (const VkRayTracingPipelineInterfaceCreateInfoKHR32 *)UlongToPtr(in->pLibraryInterface), 1);
16448     out->pDynamicState = convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDynamicStateCreateInfo32 *)UlongToPtr(in->pDynamicState), 1);
16449     out->layout = in->layout;
16450     out->basePipelineHandle = in->basePipelineHandle;
16451     out->basePipelineIndex = in->basePipelineIndex;
16452
16453     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16454     {
16455         switch (in_header->sType)
16456         {
16457         case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
16458         {
16459             VkPipelineCreateFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16460             const VkPipelineCreateFlags2CreateInfoKHR32 *in_ext = (const VkPipelineCreateFlags2CreateInfoKHR32 *)in_header;
16461             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR;
16462             out_ext->pNext = NULL;
16463             out_ext->flags = in_ext->flags;
16464             out_header->pNext = (void *)out_ext;
16465             out_header = (void *)out_ext;
16466             break;
16467         }
16468         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
16469         {
16470             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16471             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
16472             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
16473             out_ext->pNext = NULL;
16474             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
16475             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
16476             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
16477             out_header->pNext = (void *)out_ext;
16478             out_header = (void *)out_ext;
16479             break;
16480         }
16481         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
16482         {
16483             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16484             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
16485             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
16486             out_ext->pNext = NULL;
16487             out_ext->storageBuffers = in_ext->storageBuffers;
16488             out_ext->uniformBuffers = in_ext->uniformBuffers;
16489             out_ext->vertexInputs = in_ext->vertexInputs;
16490             out_ext->images = in_ext->images;
16491             out_header->pNext = (void *)out_ext;
16492             out_header = (void *)out_ext;
16493             break;
16494         }
16495         default:
16496             FIXME("Unhandled sType %u.\n", in_header->sType);
16497             break;
16498         }
16499     }
16500 }
16501
16502 static inline void convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out)
16503 {
16504     const VkBaseInStructure *in_header;
16505     VkBaseOutStructure32 *out_header = (void *)out;
16506
16507     if (!in) return;
16508
16509
16510     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
16511     {
16512         switch (in_header->sType)
16513         {
16514         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
16515         {
16516             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
16517             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
16518             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
16519             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
16520             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
16521             out_header = (void *)out_ext;
16522             break;
16523         }
16524         default:
16525             break;
16526         }
16527     }
16528 }
16529
16530 #ifdef _WIN64
16531 static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, uint32_t count)
16532 {
16533     VkRayTracingPipelineCreateInfoKHR *out;
16534     unsigned int i;
16535
16536     if (!in || !count) return NULL;
16537
16538     out = conversion_context_alloc(ctx, count * sizeof(*out));
16539     for (i = 0; i < count; i++)
16540     {
16541         convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(ctx, &in[i], &out[i]);
16542     }
16543
16544     return out;
16545 }
16546 #endif /* _WIN64 */
16547
16548 static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, uint32_t count)
16549 {
16550     VkRayTracingPipelineCreateInfoKHR *out;
16551     unsigned int i;
16552
16553     if (!in || !count) return NULL;
16554
16555     out = conversion_context_alloc(ctx, count * sizeof(*out));
16556     for (i = 0; i < count; i++)
16557     {
16558         convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
16559     }
16560
16561     return out;
16562 }
16563
16564 static inline void convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out, uint32_t count)
16565 {
16566     unsigned int i;
16567
16568     if (!in) return;
16569
16570     for (i = 0; i < count; i++)
16571     {
16572         convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(&in[i], &out[i]);
16573     }
16574 }
16575
16576 static inline void convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(const VkRayTracingShaderGroupCreateInfoNV32 *in, VkRayTracingShaderGroupCreateInfoNV *out)
16577 {
16578     if (!in) return;
16579
16580     out->sType = in->sType;
16581     out->pNext = NULL;
16582     out->type = in->type;
16583     out->generalShader = in->generalShader;
16584     out->closestHitShader = in->closestHitShader;
16585     out->anyHitShader = in->anyHitShader;
16586     out->intersectionShader = in->intersectionShader;
16587     if (in->pNext)
16588         FIXME("Unexpected pNext\n");
16589 }
16590
16591 static inline const VkRayTracingShaderGroupCreateInfoNV *convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoNV32 *in, uint32_t count)
16592 {
16593     VkRayTracingShaderGroupCreateInfoNV *out;
16594     unsigned int i;
16595
16596     if (!in || !count) return NULL;
16597
16598     out = conversion_context_alloc(ctx, count * sizeof(*out));
16599     for (i = 0; i < count; i++)
16600     {
16601         convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(&in[i], &out[i]);
16602     }
16603
16604     return out;
16605 }
16606
16607 #ifdef _WIN64
16608 static inline void convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, VkRayTracingPipelineCreateInfoNV *out)
16609 {
16610     if (!in) return;
16611
16612     out->sType = in->sType;
16613     out->pNext = in->pNext;
16614     out->flags = in->flags;
16615     out->stageCount = in->stageCount;
16616     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
16617     out->groupCount = in->groupCount;
16618     out->pGroups = in->pGroups;
16619     out->maxRecursionDepth = in->maxRecursionDepth;
16620     out->layout = in->layout;
16621     out->basePipelineHandle = in->basePipelineHandle;
16622     out->basePipelineIndex = in->basePipelineIndex;
16623 }
16624 #endif /* _WIN64 */
16625
16626 static inline void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, VkRayTracingPipelineCreateInfoNV *out)
16627 {
16628     const VkBaseInStructure32 *in_header;
16629     VkBaseOutStructure *out_header = (void *)out;
16630
16631     if (!in) return;
16632
16633     out->sType = in->sType;
16634     out->pNext = NULL;
16635     out->flags = in->flags;
16636     out->stageCount = in->stageCount;
16637     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
16638     out->groupCount = in->groupCount;
16639     out->pGroups = convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(ctx, (const VkRayTracingShaderGroupCreateInfoNV32 *)UlongToPtr(in->pGroups), in->groupCount);
16640     out->maxRecursionDepth = in->maxRecursionDepth;
16641     out->layout = in->layout;
16642     out->basePipelineHandle = in->basePipelineHandle;
16643     out->basePipelineIndex = in->basePipelineIndex;
16644
16645     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16646     {
16647         switch (in_header->sType)
16648         {
16649         case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
16650         {
16651             VkPipelineCreateFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16652             const VkPipelineCreateFlags2CreateInfoKHR32 *in_ext = (const VkPipelineCreateFlags2CreateInfoKHR32 *)in_header;
16653             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR;
16654             out_ext->pNext = NULL;
16655             out_ext->flags = in_ext->flags;
16656             out_header->pNext = (void *)out_ext;
16657             out_header = (void *)out_ext;
16658             break;
16659         }
16660         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
16661         {
16662             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16663             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
16664             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
16665             out_ext->pNext = NULL;
16666             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
16667             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
16668             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
16669             out_header->pNext = (void *)out_ext;
16670             out_header = (void *)out_ext;
16671             break;
16672         }
16673         default:
16674             FIXME("Unhandled sType %u.\n", in_header->sType);
16675             break;
16676         }
16677     }
16678 }
16679
16680 static inline void convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out)
16681 {
16682     const VkBaseInStructure *in_header;
16683     VkBaseOutStructure32 *out_header = (void *)out;
16684
16685     if (!in) return;
16686
16687
16688     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
16689     {
16690         switch (in_header->sType)
16691         {
16692         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
16693         {
16694             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
16695             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
16696             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
16697             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
16698             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
16699             out_header = (void *)out_ext;
16700             break;
16701         }
16702         default:
16703             break;
16704         }
16705     }
16706 }
16707
16708 #ifdef _WIN64
16709 static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, uint32_t count)
16710 {
16711     VkRayTracingPipelineCreateInfoNV *out;
16712     unsigned int i;
16713
16714     if (!in || !count) return NULL;
16715
16716     out = conversion_context_alloc(ctx, count * sizeof(*out));
16717     for (i = 0; i < count; i++)
16718     {
16719         convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
16720     }
16721
16722     return out;
16723 }
16724 #endif /* _WIN64 */
16725
16726 static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, uint32_t count)
16727 {
16728     VkRayTracingPipelineCreateInfoNV *out;
16729     unsigned int i;
16730
16731     if (!in || !count) return NULL;
16732
16733     out = conversion_context_alloc(ctx, count * sizeof(*out));
16734     for (i = 0; i < count; i++)
16735     {
16736         convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
16737     }
16738
16739     return out;
16740 }
16741
16742 static inline void convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out, uint32_t count)
16743 {
16744     unsigned int i;
16745
16746     if (!in) return;
16747
16748     for (i = 0; i < count; i++)
16749     {
16750         convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(&in[i], &out[i]);
16751     }
16752 }
16753
16754 static inline void convert_VkSubpassDescription_win32_to_host(const VkSubpassDescription32 *in, VkSubpassDescription *out)
16755 {
16756     if (!in) return;
16757
16758     out->flags = in->flags;
16759     out->pipelineBindPoint = in->pipelineBindPoint;
16760     out->inputAttachmentCount = in->inputAttachmentCount;
16761     out->pInputAttachments = (const VkAttachmentReference *)UlongToPtr(in->pInputAttachments);
16762     out->colorAttachmentCount = in->colorAttachmentCount;
16763     out->pColorAttachments = (const VkAttachmentReference *)UlongToPtr(in->pColorAttachments);
16764     out->pResolveAttachments = (const VkAttachmentReference *)UlongToPtr(in->pResolveAttachments);
16765     out->pDepthStencilAttachment = (const VkAttachmentReference *)UlongToPtr(in->pDepthStencilAttachment);
16766     out->preserveAttachmentCount = in->preserveAttachmentCount;
16767     out->pPreserveAttachments = (const uint32_t *)UlongToPtr(in->pPreserveAttachments);
16768 }
16769
16770 static inline const VkSubpassDescription *convert_VkSubpassDescription_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription32 *in, uint32_t count)
16771 {
16772     VkSubpassDescription *out;
16773     unsigned int i;
16774
16775     if (!in || !count) return NULL;
16776
16777     out = conversion_context_alloc(ctx, count * sizeof(*out));
16778     for (i = 0; i < count; i++)
16779     {
16780         convert_VkSubpassDescription_win32_to_host(&in[i], &out[i]);
16781     }
16782
16783     return out;
16784 }
16785
16786 static inline void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo32 *in, VkRenderPassCreateInfo *out)
16787 {
16788     const VkBaseInStructure32 *in_header;
16789     VkBaseOutStructure *out_header = (void *)out;
16790
16791     if (!in) return;
16792
16793     out->sType = in->sType;
16794     out->pNext = NULL;
16795     out->flags = in->flags;
16796     out->attachmentCount = in->attachmentCount;
16797     out->pAttachments = (const VkAttachmentDescription *)UlongToPtr(in->pAttachments);
16798     out->subpassCount = in->subpassCount;
16799     out->pSubpasses = convert_VkSubpassDescription_array_win32_to_host(ctx, (const VkSubpassDescription32 *)UlongToPtr(in->pSubpasses), in->subpassCount);
16800     out->dependencyCount = in->dependencyCount;
16801     out->pDependencies = (const VkSubpassDependency *)UlongToPtr(in->pDependencies);
16802
16803     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16804     {
16805         switch (in_header->sType)
16806         {
16807         case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
16808         {
16809             VkRenderPassMultiviewCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16810             const VkRenderPassMultiviewCreateInfo32 *in_ext = (const VkRenderPassMultiviewCreateInfo32 *)in_header;
16811             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
16812             out_ext->pNext = NULL;
16813             out_ext->subpassCount = in_ext->subpassCount;
16814             out_ext->pViewMasks = (const uint32_t *)UlongToPtr(in_ext->pViewMasks);
16815             out_ext->dependencyCount = in_ext->dependencyCount;
16816             out_ext->pViewOffsets = (const int32_t *)UlongToPtr(in_ext->pViewOffsets);
16817             out_ext->correlationMaskCount = in_ext->correlationMaskCount;
16818             out_ext->pCorrelationMasks = (const uint32_t *)UlongToPtr(in_ext->pCorrelationMasks);
16819             out_header->pNext = (void *)out_ext;
16820             out_header = (void *)out_ext;
16821             break;
16822         }
16823         case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
16824         {
16825             VkRenderPassInputAttachmentAspectCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16826             const VkRenderPassInputAttachmentAspectCreateInfo32 *in_ext = (const VkRenderPassInputAttachmentAspectCreateInfo32 *)in_header;
16827             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
16828             out_ext->pNext = NULL;
16829             out_ext->aspectReferenceCount = in_ext->aspectReferenceCount;
16830             out_ext->pAspectReferences = (const VkInputAttachmentAspectReference *)UlongToPtr(in_ext->pAspectReferences);
16831             out_header->pNext = (void *)out_ext;
16832             out_header = (void *)out_ext;
16833             break;
16834         }
16835         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
16836         {
16837             VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16838             const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header;
16839             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
16840             out_ext->pNext = NULL;
16841             out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment;
16842             out_header->pNext = (void *)out_ext;
16843             out_header = (void *)out_ext;
16844             break;
16845         }
16846         default:
16847             FIXME("Unhandled sType %u.\n", in_header->sType);
16848             break;
16849         }
16850     }
16851 }
16852
16853 static inline void convert_VkAttachmentDescription2_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, VkAttachmentDescription2 *out)
16854 {
16855     const VkBaseInStructure32 *in_header;
16856     VkBaseOutStructure *out_header = (void *)out;
16857
16858     if (!in) return;
16859
16860     out->sType = in->sType;
16861     out->pNext = NULL;
16862     out->flags = in->flags;
16863     out->format = in->format;
16864     out->samples = in->samples;
16865     out->loadOp = in->loadOp;
16866     out->storeOp = in->storeOp;
16867     out->stencilLoadOp = in->stencilLoadOp;
16868     out->stencilStoreOp = in->stencilStoreOp;
16869     out->initialLayout = in->initialLayout;
16870     out->finalLayout = in->finalLayout;
16871
16872     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16873     {
16874         switch (in_header->sType)
16875         {
16876         case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
16877         {
16878             VkAttachmentDescriptionStencilLayout *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16879             const VkAttachmentDescriptionStencilLayout32 *in_ext = (const VkAttachmentDescriptionStencilLayout32 *)in_header;
16880             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
16881             out_ext->pNext = NULL;
16882             out_ext->stencilInitialLayout = in_ext->stencilInitialLayout;
16883             out_ext->stencilFinalLayout = in_ext->stencilFinalLayout;
16884             out_header->pNext = (void *)out_ext;
16885             out_header = (void *)out_ext;
16886             break;
16887         }
16888         default:
16889             FIXME("Unhandled sType %u.\n", in_header->sType);
16890             break;
16891         }
16892     }
16893 }
16894
16895 static inline const VkAttachmentDescription2 *convert_VkAttachmentDescription2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, uint32_t count)
16896 {
16897     VkAttachmentDescription2 *out;
16898     unsigned int i;
16899
16900     if (!in || !count) return NULL;
16901
16902     out = conversion_context_alloc(ctx, count * sizeof(*out));
16903     for (i = 0; i < count; i++)
16904     {
16905         convert_VkAttachmentDescription2_win32_to_host(ctx, &in[i], &out[i]);
16906     }
16907
16908     return out;
16909 }
16910
16911 static inline void convert_VkAttachmentReference2_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, VkAttachmentReference2 *out)
16912 {
16913     const VkBaseInStructure32 *in_header;
16914     VkBaseOutStructure *out_header = (void *)out;
16915
16916     if (!in) return;
16917
16918     out->sType = in->sType;
16919     out->pNext = NULL;
16920     out->attachment = in->attachment;
16921     out->layout = in->layout;
16922     out->aspectMask = in->aspectMask;
16923
16924     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16925     {
16926         switch (in_header->sType)
16927         {
16928         case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
16929         {
16930             VkAttachmentReferenceStencilLayout *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16931             const VkAttachmentReferenceStencilLayout32 *in_ext = (const VkAttachmentReferenceStencilLayout32 *)in_header;
16932             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
16933             out_ext->pNext = NULL;
16934             out_ext->stencilLayout = in_ext->stencilLayout;
16935             out_header->pNext = (void *)out_ext;
16936             out_header = (void *)out_ext;
16937             break;
16938         }
16939         default:
16940             FIXME("Unhandled sType %u.\n", in_header->sType);
16941             break;
16942         }
16943     }
16944 }
16945
16946 static inline const VkAttachmentReference2 *convert_VkAttachmentReference2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, uint32_t count)
16947 {
16948     VkAttachmentReference2 *out;
16949     unsigned int i;
16950
16951     if (!in || !count) return NULL;
16952
16953     out = conversion_context_alloc(ctx, count * sizeof(*out));
16954     for (i = 0; i < count; i++)
16955     {
16956         convert_VkAttachmentReference2_win32_to_host(ctx, &in[i], &out[i]);
16957     }
16958
16959     return out;
16960 }
16961
16962 static inline void convert_VkSubpassDescription2_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, VkSubpassDescription2 *out)
16963 {
16964     const VkBaseInStructure32 *in_header;
16965     VkBaseOutStructure *out_header = (void *)out;
16966
16967     if (!in) return;
16968
16969     out->sType = in->sType;
16970     out->pNext = NULL;
16971     out->flags = in->flags;
16972     out->pipelineBindPoint = in->pipelineBindPoint;
16973     out->viewMask = in->viewMask;
16974     out->inputAttachmentCount = in->inputAttachmentCount;
16975     out->pInputAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pInputAttachments), in->inputAttachmentCount);
16976     out->colorAttachmentCount = in->colorAttachmentCount;
16977     out->pColorAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pColorAttachments), in->colorAttachmentCount);
16978     out->pResolveAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pResolveAttachments), in->colorAttachmentCount);
16979     out->pDepthStencilAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pDepthStencilAttachment), 1);
16980     out->preserveAttachmentCount = in->preserveAttachmentCount;
16981     out->pPreserveAttachments = (const uint32_t *)UlongToPtr(in->pPreserveAttachments);
16982
16983     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16984     {
16985         switch (in_header->sType)
16986         {
16987         case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
16988         {
16989             VkSubpassDescriptionDepthStencilResolve *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16990             const VkSubpassDescriptionDepthStencilResolve32 *in_ext = (const VkSubpassDescriptionDepthStencilResolve32 *)in_header;
16991             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
16992             out_ext->pNext = NULL;
16993             out_ext->depthResolveMode = in_ext->depthResolveMode;
16994             out_ext->stencilResolveMode = in_ext->stencilResolveMode;
16995             out_ext->pDepthStencilResolveAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in_ext->pDepthStencilResolveAttachment), 1);
16996             out_header->pNext = (void *)out_ext;
16997             out_header = (void *)out_ext;
16998             break;
16999         }
17000         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
17001         {
17002             VkFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17003             const VkFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkFragmentShadingRateAttachmentInfoKHR32 *)in_header;
17004             out_ext->sType = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
17005             out_ext->pNext = NULL;
17006             out_ext->pFragmentShadingRateAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in_ext->pFragmentShadingRateAttachment), 1);
17007             out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize;
17008             out_header->pNext = (void *)out_ext;
17009             out_header = (void *)out_ext;
17010             break;
17011         }
17012         case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
17013         {
17014             VkMultisampledRenderToSingleSampledInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17015             const VkMultisampledRenderToSingleSampledInfoEXT32 *in_ext = (const VkMultisampledRenderToSingleSampledInfoEXT32 *)in_header;
17016             out_ext->sType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
17017             out_ext->pNext = NULL;
17018             out_ext->multisampledRenderToSingleSampledEnable = in_ext->multisampledRenderToSingleSampledEnable;
17019             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
17020             out_header->pNext = (void *)out_ext;
17021             out_header = (void *)out_ext;
17022             break;
17023         }
17024         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
17025         {
17026             VkRenderPassCreationControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17027             const VkRenderPassCreationControlEXT32 *in_ext = (const VkRenderPassCreationControlEXT32 *)in_header;
17028             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT;
17029             out_ext->pNext = NULL;
17030             out_ext->disallowMerging = in_ext->disallowMerging;
17031             out_header->pNext = (void *)out_ext;
17032             out_header = (void *)out_ext;
17033             break;
17034         }
17035         case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
17036         {
17037             VkRenderPassSubpassFeedbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17038             const VkRenderPassSubpassFeedbackCreateInfoEXT32 *in_ext = (const VkRenderPassSubpassFeedbackCreateInfoEXT32 *)in_header;
17039             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT;
17040             out_ext->pNext = NULL;
17041             out_ext->pSubpassFeedback = (VkRenderPassSubpassFeedbackInfoEXT *)UlongToPtr(in_ext->pSubpassFeedback);
17042             out_header->pNext = (void *)out_ext;
17043             out_header = (void *)out_ext;
17044             break;
17045         }
17046         default:
17047             FIXME("Unhandled sType %u.\n", in_header->sType);
17048             break;
17049         }
17050     }
17051 }
17052
17053 static inline const VkSubpassDescription2 *convert_VkSubpassDescription2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, uint32_t count)
17054 {
17055     VkSubpassDescription2 *out;
17056     unsigned int i;
17057
17058     if (!in || !count) return NULL;
17059
17060     out = conversion_context_alloc(ctx, count * sizeof(*out));
17061     for (i = 0; i < count; i++)
17062     {
17063         convert_VkSubpassDescription2_win32_to_host(ctx, &in[i], &out[i]);
17064     }
17065
17066     return out;
17067 }
17068
17069 static inline void convert_VkSubpassDependency2_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, VkSubpassDependency2 *out)
17070 {
17071     const VkBaseInStructure32 *in_header;
17072     VkBaseOutStructure *out_header = (void *)out;
17073
17074     if (!in) return;
17075
17076     out->sType = in->sType;
17077     out->pNext = NULL;
17078     out->srcSubpass = in->srcSubpass;
17079     out->dstSubpass = in->dstSubpass;
17080     out->srcStageMask = in->srcStageMask;
17081     out->dstStageMask = in->dstStageMask;
17082     out->srcAccessMask = in->srcAccessMask;
17083     out->dstAccessMask = in->dstAccessMask;
17084     out->dependencyFlags = in->dependencyFlags;
17085     out->viewOffset = in->viewOffset;
17086
17087     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17088     {
17089         switch (in_header->sType)
17090         {
17091         case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
17092         {
17093             VkMemoryBarrier2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17094             const VkMemoryBarrier232 *in_ext = (const VkMemoryBarrier232 *)in_header;
17095             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2;
17096             out_ext->pNext = NULL;
17097             out_ext->srcStageMask = in_ext->srcStageMask;
17098             out_ext->srcAccessMask = in_ext->srcAccessMask;
17099             out_ext->dstStageMask = in_ext->dstStageMask;
17100             out_ext->dstAccessMask = in_ext->dstAccessMask;
17101             out_header->pNext = (void *)out_ext;
17102             out_header = (void *)out_ext;
17103             break;
17104         }
17105         default:
17106             FIXME("Unhandled sType %u.\n", in_header->sType);
17107             break;
17108         }
17109     }
17110 }
17111
17112 static inline const VkSubpassDependency2 *convert_VkSubpassDependency2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, uint32_t count)
17113 {
17114     VkSubpassDependency2 *out;
17115     unsigned int i;
17116
17117     if (!in || !count) return NULL;
17118
17119     out = conversion_context_alloc(ctx, count * sizeof(*out));
17120     for (i = 0; i < count; i++)
17121     {
17122         convert_VkSubpassDependency2_win32_to_host(ctx, &in[i], &out[i]);
17123     }
17124
17125     return out;
17126 }
17127
17128 static inline void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo232 *in, VkRenderPassCreateInfo2 *out)
17129 {
17130     const VkBaseInStructure32 *in_header;
17131     VkBaseOutStructure *out_header = (void *)out;
17132
17133     if (!in) return;
17134
17135     out->sType = in->sType;
17136     out->pNext = NULL;
17137     out->flags = in->flags;
17138     out->attachmentCount = in->attachmentCount;
17139     out->pAttachments = convert_VkAttachmentDescription2_array_win32_to_host(ctx, (const VkAttachmentDescription232 *)UlongToPtr(in->pAttachments), in->attachmentCount);
17140     out->subpassCount = in->subpassCount;
17141     out->pSubpasses = convert_VkSubpassDescription2_array_win32_to_host(ctx, (const VkSubpassDescription232 *)UlongToPtr(in->pSubpasses), in->subpassCount);
17142     out->dependencyCount = in->dependencyCount;
17143     out->pDependencies = convert_VkSubpassDependency2_array_win32_to_host(ctx, (const VkSubpassDependency232 *)UlongToPtr(in->pDependencies), in->dependencyCount);
17144     out->correlatedViewMaskCount = in->correlatedViewMaskCount;
17145     out->pCorrelatedViewMasks = (const uint32_t *)UlongToPtr(in->pCorrelatedViewMasks);
17146
17147     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17148     {
17149         switch (in_header->sType)
17150         {
17151         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
17152         {
17153             VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17154             const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header;
17155             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
17156             out_ext->pNext = NULL;
17157             out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment;
17158             out_header->pNext = (void *)out_ext;
17159             out_header = (void *)out_ext;
17160             break;
17161         }
17162         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
17163         {
17164             VkRenderPassCreationControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17165             const VkRenderPassCreationControlEXT32 *in_ext = (const VkRenderPassCreationControlEXT32 *)in_header;
17166             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT;
17167             out_ext->pNext = NULL;
17168             out_ext->disallowMerging = in_ext->disallowMerging;
17169             out_header->pNext = (void *)out_ext;
17170             out_header = (void *)out_ext;
17171             break;
17172         }
17173         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
17174         {
17175             VkRenderPassCreationFeedbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17176             const VkRenderPassCreationFeedbackCreateInfoEXT32 *in_ext = (const VkRenderPassCreationFeedbackCreateInfoEXT32 *)in_header;
17177             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT;
17178             out_ext->pNext = NULL;
17179             out_ext->pRenderPassFeedback = (VkRenderPassCreationFeedbackInfoEXT *)UlongToPtr(in_ext->pRenderPassFeedback);
17180             out_header->pNext = (void *)out_ext;
17181             out_header = (void *)out_ext;
17182             break;
17183         }
17184         default:
17185             FIXME("Unhandled sType %u.\n", in_header->sType);
17186             break;
17187         }
17188     }
17189 }
17190
17191 static inline void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSamplerCreateInfo32 *in, VkSamplerCreateInfo *out)
17192 {
17193     const VkBaseInStructure32 *in_header;
17194     VkBaseOutStructure *out_header = (void *)out;
17195
17196     if (!in) return;
17197
17198     out->sType = in->sType;
17199     out->pNext = NULL;
17200     out->flags = in->flags;
17201     out->magFilter = in->magFilter;
17202     out->minFilter = in->minFilter;
17203     out->mipmapMode = in->mipmapMode;
17204     out->addressModeU = in->addressModeU;
17205     out->addressModeV = in->addressModeV;
17206     out->addressModeW = in->addressModeW;
17207     out->mipLodBias = in->mipLodBias;
17208     out->anisotropyEnable = in->anisotropyEnable;
17209     out->maxAnisotropy = in->maxAnisotropy;
17210     out->compareEnable = in->compareEnable;
17211     out->compareOp = in->compareOp;
17212     out->minLod = in->minLod;
17213     out->maxLod = in->maxLod;
17214     out->borderColor = in->borderColor;
17215     out->unnormalizedCoordinates = in->unnormalizedCoordinates;
17216
17217     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17218     {
17219         switch (in_header->sType)
17220         {
17221         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
17222         {
17223             VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17224             const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
17225             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
17226             out_ext->pNext = NULL;
17227             out_ext->conversion = in_ext->conversion;
17228             out_header->pNext = (void *)out_ext;
17229             out_header = (void *)out_ext;
17230             break;
17231         }
17232         case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
17233         {
17234             VkSamplerReductionModeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17235             const VkSamplerReductionModeCreateInfo32 *in_ext = (const VkSamplerReductionModeCreateInfo32 *)in_header;
17236             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO;
17237             out_ext->pNext = NULL;
17238             out_ext->reductionMode = in_ext->reductionMode;
17239             out_header->pNext = (void *)out_ext;
17240             out_header = (void *)out_ext;
17241             break;
17242         }
17243         case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
17244         {
17245             VkSamplerCustomBorderColorCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17246             const VkSamplerCustomBorderColorCreateInfoEXT32 *in_ext = (const VkSamplerCustomBorderColorCreateInfoEXT32 *)in_header;
17247             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT;
17248             out_ext->pNext = NULL;
17249             out_ext->customBorderColor = in_ext->customBorderColor;
17250             out_ext->format = in_ext->format;
17251             out_header->pNext = (void *)out_ext;
17252             out_header = (void *)out_ext;
17253             break;
17254         }
17255         case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
17256         {
17257             VkSamplerBorderColorComponentMappingCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17258             const VkSamplerBorderColorComponentMappingCreateInfoEXT32 *in_ext = (const VkSamplerBorderColorComponentMappingCreateInfoEXT32 *)in_header;
17259             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT;
17260             out_ext->pNext = NULL;
17261             out_ext->components = in_ext->components;
17262             out_ext->srgb = in_ext->srgb;
17263             out_header->pNext = (void *)out_ext;
17264             out_header = (void *)out_ext;
17265             break;
17266         }
17267         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
17268         {
17269             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17270             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
17271             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
17272             out_ext->pNext = NULL;
17273             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
17274             out_header->pNext = (void *)out_ext;
17275             out_header = (void *)out_ext;
17276             break;
17277         }
17278         default:
17279             FIXME("Unhandled sType %u.\n", in_header->sType);
17280             break;
17281         }
17282     }
17283 }
17284
17285 static inline void convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(const VkSamplerYcbcrConversionCreateInfo32 *in, VkSamplerYcbcrConversionCreateInfo *out)
17286 {
17287     if (!in) return;
17288
17289     out->sType = in->sType;
17290     out->pNext = NULL;
17291     out->format = in->format;
17292     out->ycbcrModel = in->ycbcrModel;
17293     out->ycbcrRange = in->ycbcrRange;
17294     out->components = in->components;
17295     out->xChromaOffset = in->xChromaOffset;
17296     out->yChromaOffset = in->yChromaOffset;
17297     out->chromaFilter = in->chromaFilter;
17298     out->forceExplicitReconstruction = in->forceExplicitReconstruction;
17299     if (in->pNext)
17300         FIXME("Unexpected pNext\n");
17301 }
17302
17303 static inline void convert_VkSemaphoreCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSemaphoreCreateInfo32 *in, VkSemaphoreCreateInfo *out)
17304 {
17305     const VkBaseInStructure32 *in_header;
17306     VkBaseOutStructure *out_header = (void *)out;
17307
17308     if (!in) return;
17309
17310     out->sType = in->sType;
17311     out->pNext = NULL;
17312     out->flags = in->flags;
17313
17314     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17315     {
17316         switch (in_header->sType)
17317         {
17318         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
17319         {
17320             VkExportSemaphoreCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17321             const VkExportSemaphoreCreateInfo32 *in_ext = (const VkExportSemaphoreCreateInfo32 *)in_header;
17322             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO;
17323             out_ext->pNext = NULL;
17324             out_ext->handleTypes = in_ext->handleTypes;
17325             out_header->pNext = (void *)out_ext;
17326             out_header = (void *)out_ext;
17327             break;
17328         }
17329         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
17330         {
17331             VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17332             const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header;
17333             out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
17334             out_ext->pNext = NULL;
17335             out_ext->semaphoreType = in_ext->semaphoreType;
17336             out_ext->initialValue = in_ext->initialValue;
17337             out_header->pNext = (void *)out_ext;
17338             out_header = (void *)out_ext;
17339             break;
17340         }
17341         case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
17342         {
17343             VkQueryLowLatencySupportNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17344             const VkQueryLowLatencySupportNV32 *in_ext = (const VkQueryLowLatencySupportNV32 *)in_header;
17345             out_ext->sType = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV;
17346             out_ext->pNext = NULL;
17347             out_ext->pQueriedLowLatencyData = (void *)UlongToPtr(in_ext->pQueriedLowLatencyData);
17348             out_header->pNext = (void *)out_ext;
17349             out_header = (void *)out_ext;
17350             break;
17351         }
17352         default:
17353             FIXME("Unhandled sType %u.\n", in_header->sType);
17354             break;
17355         }
17356     }
17357 }
17358
17359 static inline void convert_VkShaderModuleCreateInfo_win32_to_host(struct conversion_context *ctx, const VkShaderModuleCreateInfo32 *in, VkShaderModuleCreateInfo *out)
17360 {
17361     const VkBaseInStructure32 *in_header;
17362     VkBaseOutStructure *out_header = (void *)out;
17363
17364     if (!in) return;
17365
17366     out->sType = in->sType;
17367     out->pNext = NULL;
17368     out->flags = in->flags;
17369     out->codeSize = in->codeSize;
17370     out->pCode = (const uint32_t *)UlongToPtr(in->pCode);
17371
17372     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17373     {
17374         switch (in_header->sType)
17375         {
17376         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
17377         {
17378             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17379             const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
17380             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
17381             out_ext->pNext = NULL;
17382             out_ext->validationCache = in_ext->validationCache;
17383             out_header->pNext = (void *)out_ext;
17384             out_header = (void *)out_ext;
17385             break;
17386         }
17387         default:
17388             FIXME("Unhandled sType %u.\n", in_header->sType);
17389             break;
17390         }
17391     }
17392 }
17393
17394 static inline void convert_VkShaderCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkShaderCreateInfoEXT32 *in, VkShaderCreateInfoEXT *out)
17395 {
17396     const VkBaseInStructure32 *in_header;
17397     VkBaseOutStructure *out_header = (void *)out;
17398
17399     if (!in) return;
17400
17401     out->sType = in->sType;
17402     out->pNext = NULL;
17403     out->flags = in->flags;
17404     out->stage = in->stage;
17405     out->nextStage = in->nextStage;
17406     out->codeType = in->codeType;
17407     out->codeSize = in->codeSize;
17408     out->pCode = (const void *)UlongToPtr(in->pCode);
17409     out->pName = (const char *)UlongToPtr(in->pName);
17410     out->setLayoutCount = in->setLayoutCount;
17411     out->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in->pSetLayouts);
17412     out->pushConstantRangeCount = in->pushConstantRangeCount;
17413     out->pPushConstantRanges = (const VkPushConstantRange *)UlongToPtr(in->pPushConstantRanges);
17414     out->pSpecializationInfo = convert_VkSpecializationInfo_array_win32_to_host(ctx, (const VkSpecializationInfo32 *)UlongToPtr(in->pSpecializationInfo), 1);
17415
17416     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17417     {
17418         switch (in_header->sType)
17419         {
17420         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
17421         {
17422             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17423             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *)in_header;
17424             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
17425             out_ext->pNext = NULL;
17426             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
17427             out_header->pNext = (void *)out_ext;
17428             out_header = (void *)out_ext;
17429             break;
17430         }
17431         default:
17432             FIXME("Unhandled sType %u.\n", in_header->sType);
17433             break;
17434         }
17435     }
17436 }
17437
17438 static inline const VkShaderCreateInfoEXT *convert_VkShaderCreateInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkShaderCreateInfoEXT32 *in, uint32_t count)
17439 {
17440     VkShaderCreateInfoEXT *out;
17441     unsigned int i;
17442
17443     if (!in || !count) return NULL;
17444
17445     out = conversion_context_alloc(ctx, count * sizeof(*out));
17446     for (i = 0; i < count; i++)
17447     {
17448         convert_VkShaderCreateInfoEXT_win32_to_host(ctx, &in[i], &out[i]);
17449     }
17450
17451     return out;
17452 }
17453
17454 #ifdef _WIN64
17455 static inline void convert_VkSwapchainCreateInfoKHR_win64_to_host(const VkSwapchainCreateInfoKHR *in, VkSwapchainCreateInfoKHR *out)
17456 {
17457     if (!in) return;
17458
17459     out->sType = in->sType;
17460     out->pNext = in->pNext;
17461     out->flags = in->flags;
17462     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
17463     out->minImageCount = in->minImageCount;
17464     out->imageFormat = in->imageFormat;
17465     out->imageColorSpace = in->imageColorSpace;
17466     out->imageExtent = in->imageExtent;
17467     out->imageArrayLayers = in->imageArrayLayers;
17468     out->imageUsage = in->imageUsage;
17469     out->imageSharingMode = in->imageSharingMode;
17470     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
17471     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
17472     out->preTransform = in->preTransform;
17473     out->compositeAlpha = in->compositeAlpha;
17474     out->presentMode = in->presentMode;
17475     out->clipped = in->clipped;
17476     out->oldSwapchain = in->oldSwapchain;
17477 }
17478 #endif /* _WIN64 */
17479
17480 static inline void convert_VkSwapchainCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkSwapchainCreateInfoKHR32 *in, VkSwapchainCreateInfoKHR *out)
17481 {
17482     const VkBaseInStructure32 *in_header;
17483     VkBaseOutStructure *out_header = (void *)out;
17484
17485     if (!in) return;
17486
17487     out->sType = in->sType;
17488     out->pNext = NULL;
17489     out->flags = in->flags;
17490     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
17491     out->minImageCount = in->minImageCount;
17492     out->imageFormat = in->imageFormat;
17493     out->imageColorSpace = in->imageColorSpace;
17494     out->imageExtent = in->imageExtent;
17495     out->imageArrayLayers = in->imageArrayLayers;
17496     out->imageUsage = in->imageUsage;
17497     out->imageSharingMode = in->imageSharingMode;
17498     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
17499     out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);
17500     out->preTransform = in->preTransform;
17501     out->compositeAlpha = in->compositeAlpha;
17502     out->presentMode = in->presentMode;
17503     out->clipped = in->clipped;
17504     out->oldSwapchain = in->oldSwapchain;
17505
17506     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17507     {
17508         switch (in_header->sType)
17509         {
17510         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
17511         {
17512             VkDeviceGroupSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17513             const VkDeviceGroupSwapchainCreateInfoKHR32 *in_ext = (const VkDeviceGroupSwapchainCreateInfoKHR32 *)in_header;
17514             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR;
17515             out_ext->pNext = NULL;
17516             out_ext->modes = in_ext->modes;
17517             out_header->pNext = (void *)out_ext;
17518             out_header = (void *)out_ext;
17519             break;
17520         }
17521         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
17522         {
17523             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17524             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
17525             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
17526             out_ext->pNext = NULL;
17527             out_ext->viewFormatCount = in_ext->viewFormatCount;
17528             out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
17529             out_header->pNext = (void *)out_ext;
17530             out_header = (void *)out_ext;
17531             break;
17532         }
17533         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
17534         {
17535             VkSwapchainPresentBarrierCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17536             const VkSwapchainPresentBarrierCreateInfoNV32 *in_ext = (const VkSwapchainPresentBarrierCreateInfoNV32 *)in_header;
17537             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV;
17538             out_ext->pNext = NULL;
17539             out_ext->presentBarrierEnable = in_ext->presentBarrierEnable;
17540             out_header->pNext = (void *)out_ext;
17541             out_header = (void *)out_ext;
17542             break;
17543         }
17544         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
17545         {
17546             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17547             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
17548             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
17549             out_ext->pNext = NULL;
17550             out_ext->flags = in_ext->flags;
17551             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
17552             out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
17553             out_header->pNext = (void *)out_ext;
17554             out_header = (void *)out_ext;
17555             break;
17556         }
17557         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT:
17558         {
17559             VkSwapchainPresentModesCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17560             const VkSwapchainPresentModesCreateInfoEXT32 *in_ext = (const VkSwapchainPresentModesCreateInfoEXT32 *)in_header;
17561             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT;
17562             out_ext->pNext = NULL;
17563             out_ext->presentModeCount = in_ext->presentModeCount;
17564             out_ext->pPresentModes = (const VkPresentModeKHR *)UlongToPtr(in_ext->pPresentModes);
17565             out_header->pNext = (void *)out_ext;
17566             out_header = (void *)out_ext;
17567             break;
17568         }
17569         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT:
17570         {
17571             VkSwapchainPresentScalingCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17572             const VkSwapchainPresentScalingCreateInfoEXT32 *in_ext = (const VkSwapchainPresentScalingCreateInfoEXT32 *)in_header;
17573             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT;
17574             out_ext->pNext = NULL;
17575             out_ext->scalingBehavior = in_ext->scalingBehavior;
17576             out_ext->presentGravityX = in_ext->presentGravityX;
17577             out_ext->presentGravityY = in_ext->presentGravityY;
17578             out_header->pNext = (void *)out_ext;
17579             out_header = (void *)out_ext;
17580             break;
17581         }
17582         default:
17583             FIXME("Unhandled sType %u.\n", in_header->sType);
17584             break;
17585         }
17586     }
17587 }
17588
17589 static inline void convert_VkValidationCacheCreateInfoEXT_win32_to_host(const VkValidationCacheCreateInfoEXT32 *in, VkValidationCacheCreateInfoEXT *out)
17590 {
17591     if (!in) return;
17592
17593     out->sType = in->sType;
17594     out->pNext = NULL;
17595     out->flags = in->flags;
17596     out->initialDataSize = in->initialDataSize;
17597     out->pInitialData = (const void *)UlongToPtr(in->pInitialData);
17598     if (in->pNext)
17599         FIXME("Unexpected pNext\n");
17600 }
17601
17602 static inline void convert_VkWin32SurfaceCreateInfoKHR_win32_to_host(const VkWin32SurfaceCreateInfoKHR32 *in, VkWin32SurfaceCreateInfoKHR *out)
17603 {
17604     if (!in) return;
17605
17606     out->sType = in->sType;
17607     out->pNext = NULL;
17608     out->flags = in->flags;
17609     out->hinstance = (HINSTANCE)UlongToPtr(in->hinstance);
17610     out->hwnd = (HWND)UlongToPtr(in->hwnd);
17611     if (in->pNext)
17612         FIXME("Unexpected pNext\n");
17613 }
17614
17615 #ifdef _WIN64
17616 static inline void convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(const VkDebugMarkerObjectNameInfoEXT *in, VkDebugMarkerObjectNameInfoEXT *out)
17617 {
17618     if (!in) return;
17619
17620     out->sType = in->sType;
17621     out->pNext = in->pNext;
17622     out->objectType = in->objectType;
17623     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
17624     out->pObjectName = in->pObjectName;
17625 }
17626 #endif /* _WIN64 */
17627
17628 static inline void convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(const VkDebugMarkerObjectNameInfoEXT32 *in, VkDebugMarkerObjectNameInfoEXT *out)
17629 {
17630     if (!in) return;
17631
17632     out->sType = in->sType;
17633     out->pNext = NULL;
17634     out->objectType = in->objectType;
17635     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
17636     out->pObjectName = (const char *)UlongToPtr(in->pObjectName);
17637     if (in->pNext)
17638         FIXME("Unexpected pNext\n");
17639 }
17640
17641 #ifdef _WIN64
17642 static inline void convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(const VkDebugMarkerObjectTagInfoEXT *in, VkDebugMarkerObjectTagInfoEXT *out)
17643 {
17644     if (!in) return;
17645
17646     out->sType = in->sType;
17647     out->pNext = in->pNext;
17648     out->objectType = in->objectType;
17649     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
17650     out->tagName = in->tagName;
17651     out->tagSize = in->tagSize;
17652     out->pTag = in->pTag;
17653 }
17654 #endif /* _WIN64 */
17655
17656 static inline void convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(const VkDebugMarkerObjectTagInfoEXT32 *in, VkDebugMarkerObjectTagInfoEXT *out)
17657 {
17658     if (!in) return;
17659
17660     out->sType = in->sType;
17661     out->pNext = NULL;
17662     out->objectType = in->objectType;
17663     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
17664     out->tagName = in->tagName;
17665     out->tagSize = in->tagSize;
17666     out->pTag = (const void *)UlongToPtr(in->pTag);
17667     if (in->pNext)
17668         FIXME("Unexpected pNext\n");
17669 }
17670
17671 static inline void convert_VkPhysicalDevice_array_unwrapped_host_to_win32(const VkPhysicalDevice *in, PTR32 *out, uint32_t count)
17672 {
17673     unsigned int i;
17674
17675     if (!in) return;
17676
17677     for (i = 0; i < count; i++)
17678     {
17679         out[i] = PtrToUlong(in[i]);
17680     }
17681 }
17682
17683 static inline void convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_host(const VkPhysicalDeviceGroupProperties32 *in, VkPhysicalDeviceGroupProperties *out)
17684 {
17685     if (!in) return;
17686
17687     out->sType = in->sType;
17688     out->pNext = NULL;
17689     if (in->pNext)
17690         FIXME("Unexpected pNext\n");
17691 }
17692
17693 static inline void convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out)
17694 {
17695     if (!in) return;
17696
17697     out->physicalDeviceCount = in->physicalDeviceCount;
17698     convert_VkPhysicalDevice_array_unwrapped_host_to_win32(in->physicalDevices, out->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE);
17699     out->subsetAllocation = in->subsetAllocation;
17700 }
17701
17702 static inline VkPhysicalDeviceGroupProperties *convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceGroupProperties32 *in, uint32_t count)
17703 {
17704     VkPhysicalDeviceGroupProperties *out;
17705     unsigned int i;
17706
17707     if (!in || !count) return NULL;
17708
17709     out = conversion_context_alloc(ctx, count * sizeof(*out));
17710     for (i = 0; i < count; i++)
17711     {
17712         convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_host(&in[i], &out[i]);
17713     }
17714
17715     return out;
17716 }
17717
17718 static inline void convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out, uint32_t count)
17719 {
17720     unsigned int i;
17721
17722     if (!in) return;
17723
17724     for (i = 0; i < count; i++)
17725     {
17726         convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(&in[i], &out[i]);
17727     }
17728 }
17729
17730 static inline void convert_VkPerformanceCounterKHR_win32_to_host(const VkPerformanceCounterKHR32 *in, VkPerformanceCounterKHR *out)
17731 {
17732     if (!in) return;
17733
17734     out->sType = in->sType;
17735     out->pNext = NULL;
17736     if (in->pNext)
17737         FIXME("Unexpected pNext\n");
17738 }
17739
17740 static inline void convert_VkPerformanceCounterKHR_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out)
17741 {
17742     if (!in) return;
17743
17744     out->unit = in->unit;
17745     out->scope = in->scope;
17746     out->storage = in->storage;
17747     memcpy(out->uuid, in->uuid, VK_UUID_SIZE * sizeof(uint8_t));
17748 }
17749
17750 static inline VkPerformanceCounterKHR *convert_VkPerformanceCounterKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterKHR32 *in, uint32_t count)
17751 {
17752     VkPerformanceCounterKHR *out;
17753     unsigned int i;
17754
17755     if (!in || !count) return NULL;
17756
17757     out = conversion_context_alloc(ctx, count * sizeof(*out));
17758     for (i = 0; i < count; i++)
17759     {
17760         convert_VkPerformanceCounterKHR_win32_to_host(&in[i], &out[i]);
17761     }
17762
17763     return out;
17764 }
17765
17766 static inline void convert_VkPerformanceCounterKHR_array_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out, uint32_t count)
17767 {
17768     unsigned int i;
17769
17770     if (!in) return;
17771
17772     for (i = 0; i < count; i++)
17773     {
17774         convert_VkPerformanceCounterKHR_host_to_win32(&in[i], &out[i]);
17775     }
17776 }
17777
17778 static inline void convert_VkPerformanceCounterDescriptionKHR_win32_to_host(const VkPerformanceCounterDescriptionKHR32 *in, VkPerformanceCounterDescriptionKHR *out)
17779 {
17780     if (!in) return;
17781
17782     out->sType = in->sType;
17783     out->pNext = NULL;
17784     if (in->pNext)
17785         FIXME("Unexpected pNext\n");
17786 }
17787
17788 static inline void convert_VkPerformanceCounterDescriptionKHR_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out)
17789 {
17790     if (!in) return;
17791
17792     out->flags = in->flags;
17793     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17794     memcpy(out->category, in->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17795     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17796 }
17797
17798 static inline VkPerformanceCounterDescriptionKHR *convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterDescriptionKHR32 *in, uint32_t count)
17799 {
17800     VkPerformanceCounterDescriptionKHR *out;
17801     unsigned int i;
17802
17803     if (!in || !count) return NULL;
17804
17805     out = conversion_context_alloc(ctx, count * sizeof(*out));
17806     for (i = 0; i < count; i++)
17807     {
17808         convert_VkPerformanceCounterDescriptionKHR_win32_to_host(&in[i], &out[i]);
17809     }
17810
17811     return out;
17812 }
17813
17814 static inline void convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out, uint32_t count)
17815 {
17816     unsigned int i;
17817
17818     if (!in) return;
17819
17820     for (i = 0; i < count; i++)
17821     {
17822         convert_VkPerformanceCounterDescriptionKHR_host_to_win32(&in[i], &out[i]);
17823     }
17824 }
17825
17826 #ifdef _WIN64
17827 static inline void convert_VkMappedMemoryRange_win64_to_host(const VkMappedMemoryRange *in, VkMappedMemoryRange *out)
17828 {
17829     if (!in) return;
17830
17831     out->sType = in->sType;
17832     out->pNext = in->pNext;
17833     out->memory = wine_device_memory_from_handle(in->memory)->memory;
17834     out->offset = in->offset;
17835     out->size = in->size;
17836 }
17837 #endif /* _WIN64 */
17838
17839 static inline void convert_VkMappedMemoryRange_win32_to_host(const VkMappedMemoryRange32 *in, VkMappedMemoryRange *out)
17840 {
17841     if (!in) return;
17842
17843     out->sType = in->sType;
17844     out->pNext = NULL;
17845     out->memory = wine_device_memory_from_handle(in->memory)->memory;
17846     out->offset = in->offset;
17847     out->size = in->size;
17848     if (in->pNext)
17849         FIXME("Unexpected pNext\n");
17850 }
17851
17852 #ifdef _WIN64
17853 static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win64_to_host(struct conversion_context *ctx, const VkMappedMemoryRange *in, uint32_t count)
17854 {
17855     VkMappedMemoryRange *out;
17856     unsigned int i;
17857
17858     if (!in || !count) return NULL;
17859
17860     out = conversion_context_alloc(ctx, count * sizeof(*out));
17861     for (i = 0; i < count; i++)
17862     {
17863         convert_VkMappedMemoryRange_win64_to_host(&in[i], &out[i]);
17864     }
17865
17866     return out;
17867 }
17868 #endif /* _WIN64 */
17869
17870 static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win32_to_host(struct conversion_context *ctx, const VkMappedMemoryRange32 *in, uint32_t count)
17871 {
17872     VkMappedMemoryRange *out;
17873     unsigned int i;
17874
17875     if (!in || !count) return NULL;
17876
17877     out = conversion_context_alloc(ctx, count * sizeof(*out));
17878     for (i = 0; i < count; i++)
17879     {
17880         convert_VkMappedMemoryRange_win32_to_host(&in[i], &out[i]);
17881     }
17882
17883     return out;
17884 }
17885
17886 static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host(const VkAccelerationStructureBuildSizesInfoKHR32 *in, VkAccelerationStructureBuildSizesInfoKHR *out)
17887 {
17888     if (!in) return;
17889
17890     out->sType = in->sType;
17891     out->pNext = NULL;
17892     out->accelerationStructureSize = in->accelerationStructureSize;
17893     out->updateScratchSize = in->updateScratchSize;
17894     out->buildScratchSize = in->buildScratchSize;
17895     if (in->pNext)
17896         FIXME("Unexpected pNext\n");
17897 }
17898
17899 static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(const VkAccelerationStructureBuildSizesInfoKHR *in, VkAccelerationStructureBuildSizesInfoKHR32 *out)
17900 {
17901     if (!in) return;
17902
17903     out->accelerationStructureSize = in->accelerationStructureSize;
17904     out->updateScratchSize = in->updateScratchSize;
17905     out->buildScratchSize = in->buildScratchSize;
17906 }
17907
17908 static inline void convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host(const VkAccelerationStructureDeviceAddressInfoKHR32 *in, VkAccelerationStructureDeviceAddressInfoKHR *out)
17909 {
17910     if (!in) return;
17911
17912     out->sType = in->sType;
17913     out->pNext = NULL;
17914     out->accelerationStructure = in->accelerationStructure;
17915     if (in->pNext)
17916         FIXME("Unexpected pNext\n");
17917 }
17918
17919 static inline void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host(const VkAccelerationStructureMemoryRequirementsInfoNV32 *in, VkAccelerationStructureMemoryRequirementsInfoNV *out)
17920 {
17921     if (!in) return;
17922
17923     out->sType = in->sType;
17924     out->pNext = NULL;
17925     out->type = in->type;
17926     out->accelerationStructure = in->accelerationStructure;
17927     if (in->pNext)
17928         FIXME("Unexpected pNext\n");
17929 }
17930
17931 static inline void convert_VkMemoryRequirements_host_to_win32(const VkMemoryRequirements *in, VkMemoryRequirements32 *out)
17932 {
17933     if (!in) return;
17934
17935     out->size = in->size;
17936     out->alignment = in->alignment;
17937     out->memoryTypeBits = in->memoryTypeBits;
17938 }
17939
17940 static inline void convert_VkMemoryRequirements2KHR_win32_to_host(const VkMemoryRequirements2KHR32 *in, VkMemoryRequirements2KHR *out)
17941 {
17942     if (!in) return;
17943
17944     out->sType = in->sType;
17945     out->pNext = NULL;
17946     if (in->pNext)
17947         FIXME("Unexpected pNext\n");
17948 }
17949
17950 static inline void convert_VkMemoryRequirements2KHR_host_to_win32(const VkMemoryRequirements2KHR *in, VkMemoryRequirements2KHR32 *out)
17951 {
17952     if (!in) return;
17953
17954     convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
17955 }
17956
17957 static inline void convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_win32_to_host(const VkAccelerationStructureCaptureDescriptorDataInfoEXT32 *in, VkAccelerationStructureCaptureDescriptorDataInfoEXT *out)
17958 {
17959     if (!in) return;
17960
17961     out->sType = in->sType;
17962     out->pNext = NULL;
17963     out->accelerationStructure = in->accelerationStructure;
17964     out->accelerationStructureNV = in->accelerationStructureNV;
17965     if (in->pNext)
17966         FIXME("Unexpected pNext\n");
17967 }
17968
17969 static inline void convert_VkBufferDeviceAddressInfo_win32_to_host(const VkBufferDeviceAddressInfo32 *in, VkBufferDeviceAddressInfo *out)
17970 {
17971     if (!in) return;
17972
17973     out->sType = in->sType;
17974     out->pNext = NULL;
17975     out->buffer = in->buffer;
17976     if (in->pNext)
17977         FIXME("Unexpected pNext\n");
17978 }
17979
17980 static inline void convert_VkBufferMemoryRequirementsInfo2_win32_to_host(const VkBufferMemoryRequirementsInfo232 *in, VkBufferMemoryRequirementsInfo2 *out)
17981 {
17982     if (!in) return;
17983
17984     out->sType = in->sType;
17985     out->pNext = NULL;
17986     out->buffer = in->buffer;
17987     if (in->pNext)
17988         FIXME("Unexpected pNext\n");
17989 }
17990
17991 static inline void convert_VkMemoryRequirements2_win32_to_host(struct conversion_context *ctx, const VkMemoryRequirements232 *in, VkMemoryRequirements2 *out)
17992 {
17993     const VkBaseInStructure32 *in_header;
17994     VkBaseOutStructure *out_header = (void *)out;
17995
17996     if (!in) return;
17997
17998     out->sType = in->sType;
17999     out->pNext = NULL;
18000
18001     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
18002     {
18003         switch (in_header->sType)
18004         {
18005         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
18006         {
18007             VkMemoryDedicatedRequirements *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18008             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
18009             out_ext->pNext = NULL;
18010             out_header->pNext = (void *)out_ext;
18011             out_header = (void *)out_ext;
18012             break;
18013         }
18014         default:
18015             FIXME("Unhandled sType %u.\n", in_header->sType);
18016             break;
18017         }
18018     }
18019 }
18020
18021 static inline void convert_VkMemoryRequirements2_host_to_win32(const VkMemoryRequirements2 *in, VkMemoryRequirements232 *out)
18022 {
18023     const VkBaseInStructure *in_header;
18024     VkBaseOutStructure32 *out_header = (void *)out;
18025
18026     if (!in) return;
18027
18028     convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
18029
18030     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
18031     {
18032         switch (in_header->sType)
18033         {
18034         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
18035         {
18036             VkMemoryDedicatedRequirements32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
18037             const VkMemoryDedicatedRequirements *in_ext = (const VkMemoryDedicatedRequirements *)in_header;
18038             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
18039             out_ext->prefersDedicatedAllocation = in_ext->prefersDedicatedAllocation;
18040             out_ext->requiresDedicatedAllocation = in_ext->requiresDedicatedAllocation;
18041             out_header = (void *)out_ext;
18042             break;
18043         }
18044         default:
18045             break;
18046         }
18047     }
18048 }
18049
18050 static inline void convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host(const VkBufferCaptureDescriptorDataInfoEXT32 *in, VkBufferCaptureDescriptorDataInfoEXT *out)
18051 {
18052     if (!in) return;
18053
18054     out->sType = in->sType;
18055     out->pNext = NULL;
18056     out->buffer = in->buffer;
18057     if (in->pNext)
18058         FIXME("Unexpected pNext\n");
18059 }
18060
18061 static inline void convert_VkCalibratedTimestampInfoEXT_win32_to_host(const VkCalibratedTimestampInfoEXT32 *in, VkCalibratedTimestampInfoEXT *out)
18062 {
18063     if (!in) return;
18064
18065     out->sType = in->sType;
18066     out->pNext = NULL;
18067     out->timeDomain = in->timeDomain;
18068     if (in->pNext)
18069         FIXME("Unexpected pNext\n");
18070 }
18071
18072 static inline const VkCalibratedTimestampInfoEXT *convert_VkCalibratedTimestampInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoEXT32 *in, uint32_t count)
18073 {
18074     VkCalibratedTimestampInfoEXT *out;
18075     unsigned int i;
18076
18077     if (!in || !count) return NULL;
18078
18079     out = conversion_context_alloc(ctx, count * sizeof(*out));
18080     for (i = 0; i < count; i++)
18081     {
18082         convert_VkCalibratedTimestampInfoEXT_win32_to_host(&in[i], &out[i]);
18083     }
18084
18085     return out;
18086 }
18087
18088 static inline void convert_VkDescriptorAddressInfoEXT_win32_to_host(const VkDescriptorAddressInfoEXT32 *in, VkDescriptorAddressInfoEXT *out)
18089 {
18090     if (!in) return;
18091
18092     out->sType = in->sType;
18093     out->pNext = NULL;
18094     out->address = in->address;
18095     out->range = in->range;
18096     out->format = in->format;
18097     if (in->pNext)
18098         FIXME("Unexpected pNext\n");
18099 }
18100
18101 static inline const VkDescriptorAddressInfoEXT *convert_VkDescriptorAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorAddressInfoEXT32 *in, uint32_t count)
18102 {
18103     VkDescriptorAddressInfoEXT *out;
18104     unsigned int i;
18105
18106     if (!in || !count) return NULL;
18107
18108     out = conversion_context_alloc(ctx, count * sizeof(*out));
18109     for (i = 0; i < count; i++)
18110     {
18111         convert_VkDescriptorAddressInfoEXT_win32_to_host(&in[i], &out[i]);
18112     }
18113
18114     return out;
18115 }
18116
18117 static inline void convert_VkDescriptorDataEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorDataEXT32 *in, VkDescriptorDataEXT *out, VkFlags selector)
18118 {
18119     if (!in) return;
18120
18121     if (selector == VK_DESCRIPTOR_TYPE_SAMPLER)
18122         out->pSampler = (const VkSampler *)UlongToPtr(in->pSampler);
18123     if (selector == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
18124         out->pCombinedImageSampler = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pCombinedImageSampler), 1);
18125     if (selector == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
18126         out->pInputAttachmentImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pInputAttachmentImage), 1);
18127     if (selector == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE)
18128         out->pSampledImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pSampledImage), 1);
18129     if (selector == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
18130         out->pStorageImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pStorageImage), 1);
18131     if (selector == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER)
18132         out->pUniformTexelBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pUniformTexelBuffer), 1);
18133     if (selector == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)
18134         out->pStorageTexelBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pStorageTexelBuffer), 1);
18135     if (selector == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER)
18136         out->pUniformBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pUniformBuffer), 1);
18137     if (selector == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
18138         out->pStorageBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pStorageBuffer), 1);
18139     if (selector == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR || selector == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV)
18140         out->accelerationStructure = in->accelerationStructure;
18141 }
18142
18143 static inline void convert_VkDescriptorGetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorGetInfoEXT32 *in, VkDescriptorGetInfoEXT *out)
18144 {
18145     if (!in) return;
18146
18147     out->sType = in->sType;
18148     out->pNext = NULL;
18149     out->type = in->type;
18150     convert_VkDescriptorDataEXT_win32_to_host(ctx, &in->data, &out->data, in->type);
18151     if (in->pNext)
18152         FIXME("Unexpected pNext\n");
18153 }
18154
18155 static inline void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(const VkDescriptorSetBindingReferenceVALVE32 *in, VkDescriptorSetBindingReferenceVALVE *out)
18156 {
18157     if (!in) return;
18158
18159     out->sType = in->sType;
18160     out->pNext = NULL;
18161     out->descriptorSetLayout = in->descriptorSetLayout;
18162     out->binding = in->binding;
18163     if (in->pNext)
18164         FIXME("Unexpected pNext\n");
18165 }
18166
18167 static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host(const VkDescriptorSetLayoutHostMappingInfoVALVE32 *in, VkDescriptorSetLayoutHostMappingInfoVALVE *out)
18168 {
18169     if (!in) return;
18170
18171     out->sType = in->sType;
18172     out->pNext = NULL;
18173     out->descriptorOffset = in->descriptorOffset;
18174     out->descriptorSize = in->descriptorSize;
18175     if (in->pNext)
18176         FIXME("Unexpected pNext\n");
18177 }
18178
18179 static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(const VkDescriptorSetLayoutHostMappingInfoVALVE *in, VkDescriptorSetLayoutHostMappingInfoVALVE32 *out)
18180 {
18181     if (!in) return;
18182
18183     out->descriptorOffset = in->descriptorOffset;
18184     out->descriptorSize = in->descriptorSize;
18185 }
18186
18187 static inline void convert_VkDescriptorSetLayoutSupport_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutSupport32 *in, VkDescriptorSetLayoutSupport *out)
18188 {
18189     const VkBaseInStructure32 *in_header;
18190     VkBaseOutStructure *out_header = (void *)out;
18191
18192     if (!in) return;
18193
18194     out->sType = in->sType;
18195     out->pNext = NULL;
18196
18197     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
18198     {
18199         switch (in_header->sType)
18200         {
18201         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
18202         {
18203             VkDescriptorSetVariableDescriptorCountLayoutSupport *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18204             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
18205             out_ext->pNext = NULL;
18206             out_header->pNext = (void *)out_ext;
18207             out_header = (void *)out_ext;
18208             break;
18209         }
18210         default:
18211             FIXME("Unhandled sType %u.\n", in_header->sType);
18212             break;
18213         }
18214     }
18215 }
18216
18217 static inline void convert_VkDescriptorSetLayoutSupport_host_to_win32(const VkDescriptorSetLayoutSupport *in, VkDescriptorSetLayoutSupport32 *out)
18218 {
18219     const VkBaseInStructure *in_header;
18220     VkBaseOutStructure32 *out_header = (void *)out;
18221
18222     if (!in) return;
18223
18224     out->supported = in->supported;
18225
18226     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
18227     {
18228         switch (in_header->sType)
18229         {
18230         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
18231         {
18232             VkDescriptorSetVariableDescriptorCountLayoutSupport32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT);
18233             const VkDescriptorSetVariableDescriptorCountLayoutSupport *in_ext = (const VkDescriptorSetVariableDescriptorCountLayoutSupport *)in_header;
18234             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
18235             out_ext->maxVariableDescriptorCount = in_ext->maxVariableDescriptorCount;
18236             out_header = (void *)out_ext;
18237             break;
18238         }
18239         default:
18240             break;
18241         }
18242     }
18243 }
18244
18245 static inline void convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(const VkAccelerationStructureVersionInfoKHR32 *in, VkAccelerationStructureVersionInfoKHR *out)
18246 {
18247     if (!in) return;
18248
18249     out->sType = in->sType;
18250     out->pNext = NULL;
18251     out->pVersionData = (const uint8_t *)UlongToPtr(in->pVersionData);
18252     if (in->pNext)
18253         FIXME("Unexpected pNext\n");
18254 }
18255
18256 static inline const VkBufferCreateInfo *convert_VkBufferCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, uint32_t count)
18257 {
18258     VkBufferCreateInfo *out;
18259     unsigned int i;
18260
18261     if (!in || !count) return NULL;
18262
18263     out = conversion_context_alloc(ctx, count * sizeof(*out));
18264     for (i = 0; i < count; i++)
18265     {
18266         convert_VkBufferCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
18267     }
18268
18269     return out;
18270 }
18271
18272 static inline void convert_VkDeviceBufferMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceBufferMemoryRequirements32 *in, VkDeviceBufferMemoryRequirements *out)
18273 {
18274     if (!in) return;
18275
18276     out->sType = in->sType;
18277     out->pNext = NULL;
18278     out->pCreateInfo = convert_VkBufferCreateInfo_array_win32_to_host(ctx, (const VkBufferCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1);
18279     if (in->pNext)
18280         FIXME("Unexpected pNext\n");
18281 }
18282
18283 static inline void convert_VkDeviceFaultCountsEXT_win32_to_host(const VkDeviceFaultCountsEXT32 *in, VkDeviceFaultCountsEXT *out)
18284 {
18285     if (!in) return;
18286
18287     out->sType = in->sType;
18288     out->pNext = NULL;
18289     out->addressInfoCount = in->addressInfoCount;
18290     out->vendorInfoCount = in->vendorInfoCount;
18291     out->vendorBinarySize = in->vendorBinarySize;
18292     if (in->pNext)
18293         FIXME("Unexpected pNext\n");
18294 }
18295
18296 static inline void convert_VkDeviceFaultCountsEXT_host_to_win32(const VkDeviceFaultCountsEXT *in, VkDeviceFaultCountsEXT32 *out)
18297 {
18298     if (!in) return;
18299
18300     out->addressInfoCount = in->addressInfoCount;
18301     out->vendorInfoCount = in->vendorInfoCount;
18302     out->vendorBinarySize = in->vendorBinarySize;
18303 }
18304
18305 static inline void convert_VkDeviceFaultAddressInfoEXT_win32_to_host(const VkDeviceFaultAddressInfoEXT32 *in, VkDeviceFaultAddressInfoEXT *out)
18306 {
18307     if (!in) return;
18308
18309     out->addressType = in->addressType;
18310     out->reportedAddress = in->reportedAddress;
18311     out->addressPrecision = in->addressPrecision;
18312 }
18313
18314 static inline void convert_VkDeviceFaultAddressInfoEXT_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out)
18315 {
18316     if (!in) return;
18317
18318     out->addressType = in->addressType;
18319     out->reportedAddress = in->reportedAddress;
18320     out->addressPrecision = in->addressPrecision;
18321 }
18322
18323 static inline VkDeviceFaultAddressInfoEXT *convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultAddressInfoEXT32 *in, uint32_t count)
18324 {
18325     VkDeviceFaultAddressInfoEXT *out;
18326     unsigned int i;
18327
18328     if (!in || !count) return NULL;
18329
18330     out = conversion_context_alloc(ctx, count * sizeof(*out));
18331     for (i = 0; i < count; i++)
18332     {
18333         convert_VkDeviceFaultAddressInfoEXT_win32_to_host(&in[i], &out[i]);
18334     }
18335
18336     return out;
18337 }
18338
18339 static inline void convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out, uint32_t count)
18340 {
18341     unsigned int i;
18342
18343     if (!in) return;
18344
18345     for (i = 0; i < count; i++)
18346     {
18347         convert_VkDeviceFaultAddressInfoEXT_host_to_win32(&in[i], &out[i]);
18348     }
18349 }
18350
18351 static inline void convert_VkDeviceFaultVendorInfoEXT_win32_to_host(const VkDeviceFaultVendorInfoEXT32 *in, VkDeviceFaultVendorInfoEXT *out)
18352 {
18353     if (!in) return;
18354
18355     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
18356     out->vendorFaultCode = in->vendorFaultCode;
18357     out->vendorFaultData = in->vendorFaultData;
18358 }
18359
18360 static inline void convert_VkDeviceFaultVendorInfoEXT_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out)
18361 {
18362     if (!in) return;
18363
18364     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
18365     out->vendorFaultCode = in->vendorFaultCode;
18366     out->vendorFaultData = in->vendorFaultData;
18367 }
18368
18369 static inline VkDeviceFaultVendorInfoEXT *convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultVendorInfoEXT32 *in, uint32_t count)
18370 {
18371     VkDeviceFaultVendorInfoEXT *out;
18372     unsigned int i;
18373
18374     if (!in || !count) return NULL;
18375
18376     out = conversion_context_alloc(ctx, count * sizeof(*out));
18377     for (i = 0; i < count; i++)
18378     {
18379         convert_VkDeviceFaultVendorInfoEXT_win32_to_host(&in[i], &out[i]);
18380     }
18381
18382     return out;
18383 }
18384
18385 static inline void convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out, uint32_t count)
18386 {
18387     unsigned int i;
18388
18389     if (!in) return;
18390
18391     for (i = 0; i < count; i++)
18392     {
18393         convert_VkDeviceFaultVendorInfoEXT_host_to_win32(&in[i], &out[i]);
18394     }
18395 }
18396
18397 static inline void convert_VkDeviceFaultInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultInfoEXT32 *in, VkDeviceFaultInfoEXT *out)
18398 {
18399     if (!in) return;
18400
18401     out->sType = in->sType;
18402     out->pNext = NULL;
18403     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
18404     out->pAddressInfos = convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(in->pAddressInfos), 1);
18405     out->pVendorInfos = convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(in->pVendorInfos), 1);
18406     out->pVendorBinaryData = (void *)UlongToPtr(in->pVendorBinaryData);
18407     if (in->pNext)
18408         FIXME("Unexpected pNext\n");
18409 }
18410
18411 static inline void convert_VkDeviceFaultInfoEXT_host_to_win32(const VkDeviceFaultInfoEXT *in, VkDeviceFaultInfoEXT32 *out)
18412 {
18413     if (!in) return;
18414
18415     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
18416     convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(in->pAddressInfos, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(out->pAddressInfos), 1);
18417     convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(in->pVendorInfos, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(out->pVendorInfos), 1);
18418     out->pVendorBinaryData = PtrToUlong(in->pVendorBinaryData);
18419 }
18420
18421 static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host(const VkDeviceGroupPresentCapabilitiesKHR32 *in, VkDeviceGroupPresentCapabilitiesKHR *out)
18422 {
18423     if (!in) return;
18424
18425     out->sType = in->sType;
18426     out->pNext = NULL;
18427     if (in->pNext)
18428         FIXME("Unexpected pNext\n");
18429 }
18430
18431 static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(const VkDeviceGroupPresentCapabilitiesKHR *in, VkDeviceGroupPresentCapabilitiesKHR32 *out)
18432 {
18433     if (!in) return;
18434
18435     memcpy(out->presentMask, in->presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
18436     out->modes = in->modes;
18437 }
18438
18439 static inline const VkImageCreateInfo *convert_VkImageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, uint32_t count)
18440 {
18441     VkImageCreateInfo *out;
18442     unsigned int i;
18443
18444     if (!in || !count) return NULL;
18445
18446     out = conversion_context_alloc(ctx, count * sizeof(*out));
18447     for (i = 0; i < count; i++)
18448     {
18449         convert_VkImageCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
18450     }
18451
18452     return out;
18453 }
18454
18455 static inline void convert_VkDeviceImageMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceImageMemoryRequirements32 *in, VkDeviceImageMemoryRequirements *out)
18456 {
18457     if (!in) return;
18458
18459     out->sType = in->sType;
18460     out->pNext = NULL;
18461     out->pCreateInfo = convert_VkImageCreateInfo_array_win32_to_host(ctx, (const VkImageCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1);
18462     out->planeAspect = in->planeAspect;
18463     if (in->pNext)
18464         FIXME("Unexpected pNext\n");
18465 }
18466
18467 static inline void convert_VkSparseImageMemoryRequirements_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out)
18468 {
18469     if (!in) return;
18470
18471     out->formatProperties = in->formatProperties;
18472     out->imageMipTailFirstLod = in->imageMipTailFirstLod;
18473     out->imageMipTailSize = in->imageMipTailSize;
18474     out->imageMipTailOffset = in->imageMipTailOffset;
18475     out->imageMipTailStride = in->imageMipTailStride;
18476 }
18477
18478 static inline void convert_VkSparseImageMemoryRequirements2_win32_to_host(const VkSparseImageMemoryRequirements232 *in, VkSparseImageMemoryRequirements2 *out)
18479 {
18480     if (!in) return;
18481
18482     out->sType = in->sType;
18483     out->pNext = NULL;
18484     if (in->pNext)
18485         FIXME("Unexpected pNext\n");
18486 }
18487
18488 static inline void convert_VkSparseImageMemoryRequirements2_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out)
18489 {
18490     if (!in) return;
18491
18492     convert_VkSparseImageMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
18493 }
18494
18495 static inline VkSparseImageMemoryRequirements2 *convert_VkSparseImageMemoryRequirements2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryRequirements232 *in, uint32_t count)
18496 {
18497     VkSparseImageMemoryRequirements2 *out;
18498     unsigned int i;
18499
18500     if (!in || !count) return NULL;
18501
18502     out = conversion_context_alloc(ctx, count * sizeof(*out));
18503     for (i = 0; i < count; i++)
18504     {
18505         convert_VkSparseImageMemoryRequirements2_win32_to_host(&in[i], &out[i]);
18506     }
18507
18508     return out;
18509 }
18510
18511 static inline void convert_VkSparseImageMemoryRequirements2_array_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out, uint32_t count)
18512 {
18513     unsigned int i;
18514
18515     if (!in) return;
18516
18517     for (i = 0; i < count; i++)
18518     {
18519         convert_VkSparseImageMemoryRequirements2_host_to_win32(&in[i], &out[i]);
18520     }
18521 }
18522
18523 static inline void convert_VkImageSubresource2KHR_win32_to_host(const VkImageSubresource2KHR32 *in, VkImageSubresource2KHR *out)
18524 {
18525     if (!in) return;
18526
18527     out->sType = in->sType;
18528     out->pNext = NULL;
18529     out->imageSubresource = in->imageSubresource;
18530     if (in->pNext)
18531         FIXME("Unexpected pNext\n");
18532 }
18533
18534 static inline const VkImageSubresource2KHR *convert_VkImageSubresource2KHR_array_win32_to_host(struct conversion_context *ctx, const VkImageSubresource2KHR32 *in, uint32_t count)
18535 {
18536     VkImageSubresource2KHR *out;
18537     unsigned int i;
18538
18539     if (!in || !count) return NULL;
18540
18541     out = conversion_context_alloc(ctx, count * sizeof(*out));
18542     for (i = 0; i < count; i++)
18543     {
18544         convert_VkImageSubresource2KHR_win32_to_host(&in[i], &out[i]);
18545     }
18546
18547     return out;
18548 }
18549
18550 static inline void convert_VkDeviceImageSubresourceInfoKHR_win32_to_host(struct conversion_context *ctx, const VkDeviceImageSubresourceInfoKHR32 *in, VkDeviceImageSubresourceInfoKHR *out)
18551 {
18552     if (!in) return;
18553
18554     out->sType = in->sType;
18555     out->pNext = NULL;
18556     out->pCreateInfo = convert_VkImageCreateInfo_array_win32_to_host(ctx, (const VkImageCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1);
18557     out->pSubresource = convert_VkImageSubresource2KHR_array_win32_to_host(ctx, (const VkImageSubresource2KHR32 *)UlongToPtr(in->pSubresource), 1);
18558     if (in->pNext)
18559         FIXME("Unexpected pNext\n");
18560 }
18561
18562 static inline void convert_VkSubresourceLayout_win32_to_host(const VkSubresourceLayout32 *in, VkSubresourceLayout *out)
18563 {
18564     if (!in) return;
18565
18566     out->offset = in->offset;
18567     out->size = in->size;
18568     out->rowPitch = in->rowPitch;
18569     out->arrayPitch = in->arrayPitch;
18570     out->depthPitch = in->depthPitch;
18571 }
18572
18573 static inline void convert_VkSubresourceLayout_host_to_win32(const VkSubresourceLayout *in, VkSubresourceLayout32 *out)
18574 {
18575     if (!in) return;
18576
18577     out->offset = in->offset;
18578     out->size = in->size;
18579     out->rowPitch = in->rowPitch;
18580     out->arrayPitch = in->arrayPitch;
18581     out->depthPitch = in->depthPitch;
18582 }
18583
18584 static inline void convert_VkSubresourceLayout2KHR_win32_to_host(struct conversion_context *ctx, const VkSubresourceLayout2KHR32 *in, VkSubresourceLayout2KHR *out)
18585 {
18586     const VkBaseInStructure32 *in_header;
18587     VkBaseOutStructure *out_header = (void *)out;
18588
18589     if (!in) return;
18590
18591     out->sType = in->sType;
18592     out->pNext = NULL;
18593
18594     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
18595     {
18596         switch (in_header->sType)
18597         {
18598         case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT:
18599         {
18600             VkSubresourceHostMemcpySizeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18601             out_ext->sType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT;
18602             out_ext->pNext = NULL;
18603             out_header->pNext = (void *)out_ext;
18604             out_header = (void *)out_ext;
18605             break;
18606         }
18607         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
18608         {
18609             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18610             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
18611             out_ext->pNext = NULL;
18612             out_header->pNext = (void *)out_ext;
18613             out_header = (void *)out_ext;
18614             break;
18615         }
18616         default:
18617             FIXME("Unhandled sType %u.\n", in_header->sType);
18618             break;
18619         }
18620     }
18621 }
18622
18623 static inline void convert_VkSubresourceLayout2KHR_host_to_win32(const VkSubresourceLayout2KHR *in, VkSubresourceLayout2KHR32 *out)
18624 {
18625     const VkBaseInStructure *in_header;
18626     VkBaseOutStructure32 *out_header = (void *)out;
18627
18628     if (!in) return;
18629
18630     convert_VkSubresourceLayout_host_to_win32(&in->subresourceLayout, &out->subresourceLayout);
18631
18632     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
18633     {
18634         switch (in_header->sType)
18635         {
18636         case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT:
18637         {
18638             VkSubresourceHostMemcpySizeEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT);
18639             const VkSubresourceHostMemcpySizeEXT *in_ext = (const VkSubresourceHostMemcpySizeEXT *)in_header;
18640             out_ext->sType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT;
18641             out_ext->size = in_ext->size;
18642             out_header = (void *)out_ext;
18643             break;
18644         }
18645         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
18646         {
18647             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
18648             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
18649             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
18650             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
18651             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
18652             out_header = (void *)out_ext;
18653             break;
18654         }
18655         default:
18656             break;
18657         }
18658     }
18659 }
18660
18661 #ifdef _WIN64
18662 static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out)
18663 {
18664     if (!in) return;
18665
18666     out->sType = in->sType;
18667     out->pNext = in->pNext;
18668     out->memory = wine_device_memory_from_handle(in->memory)->memory;
18669 }
18670 #endif /* _WIN64 */
18671
18672 static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo32 *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out)
18673 {
18674     if (!in) return;
18675
18676     out->sType = in->sType;
18677     out->pNext = NULL;
18678     out->memory = wine_device_memory_from_handle(in->memory)->memory;
18679     if (in->pNext)
18680         FIXME("Unexpected pNext\n");
18681 }
18682
18683 static inline void convert_VkMicromapVersionInfoEXT_win32_to_host(const VkMicromapVersionInfoEXT32 *in, VkMicromapVersionInfoEXT *out)
18684 {
18685     if (!in) return;
18686
18687     out->sType = in->sType;
18688     out->pNext = NULL;
18689     out->pVersionData = (const uint8_t *)UlongToPtr(in->pVersionData);
18690     if (in->pNext)
18691         FIXME("Unexpected pNext\n");
18692 }
18693
18694 static inline void convert_VkDeviceQueueInfo2_win32_to_host(const VkDeviceQueueInfo232 *in, VkDeviceQueueInfo2 *out)
18695 {
18696     if (!in) return;
18697
18698     out->sType = in->sType;
18699     out->pNext = NULL;
18700     out->flags = in->flags;
18701     out->queueFamilyIndex = in->queueFamilyIndex;
18702     out->queueIndex = in->queueIndex;
18703     if (in->pNext)
18704         FIXME("Unexpected pNext\n");
18705 }
18706
18707 static inline void convert_VkTilePropertiesQCOM_win32_to_host(const VkTilePropertiesQCOM32 *in, VkTilePropertiesQCOM *out)
18708 {
18709     if (!in) return;
18710
18711     out->sType = in->sType;
18712     out->pNext = NULL;
18713     out->tileSize = in->tileSize;
18714     out->apronSize = in->apronSize;
18715     out->origin = in->origin;
18716     if (in->pNext)
18717         FIXME("Unexpected pNext\n");
18718 }
18719
18720 static inline void convert_VkTilePropertiesQCOM_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out)
18721 {
18722     if (!in) return;
18723
18724     out->tileSize = in->tileSize;
18725     out->apronSize = in->apronSize;
18726     out->origin = in->origin;
18727 }
18728
18729 static inline VkTilePropertiesQCOM *convert_VkTilePropertiesQCOM_array_win32_to_host(struct conversion_context *ctx, const VkTilePropertiesQCOM32 *in, uint32_t count)
18730 {
18731     VkTilePropertiesQCOM *out;
18732     unsigned int i;
18733
18734     if (!in || !count) return NULL;
18735
18736     out = conversion_context_alloc(ctx, count * sizeof(*out));
18737     for (i = 0; i < count; i++)
18738     {
18739         convert_VkTilePropertiesQCOM_win32_to_host(&in[i], &out[i]);
18740     }
18741
18742     return out;
18743 }
18744
18745 static inline void convert_VkTilePropertiesQCOM_array_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out, uint32_t count)
18746 {
18747     unsigned int i;
18748
18749     if (!in) return;
18750
18751     for (i = 0; i < count; i++)
18752     {
18753         convert_VkTilePropertiesQCOM_host_to_win32(&in[i], &out[i]);
18754     }
18755 }
18756
18757 static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV32 *in, VkGeneratedCommandsMemoryRequirementsInfoNV *out)
18758 {
18759     if (!in) return;
18760
18761     out->sType = in->sType;
18762     out->pNext = NULL;
18763     out->pipelineBindPoint = in->pipelineBindPoint;
18764     out->pipeline = in->pipeline;
18765     out->indirectCommandsLayout = in->indirectCommandsLayout;
18766     out->maxSequencesCount = in->maxSequencesCount;
18767     if (in->pNext)
18768         FIXME("Unexpected pNext\n");
18769 }
18770
18771 static inline void convert_VkImageMemoryRequirementsInfo2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryRequirementsInfo232 *in, VkImageMemoryRequirementsInfo2 *out)
18772 {
18773     const VkBaseInStructure32 *in_header;
18774     VkBaseOutStructure *out_header = (void *)out;
18775
18776     if (!in) return;
18777
18778     out->sType = in->sType;
18779     out->pNext = NULL;
18780     out->image = in->image;
18781
18782     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
18783     {
18784         switch (in_header->sType)
18785         {
18786         case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
18787         {
18788             VkImagePlaneMemoryRequirementsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18789             const VkImagePlaneMemoryRequirementsInfo32 *in_ext = (const VkImagePlaneMemoryRequirementsInfo32 *)in_header;
18790             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
18791             out_ext->pNext = NULL;
18792             out_ext->planeAspect = in_ext->planeAspect;
18793             out_header->pNext = (void *)out_ext;
18794             out_header = (void *)out_ext;
18795             break;
18796         }
18797         default:
18798             FIXME("Unhandled sType %u.\n", in_header->sType);
18799             break;
18800         }
18801     }
18802 }
18803
18804 static inline void convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageCaptureDescriptorDataInfoEXT32 *in, VkImageCaptureDescriptorDataInfoEXT *out)
18805 {
18806     if (!in) return;
18807
18808     out->sType = in->sType;
18809     out->pNext = NULL;
18810     out->image = in->image;
18811     if (in->pNext)
18812         FIXME("Unexpected pNext\n");
18813 }
18814
18815 static inline void convert_VkSparseImageMemoryRequirements_array_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out, uint32_t count)
18816 {
18817     unsigned int i;
18818
18819     if (!in) return;
18820
18821     for (i = 0; i < count; i++)
18822     {
18823         convert_VkSparseImageMemoryRequirements_host_to_win32(&in[i], &out[i]);
18824     }
18825 }
18826
18827 static inline void convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(const VkImageSparseMemoryRequirementsInfo232 *in, VkImageSparseMemoryRequirementsInfo2 *out)
18828 {
18829     if (!in) return;
18830
18831     out->sType = in->sType;
18832     out->pNext = NULL;
18833     out->image = in->image;
18834     if (in->pNext)
18835         FIXME("Unexpected pNext\n");
18836 }
18837
18838 static inline void convert_VkImageViewAddressPropertiesNVX_win32_to_host(const VkImageViewAddressPropertiesNVX32 *in, VkImageViewAddressPropertiesNVX *out)
18839 {
18840     if (!in) return;
18841
18842     out->sType = in->sType;
18843     out->pNext = NULL;
18844     if (in->pNext)
18845         FIXME("Unexpected pNext\n");
18846 }
18847
18848 static inline void convert_VkImageViewAddressPropertiesNVX_host_to_win32(const VkImageViewAddressPropertiesNVX *in, VkImageViewAddressPropertiesNVX32 *out)
18849 {
18850     if (!in) return;
18851
18852     out->deviceAddress = in->deviceAddress;
18853     out->size = in->size;
18854 }
18855
18856 static inline void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageViewHandleInfoNVX32 *in, VkImageViewHandleInfoNVX *out)
18857 {
18858     if (!in) return;
18859
18860     out->sType = in->sType;
18861     out->pNext = NULL;
18862     out->imageView = in->imageView;
18863     out->descriptorType = in->descriptorType;
18864     out->sampler = in->sampler;
18865     if (in->pNext)
18866         FIXME("Unexpected pNext\n");
18867 }
18868
18869 static inline void convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageViewCaptureDescriptorDataInfoEXT32 *in, VkImageViewCaptureDescriptorDataInfoEXT *out)
18870 {
18871     if (!in) return;
18872
18873     out->sType = in->sType;
18874     out->pNext = NULL;
18875     out->imageView = in->imageView;
18876     if (in->pNext)
18877         FIXME("Unexpected pNext\n");
18878 }
18879
18880 static inline void convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(const VkMemoryHostPointerPropertiesEXT32 *in, VkMemoryHostPointerPropertiesEXT *out)
18881 {
18882     if (!in) return;
18883
18884     out->sType = in->sType;
18885     out->pNext = NULL;
18886     if (in->pNext)
18887         FIXME("Unexpected pNext\n");
18888 }
18889
18890 static inline void convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(const VkMemoryHostPointerPropertiesEXT *in, VkMemoryHostPointerPropertiesEXT32 *out)
18891 {
18892     if (!in) return;
18893
18894     out->memoryTypeBits = in->memoryTypeBits;
18895 }
18896
18897 static inline void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMicromapBuildSizesInfoEXT32 *in, VkMicromapBuildSizesInfoEXT *out)
18898 {
18899     if (!in) return;
18900
18901     out->sType = in->sType;
18902     out->pNext = NULL;
18903     out->micromapSize = in->micromapSize;
18904     out->buildScratchSize = in->buildScratchSize;
18905     out->discardable = in->discardable;
18906     if (in->pNext)
18907         FIXME("Unexpected pNext\n");
18908 }
18909
18910 static inline void convert_VkMicromapBuildSizesInfoEXT_host_to_win32(const VkMicromapBuildSizesInfoEXT *in, VkMicromapBuildSizesInfoEXT32 *out)
18911 {
18912     if (!in) return;
18913
18914     out->micromapSize = in->micromapSize;
18915     out->buildScratchSize = in->buildScratchSize;
18916     out->discardable = in->discardable;
18917 }
18918
18919 static inline void convert_VkPerformanceValueDataINTEL_win32_to_host(const VkPerformanceValueDataINTEL32 *in, VkPerformanceValueDataINTEL *out, VkFlags selector)
18920 {
18921     if (!in) return;
18922
18923     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL)
18924         out->value32 = in->value32;
18925     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL)
18926         out->value64 = in->value64;
18927     if (selector == VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL)
18928         out->valueFloat = in->valueFloat;
18929     if (selector == VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL)
18930         out->valueBool = in->valueBool;
18931     if (selector == VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL)
18932         out->valueString = (const char *)UlongToPtr(in->valueString);
18933 }
18934
18935 static inline void convert_VkPerformanceValueDataINTEL_host_to_win32(const VkPerformanceValueDataINTEL *in, VkPerformanceValueDataINTEL32 *out, VkFlags selector)
18936 {
18937     if (!in) return;
18938
18939     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL)
18940         out->value32 = in->value32;
18941     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL)
18942         out->value64 = in->value64;
18943     if (selector == VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL)
18944         out->valueFloat = in->valueFloat;
18945     if (selector == VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL)
18946         out->valueBool = in->valueBool;
18947 }
18948
18949 static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerformanceValueINTEL *in, VkPerformanceValueINTEL32 *out)
18950 {
18951     if (!in) return;
18952
18953     out->type = in->type;
18954     convert_VkPerformanceValueDataINTEL_host_to_win32(&in->data, &out->data, in->type);
18955 }
18956
18957 static inline void convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(const VkCooperativeMatrixPropertiesKHR32 *in, VkCooperativeMatrixPropertiesKHR *out)
18958 {
18959     if (!in) return;
18960
18961     out->sType = in->sType;
18962     out->pNext = NULL;
18963     out->MSize = in->MSize;
18964     out->NSize = in->NSize;
18965     out->KSize = in->KSize;
18966     out->AType = in->AType;
18967     out->BType = in->BType;
18968     out->CType = in->CType;
18969     out->ResultType = in->ResultType;
18970     out->saturatingAccumulation = in->saturatingAccumulation;
18971     out->scope = in->scope;
18972     if (in->pNext)
18973         FIXME("Unexpected pNext\n");
18974 }
18975
18976 static inline void convert_VkCooperativeMatrixPropertiesKHR_host_to_win32(const VkCooperativeMatrixPropertiesKHR *in, VkCooperativeMatrixPropertiesKHR32 *out)
18977 {
18978     if (!in) return;
18979
18980     out->MSize = in->MSize;
18981     out->NSize = in->NSize;
18982     out->KSize = in->KSize;
18983     out->AType = in->AType;
18984     out->BType = in->BType;
18985     out->CType = in->CType;
18986     out->ResultType = in->ResultType;
18987     out->saturatingAccumulation = in->saturatingAccumulation;
18988     out->scope = in->scope;
18989 }
18990
18991 static inline VkCooperativeMatrixPropertiesKHR *convert_VkCooperativeMatrixPropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesKHR32 *in, uint32_t count)
18992 {
18993     VkCooperativeMatrixPropertiesKHR *out;
18994     unsigned int i;
18995
18996     if (!in || !count) return NULL;
18997
18998     out = conversion_context_alloc(ctx, count * sizeof(*out));
18999     for (i = 0; i < count; i++)
19000     {
19001         convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(&in[i], &out[i]);
19002     }
19003
19004     return out;
19005 }
19006
19007 static inline void convert_VkCooperativeMatrixPropertiesKHR_array_host_to_win32(const VkCooperativeMatrixPropertiesKHR *in, VkCooperativeMatrixPropertiesKHR32 *out, uint32_t count)
19008 {
19009     unsigned int i;
19010
19011     if (!in) return;
19012
19013     for (i = 0; i < count; i++)
19014     {
19015         convert_VkCooperativeMatrixPropertiesKHR_host_to_win32(&in[i], &out[i]);
19016     }
19017 }
19018
19019 static inline void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const VkCooperativeMatrixPropertiesNV32 *in, VkCooperativeMatrixPropertiesNV *out)
19020 {
19021     if (!in) return;
19022
19023     out->sType = in->sType;
19024     out->pNext = NULL;
19025     if (in->pNext)
19026         FIXME("Unexpected pNext\n");
19027 }
19028
19029 static inline void convert_VkCooperativeMatrixPropertiesNV_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out)
19030 {
19031     if (!in) return;
19032
19033     out->MSize = in->MSize;
19034     out->NSize = in->NSize;
19035     out->KSize = in->KSize;
19036     out->AType = in->AType;
19037     out->BType = in->BType;
19038     out->CType = in->CType;
19039     out->DType = in->DType;
19040     out->scope = in->scope;
19041 }
19042
19043 static inline VkCooperativeMatrixPropertiesNV *convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesNV32 *in, uint32_t count)
19044 {
19045     VkCooperativeMatrixPropertiesNV *out;
19046     unsigned int i;
19047
19048     if (!in || !count) return NULL;
19049
19050     out = conversion_context_alloc(ctx, count * sizeof(*out));
19051     for (i = 0; i < count; i++)
19052     {
19053         convert_VkCooperativeMatrixPropertiesNV_win32_to_host(&in[i], &out[i]);
19054     }
19055
19056     return out;
19057 }
19058
19059 static inline void convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out, uint32_t count)
19060 {
19061     unsigned int i;
19062
19063     if (!in) return;
19064
19065     for (i = 0; i < count; i++)
19066     {
19067         convert_VkCooperativeMatrixPropertiesNV_host_to_win32(&in[i], &out[i]);
19068     }
19069 }
19070
19071 static inline void convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalBufferInfo32 *in, VkPhysicalDeviceExternalBufferInfo *out)
19072 {
19073     const VkBaseInStructure32 *in_header;
19074     VkBaseOutStructure *out_header = (void *)out;
19075
19076     if (!in) return;
19077
19078     out->sType = in->sType;
19079     out->pNext = NULL;
19080     out->flags = in->flags;
19081     out->usage = in->usage;
19082     out->handleType = in->handleType;
19083
19084     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
19085     {
19086         switch (in_header->sType)
19087         {
19088         case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
19089         {
19090             VkBufferUsageFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19091             const VkBufferUsageFlags2CreateInfoKHR32 *in_ext = (const VkBufferUsageFlags2CreateInfoKHR32 *)in_header;
19092             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR;
19093             out_ext->pNext = NULL;
19094             out_ext->usage = in_ext->usage;
19095             out_header->pNext = (void *)out_ext;
19096             out_header = (void *)out_ext;
19097             break;
19098         }
19099         default:
19100             FIXME("Unhandled sType %u.\n", in_header->sType);
19101             break;
19102         }
19103     }
19104 }
19105
19106 static inline void convert_VkExternalBufferProperties_win32_to_host(const VkExternalBufferProperties32 *in, VkExternalBufferProperties *out)
19107 {
19108     if (!in) return;
19109
19110     out->sType = in->sType;
19111     out->pNext = NULL;
19112     if (in->pNext)
19113         FIXME("Unexpected pNext\n");
19114 }
19115
19116 static inline void convert_VkExternalBufferProperties_host_to_win32(const VkExternalBufferProperties *in, VkExternalBufferProperties32 *out)
19117 {
19118     if (!in) return;
19119
19120     out->externalMemoryProperties = in->externalMemoryProperties;
19121 }
19122
19123 static inline void convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(const VkPhysicalDeviceExternalFenceInfo32 *in, VkPhysicalDeviceExternalFenceInfo *out)
19124 {
19125     if (!in) return;
19126
19127     out->sType = in->sType;
19128     out->pNext = NULL;
19129     out->handleType = in->handleType;
19130     if (in->pNext)
19131         FIXME("Unexpected pNext\n");
19132 }
19133
19134 static inline void convert_VkExternalFenceProperties_win32_to_host(const VkExternalFenceProperties32 *in, VkExternalFenceProperties *out)
19135 {
19136     if (!in) return;
19137
19138     out->sType = in->sType;
19139     out->pNext = NULL;
19140     if (in->pNext)
19141         FIXME("Unexpected pNext\n");
19142 }
19143
19144 static inline void convert_VkExternalFenceProperties_host_to_win32(const VkExternalFenceProperties *in, VkExternalFenceProperties32 *out)
19145 {
19146     if (!in) return;
19147
19148     out->exportFromImportedHandleTypes = in->exportFromImportedHandleTypes;
19149     out->compatibleHandleTypes = in->compatibleHandleTypes;
19150     out->externalFenceFeatures = in->externalFenceFeatures;
19151 }
19152
19153 static inline void convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalSemaphoreInfo32 *in, VkPhysicalDeviceExternalSemaphoreInfo *out)
19154 {
19155     const VkBaseInStructure32 *in_header;
19156     VkBaseOutStructure *out_header = (void *)out;
19157
19158     if (!in) return;
19159
19160     out->sType = in->sType;
19161     out->pNext = NULL;
19162     out->handleType = in->handleType;
19163
19164     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
19165     {
19166         switch (in_header->sType)
19167         {
19168         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
19169         {
19170             VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19171             const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header;
19172             out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
19173             out_ext->pNext = NULL;
19174             out_ext->semaphoreType = in_ext->semaphoreType;
19175             out_ext->initialValue = in_ext->initialValue;
19176             out_header->pNext = (void *)out_ext;
19177             out_header = (void *)out_ext;
19178             break;
19179         }
19180         default:
19181             FIXME("Unhandled sType %u.\n", in_header->sType);
19182             break;
19183         }
19184     }
19185 }
19186
19187 static inline void convert_VkExternalSemaphoreProperties_win32_to_host(const VkExternalSemaphoreProperties32 *in, VkExternalSemaphoreProperties *out)
19188 {
19189     if (!in) return;
19190
19191     out->sType = in->sType;
19192     out->pNext = NULL;
19193     if (in->pNext)
19194         FIXME("Unexpected pNext\n");
19195 }
19196
19197 static inline void convert_VkExternalSemaphoreProperties_host_to_win32(const VkExternalSemaphoreProperties *in, VkExternalSemaphoreProperties32 *out)
19198 {
19199     if (!in) return;
19200
19201     out->exportFromImportedHandleTypes = in->exportFromImportedHandleTypes;
19202     out->compatibleHandleTypes = in->compatibleHandleTypes;
19203     out->externalSemaphoreFeatures = in->externalSemaphoreFeatures;
19204 }
19205
19206 static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFeatures232 *in, VkPhysicalDeviceFeatures2 *out)
19207 {
19208     const VkBaseInStructure32 *in_header;
19209     VkBaseOutStructure *out_header = (void *)out;
19210
19211     if (!in) return;
19212
19213     out->sType = in->sType;
19214     out->pNext = NULL;
19215     out->features = in->features;
19216
19217     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
19218     {
19219         switch (in_header->sType)
19220         {
19221         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
19222         {
19223             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19224             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header;
19225             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
19226             out_ext->pNext = NULL;
19227             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
19228             out_header->pNext = (void *)out_ext;
19229             out_header = (void *)out_ext;
19230             break;
19231         }
19232         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
19233         {
19234             VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19235             const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *)in_header;
19236             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV;
19237             out_ext->pNext = NULL;
19238             out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute;
19239             out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines;
19240             out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay;
19241             out_header->pNext = (void *)out_ext;
19242             out_header = (void *)out_ext;
19243             break;
19244         }
19245         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
19246         {
19247             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19248             const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header;
19249             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
19250             out_ext->pNext = NULL;
19251             out_ext->privateData = in_ext->privateData;
19252             out_header->pNext = (void *)out_ext;
19253             out_header = (void *)out_ext;
19254             break;
19255         }
19256         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
19257         {
19258             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19259             const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header;
19260             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
19261             out_ext->pNext = NULL;
19262             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
19263             out_ext->variablePointers = in_ext->variablePointers;
19264             out_header->pNext = (void *)out_ext;
19265             out_header = (void *)out_ext;
19266             break;
19267         }
19268         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
19269         {
19270             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19271             const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header;
19272             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
19273             out_ext->pNext = NULL;
19274             out_ext->multiview = in_ext->multiview;
19275             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
19276             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
19277             out_header->pNext = (void *)out_ext;
19278             out_header = (void *)out_ext;
19279             break;
19280         }
19281         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
19282         {
19283             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19284             const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header;
19285             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
19286             out_ext->pNext = NULL;
19287             out_ext->presentId = in_ext->presentId;
19288             out_header->pNext = (void *)out_ext;
19289             out_header = (void *)out_ext;
19290             break;
19291         }
19292         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
19293         {
19294             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19295             const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header;
19296             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
19297             out_ext->pNext = NULL;
19298             out_ext->presentWait = in_ext->presentWait;
19299             out_header->pNext = (void *)out_ext;
19300             out_header = (void *)out_ext;
19301             break;
19302         }
19303         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
19304         {
19305             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19306             const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header;
19307             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
19308             out_ext->pNext = NULL;
19309             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
19310             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
19311             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
19312             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
19313             out_header->pNext = (void *)out_ext;
19314             out_header = (void *)out_ext;
19315             break;
19316         }
19317         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
19318         {
19319             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19320             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header;
19321             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
19322             out_ext->pNext = NULL;
19323             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
19324             out_header->pNext = (void *)out_ext;
19325             out_header = (void *)out_ext;
19326             break;
19327         }
19328         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
19329         {
19330             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19331             const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header;
19332             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
19333             out_ext->pNext = NULL;
19334             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
19335             out_header->pNext = (void *)out_ext;
19336             out_header = (void *)out_ext;
19337             break;
19338         }
19339         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
19340         {
19341             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19342             const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header;
19343             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
19344             out_ext->pNext = NULL;
19345             out_ext->protectedMemory = in_ext->protectedMemory;
19346             out_header->pNext = (void *)out_ext;
19347             out_header = (void *)out_ext;
19348             break;
19349         }
19350         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
19351         {
19352             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19353             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *)in_header;
19354             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
19355             out_ext->pNext = NULL;
19356             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
19357             out_header->pNext = (void *)out_ext;
19358             out_header = (void *)out_ext;
19359             break;
19360         }
19361         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
19362         {
19363             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19364             const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header;
19365             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
19366             out_ext->pNext = NULL;
19367             out_ext->multiDraw = in_ext->multiDraw;
19368             out_header->pNext = (void *)out_ext;
19369             out_header = (void *)out_ext;
19370             break;
19371         }
19372         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
19373         {
19374             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19375             const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header;
19376             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
19377             out_ext->pNext = NULL;
19378             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
19379             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
19380             out_header->pNext = (void *)out_ext;
19381             out_header = (void *)out_ext;
19382             break;
19383         }
19384         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
19385         {
19386             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19387             const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header;
19388             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
19389             out_ext->pNext = NULL;
19390             out_ext->maintenance4 = in_ext->maintenance4;
19391             out_header->pNext = (void *)out_ext;
19392             out_header = (void *)out_ext;
19393             break;
19394         }
19395         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
19396         {
19397             VkPhysicalDeviceMaintenance5FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19398             const VkPhysicalDeviceMaintenance5FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance5FeaturesKHR32 *)in_header;
19399             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR;
19400             out_ext->pNext = NULL;
19401             out_ext->maintenance5 = in_ext->maintenance5;
19402             out_header->pNext = (void *)out_ext;
19403             out_header = (void *)out_ext;
19404             break;
19405         }
19406         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
19407         {
19408             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19409             const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header;
19410             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
19411             out_ext->pNext = NULL;
19412             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
19413             out_header->pNext = (void *)out_ext;
19414             out_header = (void *)out_ext;
19415             break;
19416         }
19417         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
19418         {
19419             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19420             const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header;
19421             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
19422             out_ext->pNext = NULL;
19423             out_ext->shaderFloat16 = in_ext->shaderFloat16;
19424             out_ext->shaderInt8 = in_ext->shaderInt8;
19425             out_header->pNext = (void *)out_ext;
19426             out_header = (void *)out_ext;
19427             break;
19428         }
19429         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
19430         {
19431             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19432             const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header;
19433             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
19434             out_ext->pNext = NULL;
19435             out_ext->hostQueryReset = in_ext->hostQueryReset;
19436             out_header->pNext = (void *)out_ext;
19437             out_header = (void *)out_ext;
19438             break;
19439         }
19440         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
19441         {
19442             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19443             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *)in_header;
19444             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
19445             out_ext->pNext = NULL;
19446             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
19447             out_header->pNext = (void *)out_ext;
19448             out_header = (void *)out_ext;
19449             break;
19450         }
19451         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
19452         {
19453             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19454             const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header;
19455             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
19456             out_ext->pNext = NULL;
19457             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
19458             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
19459             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
19460             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
19461             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
19462             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
19463             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
19464             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
19465             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
19466             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
19467             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
19468             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
19469             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
19470             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
19471             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
19472             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
19473             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
19474             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
19475             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
19476             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
19477             out_header->pNext = (void *)out_ext;
19478             out_header = (void *)out_ext;
19479             break;
19480         }
19481         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
19482         {
19483             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19484             const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header;
19485             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
19486             out_ext->pNext = NULL;
19487             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
19488             out_header->pNext = (void *)out_ext;
19489             out_header = (void *)out_ext;
19490             break;
19491         }
19492         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
19493         {
19494             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19495             const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header;
19496             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
19497             out_ext->pNext = NULL;
19498             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
19499             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
19500             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
19501             out_header->pNext = (void *)out_ext;
19502             out_header = (void *)out_ext;
19503             break;
19504         }
19505         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
19506         {
19507             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19508             const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header;
19509             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
19510             out_ext->pNext = NULL;
19511             out_ext->conditionalRendering = in_ext->conditionalRendering;
19512             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
19513             out_header->pNext = (void *)out_ext;
19514             out_header = (void *)out_ext;
19515             break;
19516         }
19517         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
19518         {
19519             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19520             const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header;
19521             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
19522             out_ext->pNext = NULL;
19523             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
19524             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
19525             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
19526             out_header->pNext = (void *)out_ext;
19527             out_header = (void *)out_ext;
19528             break;
19529         }
19530         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
19531         {
19532             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19533             const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header;
19534             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
19535             out_ext->pNext = NULL;
19536             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
19537             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
19538             out_header->pNext = (void *)out_ext;
19539             out_header = (void *)out_ext;
19540             break;
19541         }
19542         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
19543         {
19544             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19545             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header;
19546             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
19547             out_ext->pNext = NULL;
19548             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
19549             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
19550             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
19551             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
19552             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
19553             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
19554             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
19555             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
19556             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
19557             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
19558             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
19559             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
19560             out_header->pNext = (void *)out_ext;
19561             out_header = (void *)out_ext;
19562             break;
19563         }
19564         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
19565         {
19566             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19567             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header;
19568             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
19569             out_ext->pNext = NULL;
19570             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
19571             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
19572             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
19573             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
19574             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
19575             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
19576             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
19577             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
19578             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
19579             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
19580             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
19581             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
19582             out_header->pNext = (void *)out_ext;
19583             out_header = (void *)out_ext;
19584             break;
19585         }
19586         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
19587         {
19588             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19589             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *)in_header;
19590             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
19591             out_ext->pNext = NULL;
19592             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
19593             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
19594             out_header->pNext = (void *)out_ext;
19595             out_header = (void *)out_ext;
19596             break;
19597         }
19598         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
19599         {
19600             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19601             const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header;
19602             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
19603             out_ext->pNext = NULL;
19604             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
19605             out_header->pNext = (void *)out_ext;
19606             out_header = (void *)out_ext;
19607             break;
19608         }
19609         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
19610         {
19611             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19612             const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header;
19613             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
19614             out_ext->pNext = NULL;
19615             out_ext->transformFeedback = in_ext->transformFeedback;
19616             out_ext->geometryStreams = in_ext->geometryStreams;
19617             out_header->pNext = (void *)out_ext;
19618             out_header = (void *)out_ext;
19619             break;
19620         }
19621         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
19622         {
19623             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19624             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header;
19625             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
19626             out_ext->pNext = NULL;
19627             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
19628             out_header->pNext = (void *)out_ext;
19629             out_header = (void *)out_ext;
19630             break;
19631         }
19632         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
19633         {
19634             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19635             const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header;
19636             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
19637             out_ext->pNext = NULL;
19638             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
19639             out_header->pNext = (void *)out_ext;
19640             out_header = (void *)out_ext;
19641             break;
19642         }
19643         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
19644         {
19645             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19646             const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header;
19647             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
19648             out_ext->pNext = NULL;
19649             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
19650             out_header->pNext = (void *)out_ext;
19651             out_header = (void *)out_ext;
19652             break;
19653         }
19654         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
19655         {
19656             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19657             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *)in_header;
19658             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
19659             out_ext->pNext = NULL;
19660             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
19661             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
19662             out_header->pNext = (void *)out_ext;
19663             out_header = (void *)out_ext;
19664             break;
19665         }
19666         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
19667         {
19668             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19669             const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header;
19670             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
19671             out_ext->pNext = NULL;
19672             out_ext->imageFootprint = in_ext->imageFootprint;
19673             out_header->pNext = (void *)out_ext;
19674             out_header = (void *)out_ext;
19675             break;
19676         }
19677         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
19678         {
19679             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19680             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header;
19681             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
19682             out_ext->pNext = NULL;
19683             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
19684             out_header->pNext = (void *)out_ext;
19685             out_header = (void *)out_ext;
19686             break;
19687         }
19688         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
19689         {
19690             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19691             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header;
19692             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
19693             out_ext->pNext = NULL;
19694             out_ext->indirectCopy = in_ext->indirectCopy;
19695             out_header->pNext = (void *)out_ext;
19696             out_header = (void *)out_ext;
19697             break;
19698         }
19699         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
19700         {
19701             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19702             const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header;
19703             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
19704             out_ext->pNext = NULL;
19705             out_ext->memoryDecompression = in_ext->memoryDecompression;
19706             out_header->pNext = (void *)out_ext;
19707             out_header = (void *)out_ext;
19708             break;
19709         }
19710         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
19711         {
19712             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19713             const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header;
19714             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
19715             out_ext->pNext = NULL;
19716             out_ext->shadingRateImage = in_ext->shadingRateImage;
19717             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
19718             out_header->pNext = (void *)out_ext;
19719             out_header = (void *)out_ext;
19720             break;
19721         }
19722         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
19723         {
19724             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19725             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header;
19726             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
19727             out_ext->pNext = NULL;
19728             out_ext->invocationMask = in_ext->invocationMask;
19729             out_header->pNext = (void *)out_ext;
19730             out_header = (void *)out_ext;
19731             break;
19732         }
19733         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
19734         {
19735             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19736             const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header;
19737             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
19738             out_ext->pNext = NULL;
19739             out_ext->taskShader = in_ext->taskShader;
19740             out_ext->meshShader = in_ext->meshShader;
19741             out_header->pNext = (void *)out_ext;
19742             out_header = (void *)out_ext;
19743             break;
19744         }
19745         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
19746         {
19747             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19748             const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header;
19749             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
19750             out_ext->pNext = NULL;
19751             out_ext->taskShader = in_ext->taskShader;
19752             out_ext->meshShader = in_ext->meshShader;
19753             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
19754             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
19755             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
19756             out_header->pNext = (void *)out_ext;
19757             out_header = (void *)out_ext;
19758             break;
19759         }
19760         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
19761         {
19762             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19763             const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header;
19764             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
19765             out_ext->pNext = NULL;
19766             out_ext->accelerationStructure = in_ext->accelerationStructure;
19767             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
19768             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
19769             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
19770             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
19771             out_header->pNext = (void *)out_ext;
19772             out_header = (void *)out_ext;
19773             break;
19774         }
19775         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
19776         {
19777             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19778             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header;
19779             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
19780             out_ext->pNext = NULL;
19781             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
19782             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
19783             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
19784             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
19785             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
19786             out_header->pNext = (void *)out_ext;
19787             out_header = (void *)out_ext;
19788             break;
19789         }
19790         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
19791         {
19792             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19793             const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header;
19794             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
19795             out_ext->pNext = NULL;
19796             out_ext->rayQuery = in_ext->rayQuery;
19797             out_header->pNext = (void *)out_ext;
19798             out_header = (void *)out_ext;
19799             break;
19800         }
19801         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
19802         {
19803             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19804             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header;
19805             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
19806             out_ext->pNext = NULL;
19807             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
19808             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
19809             out_header->pNext = (void *)out_ext;
19810             out_header = (void *)out_ext;
19811             break;
19812         }
19813         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
19814         {
19815             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19816             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header;
19817             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
19818             out_ext->pNext = NULL;
19819             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
19820             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
19821             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
19822             out_header->pNext = (void *)out_ext;
19823             out_header = (void *)out_ext;
19824             break;
19825         }
19826         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
19827         {
19828             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19829             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header;
19830             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
19831             out_ext->pNext = NULL;
19832             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
19833             out_header->pNext = (void *)out_ext;
19834             out_header = (void *)out_ext;
19835             break;
19836         }
19837         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
19838         {
19839             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19840             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *)in_header;
19841             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
19842             out_ext->pNext = NULL;
19843             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
19844             out_header->pNext = (void *)out_ext;
19845             out_header = (void *)out_ext;
19846             break;
19847         }
19848         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
19849         {
19850             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19851             const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header;
19852             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
19853             out_ext->pNext = NULL;
19854             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
19855             out_header->pNext = (void *)out_ext;
19856             out_header = (void *)out_ext;
19857             break;
19858         }
19859         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
19860         {
19861             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19862             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header;
19863             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
19864             out_ext->pNext = NULL;
19865             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
19866             out_header->pNext = (void *)out_ext;
19867             out_header = (void *)out_ext;
19868             break;
19869         }
19870         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
19871         {
19872             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19873             const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header;
19874             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
19875             out_ext->pNext = NULL;
19876             out_ext->depthClipEnable = in_ext->depthClipEnable;
19877             out_header->pNext = (void *)out_ext;
19878             out_header = (void *)out_ext;
19879             break;
19880         }
19881         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
19882         {
19883             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19884             const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header;
19885             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
19886             out_ext->pNext = NULL;
19887             out_ext->memoryPriority = in_ext->memoryPriority;
19888             out_header->pNext = (void *)out_ext;
19889             out_header = (void *)out_ext;
19890             break;
19891         }
19892         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
19893         {
19894             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19895             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header;
19896             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
19897             out_ext->pNext = NULL;
19898             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
19899             out_header->pNext = (void *)out_ext;
19900             out_header = (void *)out_ext;
19901             break;
19902         }
19903         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
19904         {
19905             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19906             const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header;
19907             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
19908             out_ext->pNext = NULL;
19909             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
19910             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
19911             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
19912             out_header->pNext = (void *)out_ext;
19913             out_header = (void *)out_ext;
19914             break;
19915         }
19916         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
19917         {
19918             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19919             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header;
19920             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
19921             out_ext->pNext = NULL;
19922             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
19923             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
19924             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
19925             out_header->pNext = (void *)out_ext;
19926             out_header = (void *)out_ext;
19927             break;
19928         }
19929         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
19930         {
19931             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19932             const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header;
19933             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
19934             out_ext->pNext = NULL;
19935             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
19936             out_header->pNext = (void *)out_ext;
19937             out_header = (void *)out_ext;
19938             break;
19939         }
19940         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
19941         {
19942             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19943             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header;
19944             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
19945             out_ext->pNext = NULL;
19946             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
19947             out_header->pNext = (void *)out_ext;
19948             out_header = (void *)out_ext;
19949             break;
19950         }
19951         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
19952         {
19953             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19954             const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header;
19955             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
19956             out_ext->pNext = NULL;
19957             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
19958             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
19959             out_header->pNext = (void *)out_ext;
19960             out_header = (void *)out_ext;
19961             break;
19962         }
19963         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
19964         {
19965             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19966             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header;
19967             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
19968             out_ext->pNext = NULL;
19969             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
19970             out_header->pNext = (void *)out_ext;
19971             out_header = (void *)out_ext;
19972             break;
19973         }
19974         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
19975         {
19976             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19977             const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header;
19978             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
19979             out_ext->pNext = NULL;
19980             out_ext->presentBarrier = in_ext->presentBarrier;
19981             out_header->pNext = (void *)out_ext;
19982             out_header = (void *)out_ext;
19983             break;
19984         }
19985         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
19986         {
19987             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19988             const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header;
19989             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
19990             out_ext->pNext = NULL;
19991             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
19992             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
19993             out_header->pNext = (void *)out_ext;
19994             out_header = (void *)out_ext;
19995             break;
19996         }
19997         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
19998         {
19999             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20000             const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header;
20001             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
20002             out_ext->pNext = NULL;
20003             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
20004             out_header->pNext = (void *)out_ext;
20005             out_header = (void *)out_ext;
20006             break;
20007         }
20008         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
20009         {
20010             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20011             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header;
20012             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
20013             out_ext->pNext = NULL;
20014             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
20015             out_header->pNext = (void *)out_ext;
20016             out_header = (void *)out_ext;
20017             break;
20018         }
20019         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
20020         {
20021             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20022             const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header;
20023             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
20024             out_ext->pNext = NULL;
20025             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
20026             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
20027             out_header->pNext = (void *)out_ext;
20028             out_header = (void *)out_ext;
20029             break;
20030         }
20031         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
20032         {
20033             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20034             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *)in_header;
20035             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
20036             out_ext->pNext = NULL;
20037             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
20038             out_header->pNext = (void *)out_ext;
20039             out_header = (void *)out_ext;
20040             break;
20041         }
20042         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
20043         {
20044             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20045             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header;
20046             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
20047             out_ext->pNext = NULL;
20048             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
20049             out_header->pNext = (void *)out_ext;
20050             out_header = (void *)out_ext;
20051             break;
20052         }
20053         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
20054         {
20055             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20056             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header;
20057             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
20058             out_ext->pNext = NULL;
20059             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
20060             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
20061             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
20062             out_header->pNext = (void *)out_ext;
20063             out_header = (void *)out_ext;
20064             break;
20065         }
20066         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
20067         {
20068             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20069             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header;
20070             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
20071             out_ext->pNext = NULL;
20072             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
20073             out_header->pNext = (void *)out_ext;
20074             out_header = (void *)out_ext;
20075             break;
20076         }
20077         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
20078         {
20079             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20080             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header;
20081             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
20082             out_ext->pNext = NULL;
20083             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
20084             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
20085             out_header->pNext = (void *)out_ext;
20086             out_header = (void *)out_ext;
20087             break;
20088         }
20089         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
20090         {
20091             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20092             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header;
20093             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
20094             out_ext->pNext = NULL;
20095             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
20096             out_header->pNext = (void *)out_ext;
20097             out_header = (void *)out_ext;
20098             break;
20099         }
20100         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
20101         {
20102             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20103             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header;
20104             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
20105             out_ext->pNext = NULL;
20106             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
20107             out_header->pNext = (void *)out_ext;
20108             out_header = (void *)out_ext;
20109             break;
20110         }
20111         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
20112         {
20113             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20114             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header;
20115             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
20116             out_ext->pNext = NULL;
20117             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
20118             out_header->pNext = (void *)out_ext;
20119             out_header = (void *)out_ext;
20120             break;
20121         }
20122         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
20123         {
20124             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20125             const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header;
20126             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
20127             out_ext->pNext = NULL;
20128             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
20129             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
20130             out_header->pNext = (void *)out_ext;
20131             out_header = (void *)out_ext;
20132             break;
20133         }
20134         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
20135         {
20136             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20137             const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *)in_header;
20138             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
20139             out_ext->pNext = NULL;
20140             out_ext->rectangularLines = in_ext->rectangularLines;
20141             out_ext->bresenhamLines = in_ext->bresenhamLines;
20142             out_ext->smoothLines = in_ext->smoothLines;
20143             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
20144             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
20145             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
20146             out_header->pNext = (void *)out_ext;
20147             out_header = (void *)out_ext;
20148             break;
20149         }
20150         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
20151         {
20152             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20153             const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header;
20154             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
20155             out_ext->pNext = NULL;
20156             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
20157             out_header->pNext = (void *)out_ext;
20158             out_header = (void *)out_ext;
20159             break;
20160         }
20161         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
20162         {
20163             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20164             const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header;
20165             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
20166             out_ext->pNext = NULL;
20167             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
20168             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
20169             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
20170             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
20171             out_ext->multiview = in_ext->multiview;
20172             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
20173             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
20174             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
20175             out_ext->variablePointers = in_ext->variablePointers;
20176             out_ext->protectedMemory = in_ext->protectedMemory;
20177             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
20178             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
20179             out_header->pNext = (void *)out_ext;
20180             out_header = (void *)out_ext;
20181             break;
20182         }
20183         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
20184         {
20185             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20186             const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header;
20187             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
20188             out_ext->pNext = NULL;
20189             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
20190             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
20191             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
20192             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
20193             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
20194             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
20195             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
20196             out_ext->shaderFloat16 = in_ext->shaderFloat16;
20197             out_ext->shaderInt8 = in_ext->shaderInt8;
20198             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
20199             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
20200             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
20201             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
20202             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
20203             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
20204             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
20205             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
20206             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
20207             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
20208             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
20209             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
20210             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
20211             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
20212             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
20213             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
20214             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
20215             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
20216             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
20217             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
20218             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
20219             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
20220             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
20221             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
20222             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
20223             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
20224             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
20225             out_ext->hostQueryReset = in_ext->hostQueryReset;
20226             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
20227             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
20228             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
20229             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
20230             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
20231             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
20232             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
20233             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
20234             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
20235             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
20236             out_header->pNext = (void *)out_ext;
20237             out_header = (void *)out_ext;
20238             break;
20239         }
20240         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
20241         {
20242             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20243             const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header;
20244             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
20245             out_ext->pNext = NULL;
20246             out_ext->robustImageAccess = in_ext->robustImageAccess;
20247             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
20248             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
20249             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
20250             out_ext->privateData = in_ext->privateData;
20251             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
20252             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
20253             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
20254             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
20255             out_ext->synchronization2 = in_ext->synchronization2;
20256             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
20257             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
20258             out_ext->dynamicRendering = in_ext->dynamicRendering;
20259             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
20260             out_ext->maintenance4 = in_ext->maintenance4;
20261             out_header->pNext = (void *)out_ext;
20262             out_header = (void *)out_ext;
20263             break;
20264         }
20265         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
20266         {
20267             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20268             const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header;
20269             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
20270             out_ext->pNext = NULL;
20271             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
20272             out_header->pNext = (void *)out_ext;
20273             out_header = (void *)out_ext;
20274             break;
20275         }
20276         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
20277         {
20278             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20279             const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header;
20280             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
20281             out_ext->pNext = NULL;
20282             out_ext->customBorderColors = in_ext->customBorderColors;
20283             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
20284             out_header->pNext = (void *)out_ext;
20285             out_header = (void *)out_ext;
20286             break;
20287         }
20288         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
20289         {
20290             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20291             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header;
20292             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
20293             out_ext->pNext = NULL;
20294             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
20295             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
20296             out_header->pNext = (void *)out_ext;
20297             out_header = (void *)out_ext;
20298             break;
20299         }
20300         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
20301         {
20302             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20303             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header;
20304             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
20305             out_ext->pNext = NULL;
20306             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
20307             out_header->pNext = (void *)out_ext;
20308             out_header = (void *)out_ext;
20309             break;
20310         }
20311         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
20312         {
20313             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20314             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header;
20315             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
20316             out_ext->pNext = NULL;
20317             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
20318             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
20319             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
20320             out_header->pNext = (void *)out_ext;
20321             out_header = (void *)out_ext;
20322             break;
20323         }
20324         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
20325         {
20326             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20327             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header;
20328             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
20329             out_ext->pNext = NULL;
20330             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
20331             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
20332             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
20333             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
20334             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
20335             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
20336             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
20337             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
20338             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
20339             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
20340             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
20341             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
20342             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
20343             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
20344             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
20345             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
20346             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
20347             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
20348             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
20349             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
20350             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
20351             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
20352             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
20353             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
20354             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
20355             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
20356             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
20357             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
20358             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
20359             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
20360             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
20361             out_header->pNext = (void *)out_ext;
20362             out_header = (void *)out_ext;
20363             break;
20364         }
20365         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
20366         {
20367             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20368             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header;
20369             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
20370             out_ext->pNext = NULL;
20371             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
20372             out_header->pNext = (void *)out_ext;
20373             out_header = (void *)out_ext;
20374             break;
20375         }
20376         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
20377         {
20378             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20379             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header;
20380             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
20381             out_ext->pNext = NULL;
20382             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
20383             out_header->pNext = (void *)out_ext;
20384             out_header = (void *)out_ext;
20385             break;
20386         }
20387         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
20388         {
20389             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20390             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header;
20391             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
20392             out_ext->pNext = NULL;
20393             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
20394             out_header->pNext = (void *)out_ext;
20395             out_header = (void *)out_ext;
20396             break;
20397         }
20398         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
20399         {
20400             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20401             const VkPhysicalDeviceRobustness2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT32 *)in_header;
20402             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
20403             out_ext->pNext = NULL;
20404             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
20405             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
20406             out_ext->nullDescriptor = in_ext->nullDescriptor;
20407             out_header->pNext = (void *)out_ext;
20408             out_header = (void *)out_ext;
20409             break;
20410         }
20411         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
20412         {
20413             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20414             const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header;
20415             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
20416             out_ext->pNext = NULL;
20417             out_ext->robustImageAccess = in_ext->robustImageAccess;
20418             out_header->pNext = (void *)out_ext;
20419             out_header = (void *)out_ext;
20420             break;
20421         }
20422         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
20423         {
20424             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20425             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header;
20426             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
20427             out_ext->pNext = NULL;
20428             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
20429             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
20430             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
20431             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
20432             out_header->pNext = (void *)out_ext;
20433             out_header = (void *)out_ext;
20434             break;
20435         }
20436         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
20437         {
20438             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20439             const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header;
20440             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
20441             out_ext->pNext = NULL;
20442             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
20443             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
20444             out_header->pNext = (void *)out_ext;
20445             out_header = (void *)out_ext;
20446             break;
20447         }
20448         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
20449         {
20450             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20451             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header;
20452             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
20453             out_ext->pNext = NULL;
20454             out_ext->subpassShading = in_ext->subpassShading;
20455             out_header->pNext = (void *)out_ext;
20456             out_header = (void *)out_ext;
20457             break;
20458         }
20459         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
20460         {
20461             VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20462             const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *)in_header;
20463             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
20464             out_ext->pNext = NULL;
20465             out_ext->clustercullingShader = in_ext->clustercullingShader;
20466             out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
20467             out_header->pNext = (void *)out_ext;
20468             out_header = (void *)out_ext;
20469             break;
20470         }
20471         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
20472         {
20473             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20474             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header;
20475             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
20476             out_ext->pNext = NULL;
20477             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
20478             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
20479             out_header->pNext = (void *)out_ext;
20480             out_header = (void *)out_ext;
20481             break;
20482         }
20483         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
20484         {
20485             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20486             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header;
20487             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
20488             out_ext->pNext = NULL;
20489             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
20490             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
20491             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
20492             out_header->pNext = (void *)out_ext;
20493             out_header = (void *)out_ext;
20494             break;
20495         }
20496         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
20497         {
20498             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20499             const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header;
20500             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
20501             out_ext->pNext = NULL;
20502             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
20503             out_header->pNext = (void *)out_ext;
20504             out_header = (void *)out_ext;
20505             break;
20506         }
20507         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
20508         {
20509             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20510             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header;
20511             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
20512             out_ext->pNext = NULL;
20513             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
20514             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
20515             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
20516             out_header->pNext = (void *)out_ext;
20517             out_header = (void *)out_ext;
20518             break;
20519         }
20520         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
20521         {
20522             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20523             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header;
20524             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
20525             out_ext->pNext = NULL;
20526             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
20527             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
20528             out_header->pNext = (void *)out_ext;
20529             out_header = (void *)out_ext;
20530             break;
20531         }
20532         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
20533         {
20534             VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20535             const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *)in_header;
20536             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
20537             out_ext->pNext = NULL;
20538             out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
20539             out_header->pNext = (void *)out_ext;
20540             out_header = (void *)out_ext;
20541             break;
20542         }
20543         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
20544         {
20545             VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20546             const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *)in_header;
20547             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
20548             out_ext->pNext = NULL;
20549             out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
20550             out_header->pNext = (void *)out_ext;
20551             out_header = (void *)out_ext;
20552             break;
20553         }
20554         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
20555         {
20556             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20557             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header;
20558             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
20559             out_ext->pNext = NULL;
20560             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
20561             out_header->pNext = (void *)out_ext;
20562             out_header = (void *)out_ext;
20563             break;
20564         }
20565         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
20566         {
20567             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20568             const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header;
20569             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
20570             out_ext->pNext = NULL;
20571             out_ext->depthClipControl = in_ext->depthClipControl;
20572             out_header->pNext = (void *)out_ext;
20573             out_header = (void *)out_ext;
20574             break;
20575         }
20576         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
20577         {
20578             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20579             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header;
20580             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
20581             out_ext->pNext = NULL;
20582             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
20583             out_header->pNext = (void *)out_ext;
20584             out_header = (void *)out_ext;
20585             break;
20586         }
20587         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
20588         {
20589             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20590             const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header;
20591             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
20592             out_ext->pNext = NULL;
20593             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
20594             out_header->pNext = (void *)out_ext;
20595             out_header = (void *)out_ext;
20596             break;
20597         }
20598         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
20599         {
20600             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20601             const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header;
20602             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
20603             out_ext->pNext = NULL;
20604             out_ext->synchronization2 = in_ext->synchronization2;
20605             out_header->pNext = (void *)out_ext;
20606             out_header = (void *)out_ext;
20607             break;
20608         }
20609         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
20610         {
20611             VkPhysicalDeviceHostImageCopyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20612             const VkPhysicalDeviceHostImageCopyFeaturesEXT32 *in_ext = (const VkPhysicalDeviceHostImageCopyFeaturesEXT32 *)in_header;
20613             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT;
20614             out_ext->pNext = NULL;
20615             out_ext->hostImageCopy = in_ext->hostImageCopy;
20616             out_header->pNext = (void *)out_ext;
20617             out_header = (void *)out_ext;
20618             break;
20619         }
20620         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
20621         {
20622             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20623             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header;
20624             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
20625             out_ext->pNext = NULL;
20626             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
20627             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
20628             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
20629             out_header->pNext = (void *)out_ext;
20630             out_header = (void *)out_ext;
20631             break;
20632         }
20633         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
20634         {
20635             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20636             const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header;
20637             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
20638             out_ext->pNext = NULL;
20639             out_ext->legacyDithering = in_ext->legacyDithering;
20640             out_header->pNext = (void *)out_ext;
20641             out_header = (void *)out_ext;
20642             break;
20643         }
20644         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
20645         {
20646             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20647             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header;
20648             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
20649             out_ext->pNext = NULL;
20650             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
20651             out_header->pNext = (void *)out_ext;
20652             out_header = (void *)out_ext;
20653             break;
20654         }
20655         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
20656         {
20657             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20658             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *)in_header;
20659             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
20660             out_ext->pNext = NULL;
20661             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
20662             out_header->pNext = (void *)out_ext;
20663             out_header = (void *)out_ext;
20664             break;
20665         }
20666         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
20667         {
20668             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20669             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header;
20670             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
20671             out_ext->pNext = NULL;
20672             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
20673             out_header->pNext = (void *)out_ext;
20674             out_header = (void *)out_ext;
20675             break;
20676         }
20677         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
20678         {
20679             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20680             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header;
20681             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
20682             out_ext->pNext = NULL;
20683             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
20684             out_header->pNext = (void *)out_ext;
20685             out_header = (void *)out_ext;
20686             break;
20687         }
20688         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
20689         {
20690             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20691             const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *)in_header;
20692             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
20693             out_ext->pNext = NULL;
20694             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
20695             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
20696             out_header->pNext = (void *)out_ext;
20697             out_header = (void *)out_ext;
20698             break;
20699         }
20700         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
20701         {
20702             VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20703             const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header;
20704             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
20705             out_ext->pNext = NULL;
20706             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
20707             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
20708             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
20709             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
20710             out_header->pNext = (void *)out_ext;
20711             out_header = (void *)out_ext;
20712             break;
20713         }
20714         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
20715         {
20716             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20717             const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header;
20718             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
20719             out_ext->pNext = NULL;
20720             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
20721             out_header->pNext = (void *)out_ext;
20722             out_header = (void *)out_ext;
20723             break;
20724         }
20725         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
20726         {
20727             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20728             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header;
20729             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
20730             out_ext->pNext = NULL;
20731             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
20732             out_header->pNext = (void *)out_ext;
20733             out_header = (void *)out_ext;
20734             break;
20735         }
20736         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
20737         {
20738             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20739             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header;
20740             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
20741             out_ext->pNext = NULL;
20742             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
20743             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
20744             out_header->pNext = (void *)out_ext;
20745             out_header = (void *)out_ext;
20746             break;
20747         }
20748         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
20749         {
20750             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20751             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header;
20752             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
20753             out_ext->pNext = NULL;
20754             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
20755             out_header->pNext = (void *)out_ext;
20756             out_header = (void *)out_ext;
20757             break;
20758         }
20759         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
20760         {
20761             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20762             const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header;
20763             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
20764             out_ext->pNext = NULL;
20765             out_ext->dynamicRendering = in_ext->dynamicRendering;
20766             out_header->pNext = (void *)out_ext;
20767             out_header = (void *)out_ext;
20768             break;
20769         }
20770         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
20771         {
20772             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20773             const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header;
20774             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
20775             out_ext->pNext = NULL;
20776             out_ext->minLod = in_ext->minLod;
20777             out_header->pNext = (void *)out_ext;
20778             out_header = (void *)out_ext;
20779             break;
20780         }
20781         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
20782         {
20783             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20784             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header;
20785             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
20786             out_ext->pNext = NULL;
20787             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
20788             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
20789             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
20790             out_header->pNext = (void *)out_ext;
20791             out_header = (void *)out_ext;
20792             break;
20793         }
20794         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
20795         {
20796             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20797             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header;
20798             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
20799             out_ext->pNext = NULL;
20800             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
20801             out_header->pNext = (void *)out_ext;
20802             out_header = (void *)out_ext;
20803             break;
20804         }
20805         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
20806         {
20807             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20808             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header;
20809             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
20810             out_ext->pNext = NULL;
20811             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
20812             out_header->pNext = (void *)out_ext;
20813             out_header = (void *)out_ext;
20814             break;
20815         }
20816         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
20817         {
20818             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20819             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header;
20820             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
20821             out_ext->pNext = NULL;
20822             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
20823             out_header->pNext = (void *)out_ext;
20824             out_header = (void *)out_ext;
20825             break;
20826         }
20827         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
20828         {
20829             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20830             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header;
20831             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
20832             out_ext->pNext = NULL;
20833             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
20834             out_header->pNext = (void *)out_ext;
20835             out_header = (void *)out_ext;
20836             break;
20837         }
20838         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
20839         {
20840             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20841             const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header;
20842             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
20843             out_ext->pNext = NULL;
20844             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
20845             out_header->pNext = (void *)out_ext;
20846             out_header = (void *)out_ext;
20847             break;
20848         }
20849         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
20850         {
20851             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20852             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header;
20853             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
20854             out_ext->pNext = NULL;
20855             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
20856             out_header->pNext = (void *)out_ext;
20857             out_header = (void *)out_ext;
20858             break;
20859         }
20860         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
20861         {
20862             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20863             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header;
20864             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
20865             out_ext->pNext = NULL;
20866             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
20867             out_header->pNext = (void *)out_ext;
20868             out_header = (void *)out_ext;
20869             break;
20870         }
20871         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
20872         {
20873             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20874             const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header;
20875             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
20876             out_ext->pNext = NULL;
20877             out_ext->micromap = in_ext->micromap;
20878             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
20879             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
20880             out_header->pNext = (void *)out_ext;
20881             out_header = (void *)out_ext;
20882             break;
20883         }
20884         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
20885         {
20886             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20887             const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header;
20888             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
20889             out_ext->pNext = NULL;
20890             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
20891             out_header->pNext = (void *)out_ext;
20892             out_header = (void *)out_ext;
20893             break;
20894         }
20895         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
20896         {
20897             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20898             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header;
20899             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
20900             out_ext->pNext = NULL;
20901             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
20902             out_header->pNext = (void *)out_ext;
20903             out_header = (void *)out_ext;
20904             break;
20905         }
20906         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
20907         {
20908             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20909             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header;
20910             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
20911             out_ext->pNext = NULL;
20912             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
20913             out_header->pNext = (void *)out_ext;
20914             out_header = (void *)out_ext;
20915             break;
20916         }
20917         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
20918         {
20919             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20920             const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *)in_header;
20921             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
20922             out_ext->pNext = NULL;
20923             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
20924             out_header->pNext = (void *)out_ext;
20925             out_header = (void *)out_ext;
20926             break;
20927         }
20928         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
20929         {
20930             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20931             const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header;
20932             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
20933             out_ext->pNext = NULL;
20934             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
20935             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
20936             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
20937             out_header->pNext = (void *)out_ext;
20938             out_header = (void *)out_ext;
20939             break;
20940         }
20941         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
20942         {
20943             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20944             const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header;
20945             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
20946             out_ext->pNext = NULL;
20947             out_ext->tileProperties = in_ext->tileProperties;
20948             out_header->pNext = (void *)out_ext;
20949             out_header = (void *)out_ext;
20950             break;
20951         }
20952         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
20953         {
20954             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20955             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header;
20956             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
20957             out_ext->pNext = NULL;
20958             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
20959             out_header->pNext = (void *)out_ext;
20960             out_header = (void *)out_ext;
20961             break;
20962         }
20963         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
20964         {
20965             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20966             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *)in_header;
20967             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
20968             out_ext->pNext = NULL;
20969             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
20970             out_header->pNext = (void *)out_ext;
20971             out_header = (void *)out_ext;
20972             break;
20973         }
20974         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
20975         {
20976             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20977             const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header;
20978             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
20979             out_ext->pNext = NULL;
20980             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
20981             out_header->pNext = (void *)out_ext;
20982             out_header = (void *)out_ext;
20983             break;
20984         }
20985         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
20986         {
20987             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20988             const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header;
20989             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
20990             out_ext->pNext = NULL;
20991             out_ext->opticalFlow = in_ext->opticalFlow;
20992             out_header->pNext = (void *)out_ext;
20993             out_header = (void *)out_ext;
20994             break;
20995         }
20996         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
20997         {
20998             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20999             const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header;
21000             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
21001             out_ext->pNext = NULL;
21002             out_ext->deviceFault = in_ext->deviceFault;
21003             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
21004             out_header->pNext = (void *)out_ext;
21005             out_header = (void *)out_ext;
21006             break;
21007         }
21008         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
21009         {
21010             VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21011             const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *)in_header;
21012             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
21013             out_ext->pNext = NULL;
21014             out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
21015             out_header->pNext = (void *)out_ext;
21016             out_header = (void *)out_ext;
21017             break;
21018         }
21019         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
21020         {
21021             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21022             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header;
21023             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
21024             out_ext->pNext = NULL;
21025             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
21026             out_header->pNext = (void *)out_ext;
21027             out_header = (void *)out_ext;
21028             break;
21029         }
21030         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
21031         {
21032             VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21033             const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *)in_header;
21034             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
21035             out_ext->pNext = NULL;
21036             out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
21037             out_header->pNext = (void *)out_ext;
21038             out_header = (void *)out_ext;
21039             break;
21040         }
21041         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
21042         {
21043             VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21044             const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *)in_header;
21045             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT;
21046             out_ext->pNext = NULL;
21047             out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
21048             out_header->pNext = (void *)out_ext;
21049             out_header = (void *)out_ext;
21050             break;
21051         }
21052         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
21053         {
21054             VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21055             const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *)in_header;
21056             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
21057             out_ext->pNext = NULL;
21058             out_ext->depthBiasControl = in_ext->depthBiasControl;
21059             out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
21060             out_ext->floatRepresentation = in_ext->floatRepresentation;
21061             out_ext->depthBiasExact = in_ext->depthBiasExact;
21062             out_header->pNext = (void *)out_ext;
21063             out_header = (void *)out_ext;
21064             break;
21065         }
21066         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
21067         {
21068             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21069             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header;
21070             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
21071             out_ext->pNext = NULL;
21072             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
21073             out_header->pNext = (void *)out_ext;
21074             out_header = (void *)out_ext;
21075             break;
21076         }
21077         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
21078         {
21079             VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21080             const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *)in_header;
21081             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
21082             out_ext->pNext = NULL;
21083             out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
21084             out_header->pNext = (void *)out_ext;
21085             out_header = (void *)out_ext;
21086             break;
21087         }
21088         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
21089         {
21090             VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21091             const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *)in_header;
21092             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
21093             out_ext->pNext = NULL;
21094             out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
21095             out_header->pNext = (void *)out_ext;
21096             out_header = (void *)out_ext;
21097             break;
21098         }
21099         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
21100         {
21101             VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21102             const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *)in_header;
21103             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
21104             out_ext->pNext = NULL;
21105             out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
21106             out_header->pNext = (void *)out_ext;
21107             out_header = (void *)out_ext;
21108             break;
21109         }
21110         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
21111         {
21112             VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21113             const VkPhysicalDeviceShaderObjectFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT32 *)in_header;
21114             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
21115             out_ext->pNext = NULL;
21116             out_ext->shaderObject = in_ext->shaderObject;
21117             out_header->pNext = (void *)out_ext;
21118             out_header = (void *)out_ext;
21119             break;
21120         }
21121         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
21122         {
21123             VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21124             const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *)in_header;
21125             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
21126             out_ext->pNext = NULL;
21127             out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
21128             out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
21129             out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
21130             out_header->pNext = (void *)out_ext;
21131             out_header = (void *)out_ext;
21132             break;
21133         }
21134         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
21135         {
21136             VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21137             const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *)in_header;
21138             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
21139             out_ext->pNext = NULL;
21140             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
21141             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
21142             out_header->pNext = (void *)out_ext;
21143             out_header = (void *)out_ext;
21144             break;
21145         }
21146         default:
21147             FIXME("Unhandled sType %u.\n", in_header->sType);
21148             break;
21149         }
21150     }
21151 }
21152
21153 static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDeviceFeatures2 *in, VkPhysicalDeviceFeatures232 *out)
21154 {
21155     const VkBaseInStructure *in_header;
21156     VkBaseOutStructure32 *out_header = (void *)out;
21157
21158     if (!in) return;
21159
21160     out->features = in->features;
21161
21162     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
21163     {
21164         switch (in_header->sType)
21165         {
21166         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
21167         {
21168             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV);
21169             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
21170             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
21171             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
21172             out_header = (void *)out_ext;
21173             break;
21174         }
21175         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
21176         {
21177             VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV);
21178             const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *)in_header;
21179             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV;
21180             out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute;
21181             out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines;
21182             out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay;
21183             out_header = (void *)out_ext;
21184             break;
21185         }
21186         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
21187         {
21188             VkPhysicalDevicePrivateDataFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES);
21189             const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
21190             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
21191             out_ext->privateData = in_ext->privateData;
21192             out_header = (void *)out_ext;
21193             break;
21194         }
21195         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
21196         {
21197             VkPhysicalDeviceVariablePointersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
21198             const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
21199             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
21200             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
21201             out_ext->variablePointers = in_ext->variablePointers;
21202             out_header = (void *)out_ext;
21203             break;
21204         }
21205         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
21206         {
21207             VkPhysicalDeviceMultiviewFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
21208             const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
21209             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
21210             out_ext->multiview = in_ext->multiview;
21211             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
21212             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
21213             out_header = (void *)out_ext;
21214             break;
21215         }
21216         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
21217         {
21218             VkPhysicalDevicePresentIdFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR);
21219             const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
21220             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
21221             out_ext->presentId = in_ext->presentId;
21222             out_header = (void *)out_ext;
21223             break;
21224         }
21225         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
21226         {
21227             VkPhysicalDevicePresentWaitFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR);
21228             const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
21229             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
21230             out_ext->presentWait = in_ext->presentWait;
21231             out_header = (void *)out_ext;
21232             break;
21233         }
21234         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
21235         {
21236             VkPhysicalDevice16BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
21237             const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
21238             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
21239             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
21240             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
21241             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
21242             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
21243             out_header = (void *)out_ext;
21244             break;
21245         }
21246         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
21247         {
21248             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
21249             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
21250             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
21251             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
21252             out_header = (void *)out_ext;
21253             break;
21254         }
21255         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
21256         {
21257             VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
21258             const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
21259             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
21260             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
21261             out_header = (void *)out_ext;
21262             break;
21263         }
21264         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
21265         {
21266             VkPhysicalDeviceProtectedMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
21267             const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
21268             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
21269             out_ext->protectedMemory = in_ext->protectedMemory;
21270             out_header = (void *)out_ext;
21271             break;
21272         }
21273         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
21274         {
21275             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT);
21276             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
21277             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
21278             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
21279             out_header = (void *)out_ext;
21280             break;
21281         }
21282         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
21283         {
21284             VkPhysicalDeviceMultiDrawFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT);
21285             const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
21286             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
21287             out_ext->multiDraw = in_ext->multiDraw;
21288             out_header = (void *)out_ext;
21289             break;
21290         }
21291         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
21292         {
21293             VkPhysicalDeviceInlineUniformBlockFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES);
21294             const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
21295             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
21296             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
21297             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
21298             out_header = (void *)out_ext;
21299             break;
21300         }
21301         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
21302         {
21303             VkPhysicalDeviceMaintenance4Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES);
21304             const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
21305             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
21306             out_ext->maintenance4 = in_ext->maintenance4;
21307             out_header = (void *)out_ext;
21308             break;
21309         }
21310         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
21311         {
21312             VkPhysicalDeviceMaintenance5FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR);
21313             const VkPhysicalDeviceMaintenance5FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance5FeaturesKHR *)in_header;
21314             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR;
21315             out_ext->maintenance5 = in_ext->maintenance5;
21316             out_header = (void *)out_ext;
21317             break;
21318         }
21319         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
21320         {
21321             VkPhysicalDeviceShaderDrawParametersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
21322             const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
21323             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
21324             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
21325             out_header = (void *)out_ext;
21326             break;
21327         }
21328         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
21329         {
21330             VkPhysicalDeviceShaderFloat16Int8Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
21331             const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
21332             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
21333             out_ext->shaderFloat16 = in_ext->shaderFloat16;
21334             out_ext->shaderInt8 = in_ext->shaderInt8;
21335             out_header = (void *)out_ext;
21336             break;
21337         }
21338         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
21339         {
21340             VkPhysicalDeviceHostQueryResetFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
21341             const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
21342             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
21343             out_ext->hostQueryReset = in_ext->hostQueryReset;
21344             out_header = (void *)out_ext;
21345             break;
21346         }
21347         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
21348         {
21349             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR);
21350             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *)in_header;
21351             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
21352             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
21353             out_header = (void *)out_ext;
21354             break;
21355         }
21356         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
21357         {
21358             VkPhysicalDeviceDescriptorIndexingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
21359             const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
21360             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
21361             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
21362             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
21363             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
21364             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
21365             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
21366             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
21367             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
21368             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
21369             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
21370             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
21371             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
21372             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
21373             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
21374             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
21375             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
21376             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
21377             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
21378             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
21379             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
21380             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
21381             out_header = (void *)out_ext;
21382             break;
21383         }
21384         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
21385         {
21386             VkPhysicalDeviceTimelineSemaphoreFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
21387             const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
21388             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
21389             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
21390             out_header = (void *)out_ext;
21391             break;
21392         }
21393         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
21394         {
21395             VkPhysicalDevice8BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
21396             const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
21397             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
21398             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
21399             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
21400             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
21401             out_header = (void *)out_ext;
21402             break;
21403         }
21404         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
21405         {
21406             VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT);
21407             const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
21408             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
21409             out_ext->conditionalRendering = in_ext->conditionalRendering;
21410             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
21411             out_header = (void *)out_ext;
21412             break;
21413         }
21414         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
21415         {
21416             VkPhysicalDeviceVulkanMemoryModelFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
21417             const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
21418             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
21419             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
21420             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
21421             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
21422             out_header = (void *)out_ext;
21423             break;
21424         }
21425         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
21426         {
21427             VkPhysicalDeviceShaderAtomicInt64Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
21428             const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
21429             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
21430             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
21431             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
21432             out_header = (void *)out_ext;
21433             break;
21434         }
21435         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
21436         {
21437             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT);
21438             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
21439             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
21440             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
21441             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
21442             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
21443             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
21444             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
21445             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
21446             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
21447             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
21448             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
21449             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
21450             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
21451             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
21452             out_header = (void *)out_ext;
21453             break;
21454         }
21455         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
21456         {
21457             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT);
21458             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
21459             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
21460             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
21461             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
21462             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
21463             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
21464             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
21465             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
21466             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
21467             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
21468             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
21469             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
21470             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
21471             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
21472             out_header = (void *)out_ext;
21473             break;
21474         }
21475         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
21476         {
21477             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT);
21478             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header;
21479             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
21480             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
21481             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
21482             out_header = (void *)out_ext;
21483             break;
21484         }
21485         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
21486         {
21487             VkPhysicalDeviceASTCDecodeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT);
21488             const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
21489             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
21490             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
21491             out_header = (void *)out_ext;
21492             break;
21493         }
21494         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
21495         {
21496             VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
21497             const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
21498             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
21499             out_ext->transformFeedback = in_ext->transformFeedback;
21500             out_ext->geometryStreams = in_ext->geometryStreams;
21501             out_header = (void *)out_ext;
21502             break;
21503         }
21504         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
21505         {
21506             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV);
21507             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
21508             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
21509             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
21510             out_header = (void *)out_ext;
21511             break;
21512         }
21513         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
21514         {
21515             VkPhysicalDeviceExclusiveScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV);
21516             const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
21517             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
21518             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
21519             out_header = (void *)out_ext;
21520             break;
21521         }
21522         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
21523         {
21524             VkPhysicalDeviceCornerSampledImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV);
21525             const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
21526             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
21527             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
21528             out_header = (void *)out_ext;
21529             break;
21530         }
21531         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
21532         {
21533             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV);
21534             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header;
21535             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
21536             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
21537             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
21538             out_header = (void *)out_ext;
21539             break;
21540         }
21541         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
21542         {
21543             VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV);
21544             const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
21545             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
21546             out_ext->imageFootprint = in_ext->imageFootprint;
21547             out_header = (void *)out_ext;
21548             break;
21549         }
21550         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
21551         {
21552             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV);
21553             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
21554             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
21555             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
21556             out_header = (void *)out_ext;
21557             break;
21558         }
21559         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
21560         {
21561             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV);
21562             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
21563             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
21564             out_ext->indirectCopy = in_ext->indirectCopy;
21565             out_header = (void *)out_ext;
21566             break;
21567         }
21568         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
21569         {
21570             VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV);
21571             const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
21572             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
21573             out_ext->memoryDecompression = in_ext->memoryDecompression;
21574             out_header = (void *)out_ext;
21575             break;
21576         }
21577         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
21578         {
21579             VkPhysicalDeviceShadingRateImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV);
21580             const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
21581             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
21582             out_ext->shadingRateImage = in_ext->shadingRateImage;
21583             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
21584             out_header = (void *)out_ext;
21585             break;
21586         }
21587         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
21588         {
21589             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI);
21590             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
21591             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
21592             out_ext->invocationMask = in_ext->invocationMask;
21593             out_header = (void *)out_ext;
21594             break;
21595         }
21596         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
21597         {
21598             VkPhysicalDeviceMeshShaderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV);
21599             const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
21600             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
21601             out_ext->taskShader = in_ext->taskShader;
21602             out_ext->meshShader = in_ext->meshShader;
21603             out_header = (void *)out_ext;
21604             break;
21605         }
21606         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
21607         {
21608             VkPhysicalDeviceMeshShaderFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT);
21609             const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
21610             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
21611             out_ext->taskShader = in_ext->taskShader;
21612             out_ext->meshShader = in_ext->meshShader;
21613             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
21614             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
21615             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
21616             out_header = (void *)out_ext;
21617             break;
21618         }
21619         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
21620         {
21621             VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR);
21622             const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
21623             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
21624             out_ext->accelerationStructure = in_ext->accelerationStructure;
21625             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
21626             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
21627             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
21628             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
21629             out_header = (void *)out_ext;
21630             break;
21631         }
21632         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
21633         {
21634             VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR);
21635             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
21636             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
21637             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
21638             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
21639             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
21640             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
21641             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
21642             out_header = (void *)out_ext;
21643             break;
21644         }
21645         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
21646         {
21647             VkPhysicalDeviceRayQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR);
21648             const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
21649             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
21650             out_ext->rayQuery = in_ext->rayQuery;
21651             out_header = (void *)out_ext;
21652             break;
21653         }
21654         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
21655         {
21656             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR);
21657             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
21658             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
21659             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
21660             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
21661             out_header = (void *)out_ext;
21662             break;
21663         }
21664         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
21665         {
21666             VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT);
21667             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
21668             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
21669             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
21670             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
21671             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
21672             out_header = (void *)out_ext;
21673             break;
21674         }
21675         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
21676         {
21677             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT);
21678             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
21679             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
21680             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
21681             out_header = (void *)out_ext;
21682             break;
21683         }
21684         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
21685         {
21686             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM);
21687             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *)in_header;
21688             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
21689             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
21690             out_header = (void *)out_ext;
21691             break;
21692         }
21693         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
21694         {
21695             VkPhysicalDeviceScalarBlockLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
21696             const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
21697             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
21698             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
21699             out_header = (void *)out_ext;
21700             break;
21701         }
21702         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
21703         {
21704             VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
21705             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
21706             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
21707             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
21708             out_header = (void *)out_ext;
21709             break;
21710         }
21711         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
21712         {
21713             VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
21714             const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
21715             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
21716             out_ext->depthClipEnable = in_ext->depthClipEnable;
21717             out_header = (void *)out_ext;
21718             break;
21719         }
21720         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
21721         {
21722             VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT);
21723             const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
21724             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
21725             out_ext->memoryPriority = in_ext->memoryPriority;
21726             out_header = (void *)out_ext;
21727             break;
21728         }
21729         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
21730         {
21731             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT);
21732             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
21733             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
21734             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
21735             out_header = (void *)out_ext;
21736             break;
21737         }
21738         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
21739         {
21740             VkPhysicalDeviceBufferDeviceAddressFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
21741             const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
21742             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
21743             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
21744             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
21745             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
21746             out_header = (void *)out_ext;
21747             break;
21748         }
21749         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
21750         {
21751             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT);
21752             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
21753             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
21754             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
21755             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
21756             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
21757             out_header = (void *)out_ext;
21758             break;
21759         }
21760         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
21761         {
21762             VkPhysicalDeviceImagelessFramebufferFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
21763             const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
21764             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
21765             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
21766             out_header = (void *)out_ext;
21767             break;
21768         }
21769         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
21770         {
21771             VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES);
21772             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
21773             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
21774             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
21775             out_header = (void *)out_ext;
21776             break;
21777         }
21778         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
21779         {
21780             VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV);
21781             const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
21782             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
21783             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
21784             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
21785             out_header = (void *)out_ext;
21786             break;
21787         }
21788         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
21789         {
21790             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT);
21791             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
21792             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
21793             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
21794             out_header = (void *)out_ext;
21795             break;
21796         }
21797         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
21798         {
21799             VkPhysicalDevicePresentBarrierFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV);
21800             const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
21801             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
21802             out_ext->presentBarrier = in_ext->presentBarrier;
21803             out_header = (void *)out_ext;
21804             break;
21805         }
21806         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
21807         {
21808             VkPhysicalDevicePerformanceQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR);
21809             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
21810             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
21811             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
21812             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
21813             out_header = (void *)out_ext;
21814             break;
21815         }
21816         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
21817         {
21818             VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV);
21819             const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
21820             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
21821             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
21822             out_header = (void *)out_ext;
21823             break;
21824         }
21825         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
21826         {
21827             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL);
21828             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
21829             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
21830             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
21831             out_header = (void *)out_ext;
21832             break;
21833         }
21834         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
21835         {
21836             VkPhysicalDeviceShaderClockFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR);
21837             const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
21838             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
21839             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
21840             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
21841             out_header = (void *)out_ext;
21842             break;
21843         }
21844         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
21845         {
21846             VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT);
21847             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header;
21848             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
21849             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
21850             out_header = (void *)out_ext;
21851             break;
21852         }
21853         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
21854         {
21855             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV);
21856             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
21857             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
21858             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
21859             out_header = (void *)out_ext;
21860             break;
21861         }
21862         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
21863         {
21864             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT);
21865             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
21866             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
21867             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
21868             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
21869             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
21870             out_header = (void *)out_ext;
21871             break;
21872         }
21873         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
21874         {
21875             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
21876             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
21877             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
21878             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
21879             out_header = (void *)out_ext;
21880             break;
21881         }
21882         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
21883         {
21884             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT);
21885             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
21886             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
21887             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
21888             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
21889             out_header = (void *)out_ext;
21890             break;
21891         }
21892         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
21893         {
21894             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR);
21895             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
21896             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
21897             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
21898             out_header = (void *)out_ext;
21899             break;
21900         }
21901         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
21902         {
21903             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES);
21904             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
21905             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
21906             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
21907             out_header = (void *)out_ext;
21908             break;
21909         }
21910         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
21911         {
21912             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT);
21913             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
21914             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
21915             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
21916             out_header = (void *)out_ext;
21917             break;
21918         }
21919         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
21920         {
21921             VkPhysicalDeviceSubgroupSizeControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES);
21922             const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
21923             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
21924             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
21925             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
21926             out_header = (void *)out_ext;
21927             break;
21928         }
21929         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
21930         {
21931             VkPhysicalDeviceLineRasterizationFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT);
21932             const VkPhysicalDeviceLineRasterizationFeaturesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header;
21933             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
21934             out_ext->rectangularLines = in_ext->rectangularLines;
21935             out_ext->bresenhamLines = in_ext->bresenhamLines;
21936             out_ext->smoothLines = in_ext->smoothLines;
21937             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
21938             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
21939             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
21940             out_header = (void *)out_ext;
21941             break;
21942         }
21943         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
21944         {
21945             VkPhysicalDevicePipelineCreationCacheControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES);
21946             const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
21947             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
21948             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
21949             out_header = (void *)out_ext;
21950             break;
21951         }
21952         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
21953         {
21954             VkPhysicalDeviceVulkan11Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
21955             const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
21956             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
21957             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
21958             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
21959             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
21960             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
21961             out_ext->multiview = in_ext->multiview;
21962             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
21963             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
21964             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
21965             out_ext->variablePointers = in_ext->variablePointers;
21966             out_ext->protectedMemory = in_ext->protectedMemory;
21967             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
21968             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
21969             out_header = (void *)out_ext;
21970             break;
21971         }
21972         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
21973         {
21974             VkPhysicalDeviceVulkan12Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
21975             const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
21976             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
21977             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
21978             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
21979             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
21980             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
21981             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
21982             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
21983             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
21984             out_ext->shaderFloat16 = in_ext->shaderFloat16;
21985             out_ext->shaderInt8 = in_ext->shaderInt8;
21986             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
21987             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
21988             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
21989             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
21990             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
21991             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
21992             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
21993             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
21994             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
21995             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
21996             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
21997             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
21998             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
21999             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
22000             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
22001             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
22002             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
22003             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
22004             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
22005             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
22006             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
22007             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
22008             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
22009             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
22010             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
22011             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
22012             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
22013             out_ext->hostQueryReset = in_ext->hostQueryReset;
22014             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
22015             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
22016             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
22017             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
22018             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
22019             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
22020             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
22021             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
22022             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
22023             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
22024             out_header = (void *)out_ext;
22025             break;
22026         }
22027         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
22028         {
22029             VkPhysicalDeviceVulkan13Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
22030             const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
22031             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
22032             out_ext->robustImageAccess = in_ext->robustImageAccess;
22033             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
22034             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
22035             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
22036             out_ext->privateData = in_ext->privateData;
22037             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
22038             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
22039             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
22040             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
22041             out_ext->synchronization2 = in_ext->synchronization2;
22042             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
22043             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
22044             out_ext->dynamicRendering = in_ext->dynamicRendering;
22045             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
22046             out_ext->maintenance4 = in_ext->maintenance4;
22047             out_header = (void *)out_ext;
22048             break;
22049         }
22050         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
22051         {
22052             VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD);
22053             const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
22054             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
22055             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
22056             out_header = (void *)out_ext;
22057             break;
22058         }
22059         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
22060         {
22061             VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT);
22062             const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
22063             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
22064             out_ext->customBorderColors = in_ext->customBorderColors;
22065             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
22066             out_header = (void *)out_ext;
22067             break;
22068         }
22069         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
22070         {
22071             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT);
22072             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
22073             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
22074             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
22075             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
22076             out_header = (void *)out_ext;
22077             break;
22078         }
22079         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
22080         {
22081             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT);
22082             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
22083             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
22084             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
22085             out_header = (void *)out_ext;
22086             break;
22087         }
22088         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
22089         {
22090             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT);
22091             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
22092             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
22093             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
22094             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
22095             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
22096             out_header = (void *)out_ext;
22097             break;
22098         }
22099         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
22100         {
22101             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT);
22102             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
22103             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
22104             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
22105             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
22106             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
22107             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
22108             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
22109             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
22110             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
22111             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
22112             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
22113             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
22114             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
22115             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
22116             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
22117             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
22118             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
22119             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
22120             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
22121             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
22122             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
22123             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
22124             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
22125             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
22126             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
22127             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
22128             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
22129             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
22130             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
22131             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
22132             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
22133             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
22134             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
22135             out_header = (void *)out_ext;
22136             break;
22137         }
22138         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
22139         {
22140             VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV);
22141             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
22142             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
22143             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
22144             out_header = (void *)out_ext;
22145             break;
22146         }
22147         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
22148         {
22149             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES);
22150             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
22151             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
22152             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
22153             out_header = (void *)out_ext;
22154             break;
22155         }
22156         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
22157         {
22158             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR);
22159             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
22160             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
22161             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
22162             out_header = (void *)out_ext;
22163             break;
22164         }
22165         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
22166         {
22167             VkPhysicalDeviceRobustness2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT);
22168             const VkPhysicalDeviceRobustness2FeaturesEXT *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT *)in_header;
22169             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
22170             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
22171             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
22172             out_ext->nullDescriptor = in_ext->nullDescriptor;
22173             out_header = (void *)out_ext;
22174             break;
22175         }
22176         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
22177         {
22178             VkPhysicalDeviceImageRobustnessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES);
22179             const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
22180             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
22181             out_ext->robustImageAccess = in_ext->robustImageAccess;
22182             out_header = (void *)out_ext;
22183             break;
22184         }
22185         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
22186         {
22187             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR);
22188             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
22189             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
22190             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
22191             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
22192             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
22193             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
22194             out_header = (void *)out_ext;
22195             break;
22196         }
22197         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
22198         {
22199             VkPhysicalDevice4444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT);
22200             const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
22201             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
22202             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
22203             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
22204             out_header = (void *)out_ext;
22205             break;
22206         }
22207         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
22208         {
22209             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI);
22210             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
22211             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
22212             out_ext->subpassShading = in_ext->subpassShading;
22213             out_header = (void *)out_ext;
22214             break;
22215         }
22216         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
22217         {
22218             VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI);
22219             const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *)in_header;
22220             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
22221             out_ext->clustercullingShader = in_ext->clustercullingShader;
22222             out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
22223             out_header = (void *)out_ext;
22224             break;
22225         }
22226         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
22227         {
22228             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT);
22229             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
22230             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
22231             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
22232             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
22233             out_header = (void *)out_ext;
22234             break;
22235         }
22236         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
22237         {
22238             VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR);
22239             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
22240             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
22241             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
22242             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
22243             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
22244             out_header = (void *)out_ext;
22245             break;
22246         }
22247         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
22248         {
22249             VkPhysicalDeviceShaderTerminateInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES);
22250             const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
22251             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
22252             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
22253             out_header = (void *)out_ext;
22254             break;
22255         }
22256         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
22257         {
22258             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV);
22259             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
22260             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
22261             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
22262             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
22263             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
22264             out_header = (void *)out_ext;
22265             break;
22266         }
22267         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
22268         {
22269             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT);
22270             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
22271             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
22272             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
22273             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
22274             out_header = (void *)out_ext;
22275             break;
22276         }
22277         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
22278         {
22279             VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT);
22280             const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)in_header;
22281             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
22282             out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
22283             out_header = (void *)out_ext;
22284             break;
22285         }
22286         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
22287         {
22288             VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT);
22289             const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)in_header;
22290             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
22291             out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
22292             out_header = (void *)out_ext;
22293             break;
22294         }
22295         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
22296         {
22297             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT);
22298             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
22299             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
22300             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
22301             out_header = (void *)out_ext;
22302             break;
22303         }
22304         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
22305         {
22306             VkPhysicalDeviceDepthClipControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT);
22307             const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
22308             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
22309             out_ext->depthClipControl = in_ext->depthClipControl;
22310             out_header = (void *)out_ext;
22311             break;
22312         }
22313         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
22314         {
22315             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT);
22316             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
22317             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
22318             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
22319             out_header = (void *)out_ext;
22320             break;
22321         }
22322         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
22323         {
22324             VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT);
22325             const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
22326             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
22327             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
22328             out_header = (void *)out_ext;
22329             break;
22330         }
22331         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
22332         {
22333             VkPhysicalDeviceSynchronization2Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES);
22334             const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
22335             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
22336             out_ext->synchronization2 = in_ext->synchronization2;
22337             out_header = (void *)out_ext;
22338             break;
22339         }
22340         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
22341         {
22342             VkPhysicalDeviceHostImageCopyFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT);
22343             const VkPhysicalDeviceHostImageCopyFeaturesEXT *in_ext = (const VkPhysicalDeviceHostImageCopyFeaturesEXT *)in_header;
22344             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT;
22345             out_ext->hostImageCopy = in_ext->hostImageCopy;
22346             out_header = (void *)out_ext;
22347             break;
22348         }
22349         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
22350         {
22351             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT);
22352             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
22353             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
22354             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
22355             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
22356             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
22357             out_header = (void *)out_ext;
22358             break;
22359         }
22360         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
22361         {
22362             VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT);
22363             const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
22364             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
22365             out_ext->legacyDithering = in_ext->legacyDithering;
22366             out_header = (void *)out_ext;
22367             break;
22368         }
22369         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
22370         {
22371             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT);
22372             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
22373             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
22374             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
22375             out_header = (void *)out_ext;
22376             break;
22377         }
22378         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
22379         {
22380             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT);
22381             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)in_header;
22382             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
22383             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
22384             out_header = (void *)out_ext;
22385             break;
22386         }
22387         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
22388         {
22389             VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV);
22390             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
22391             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
22392             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
22393             out_header = (void *)out_ext;
22394             break;
22395         }
22396         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
22397         {
22398             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT);
22399             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
22400             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
22401             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
22402             out_header = (void *)out_ext;
22403             break;
22404         }
22405         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
22406         {
22407             VkPhysicalDeviceProvokingVertexFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT);
22408             const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
22409             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
22410             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
22411             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
22412             out_header = (void *)out_ext;
22413             break;
22414         }
22415         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
22416         {
22417             VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT);
22418             const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header;
22419             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
22420             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
22421             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
22422             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
22423             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
22424             out_header = (void *)out_ext;
22425             break;
22426         }
22427         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
22428         {
22429             VkPhysicalDeviceShaderIntegerDotProductFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES);
22430             const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
22431             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
22432             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
22433             out_header = (void *)out_ext;
22434             break;
22435         }
22436         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
22437         {
22438             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR);
22439             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
22440             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
22441             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
22442             out_header = (void *)out_ext;
22443             break;
22444         }
22445         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
22446         {
22447             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV);
22448             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
22449             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
22450             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
22451             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
22452             out_header = (void *)out_ext;
22453             break;
22454         }
22455         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
22456         {
22457             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT);
22458             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
22459             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
22460             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
22461             out_header = (void *)out_ext;
22462             break;
22463         }
22464         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
22465         {
22466             VkPhysicalDeviceDynamicRenderingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES);
22467             const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
22468             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
22469             out_ext->dynamicRendering = in_ext->dynamicRendering;
22470             out_header = (void *)out_ext;
22471             break;
22472         }
22473         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
22474         {
22475             VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT);
22476             const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
22477             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
22478             out_ext->minLod = in_ext->minLod;
22479             out_header = (void *)out_ext;
22480             break;
22481         }
22482         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
22483         {
22484             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT);
22485             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
22486             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
22487             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
22488             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
22489             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
22490             out_header = (void *)out_ext;
22491             break;
22492         }
22493         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
22494         {
22495             VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV);
22496             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
22497             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
22498             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
22499             out_header = (void *)out_ext;
22500             break;
22501         }
22502         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
22503         {
22504             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT);
22505             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
22506             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
22507             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
22508             out_header = (void *)out_ext;
22509             break;
22510         }
22511         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
22512         {
22513             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE);
22514             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
22515             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
22516             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
22517             out_header = (void *)out_ext;
22518             break;
22519         }
22520         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
22521         {
22522             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT);
22523             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
22524             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
22525             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
22526             out_header = (void *)out_ext;
22527             break;
22528         }
22529         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
22530         {
22531             VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT);
22532             const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
22533             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
22534             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
22535             out_header = (void *)out_ext;
22536             break;
22537         }
22538         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
22539         {
22540             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT);
22541             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
22542             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
22543             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
22544             out_header = (void *)out_ext;
22545             break;
22546         }
22547         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
22548         {
22549             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT);
22550             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
22551             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
22552             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
22553             out_header = (void *)out_ext;
22554             break;
22555         }
22556         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
22557         {
22558             VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT);
22559             const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
22560             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
22561             out_ext->micromap = in_ext->micromap;
22562             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
22563             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
22564             out_header = (void *)out_ext;
22565             break;
22566         }
22567         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
22568         {
22569             VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT);
22570             const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
22571             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
22572             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
22573             out_header = (void *)out_ext;
22574             break;
22575         }
22576         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
22577         {
22578             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD);
22579             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header;
22580             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
22581             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
22582             out_header = (void *)out_ext;
22583             break;
22584         }
22585         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
22586         {
22587             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT);
22588             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
22589             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
22590             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
22591             out_header = (void *)out_ext;
22592             break;
22593         }
22594         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
22595         {
22596             VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT);
22597             const VkPhysicalDevicePipelineRobustnessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT *)in_header;
22598             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
22599             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
22600             out_header = (void *)out_ext;
22601             break;
22602         }
22603         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
22604         {
22605             VkPhysicalDeviceImageProcessingFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM);
22606             const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
22607             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
22608             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
22609             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
22610             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
22611             out_header = (void *)out_ext;
22612             break;
22613         }
22614         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
22615         {
22616             VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM);
22617             const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
22618             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
22619             out_ext->tileProperties = in_ext->tileProperties;
22620             out_header = (void *)out_ext;
22621             break;
22622         }
22623         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
22624         {
22625             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT);
22626             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
22627             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
22628             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
22629             out_header = (void *)out_ext;
22630             break;
22631         }
22632         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
22633         {
22634             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT);
22635             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *)in_header;
22636             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
22637             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
22638             out_header = (void *)out_ext;
22639             break;
22640         }
22641         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
22642         {
22643             VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT);
22644             const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
22645             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
22646             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
22647             out_header = (void *)out_ext;
22648             break;
22649         }
22650         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
22651         {
22652             VkPhysicalDeviceOpticalFlowFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV);
22653             const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
22654             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
22655             out_ext->opticalFlow = in_ext->opticalFlow;
22656             out_header = (void *)out_ext;
22657             break;
22658         }
22659         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
22660         {
22661             VkPhysicalDeviceFaultFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT);
22662             const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
22663             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
22664             out_ext->deviceFault = in_ext->deviceFault;
22665             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
22666             out_header = (void *)out_ext;
22667             break;
22668         }
22669         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
22670         {
22671             VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT);
22672             const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)in_header;
22673             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
22674             out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
22675             out_header = (void *)out_ext;
22676             break;
22677         }
22678         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
22679         {
22680             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM);
22681             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
22682             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
22683             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
22684             out_header = (void *)out_ext;
22685             break;
22686         }
22687         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
22688         {
22689             VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT);
22690             const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)in_header;
22691             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
22692             out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
22693             out_header = (void *)out_ext;
22694             break;
22695         }
22696         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
22697         {
22698             VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT);
22699             const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *)in_header;
22700             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT;
22701             out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
22702             out_header = (void *)out_ext;
22703             break;
22704         }
22705         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
22706         {
22707             VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT);
22708             const VkPhysicalDeviceDepthBiasControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT *)in_header;
22709             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
22710             out_ext->depthBiasControl = in_ext->depthBiasControl;
22711             out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
22712             out_ext->floatRepresentation = in_ext->floatRepresentation;
22713             out_ext->depthBiasExact = in_ext->depthBiasExact;
22714             out_header = (void *)out_ext;
22715             break;
22716         }
22717         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
22718         {
22719             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV);
22720             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
22721             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
22722             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
22723             out_header = (void *)out_ext;
22724             break;
22725         }
22726         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
22727         {
22728             VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM);
22729             const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *)in_header;
22730             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
22731             out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
22732             out_header = (void *)out_ext;
22733             break;
22734         }
22735         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
22736         {
22737             VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR);
22738             const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)in_header;
22739             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
22740             out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
22741             out_header = (void *)out_ext;
22742             break;
22743         }
22744         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
22745         {
22746             VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM);
22747             const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *)in_header;
22748             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
22749             out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
22750             out_header = (void *)out_ext;
22751             break;
22752         }
22753         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
22754         {
22755             VkPhysicalDeviceShaderObjectFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT);
22756             const VkPhysicalDeviceShaderObjectFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)in_header;
22757             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
22758             out_ext->shaderObject = in_ext->shaderObject;
22759             out_header = (void *)out_ext;
22760             break;
22761         }
22762         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
22763         {
22764             VkPhysicalDeviceShaderTileImageFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT);
22765             const VkPhysicalDeviceShaderTileImageFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT *)in_header;
22766             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
22767             out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
22768             out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
22769             out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
22770             out_header = (void *)out_ext;
22771             break;
22772         }
22773         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
22774         {
22775             VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR);
22776             const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)in_header;
22777             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR;
22778             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
22779             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
22780             out_header = (void *)out_ext;
22781             break;
22782         }
22783         default:
22784             break;
22785         }
22786     }
22787 }
22788
22789 static inline void convert_VkFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkFormatProperties232 *in, VkFormatProperties2 *out)
22790 {
22791     const VkBaseInStructure32 *in_header;
22792     VkBaseOutStructure *out_header = (void *)out;
22793
22794     if (!in) return;
22795
22796     out->sType = in->sType;
22797     out->pNext = NULL;
22798
22799     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
22800     {
22801         switch (in_header->sType)
22802         {
22803         case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
22804         {
22805             VkSubpassResolvePerformanceQueryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22806             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
22807             out_ext->pNext = NULL;
22808             out_header->pNext = (void *)out_ext;
22809             out_header = (void *)out_ext;
22810             break;
22811         }
22812         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
22813         {
22814             VkFormatProperties3 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22815             out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
22816             out_ext->pNext = NULL;
22817             out_header->pNext = (void *)out_ext;
22818             out_header = (void *)out_ext;
22819             break;
22820         }
22821         default:
22822             FIXME("Unhandled sType %u.\n", in_header->sType);
22823             break;
22824         }
22825     }
22826 }
22827
22828 static inline void convert_VkFormatProperties2_host_to_win32(const VkFormatProperties2 *in, VkFormatProperties232 *out)
22829 {
22830     const VkBaseInStructure *in_header;
22831     VkBaseOutStructure32 *out_header = (void *)out;
22832
22833     if (!in) return;
22834
22835     out->formatProperties = in->formatProperties;
22836
22837     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
22838     {
22839         switch (in_header->sType)
22840         {
22841         case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
22842         {
22843             VkSubpassResolvePerformanceQueryEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT);
22844             const VkSubpassResolvePerformanceQueryEXT *in_ext = (const VkSubpassResolvePerformanceQueryEXT *)in_header;
22845             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
22846             out_ext->optimal = in_ext->optimal;
22847             out_header = (void *)out_ext;
22848             break;
22849         }
22850         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
22851         {
22852             VkFormatProperties332 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3);
22853             const VkFormatProperties3 *in_ext = (const VkFormatProperties3 *)in_header;
22854             out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
22855             out_ext->linearTilingFeatures = in_ext->linearTilingFeatures;
22856             out_ext->optimalTilingFeatures = in_ext->optimalTilingFeatures;
22857             out_ext->bufferFeatures = in_ext->bufferFeatures;
22858             out_header = (void *)out_ext;
22859             break;
22860         }
22861         default:
22862             break;
22863         }
22864     }
22865 }
22866
22867 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(const VkPhysicalDeviceFragmentShadingRateKHR32 *in, VkPhysicalDeviceFragmentShadingRateKHR *out)
22868 {
22869     if (!in) return;
22870
22871     out->sType = in->sType;
22872     out->pNext = NULL;
22873     if (in->pNext)
22874         FIXME("Unexpected pNext\n");
22875 }
22876
22877 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out)
22878 {
22879     if (!in) return;
22880
22881     out->sampleCounts = in->sampleCounts;
22882     out->fragmentSize = in->fragmentSize;
22883 }
22884
22885 static inline VkPhysicalDeviceFragmentShadingRateKHR *convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFragmentShadingRateKHR32 *in, uint32_t count)
22886 {
22887     VkPhysicalDeviceFragmentShadingRateKHR *out;
22888     unsigned int i;
22889
22890     if (!in || !count) return NULL;
22891
22892     out = conversion_context_alloc(ctx, count * sizeof(*out));
22893     for (i = 0; i < count; i++)
22894     {
22895         convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(&in[i], &out[i]);
22896     }
22897
22898     return out;
22899 }
22900
22901 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out, uint32_t count)
22902 {
22903     unsigned int i;
22904
22905     if (!in) return;
22906
22907     for (i = 0; i < count; i++)
22908     {
22909         convert_VkPhysicalDeviceFragmentShadingRateKHR_host_to_win32(&in[i], &out[i]);
22910     }
22911 }
22912
22913 static inline void convert_VkImageFormatProperties_host_to_win32(const VkImageFormatProperties *in, VkImageFormatProperties32 *out)
22914 {
22915     if (!in) return;
22916
22917     out->maxExtent = in->maxExtent;
22918     out->maxMipLevels = in->maxMipLevels;
22919     out->maxArrayLayers = in->maxArrayLayers;
22920     out->sampleCounts = in->sampleCounts;
22921     out->maxResourceSize = in->maxResourceSize;
22922 }
22923
22924 static inline void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceImageFormatInfo232 *in, VkPhysicalDeviceImageFormatInfo2 *out)
22925 {
22926     const VkBaseInStructure32 *in_header;
22927     VkBaseOutStructure *out_header = (void *)out;
22928
22929     if (!in) return;
22930
22931     out->sType = in->sType;
22932     out->pNext = NULL;
22933     out->format = in->format;
22934     out->type = in->type;
22935     out->tiling = in->tiling;
22936     out->usage = in->usage;
22937     out->flags = in->flags;
22938
22939     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
22940     {
22941         switch (in_header->sType)
22942         {
22943         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
22944         {
22945             VkPhysicalDeviceExternalImageFormatInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22946             const VkPhysicalDeviceExternalImageFormatInfo32 *in_ext = (const VkPhysicalDeviceExternalImageFormatInfo32 *)in_header;
22947             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
22948             out_ext->pNext = NULL;
22949             out_ext->handleType = in_ext->handleType;
22950             out_header->pNext = (void *)out_ext;
22951             out_header = (void *)out_ext;
22952             break;
22953         }
22954         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
22955         {
22956             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22957             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
22958             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
22959             out_ext->pNext = NULL;
22960             out_ext->viewFormatCount = in_ext->viewFormatCount;
22961             out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
22962             out_header->pNext = (void *)out_ext;
22963             out_header = (void *)out_ext;
22964             break;
22965         }
22966         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
22967         {
22968             VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22969             const VkImageStencilUsageCreateInfo32 *in_ext = (const VkImageStencilUsageCreateInfo32 *)in_header;
22970             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
22971             out_ext->pNext = NULL;
22972             out_ext->stencilUsage = in_ext->stencilUsage;
22973             out_header->pNext = (void *)out_ext;
22974             out_header = (void *)out_ext;
22975             break;
22976         }
22977         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
22978         {
22979             VkPhysicalDeviceImageViewImageFormatInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22980             const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *in_ext = (const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *)in_header;
22981             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT;
22982             out_ext->pNext = NULL;
22983             out_ext->imageViewType = in_ext->imageViewType;
22984             out_header->pNext = (void *)out_ext;
22985             out_header = (void *)out_ext;
22986             break;
22987         }
22988         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
22989         {
22990             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22991             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
22992             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
22993             out_ext->pNext = NULL;
22994             out_ext->flags = in_ext->flags;
22995             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
22996             out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
22997             out_header->pNext = (void *)out_ext;
22998             out_header = (void *)out_ext;
22999             break;
23000         }
23001         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
23002         {
23003             VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23004             const VkOpticalFlowImageFormatInfoNV32 *in_ext = (const VkOpticalFlowImageFormatInfoNV32 *)in_header;
23005             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
23006             out_ext->pNext = NULL;
23007             out_ext->usage = in_ext->usage;
23008             out_header->pNext = (void *)out_ext;
23009             out_header = (void *)out_ext;
23010             break;
23011         }
23012         default:
23013             FIXME("Unhandled sType %u.\n", in_header->sType);
23014             break;
23015         }
23016     }
23017 }
23018
23019 static inline void convert_VkImageFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkImageFormatProperties232 *in, VkImageFormatProperties2 *out)
23020 {
23021     const VkBaseInStructure32 *in_header;
23022     VkBaseOutStructure *out_header = (void *)out;
23023
23024     if (!in) return;
23025
23026     out->sType = in->sType;
23027     out->pNext = NULL;
23028
23029     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
23030     {
23031         switch (in_header->sType)
23032         {
23033         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
23034         {
23035             VkExternalImageFormatProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23036             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
23037             out_ext->pNext = NULL;
23038             out_header->pNext = (void *)out_ext;
23039             out_header = (void *)out_ext;
23040             break;
23041         }
23042         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
23043         {
23044             VkSamplerYcbcrConversionImageFormatProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23045             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
23046             out_ext->pNext = NULL;
23047             out_header->pNext = (void *)out_ext;
23048             out_header = (void *)out_ext;
23049             break;
23050         }
23051         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
23052         {
23053             VkTextureLODGatherFormatPropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23054             out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
23055             out_ext->pNext = NULL;
23056             out_header->pNext = (void *)out_ext;
23057             out_header = (void *)out_ext;
23058             break;
23059         }
23060         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
23061         {
23062             VkFilterCubicImageViewImageFormatPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23063             out_ext->sType = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT;
23064             out_ext->pNext = NULL;
23065             out_header->pNext = (void *)out_ext;
23066             out_header = (void *)out_ext;
23067             break;
23068         }
23069         case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT:
23070         {
23071             VkHostImageCopyDevicePerformanceQueryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23072             out_ext->sType = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT;
23073             out_ext->pNext = NULL;
23074             out_header->pNext = (void *)out_ext;
23075             out_header = (void *)out_ext;
23076             break;
23077         }
23078         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
23079         {
23080             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23081             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
23082             out_ext->pNext = NULL;
23083             out_header->pNext = (void *)out_ext;
23084             out_header = (void *)out_ext;
23085             break;
23086         }
23087         default:
23088             FIXME("Unhandled sType %u.\n", in_header->sType);
23089             break;
23090         }
23091     }
23092 }
23093
23094 static inline void convert_VkImageFormatProperties2_host_to_win32(const VkImageFormatProperties2 *in, VkImageFormatProperties232 *out)
23095 {
23096     const VkBaseInStructure *in_header;
23097     VkBaseOutStructure32 *out_header = (void *)out;
23098
23099     if (!in) return;
23100
23101     convert_VkImageFormatProperties_host_to_win32(&in->imageFormatProperties, &out->imageFormatProperties);
23102
23103     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
23104     {
23105         switch (in_header->sType)
23106         {
23107         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
23108         {
23109             VkExternalImageFormatProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
23110             const VkExternalImageFormatProperties *in_ext = (const VkExternalImageFormatProperties *)in_header;
23111             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
23112             out_ext->externalMemoryProperties = in_ext->externalMemoryProperties;
23113             out_header = (void *)out_ext;
23114             break;
23115         }
23116         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
23117         {
23118             VkSamplerYcbcrConversionImageFormatProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
23119             const VkSamplerYcbcrConversionImageFormatProperties *in_ext = (const VkSamplerYcbcrConversionImageFormatProperties *)in_header;
23120             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
23121             out_ext->combinedImageSamplerDescriptorCount = in_ext->combinedImageSamplerDescriptorCount;
23122             out_header = (void *)out_ext;
23123             break;
23124         }
23125         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
23126         {
23127             VkTextureLODGatherFormatPropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD);
23128             const VkTextureLODGatherFormatPropertiesAMD *in_ext = (const VkTextureLODGatherFormatPropertiesAMD *)in_header;
23129             out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
23130             out_ext->supportsTextureGatherLODBiasAMD = in_ext->supportsTextureGatherLODBiasAMD;
23131             out_header = (void *)out_ext;
23132             break;
23133         }
23134         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
23135         {
23136             VkFilterCubicImageViewImageFormatPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT);
23137             const VkFilterCubicImageViewImageFormatPropertiesEXT *in_ext = (const VkFilterCubicImageViewImageFormatPropertiesEXT *)in_header;
23138             out_ext->sType = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT;
23139             out_ext->filterCubic = in_ext->filterCubic;
23140             out_ext->filterCubicMinmax = in_ext->filterCubicMinmax;
23141             out_header = (void *)out_ext;
23142             break;
23143         }
23144         case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT:
23145         {
23146             VkHostImageCopyDevicePerformanceQueryEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT);
23147             const VkHostImageCopyDevicePerformanceQueryEXT *in_ext = (const VkHostImageCopyDevicePerformanceQueryEXT *)in_header;
23148             out_ext->sType = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT;
23149             out_ext->optimalDeviceAccess = in_ext->optimalDeviceAccess;
23150             out_ext->identicalMemoryLayout = in_ext->identicalMemoryLayout;
23151             out_header = (void *)out_ext;
23152             break;
23153         }
23154         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
23155         {
23156             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
23157             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
23158             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
23159             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
23160             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
23161             out_header = (void *)out_ext;
23162             break;
23163         }
23164         default:
23165             break;
23166         }
23167     }
23168 }
23169
23170 static inline void convert_VkMemoryHeap_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out)
23171 {
23172     if (!in) return;
23173
23174     out->size = in->size;
23175     out->flags = in->flags;
23176 }
23177
23178 static inline void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out, uint32_t count)
23179 {
23180     unsigned int i;
23181
23182     if (!in) return;
23183
23184     for (i = 0; i < count; i++)
23185     {
23186         convert_VkMemoryHeap_host_to_win32(&in[i], &out[i]);
23187     }
23188 }
23189
23190 static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win32(const VkPhysicalDeviceMemoryProperties *in, VkPhysicalDeviceMemoryProperties32 *out)
23191 {
23192     if (!in) return;
23193
23194     out->memoryTypeCount = in->memoryTypeCount;
23195     memcpy(out->memoryTypes, in->memoryTypes, VK_MAX_MEMORY_TYPES * sizeof(VkMemoryType));
23196     out->memoryHeapCount = in->memoryHeapCount;
23197     convert_VkMemoryHeap_array_host_to_win32(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
23198 }
23199
23200 static inline void convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceMemoryProperties232 *in, VkPhysicalDeviceMemoryProperties2 *out)
23201 {
23202     const VkBaseInStructure32 *in_header;
23203     VkBaseOutStructure *out_header = (void *)out;
23204
23205     if (!in) return;
23206
23207     out->sType = in->sType;
23208     out->pNext = NULL;
23209
23210     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
23211     {
23212         switch (in_header->sType)
23213         {
23214         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
23215         {
23216             VkPhysicalDeviceMemoryBudgetPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23217             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
23218             out_ext->pNext = NULL;
23219             out_header->pNext = (void *)out_ext;
23220             out_header = (void *)out_ext;
23221             break;
23222         }
23223         default:
23224             FIXME("Unhandled sType %u.\n", in_header->sType);
23225             break;
23226         }
23227     }
23228 }
23229
23230 static inline void convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(const VkPhysicalDeviceMemoryProperties2 *in, VkPhysicalDeviceMemoryProperties232 *out)
23231 {
23232     const VkBaseInStructure *in_header;
23233     VkBaseOutStructure32 *out_header = (void *)out;
23234
23235     if (!in) return;
23236
23237     convert_VkPhysicalDeviceMemoryProperties_host_to_win32(&in->memoryProperties, &out->memoryProperties);
23238
23239     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
23240     {
23241         switch (in_header->sType)
23242         {
23243         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
23244         {
23245             VkPhysicalDeviceMemoryBudgetPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT);
23246             const VkPhysicalDeviceMemoryBudgetPropertiesEXT *in_ext = (const VkPhysicalDeviceMemoryBudgetPropertiesEXT *)in_header;
23247             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
23248             memcpy(out_ext->heapBudget, in_ext->heapBudget, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
23249             memcpy(out_ext->heapUsage, in_ext->heapUsage, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
23250             out_header = (void *)out_ext;
23251             break;
23252         }
23253         default:
23254             break;
23255         }
23256     }
23257 }
23258
23259 static inline void convert_VkMultisamplePropertiesEXT_win32_to_host(const VkMultisamplePropertiesEXT32 *in, VkMultisamplePropertiesEXT *out)
23260 {
23261     if (!in) return;
23262
23263     out->sType = in->sType;
23264     out->pNext = NULL;
23265     if (in->pNext)
23266         FIXME("Unexpected pNext\n");
23267 }
23268
23269 static inline void convert_VkMultisamplePropertiesEXT_host_to_win32(const VkMultisamplePropertiesEXT *in, VkMultisamplePropertiesEXT32 *out)
23270 {
23271     if (!in) return;
23272
23273     out->maxSampleLocationGridSize = in->maxSampleLocationGridSize;
23274 }
23275
23276 static inline void convert_VkOpticalFlowImageFormatInfoNV_win32_to_host(const VkOpticalFlowImageFormatInfoNV32 *in, VkOpticalFlowImageFormatInfoNV *out)
23277 {
23278     if (!in) return;
23279
23280     out->sType = in->sType;
23281     out->pNext = NULL;
23282     out->usage = in->usage;
23283     if (in->pNext)
23284         FIXME("Unexpected pNext\n");
23285 }
23286
23287 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(const VkOpticalFlowImageFormatPropertiesNV32 *in, VkOpticalFlowImageFormatPropertiesNV *out)
23288 {
23289     if (!in) return;
23290
23291     out->sType = in->sType;
23292     out->pNext = NULL;
23293     if (in->pNext)
23294         FIXME("Unexpected pNext\n");
23295 }
23296
23297 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out)
23298 {
23299     if (!in) return;
23300
23301     out->format = in->format;
23302 }
23303
23304 static inline VkOpticalFlowImageFormatPropertiesNV *convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowImageFormatPropertiesNV32 *in, uint32_t count)
23305 {
23306     VkOpticalFlowImageFormatPropertiesNV *out;
23307     unsigned int i;
23308
23309     if (!in || !count) return NULL;
23310
23311     out = conversion_context_alloc(ctx, count * sizeof(*out));
23312     for (i = 0; i < count; i++)
23313     {
23314         convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(&in[i], &out[i]);
23315     }
23316
23317     return out;
23318 }
23319
23320 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out, uint32_t count)
23321 {
23322     unsigned int i;
23323
23324     if (!in) return;
23325
23326     for (i = 0; i < count; i++)
23327     {
23328         convert_VkOpticalFlowImageFormatPropertiesNV_host_to_win32(&in[i], &out[i]);
23329     }
23330 }
23331
23332 static inline void convert_VkPhysicalDeviceLimits_host_to_win32(const VkPhysicalDeviceLimits *in, VkPhysicalDeviceLimits32 *out)
23333 {
23334     if (!in) return;
23335
23336     out->maxImageDimension1D = in->maxImageDimension1D;
23337     out->maxImageDimension2D = in->maxImageDimension2D;
23338     out->maxImageDimension3D = in->maxImageDimension3D;
23339     out->maxImageDimensionCube = in->maxImageDimensionCube;
23340     out->maxImageArrayLayers = in->maxImageArrayLayers;
23341     out->maxTexelBufferElements = in->maxTexelBufferElements;
23342     out->maxUniformBufferRange = in->maxUniformBufferRange;
23343     out->maxStorageBufferRange = in->maxStorageBufferRange;
23344     out->maxPushConstantsSize = in->maxPushConstantsSize;
23345     out->maxMemoryAllocationCount = in->maxMemoryAllocationCount;
23346     out->maxSamplerAllocationCount = in->maxSamplerAllocationCount;
23347     out->bufferImageGranularity = in->bufferImageGranularity;
23348     out->sparseAddressSpaceSize = in->sparseAddressSpaceSize;
23349     out->maxBoundDescriptorSets = in->maxBoundDescriptorSets;
23350     out->maxPerStageDescriptorSamplers = in->maxPerStageDescriptorSamplers;
23351     out->maxPerStageDescriptorUniformBuffers = in->maxPerStageDescriptorUniformBuffers;
23352     out->maxPerStageDescriptorStorageBuffers = in->maxPerStageDescriptorStorageBuffers;
23353     out->maxPerStageDescriptorSampledImages = in->maxPerStageDescriptorSampledImages;
23354     out->maxPerStageDescriptorStorageImages = in->maxPerStageDescriptorStorageImages;
23355     out->maxPerStageDescriptorInputAttachments = in->maxPerStageDescriptorInputAttachments;
23356     out->maxPerStageResources = in->maxPerStageResources;
23357     out->maxDescriptorSetSamplers = in->maxDescriptorSetSamplers;
23358     out->maxDescriptorSetUniformBuffers = in->maxDescriptorSetUniformBuffers;
23359     out->maxDescriptorSetUniformBuffersDynamic = in->maxDescriptorSetUniformBuffersDynamic;
23360     out->maxDescriptorSetStorageBuffers = in->maxDescriptorSetStorageBuffers;
23361     out->maxDescriptorSetStorageBuffersDynamic = in->maxDescriptorSetStorageBuffersDynamic;
23362     out->maxDescriptorSetSampledImages = in->maxDescriptorSetSampledImages;
23363     out->maxDescriptorSetStorageImages = in->maxDescriptorSetStorageImages;
23364     out->maxDescriptorSetInputAttachments = in->maxDescriptorSetInputAttachments;
23365     out->maxVertexInputAttributes = in->maxVertexInputAttributes;
23366     out->maxVertexInputBindings = in->maxVertexInputBindings;
23367     out->maxVertexInputAttributeOffset = in->maxVertexInputAttributeOffset;
23368     out->maxVertexInputBindingStride = in->maxVertexInputBindingStride;
23369     out->maxVertexOutputComponents = in->maxVertexOutputComponents;
23370     out->maxTessellationGenerationLevel = in->maxTessellationGenerationLevel;
23371     out->maxTessellationPatchSize = in->maxTessellationPatchSize;
23372     out->maxTessellationControlPerVertexInputComponents = in->maxTessellationControlPerVertexInputComponents;
23373     out->maxTessellationControlPerVertexOutputComponents = in->maxTessellationControlPerVertexOutputComponents;
23374     out->maxTessellationControlPerPatchOutputComponents = in->maxTessellationControlPerPatchOutputComponents;
23375     out->maxTessellationControlTotalOutputComponents = in->maxTessellationControlTotalOutputComponents;
23376     out->maxTessellationEvaluationInputComponents = in->maxTessellationEvaluationInputComponents;
23377     out->maxTessellationEvaluationOutputComponents = in->maxTessellationEvaluationOutputComponents;
23378     out->maxGeometryShaderInvocations = in->maxGeometryShaderInvocations;
23379     out->maxGeometryInputComponents = in->maxGeometryInputComponents;
23380     out->maxGeometryOutputComponents = in->maxGeometryOutputComponents;
23381     out->maxGeometryOutputVertices = in->maxGeometryOutputVertices;
23382     out->maxGeometryTotalOutputComponents = in->maxGeometryTotalOutputComponents;
23383     out->maxFragmentInputComponents = in->maxFragmentInputComponents;
23384     out->maxFragmentOutputAttachments = in->maxFragmentOutputAttachments;
23385     out->maxFragmentDualSrcAttachments = in->maxFragmentDualSrcAttachments;
23386     out->maxFragmentCombinedOutputResources = in->maxFragmentCombinedOutputResources;
23387     out->maxComputeSharedMemorySize = in->maxComputeSharedMemorySize;
23388     memcpy(out->maxComputeWorkGroupCount, in->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
23389     out->maxComputeWorkGroupInvocations = in->maxComputeWorkGroupInvocations;
23390     memcpy(out->maxComputeWorkGroupSize, in->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
23391     out->subPixelPrecisionBits = in->subPixelPrecisionBits;
23392     out->subTexelPrecisionBits = in->subTexelPrecisionBits;
23393     out->mipmapPrecisionBits = in->mipmapPrecisionBits;
23394     out->maxDrawIndexedIndexValue = in->maxDrawIndexedIndexValue;
23395     out->maxDrawIndirectCount = in->maxDrawIndirectCount;
23396     out->maxSamplerLodBias = in->maxSamplerLodBias;
23397     out->maxSamplerAnisotropy = in->maxSamplerAnisotropy;
23398     out->maxViewports = in->maxViewports;
23399     memcpy(out->maxViewportDimensions, in->maxViewportDimensions, 2 * sizeof(uint32_t));
23400     memcpy(out->viewportBoundsRange, in->viewportBoundsRange, 2 * sizeof(float));
23401     out->viewportSubPixelBits = in->viewportSubPixelBits;
23402     out->minMemoryMapAlignment = in->minMemoryMapAlignment;
23403     out->minTexelBufferOffsetAlignment = in->minTexelBufferOffsetAlignment;
23404     out->minUniformBufferOffsetAlignment = in->minUniformBufferOffsetAlignment;
23405     out->minStorageBufferOffsetAlignment = in->minStorageBufferOffsetAlignment;
23406     out->minTexelOffset = in->minTexelOffset;
23407     out->maxTexelOffset = in->maxTexelOffset;
23408     out->minTexelGatherOffset = in->minTexelGatherOffset;
23409     out->maxTexelGatherOffset = in->maxTexelGatherOffset;
23410     out->minInterpolationOffset = in->minInterpolationOffset;
23411     out->maxInterpolationOffset = in->maxInterpolationOffset;
23412     out->subPixelInterpolationOffsetBits = in->subPixelInterpolationOffsetBits;
23413     out->maxFramebufferWidth = in->maxFramebufferWidth;
23414     out->maxFramebufferHeight = in->maxFramebufferHeight;
23415     out->maxFramebufferLayers = in->maxFramebufferLayers;
23416     out->framebufferColorSampleCounts = in->framebufferColorSampleCounts;
23417     out->framebufferDepthSampleCounts = in->framebufferDepthSampleCounts;
23418     out->framebufferStencilSampleCounts = in->framebufferStencilSampleCounts;
23419     out->framebufferNoAttachmentsSampleCounts = in->framebufferNoAttachmentsSampleCounts;
23420     out->maxColorAttachments = in->maxColorAttachments;
23421     out->sampledImageColorSampleCounts = in->sampledImageColorSampleCounts;
23422     out->sampledImageIntegerSampleCounts = in->sampledImageIntegerSampleCounts;
23423     out->sampledImageDepthSampleCounts = in->sampledImageDepthSampleCounts;
23424     out->sampledImageStencilSampleCounts = in->sampledImageStencilSampleCounts;
23425     out->storageImageSampleCounts = in->storageImageSampleCounts;
23426     out->maxSampleMaskWords = in->maxSampleMaskWords;
23427     out->timestampComputeAndGraphics = in->timestampComputeAndGraphics;
23428     out->timestampPeriod = in->timestampPeriod;
23429     out->maxClipDistances = in->maxClipDistances;
23430     out->maxCullDistances = in->maxCullDistances;
23431     out->maxCombinedClipAndCullDistances = in->maxCombinedClipAndCullDistances;
23432     out->discreteQueuePriorities = in->discreteQueuePriorities;
23433     memcpy(out->pointSizeRange, in->pointSizeRange, 2 * sizeof(float));
23434     memcpy(out->lineWidthRange, in->lineWidthRange, 2 * sizeof(float));
23435     out->pointSizeGranularity = in->pointSizeGranularity;
23436     out->lineWidthGranularity = in->lineWidthGranularity;
23437     out->strictLines = in->strictLines;
23438     out->standardSampleLocations = in->standardSampleLocations;
23439     out->optimalBufferCopyOffsetAlignment = in->optimalBufferCopyOffsetAlignment;
23440     out->optimalBufferCopyRowPitchAlignment = in->optimalBufferCopyRowPitchAlignment;
23441     out->nonCoherentAtomSize = in->nonCoherentAtomSize;
23442 }
23443
23444 static inline void convert_VkPhysicalDeviceProperties_host_to_win32(const VkPhysicalDeviceProperties *in, VkPhysicalDeviceProperties32 *out)
23445 {
23446     if (!in) return;
23447
23448     out->apiVersion = in->apiVersion;
23449     out->driverVersion = in->driverVersion;
23450     out->vendorID = in->vendorID;
23451     out->deviceID = in->deviceID;
23452     out->deviceType = in->deviceType;
23453     memcpy(out->deviceName, in->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
23454     memcpy(out->pipelineCacheUUID, in->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
23455     convert_VkPhysicalDeviceLimits_host_to_win32(&in->limits, &out->limits);
23456     out->sparseProperties = in->sparseProperties;
23457 }
23458
23459 static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceProperties232 *in, VkPhysicalDeviceProperties2 *out)
23460 {
23461     const VkBaseInStructure32 *in_header;
23462     VkBaseOutStructure *out_header = (void *)out;
23463
23464     if (!in) return;
23465
23466     out->sType = in->sType;
23467     out->pNext = NULL;
23468
23469     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
23470     {
23471         switch (in_header->sType)
23472         {
23473         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
23474         {
23475             VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23476             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
23477             out_ext->pNext = NULL;
23478             out_header->pNext = (void *)out_ext;
23479             out_header = (void *)out_ext;
23480             break;
23481         }
23482         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
23483         {
23484             VkPhysicalDeviceMultiDrawPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23485             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
23486             out_ext->pNext = NULL;
23487             out_header->pNext = (void *)out_ext;
23488             out_header = (void *)out_ext;
23489             break;
23490         }
23491         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
23492         {
23493             VkPhysicalDevicePushDescriptorPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23494             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
23495             out_ext->pNext = NULL;
23496             out_header->pNext = (void *)out_ext;
23497             out_header = (void *)out_ext;
23498             break;
23499         }
23500         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
23501         {
23502             VkPhysicalDeviceDriverProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23503             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
23504             out_ext->pNext = NULL;
23505             out_header->pNext = (void *)out_ext;
23506             out_header = (void *)out_ext;
23507             break;
23508         }
23509         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
23510         {
23511             VkPhysicalDeviceIDProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23512             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
23513             out_ext->pNext = NULL;
23514             out_header->pNext = (void *)out_ext;
23515             out_header = (void *)out_ext;
23516             break;
23517         }
23518         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
23519         {
23520             VkPhysicalDeviceMultiviewProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23521             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
23522             out_ext->pNext = NULL;
23523             out_header->pNext = (void *)out_ext;
23524             out_header = (void *)out_ext;
23525             break;
23526         }
23527         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
23528         {
23529             VkPhysicalDeviceDiscardRectanglePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23530             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
23531             out_ext->pNext = NULL;
23532             out_header->pNext = (void *)out_ext;
23533             out_header = (void *)out_ext;
23534             break;
23535         }
23536         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
23537         {
23538             VkPhysicalDeviceSubgroupProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23539             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
23540             out_ext->pNext = NULL;
23541             out_header->pNext = (void *)out_ext;
23542             out_header = (void *)out_ext;
23543             break;
23544         }
23545         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
23546         {
23547             VkPhysicalDevicePointClippingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23548             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
23549             out_ext->pNext = NULL;
23550             out_header->pNext = (void *)out_ext;
23551             out_header = (void *)out_ext;
23552             break;
23553         }
23554         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
23555         {
23556             VkPhysicalDeviceProtectedMemoryProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23557             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
23558             out_ext->pNext = NULL;
23559             out_header->pNext = (void *)out_ext;
23560             out_header = (void *)out_ext;
23561             break;
23562         }
23563         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
23564         {
23565             VkPhysicalDeviceSamplerFilterMinmaxProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23566             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
23567             out_ext->pNext = NULL;
23568             out_header->pNext = (void *)out_ext;
23569             out_header = (void *)out_ext;
23570             break;
23571         }
23572         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
23573         {
23574             VkPhysicalDeviceSampleLocationsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23575             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
23576             out_ext->pNext = NULL;
23577             out_header->pNext = (void *)out_ext;
23578             out_header = (void *)out_ext;
23579             break;
23580         }
23581         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
23582         {
23583             VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23584             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
23585             out_ext->pNext = NULL;
23586             out_header->pNext = (void *)out_ext;
23587             out_header = (void *)out_ext;
23588             break;
23589         }
23590         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
23591         {
23592             VkPhysicalDeviceInlineUniformBlockProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23593             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
23594             out_ext->pNext = NULL;
23595             out_header->pNext = (void *)out_ext;
23596             out_header = (void *)out_ext;
23597             break;
23598         }
23599         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
23600         {
23601             VkPhysicalDeviceMaintenance3Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23602             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
23603             out_ext->pNext = NULL;
23604             out_header->pNext = (void *)out_ext;
23605             out_header = (void *)out_ext;
23606             break;
23607         }
23608         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
23609         {
23610             VkPhysicalDeviceMaintenance4Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23611             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
23612             out_ext->pNext = NULL;
23613             out_header->pNext = (void *)out_ext;
23614             out_header = (void *)out_ext;
23615             break;
23616         }
23617         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
23618         {
23619             VkPhysicalDeviceMaintenance5PropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23620             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR;
23621             out_ext->pNext = NULL;
23622             out_header->pNext = (void *)out_ext;
23623             out_header = (void *)out_ext;
23624             break;
23625         }
23626         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
23627         {
23628             VkPhysicalDeviceFloatControlsProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23629             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
23630             out_ext->pNext = NULL;
23631             out_header->pNext = (void *)out_ext;
23632             out_header = (void *)out_ext;
23633             break;
23634         }
23635         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
23636         {
23637             VkPhysicalDeviceExternalMemoryHostPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23638             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
23639             out_ext->pNext = NULL;
23640             out_header->pNext = (void *)out_ext;
23641             out_header = (void *)out_ext;
23642             break;
23643         }
23644         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
23645         {
23646             VkPhysicalDeviceConservativeRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23647             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
23648             out_ext->pNext = NULL;
23649             out_header->pNext = (void *)out_ext;
23650             out_header = (void *)out_ext;
23651             break;
23652         }
23653         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
23654         {
23655             VkPhysicalDeviceShaderCorePropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23656             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
23657             out_ext->pNext = NULL;
23658             out_header->pNext = (void *)out_ext;
23659             out_header = (void *)out_ext;
23660             break;
23661         }
23662         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
23663         {
23664             VkPhysicalDeviceShaderCoreProperties2AMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23665             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
23666             out_ext->pNext = NULL;
23667             out_header->pNext = (void *)out_ext;
23668             out_header = (void *)out_ext;
23669             break;
23670         }
23671         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
23672         {
23673             VkPhysicalDeviceDescriptorIndexingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23674             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
23675             out_ext->pNext = NULL;
23676             out_header->pNext = (void *)out_ext;
23677             out_header = (void *)out_ext;
23678             break;
23679         }
23680         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
23681         {
23682             VkPhysicalDeviceTimelineSemaphoreProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23683             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
23684             out_ext->pNext = NULL;
23685             out_header->pNext = (void *)out_ext;
23686             out_header = (void *)out_ext;
23687             break;
23688         }
23689         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
23690         {
23691             VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23692             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
23693             out_ext->pNext = NULL;
23694             out_header->pNext = (void *)out_ext;
23695             out_header = (void *)out_ext;
23696             break;
23697         }
23698         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
23699         {
23700             VkPhysicalDevicePCIBusInfoPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23701             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
23702             out_ext->pNext = NULL;
23703             out_header->pNext = (void *)out_ext;
23704             out_header = (void *)out_ext;
23705             break;
23706         }
23707         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
23708         {
23709             VkPhysicalDeviceDepthStencilResolveProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23710             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
23711             out_ext->pNext = NULL;
23712             out_header->pNext = (void *)out_ext;
23713             out_header = (void *)out_ext;
23714             break;
23715         }
23716         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
23717         {
23718             VkPhysicalDeviceTransformFeedbackPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23719             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
23720             out_ext->pNext = NULL;
23721             out_header->pNext = (void *)out_ext;
23722             out_header = (void *)out_ext;
23723             break;
23724         }
23725         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
23726         {
23727             VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23728             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
23729             out_ext->pNext = NULL;
23730             out_header->pNext = (void *)out_ext;
23731             out_header = (void *)out_ext;
23732             break;
23733         }
23734         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
23735         {
23736             VkPhysicalDeviceMemoryDecompressionPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23737             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
23738             out_ext->pNext = NULL;
23739             out_header->pNext = (void *)out_ext;
23740             out_header = (void *)out_ext;
23741             break;
23742         }
23743         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
23744         {
23745             VkPhysicalDeviceShadingRateImagePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23746             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
23747             out_ext->pNext = NULL;
23748             out_header->pNext = (void *)out_ext;
23749             out_header = (void *)out_ext;
23750             break;
23751         }
23752         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
23753         {
23754             VkPhysicalDeviceMeshShaderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23755             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
23756             out_ext->pNext = NULL;
23757             out_header->pNext = (void *)out_ext;
23758             out_header = (void *)out_ext;
23759             break;
23760         }
23761         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
23762         {
23763             VkPhysicalDeviceMeshShaderPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23764             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
23765             out_ext->pNext = NULL;
23766             out_header->pNext = (void *)out_ext;
23767             out_header = (void *)out_ext;
23768             break;
23769         }
23770         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
23771         {
23772             VkPhysicalDeviceAccelerationStructurePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23773             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
23774             out_ext->pNext = NULL;
23775             out_header->pNext = (void *)out_ext;
23776             out_header = (void *)out_ext;
23777             break;
23778         }
23779         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
23780         {
23781             VkPhysicalDeviceRayTracingPipelinePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23782             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
23783             out_ext->pNext = NULL;
23784             out_header->pNext = (void *)out_ext;
23785             out_header = (void *)out_ext;
23786             break;
23787         }
23788         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
23789         {
23790             VkPhysicalDeviceRayTracingPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23791             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
23792             out_ext->pNext = NULL;
23793             out_header->pNext = (void *)out_ext;
23794             out_header = (void *)out_ext;
23795             break;
23796         }
23797         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
23798         {
23799             VkPhysicalDeviceFragmentDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23800             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
23801             out_ext->pNext = NULL;
23802             out_header->pNext = (void *)out_ext;
23803             out_header = (void *)out_ext;
23804             break;
23805         }
23806         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
23807         {
23808             VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23809             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
23810             out_ext->pNext = NULL;
23811             out_header->pNext = (void *)out_ext;
23812             out_header = (void *)out_ext;
23813             break;
23814         }
23815         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
23816         {
23817             VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23818             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM;
23819             out_ext->pNext = NULL;
23820             out_header->pNext = (void *)out_ext;
23821             out_header = (void *)out_ext;
23822             break;
23823         }
23824         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
23825         {
23826             VkPhysicalDeviceCooperativeMatrixPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23827             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
23828             out_ext->pNext = NULL;
23829             out_header->pNext = (void *)out_ext;
23830             out_header = (void *)out_ext;
23831             break;
23832         }
23833         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
23834         {
23835             VkPhysicalDevicePerformanceQueryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23836             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
23837             out_ext->pNext = NULL;
23838             out_header->pNext = (void *)out_ext;
23839             out_header = (void *)out_ext;
23840             break;
23841         }
23842         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
23843         {
23844             VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23845             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
23846             out_ext->pNext = NULL;
23847             out_header->pNext = (void *)out_ext;
23848             out_header = (void *)out_ext;
23849             break;
23850         }
23851         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
23852         {
23853             VkPhysicalDeviceTexelBufferAlignmentProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23854             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
23855             out_ext->pNext = NULL;
23856             out_header->pNext = (void *)out_ext;
23857             out_header = (void *)out_ext;
23858             break;
23859         }
23860         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
23861         {
23862             VkPhysicalDeviceSubgroupSizeControlProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23863             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
23864             out_ext->pNext = NULL;
23865             out_header->pNext = (void *)out_ext;
23866             out_header = (void *)out_ext;
23867             break;
23868         }
23869         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
23870         {
23871             VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23872             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
23873             out_ext->pNext = NULL;
23874             out_header->pNext = (void *)out_ext;
23875             out_header = (void *)out_ext;
23876             break;
23877         }
23878         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
23879         {
23880             VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23881             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI;
23882             out_ext->pNext = NULL;
23883             out_header->pNext = (void *)out_ext;
23884             out_header = (void *)out_ext;
23885             break;
23886         }
23887         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
23888         {
23889             VkPhysicalDeviceLineRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23890             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
23891             out_ext->pNext = NULL;
23892             out_header->pNext = (void *)out_ext;
23893             out_header = (void *)out_ext;
23894             break;
23895         }
23896         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
23897         {
23898             VkPhysicalDeviceVulkan11Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23899             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
23900             out_ext->pNext = NULL;
23901             out_header->pNext = (void *)out_ext;
23902             out_header = (void *)out_ext;
23903             break;
23904         }
23905         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
23906         {
23907             VkPhysicalDeviceVulkan12Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23908             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
23909             out_ext->pNext = NULL;
23910             out_header->pNext = (void *)out_ext;
23911             out_header = (void *)out_ext;
23912             break;
23913         }
23914         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
23915         {
23916             VkPhysicalDeviceVulkan13Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23917             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
23918             out_ext->pNext = NULL;
23919             out_header->pNext = (void *)out_ext;
23920             out_header = (void *)out_ext;
23921             break;
23922         }
23923         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
23924         {
23925             VkPhysicalDeviceCustomBorderColorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23926             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
23927             out_ext->pNext = NULL;
23928             out_header->pNext = (void *)out_ext;
23929             out_header = (void *)out_ext;
23930             break;
23931         }
23932         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
23933         {
23934             VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23935             const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *)in_header;
23936             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
23937             out_ext->pNext = NULL;
23938             out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted;
23939             out_header->pNext = (void *)out_ext;
23940             out_header = (void *)out_ext;
23941             break;
23942         }
23943         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
23944         {
23945             VkPhysicalDeviceRobustness2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23946             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
23947             out_ext->pNext = NULL;
23948             out_header->pNext = (void *)out_ext;
23949             out_header = (void *)out_ext;
23950             break;
23951         }
23952         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
23953         {
23954             VkPhysicalDeviceFragmentShadingRatePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23955             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
23956             out_ext->pNext = NULL;
23957             out_header->pNext = (void *)out_ext;
23958             out_header = (void *)out_ext;
23959             break;
23960         }
23961         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
23962         {
23963             VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23964             const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *)in_header;
23965             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
23966             out_ext->pNext = NULL;
23967             out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount;
23968             out_header->pNext = (void *)out_ext;
23969             out_header = (void *)out_ext;
23970             break;
23971         }
23972         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT:
23973         {
23974             VkPhysicalDeviceHostImageCopyPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23975             const VkPhysicalDeviceHostImageCopyPropertiesEXT32 *in_ext = (const VkPhysicalDeviceHostImageCopyPropertiesEXT32 *)in_header;
23976             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT;
23977             out_ext->pNext = NULL;
23978             out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount;
23979             out_ext->pCopySrcLayouts = (VkImageLayout *)UlongToPtr(in_ext->pCopySrcLayouts);
23980             out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount;
23981             out_ext->pCopyDstLayouts = (VkImageLayout *)UlongToPtr(in_ext->pCopyDstLayouts);
23982             memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t));
23983             out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements;
23984             out_header->pNext = (void *)out_ext;
23985             out_header = (void *)out_ext;
23986             break;
23987         }
23988         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
23989         {
23990             VkPhysicalDeviceProvokingVertexPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23991             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
23992             out_ext->pNext = NULL;
23993             out_header->pNext = (void *)out_ext;
23994             out_header = (void *)out_ext;
23995             break;
23996         }
23997         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
23998         {
23999             VkPhysicalDeviceDescriptorBufferPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24000             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
24001             out_ext->pNext = NULL;
24002             out_header->pNext = (void *)out_ext;
24003             out_header = (void *)out_ext;
24004             break;
24005         }
24006         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
24007         {
24008             VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24009             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
24010             out_ext->pNext = NULL;
24011             out_header->pNext = (void *)out_ext;
24012             out_header = (void *)out_ext;
24013             break;
24014         }
24015         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
24016         {
24017             VkPhysicalDeviceShaderIntegerDotProductProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24018             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
24019             out_ext->pNext = NULL;
24020             out_header->pNext = (void *)out_ext;
24021             out_header = (void *)out_ext;
24022             break;
24023         }
24024         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
24025         {
24026             VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24027             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
24028             out_ext->pNext = NULL;
24029             out_header->pNext = (void *)out_ext;
24030             out_header = (void *)out_ext;
24031             break;
24032         }
24033         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
24034         {
24035             VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24036             const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *)in_header;
24037             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
24038             out_ext->pNext = NULL;
24039             out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking;
24040             out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration;
24041             out_header->pNext = (void *)out_ext;
24042             out_header = (void *)out_ext;
24043             break;
24044         }
24045         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
24046         {
24047             VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24048             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
24049             out_ext->pNext = NULL;
24050             out_header->pNext = (void *)out_ext;
24051             out_header = (void *)out_ext;
24052             break;
24053         }
24054         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
24055         {
24056             VkPhysicalDeviceOpacityMicromapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24057             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
24058             out_ext->pNext = NULL;
24059             out_header->pNext = (void *)out_ext;
24060             out_header = (void *)out_ext;
24061             break;
24062         }
24063         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
24064         {
24065             VkPhysicalDevicePipelineRobustnessPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24066             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT;
24067             out_ext->pNext = NULL;
24068             out_header->pNext = (void *)out_ext;
24069             out_header = (void *)out_ext;
24070             break;
24071         }
24072         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
24073         {
24074             VkPhysicalDeviceImageProcessingPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24075             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
24076             out_ext->pNext = NULL;
24077             out_header->pNext = (void *)out_ext;
24078             out_header = (void *)out_ext;
24079             break;
24080         }
24081         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
24082         {
24083             VkPhysicalDeviceOpticalFlowPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24084             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
24085             out_ext->pNext = NULL;
24086             out_header->pNext = (void *)out_ext;
24087             out_header = (void *)out_ext;
24088             break;
24089         }
24090         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
24091         {
24092             VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24093             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
24094             out_ext->pNext = NULL;
24095             out_header->pNext = (void *)out_ext;
24096             out_header = (void *)out_ext;
24097             break;
24098         }
24099         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
24100         {
24101             VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24102             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
24103             out_ext->pNext = NULL;
24104             out_header->pNext = (void *)out_ext;
24105             out_header = (void *)out_ext;
24106             break;
24107         }
24108         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
24109         {
24110             VkPhysicalDeviceShaderCorePropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24111             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM;
24112             out_ext->pNext = NULL;
24113             out_header->pNext = (void *)out_ext;
24114             out_header = (void *)out_ext;
24115             break;
24116         }
24117         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
24118         {
24119             VkPhysicalDeviceShaderObjectPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24120             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
24121             out_ext->pNext = NULL;
24122             out_header->pNext = (void *)out_ext;
24123             out_header = (void *)out_ext;
24124             break;
24125         }
24126         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
24127         {
24128             VkPhysicalDeviceShaderTileImagePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24129             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
24130             out_ext->pNext = NULL;
24131             out_header->pNext = (void *)out_ext;
24132             out_header = (void *)out_ext;
24133             break;
24134         }
24135         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
24136         {
24137             VkPhysicalDeviceCooperativeMatrixPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24138             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR;
24139             out_ext->pNext = NULL;
24140             out_header->pNext = (void *)out_ext;
24141             out_header = (void *)out_ext;
24142             break;
24143         }
24144         default:
24145             FIXME("Unhandled sType %u.\n", in_header->sType);
24146             break;
24147         }
24148     }
24149 }
24150
24151 static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDeviceProperties2 *in, VkPhysicalDeviceProperties232 *out)
24152 {
24153     const VkBaseInStructure *in_header;
24154     VkBaseOutStructure32 *out_header = (void *)out;
24155
24156     if (!in) return;
24157
24158     convert_VkPhysicalDeviceProperties_host_to_win32(&in->properties, &out->properties);
24159
24160     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
24161     {
24162         switch (in_header->sType)
24163         {
24164         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
24165         {
24166             VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV);
24167             const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *)in_header;
24168             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
24169             out_ext->maxGraphicsShaderGroupCount = in_ext->maxGraphicsShaderGroupCount;
24170             out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount;
24171             out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount;
24172             out_ext->maxIndirectCommandsStreamCount = in_ext->maxIndirectCommandsStreamCount;
24173             out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset;
24174             out_ext->maxIndirectCommandsStreamStride = in_ext->maxIndirectCommandsStreamStride;
24175             out_ext->minSequencesCountBufferOffsetAlignment = in_ext->minSequencesCountBufferOffsetAlignment;
24176             out_ext->minSequencesIndexBufferOffsetAlignment = in_ext->minSequencesIndexBufferOffsetAlignment;
24177             out_ext->minIndirectCommandsBufferOffsetAlignment = in_ext->minIndirectCommandsBufferOffsetAlignment;
24178             out_header = (void *)out_ext;
24179             break;
24180         }
24181         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
24182         {
24183             VkPhysicalDeviceMultiDrawPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT);
24184             const VkPhysicalDeviceMultiDrawPropertiesEXT *in_ext = (const VkPhysicalDeviceMultiDrawPropertiesEXT *)in_header;
24185             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
24186             out_ext->maxMultiDrawCount = in_ext->maxMultiDrawCount;
24187             out_header = (void *)out_ext;
24188             break;
24189         }
24190         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
24191         {
24192             VkPhysicalDevicePushDescriptorPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR);
24193             const VkPhysicalDevicePushDescriptorPropertiesKHR *in_ext = (const VkPhysicalDevicePushDescriptorPropertiesKHR *)in_header;
24194             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
24195             out_ext->maxPushDescriptors = in_ext->maxPushDescriptors;
24196             out_header = (void *)out_ext;
24197             break;
24198         }
24199         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
24200         {
24201             VkPhysicalDeviceDriverProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
24202             const VkPhysicalDeviceDriverProperties *in_ext = (const VkPhysicalDeviceDriverProperties *)in_header;
24203             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
24204             out_ext->driverID = in_ext->driverID;
24205             memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
24206             memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
24207             out_ext->conformanceVersion = in_ext->conformanceVersion;
24208             out_header = (void *)out_ext;
24209             break;
24210         }
24211         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
24212         {
24213             VkPhysicalDeviceIDProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
24214             const VkPhysicalDeviceIDProperties *in_ext = (const VkPhysicalDeviceIDProperties *)in_header;
24215             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
24216             memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
24217             memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
24218             memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
24219             out_ext->deviceNodeMask = in_ext->deviceNodeMask;
24220             out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
24221             out_header = (void *)out_ext;
24222             break;
24223         }
24224         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
24225         {
24226             VkPhysicalDeviceMultiviewProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
24227             const VkPhysicalDeviceMultiviewProperties *in_ext = (const VkPhysicalDeviceMultiviewProperties *)in_header;
24228             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
24229             out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
24230             out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
24231             out_header = (void *)out_ext;
24232             break;
24233         }
24234         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
24235         {
24236             VkPhysicalDeviceDiscardRectanglePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT);
24237             const VkPhysicalDeviceDiscardRectanglePropertiesEXT *in_ext = (const VkPhysicalDeviceDiscardRectanglePropertiesEXT *)in_header;
24238             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
24239             out_ext->maxDiscardRectangles = in_ext->maxDiscardRectangles;
24240             out_header = (void *)out_ext;
24241             break;
24242         }
24243         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
24244         {
24245             VkPhysicalDeviceSubgroupProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
24246             const VkPhysicalDeviceSubgroupProperties *in_ext = (const VkPhysicalDeviceSubgroupProperties *)in_header;
24247             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
24248             out_ext->subgroupSize = in_ext->subgroupSize;
24249             out_ext->supportedStages = in_ext->supportedStages;
24250             out_ext->supportedOperations = in_ext->supportedOperations;
24251             out_ext->quadOperationsInAllStages = in_ext->quadOperationsInAllStages;
24252             out_header = (void *)out_ext;
24253             break;
24254         }
24255         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
24256         {
24257             VkPhysicalDevicePointClippingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
24258             const VkPhysicalDevicePointClippingProperties *in_ext = (const VkPhysicalDevicePointClippingProperties *)in_header;
24259             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
24260             out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
24261             out_header = (void *)out_ext;
24262             break;
24263         }
24264         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
24265         {
24266             VkPhysicalDeviceProtectedMemoryProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
24267             const VkPhysicalDeviceProtectedMemoryProperties *in_ext = (const VkPhysicalDeviceProtectedMemoryProperties *)in_header;
24268             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
24269             out_ext->protectedNoFault = in_ext->protectedNoFault;
24270             out_header = (void *)out_ext;
24271             break;
24272         }
24273         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
24274         {
24275             VkPhysicalDeviceSamplerFilterMinmaxProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
24276             const VkPhysicalDeviceSamplerFilterMinmaxProperties *in_ext = (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)in_header;
24277             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
24278             out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
24279             out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
24280             out_header = (void *)out_ext;
24281             break;
24282         }
24283         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
24284         {
24285             VkPhysicalDeviceSampleLocationsPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT);
24286             const VkPhysicalDeviceSampleLocationsPropertiesEXT *in_ext = (const VkPhysicalDeviceSampleLocationsPropertiesEXT *)in_header;
24287             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
24288             out_ext->sampleLocationSampleCounts = in_ext->sampleLocationSampleCounts;
24289             out_ext->maxSampleLocationGridSize = in_ext->maxSampleLocationGridSize;
24290             memcpy(out_ext->sampleLocationCoordinateRange, in_ext->sampleLocationCoordinateRange, 2 * sizeof(float));
24291             out_ext->sampleLocationSubPixelBits = in_ext->sampleLocationSubPixelBits;
24292             out_ext->variableSampleLocations = in_ext->variableSampleLocations;
24293             out_header = (void *)out_ext;
24294             break;
24295         }
24296         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
24297         {
24298             VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT);
24299             const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)in_header;
24300             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
24301             out_ext->advancedBlendMaxColorAttachments = in_ext->advancedBlendMaxColorAttachments;
24302             out_ext->advancedBlendIndependentBlend = in_ext->advancedBlendIndependentBlend;
24303             out_ext->advancedBlendNonPremultipliedSrcColor = in_ext->advancedBlendNonPremultipliedSrcColor;
24304             out_ext->advancedBlendNonPremultipliedDstColor = in_ext->advancedBlendNonPremultipliedDstColor;
24305             out_ext->advancedBlendCorrelatedOverlap = in_ext->advancedBlendCorrelatedOverlap;
24306             out_ext->advancedBlendAllOperations = in_ext->advancedBlendAllOperations;
24307             out_header = (void *)out_ext;
24308             break;
24309         }
24310         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
24311         {
24312             VkPhysicalDeviceInlineUniformBlockProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES);
24313             const VkPhysicalDeviceInlineUniformBlockProperties *in_ext = (const VkPhysicalDeviceInlineUniformBlockProperties *)in_header;
24314             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
24315             out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
24316             out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
24317             out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
24318             out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
24319             out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
24320             out_header = (void *)out_ext;
24321             break;
24322         }
24323         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
24324         {
24325             VkPhysicalDeviceMaintenance3Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
24326             const VkPhysicalDeviceMaintenance3Properties *in_ext = (const VkPhysicalDeviceMaintenance3Properties *)in_header;
24327             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
24328             out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
24329             out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
24330             out_header = (void *)out_ext;
24331             break;
24332         }
24333         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
24334         {
24335             VkPhysicalDeviceMaintenance4Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES);
24336             const VkPhysicalDeviceMaintenance4Properties *in_ext = (const VkPhysicalDeviceMaintenance4Properties *)in_header;
24337             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
24338             out_ext->maxBufferSize = in_ext->maxBufferSize;
24339             out_header = (void *)out_ext;
24340             break;
24341         }
24342         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
24343         {
24344             VkPhysicalDeviceMaintenance5PropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR);
24345             const VkPhysicalDeviceMaintenance5PropertiesKHR *in_ext = (const VkPhysicalDeviceMaintenance5PropertiesKHR *)in_header;
24346             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR;
24347             out_ext->earlyFragmentMultisampleCoverageAfterSampleCounting = in_ext->earlyFragmentMultisampleCoverageAfterSampleCounting;
24348             out_ext->earlyFragmentSampleMaskTestBeforeSampleCounting = in_ext->earlyFragmentSampleMaskTestBeforeSampleCounting;
24349             out_ext->depthStencilSwizzleOneSupport = in_ext->depthStencilSwizzleOneSupport;
24350             out_ext->polygonModePointSize = in_ext->polygonModePointSize;
24351             out_ext->nonStrictSinglePixelWideLinesUseParallelogram = in_ext->nonStrictSinglePixelWideLinesUseParallelogram;
24352             out_ext->nonStrictWideLinesUseParallelogram = in_ext->nonStrictWideLinesUseParallelogram;
24353             out_header = (void *)out_ext;
24354             break;
24355         }
24356         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
24357         {
24358             VkPhysicalDeviceFloatControlsProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
24359             const VkPhysicalDeviceFloatControlsProperties *in_ext = (const VkPhysicalDeviceFloatControlsProperties *)in_header;
24360             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
24361             out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence;
24362             out_ext->roundingModeIndependence = in_ext->roundingModeIndependence;
24363             out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16;
24364             out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32;
24365             out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64;
24366             out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16;
24367             out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32;
24368             out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64;
24369             out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16;
24370             out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32;
24371             out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64;
24372             out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16;
24373             out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32;
24374             out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64;
24375             out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16;
24376             out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32;
24377             out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64;
24378             out_header = (void *)out_ext;
24379             break;
24380         }
24381         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
24382         {
24383             VkPhysicalDeviceExternalMemoryHostPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT);
24384             const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *in_ext = (const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *)in_header;
24385             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
24386             out_ext->minImportedHostPointerAlignment = in_ext->minImportedHostPointerAlignment;
24387             out_header = (void *)out_ext;
24388             break;
24389         }
24390         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
24391         {
24392             VkPhysicalDeviceConservativeRasterizationPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT);
24393             const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)in_header;
24394             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
24395             out_ext->primitiveOverestimationSize = in_ext->primitiveOverestimationSize;
24396             out_ext->maxExtraPrimitiveOverestimationSize = in_ext->maxExtraPrimitiveOverestimationSize;
24397             out_ext->extraPrimitiveOverestimationSizeGranularity = in_ext->extraPrimitiveOverestimationSizeGranularity;
24398             out_ext->primitiveUnderestimation = in_ext->primitiveUnderestimation;
24399             out_ext->conservativePointAndLineRasterization = in_ext->conservativePointAndLineRasterization;
24400             out_ext->degenerateTrianglesRasterized = in_ext->degenerateTrianglesRasterized;
24401             out_ext->degenerateLinesRasterized = in_ext->degenerateLinesRasterized;
24402             out_ext->fullyCoveredFragmentShaderInputVariable = in_ext->fullyCoveredFragmentShaderInputVariable;
24403             out_ext->conservativeRasterizationPostDepthCoverage = in_ext->conservativeRasterizationPostDepthCoverage;
24404             out_header = (void *)out_ext;
24405             break;
24406         }
24407         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
24408         {
24409             VkPhysicalDeviceShaderCorePropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD);
24410             const VkPhysicalDeviceShaderCorePropertiesAMD *in_ext = (const VkPhysicalDeviceShaderCorePropertiesAMD *)in_header;
24411             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
24412             out_ext->shaderEngineCount = in_ext->shaderEngineCount;
24413             out_ext->shaderArraysPerEngineCount = in_ext->shaderArraysPerEngineCount;
24414             out_ext->computeUnitsPerShaderArray = in_ext->computeUnitsPerShaderArray;
24415             out_ext->simdPerComputeUnit = in_ext->simdPerComputeUnit;
24416             out_ext->wavefrontsPerSimd = in_ext->wavefrontsPerSimd;
24417             out_ext->wavefrontSize = in_ext->wavefrontSize;
24418             out_ext->sgprsPerSimd = in_ext->sgprsPerSimd;
24419             out_ext->minSgprAllocation = in_ext->minSgprAllocation;
24420             out_ext->maxSgprAllocation = in_ext->maxSgprAllocation;
24421             out_ext->sgprAllocationGranularity = in_ext->sgprAllocationGranularity;
24422             out_ext->vgprsPerSimd = in_ext->vgprsPerSimd;
24423             out_ext->minVgprAllocation = in_ext->minVgprAllocation;
24424             out_ext->maxVgprAllocation = in_ext->maxVgprAllocation;
24425             out_ext->vgprAllocationGranularity = in_ext->vgprAllocationGranularity;
24426             out_header = (void *)out_ext;
24427             break;
24428         }
24429         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
24430         {
24431             VkPhysicalDeviceShaderCoreProperties2AMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD);
24432             const VkPhysicalDeviceShaderCoreProperties2AMD *in_ext = (const VkPhysicalDeviceShaderCoreProperties2AMD *)in_header;
24433             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
24434             out_ext->shaderCoreFeatures = in_ext->shaderCoreFeatures;
24435             out_ext->activeComputeUnitCount = in_ext->activeComputeUnitCount;
24436             out_header = (void *)out_ext;
24437             break;
24438         }
24439         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
24440         {
24441             VkPhysicalDeviceDescriptorIndexingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
24442             const VkPhysicalDeviceDescriptorIndexingProperties *in_ext = (const VkPhysicalDeviceDescriptorIndexingProperties *)in_header;
24443             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
24444             out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
24445             out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
24446             out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
24447             out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
24448             out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
24449             out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
24450             out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
24451             out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
24452             out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
24453             out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
24454             out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
24455             out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
24456             out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
24457             out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
24458             out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
24459             out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
24460             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
24461             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
24462             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
24463             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
24464             out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
24465             out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
24466             out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
24467             out_header = (void *)out_ext;
24468             break;
24469         }
24470         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
24471         {
24472             VkPhysicalDeviceTimelineSemaphoreProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
24473             const VkPhysicalDeviceTimelineSemaphoreProperties *in_ext = (const VkPhysicalDeviceTimelineSemaphoreProperties *)in_header;
24474             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
24475             out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
24476             out_header = (void *)out_ext;
24477             break;
24478         }
24479         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
24480         {
24481             VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT);
24482             const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)in_header;
24483             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
24484             out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor;
24485             out_header = (void *)out_ext;
24486             break;
24487         }
24488         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
24489         {
24490             VkPhysicalDevicePCIBusInfoPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT);
24491             const VkPhysicalDevicePCIBusInfoPropertiesEXT *in_ext = (const VkPhysicalDevicePCIBusInfoPropertiesEXT *)in_header;
24492             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
24493             out_ext->pciDomain = in_ext->pciDomain;
24494             out_ext->pciBus = in_ext->pciBus;
24495             out_ext->pciDevice = in_ext->pciDevice;
24496             out_ext->pciFunction = in_ext->pciFunction;
24497             out_header = (void *)out_ext;
24498             break;
24499         }
24500         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
24501         {
24502             VkPhysicalDeviceDepthStencilResolveProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
24503             const VkPhysicalDeviceDepthStencilResolveProperties *in_ext = (const VkPhysicalDeviceDepthStencilResolveProperties *)in_header;
24504             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
24505             out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
24506             out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
24507             out_ext->independentResolveNone = in_ext->independentResolveNone;
24508             out_ext->independentResolve = in_ext->independentResolve;
24509             out_header = (void *)out_ext;
24510             break;
24511         }
24512         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
24513         {
24514             VkPhysicalDeviceTransformFeedbackPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
24515             const VkPhysicalDeviceTransformFeedbackPropertiesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)in_header;
24516             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
24517             out_ext->maxTransformFeedbackStreams = in_ext->maxTransformFeedbackStreams;
24518             out_ext->maxTransformFeedbackBuffers = in_ext->maxTransformFeedbackBuffers;
24519             out_ext->maxTransformFeedbackBufferSize = in_ext->maxTransformFeedbackBufferSize;
24520             out_ext->maxTransformFeedbackStreamDataSize = in_ext->maxTransformFeedbackStreamDataSize;
24521             out_ext->maxTransformFeedbackBufferDataSize = in_ext->maxTransformFeedbackBufferDataSize;
24522             out_ext->maxTransformFeedbackBufferDataStride = in_ext->maxTransformFeedbackBufferDataStride;
24523             out_ext->transformFeedbackQueries = in_ext->transformFeedbackQueries;
24524             out_ext->transformFeedbackStreamsLinesTriangles = in_ext->transformFeedbackStreamsLinesTriangles;
24525             out_ext->transformFeedbackRasterizationStreamSelect = in_ext->transformFeedbackRasterizationStreamSelect;
24526             out_ext->transformFeedbackDraw = in_ext->transformFeedbackDraw;
24527             out_header = (void *)out_ext;
24528             break;
24529         }
24530         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
24531         {
24532             VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV);
24533             const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *)in_header;
24534             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
24535             out_ext->supportedQueues = in_ext->supportedQueues;
24536             out_header = (void *)out_ext;
24537             break;
24538         }
24539         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
24540         {
24541             VkPhysicalDeviceMemoryDecompressionPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV);
24542             const VkPhysicalDeviceMemoryDecompressionPropertiesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionPropertiesNV *)in_header;
24543             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
24544             out_ext->decompressionMethods = in_ext->decompressionMethods;
24545             out_ext->maxDecompressionIndirectCount = in_ext->maxDecompressionIndirectCount;
24546             out_header = (void *)out_ext;
24547             break;
24548         }
24549         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
24550         {
24551             VkPhysicalDeviceShadingRateImagePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV);
24552             const VkPhysicalDeviceShadingRateImagePropertiesNV *in_ext = (const VkPhysicalDeviceShadingRateImagePropertiesNV *)in_header;
24553             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
24554             out_ext->shadingRateTexelSize = in_ext->shadingRateTexelSize;
24555             out_ext->shadingRatePaletteSize = in_ext->shadingRatePaletteSize;
24556             out_ext->shadingRateMaxCoarseSamples = in_ext->shadingRateMaxCoarseSamples;
24557             out_header = (void *)out_ext;
24558             break;
24559         }
24560         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
24561         {
24562             VkPhysicalDeviceMeshShaderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV);
24563             const VkPhysicalDeviceMeshShaderPropertiesNV *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesNV *)in_header;
24564             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
24565             out_ext->maxDrawMeshTasksCount = in_ext->maxDrawMeshTasksCount;
24566             out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations;
24567             memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
24568             out_ext->maxTaskTotalMemorySize = in_ext->maxTaskTotalMemorySize;
24569             out_ext->maxTaskOutputCount = in_ext->maxTaskOutputCount;
24570             out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations;
24571             memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
24572             out_ext->maxMeshTotalMemorySize = in_ext->maxMeshTotalMemorySize;
24573             out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices;
24574             out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives;
24575             out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount;
24576             out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity;
24577             out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity;
24578             out_header = (void *)out_ext;
24579             break;
24580         }
24581         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
24582         {
24583             VkPhysicalDeviceMeshShaderPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT);
24584             const VkPhysicalDeviceMeshShaderPropertiesEXT *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesEXT *)in_header;
24585             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
24586             out_ext->maxTaskWorkGroupTotalCount = in_ext->maxTaskWorkGroupTotalCount;
24587             memcpy(out_ext->maxTaskWorkGroupCount, in_ext->maxTaskWorkGroupCount, 3 * sizeof(uint32_t));
24588             out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations;
24589             memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
24590             out_ext->maxTaskPayloadSize = in_ext->maxTaskPayloadSize;
24591             out_ext->maxTaskSharedMemorySize = in_ext->maxTaskSharedMemorySize;
24592             out_ext->maxTaskPayloadAndSharedMemorySize = in_ext->maxTaskPayloadAndSharedMemorySize;
24593             out_ext->maxMeshWorkGroupTotalCount = in_ext->maxMeshWorkGroupTotalCount;
24594             memcpy(out_ext->maxMeshWorkGroupCount, in_ext->maxMeshWorkGroupCount, 3 * sizeof(uint32_t));
24595             out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations;
24596             memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
24597             out_ext->maxMeshSharedMemorySize = in_ext->maxMeshSharedMemorySize;
24598             out_ext->maxMeshPayloadAndSharedMemorySize = in_ext->maxMeshPayloadAndSharedMemorySize;
24599             out_ext->maxMeshOutputMemorySize = in_ext->maxMeshOutputMemorySize;
24600             out_ext->maxMeshPayloadAndOutputMemorySize = in_ext->maxMeshPayloadAndOutputMemorySize;
24601             out_ext->maxMeshOutputComponents = in_ext->maxMeshOutputComponents;
24602             out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices;
24603             out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives;
24604             out_ext->maxMeshOutputLayers = in_ext->maxMeshOutputLayers;
24605             out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount;
24606             out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity;
24607             out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity;
24608             out_ext->maxPreferredTaskWorkGroupInvocations = in_ext->maxPreferredTaskWorkGroupInvocations;
24609             out_ext->maxPreferredMeshWorkGroupInvocations = in_ext->maxPreferredMeshWorkGroupInvocations;
24610             out_ext->prefersLocalInvocationVertexOutput = in_ext->prefersLocalInvocationVertexOutput;
24611             out_ext->prefersLocalInvocationPrimitiveOutput = in_ext->prefersLocalInvocationPrimitiveOutput;
24612             out_ext->prefersCompactVertexOutput = in_ext->prefersCompactVertexOutput;
24613             out_ext->prefersCompactPrimitiveOutput = in_ext->prefersCompactPrimitiveOutput;
24614             out_header = (void *)out_ext;
24615             break;
24616         }
24617         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
24618         {
24619             VkPhysicalDeviceAccelerationStructurePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR);
24620             const VkPhysicalDeviceAccelerationStructurePropertiesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructurePropertiesKHR *)in_header;
24621             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
24622             out_ext->maxGeometryCount = in_ext->maxGeometryCount;
24623             out_ext->maxInstanceCount = in_ext->maxInstanceCount;
24624             out_ext->maxPrimitiveCount = in_ext->maxPrimitiveCount;
24625             out_ext->maxPerStageDescriptorAccelerationStructures = in_ext->maxPerStageDescriptorAccelerationStructures;
24626             out_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures = in_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
24627             out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
24628             out_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures = in_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures;
24629             out_ext->minAccelerationStructureScratchOffsetAlignment = in_ext->minAccelerationStructureScratchOffsetAlignment;
24630             out_header = (void *)out_ext;
24631             break;
24632         }
24633         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
24634         {
24635             VkPhysicalDeviceRayTracingPipelinePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR);
24636             const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *)in_header;
24637             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
24638             out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
24639             out_ext->maxRayRecursionDepth = in_ext->maxRayRecursionDepth;
24640             out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
24641             out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
24642             out_ext->shaderGroupHandleCaptureReplaySize = in_ext->shaderGroupHandleCaptureReplaySize;
24643             out_ext->maxRayDispatchInvocationCount = in_ext->maxRayDispatchInvocationCount;
24644             out_ext->shaderGroupHandleAlignment = in_ext->shaderGroupHandleAlignment;
24645             out_ext->maxRayHitAttributeSize = in_ext->maxRayHitAttributeSize;
24646             out_header = (void *)out_ext;
24647             break;
24648         }
24649         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
24650         {
24651             VkPhysicalDeviceRayTracingPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV);
24652             const VkPhysicalDeviceRayTracingPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingPropertiesNV *)in_header;
24653             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
24654             out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
24655             out_ext->maxRecursionDepth = in_ext->maxRecursionDepth;
24656             out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
24657             out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
24658             out_ext->maxGeometryCount = in_ext->maxGeometryCount;
24659             out_ext->maxInstanceCount = in_ext->maxInstanceCount;
24660             out_ext->maxTriangleCount = in_ext->maxTriangleCount;
24661             out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
24662             out_header = (void *)out_ext;
24663             break;
24664         }
24665         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
24666         {
24667             VkPhysicalDeviceFragmentDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT);
24668             const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *)in_header;
24669             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
24670             out_ext->minFragmentDensityTexelSize = in_ext->minFragmentDensityTexelSize;
24671             out_ext->maxFragmentDensityTexelSize = in_ext->maxFragmentDensityTexelSize;
24672             out_ext->fragmentDensityInvocations = in_ext->fragmentDensityInvocations;
24673             out_header = (void *)out_ext;
24674             break;
24675         }
24676         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
24677         {
24678             VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT);
24679             const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *)in_header;
24680             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
24681             out_ext->subsampledLoads = in_ext->subsampledLoads;
24682             out_ext->subsampledCoarseReconstructionEarlyAccess = in_ext->subsampledCoarseReconstructionEarlyAccess;
24683             out_ext->maxSubsampledArrayLayers = in_ext->maxSubsampledArrayLayers;
24684             out_ext->maxDescriptorSetSubsampledSamplers = in_ext->maxDescriptorSetSubsampledSamplers;
24685             out_header = (void *)out_ext;
24686             break;
24687         }
24688         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
24689         {
24690             VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM);
24691             const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *)in_header;
24692             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM;
24693             out_ext->fragmentDensityOffsetGranularity = in_ext->fragmentDensityOffsetGranularity;
24694             out_header = (void *)out_ext;
24695             break;
24696         }
24697         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
24698         {
24699             VkPhysicalDeviceCooperativeMatrixPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV);
24700             const VkPhysicalDeviceCooperativeMatrixPropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesNV *)in_header;
24701             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
24702             out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages;
24703             out_header = (void *)out_ext;
24704             break;
24705         }
24706         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
24707         {
24708             VkPhysicalDevicePerformanceQueryPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR);
24709             const VkPhysicalDevicePerformanceQueryPropertiesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryPropertiesKHR *)in_header;
24710             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
24711             out_ext->allowCommandBufferQueryCopies = in_ext->allowCommandBufferQueryCopies;
24712             out_header = (void *)out_ext;
24713             break;
24714         }
24715         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
24716         {
24717             VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV);
24718             const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *)in_header;
24719             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
24720             out_ext->shaderSMCount = in_ext->shaderSMCount;
24721             out_ext->shaderWarpsPerSM = in_ext->shaderWarpsPerSM;
24722             out_header = (void *)out_ext;
24723             break;
24724         }
24725         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
24726         {
24727             VkPhysicalDeviceTexelBufferAlignmentProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES);
24728             const VkPhysicalDeviceTexelBufferAlignmentProperties *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentProperties *)in_header;
24729             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
24730             out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
24731             out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
24732             out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
24733             out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
24734             out_header = (void *)out_ext;
24735             break;
24736         }
24737         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
24738         {
24739             VkPhysicalDeviceSubgroupSizeControlProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
24740             const VkPhysicalDeviceSubgroupSizeControlProperties *in_ext = (const VkPhysicalDeviceSubgroupSizeControlProperties *)in_header;
24741             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
24742             out_ext->minSubgroupSize = in_ext->minSubgroupSize;
24743             out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
24744             out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
24745             out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
24746             out_header = (void *)out_ext;
24747             break;
24748         }
24749         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
24750         {
24751             VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI);
24752             const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *)in_header;
24753             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
24754             out_ext->maxSubpassShadingWorkgroupSizeAspectRatio = in_ext->maxSubpassShadingWorkgroupSizeAspectRatio;
24755             out_header = (void *)out_ext;
24756             break;
24757         }
24758         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
24759         {
24760             VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI);
24761             const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *)in_header;
24762             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI;
24763             memcpy(out_ext->maxWorkGroupCount, in_ext->maxWorkGroupCount, 3 * sizeof(uint32_t));
24764             memcpy(out_ext->maxWorkGroupSize, in_ext->maxWorkGroupSize, 3 * sizeof(uint32_t));
24765             out_ext->maxOutputClusterCount = in_ext->maxOutputClusterCount;
24766             out_ext->indirectBufferOffsetAlignment = in_ext->indirectBufferOffsetAlignment;
24767             out_header = (void *)out_ext;
24768             break;
24769         }
24770         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
24771         {
24772             VkPhysicalDeviceLineRasterizationPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT);
24773             const VkPhysicalDeviceLineRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationPropertiesEXT *)in_header;
24774             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
24775             out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits;
24776             out_header = (void *)out_ext;
24777             break;
24778         }
24779         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
24780         {
24781             VkPhysicalDeviceVulkan11Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
24782             const VkPhysicalDeviceVulkan11Properties *in_ext = (const VkPhysicalDeviceVulkan11Properties *)in_header;
24783             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
24784             memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
24785             memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
24786             memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
24787             out_ext->deviceNodeMask = in_ext->deviceNodeMask;
24788             out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
24789             out_ext->subgroupSize = in_ext->subgroupSize;
24790             out_ext->subgroupSupportedStages = in_ext->subgroupSupportedStages;
24791             out_ext->subgroupSupportedOperations = in_ext->subgroupSupportedOperations;
24792             out_ext->subgroupQuadOperationsInAllStages = in_ext->subgroupQuadOperationsInAllStages;
24793             out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
24794             out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
24795             out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
24796             out_ext->protectedNoFault = in_ext->protectedNoFault;
24797             out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
24798             out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
24799             out_header = (void *)out_ext;
24800             break;
24801         }
24802         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
24803         {
24804             VkPhysicalDeviceVulkan12Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
24805             const VkPhysicalDeviceVulkan12Properties *in_ext = (const VkPhysicalDeviceVulkan12Properties *)in_header;
24806             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
24807             out_ext->driverID = in_ext->driverID;
24808             memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
24809             memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
24810             out_ext->conformanceVersion = in_ext->conformanceVersion;
24811             out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence;
24812             out_ext->roundingModeIndependence = in_ext->roundingModeIndependence;
24813             out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16;
24814             out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32;
24815             out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64;
24816             out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16;
24817             out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32;
24818             out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64;
24819             out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16;
24820             out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32;
24821             out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64;
24822             out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16;
24823             out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32;
24824             out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64;
24825             out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16;
24826             out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32;
24827             out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64;
24828             out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
24829             out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
24830             out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
24831             out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
24832             out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
24833             out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
24834             out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
24835             out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
24836             out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
24837             out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
24838             out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
24839             out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
24840             out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
24841             out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
24842             out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
24843             out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
24844             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
24845             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
24846             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
24847             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
24848             out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
24849             out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
24850             out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
24851             out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
24852             out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
24853             out_ext->independentResolveNone = in_ext->independentResolveNone;
24854             out_ext->independentResolve = in_ext->independentResolve;
24855             out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
24856             out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
24857             out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
24858             out_ext->framebufferIntegerColorSampleCounts = in_ext->framebufferIntegerColorSampleCounts;
24859             out_header = (void *)out_ext;
24860             break;
24861         }
24862         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
24863         {
24864             VkPhysicalDeviceVulkan13Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES);
24865             const VkPhysicalDeviceVulkan13Properties *in_ext = (const VkPhysicalDeviceVulkan13Properties *)in_header;
24866             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
24867             out_ext->minSubgroupSize = in_ext->minSubgroupSize;
24868             out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
24869             out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
24870             out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
24871             out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
24872             out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
24873             out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
24874             out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
24875             out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
24876             out_ext->maxInlineUniformTotalSize = in_ext->maxInlineUniformTotalSize;
24877             out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated;
24878             out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated;
24879             out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated;
24880             out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated;
24881             out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated;
24882             out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
24883             out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated;
24884             out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated;
24885             out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated;
24886             out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated;
24887             out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated;
24888             out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated;
24889             out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated;
24890             out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated;
24891             out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated;
24892             out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
24893             out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
24894             out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
24895             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
24896             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
24897             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
24898             out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
24899             out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
24900             out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
24901             out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
24902             out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
24903             out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
24904             out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
24905             out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
24906             out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
24907             out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
24908             out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
24909             out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
24910             out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
24911             out_ext->maxBufferSize = in_ext->maxBufferSize;
24912             out_header = (void *)out_ext;
24913             break;
24914         }
24915         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
24916         {
24917             VkPhysicalDeviceCustomBorderColorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT);
24918             const VkPhysicalDeviceCustomBorderColorPropertiesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)in_header;
24919             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
24920             out_ext->maxCustomBorderColorSamplers = in_ext->maxCustomBorderColorSamplers;
24921             out_header = (void *)out_ext;
24922             break;
24923         }
24924         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
24925         {
24926             VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT);
24927             const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)in_header;
24928             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
24929             out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted;
24930             out_header = (void *)out_ext;
24931             break;
24932         }
24933         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
24934         {
24935             VkPhysicalDeviceRobustness2PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT);
24936             const VkPhysicalDeviceRobustness2PropertiesEXT *in_ext = (const VkPhysicalDeviceRobustness2PropertiesEXT *)in_header;
24937             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
24938             out_ext->robustStorageBufferAccessSizeAlignment = in_ext->robustStorageBufferAccessSizeAlignment;
24939             out_ext->robustUniformBufferAccessSizeAlignment = in_ext->robustUniformBufferAccessSizeAlignment;
24940             out_header = (void *)out_ext;
24941             break;
24942         }
24943         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
24944         {
24945             VkPhysicalDeviceFragmentShadingRatePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR);
24946             const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)in_header;
24947             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
24948             out_ext->minFragmentShadingRateAttachmentTexelSize = in_ext->minFragmentShadingRateAttachmentTexelSize;
24949             out_ext->maxFragmentShadingRateAttachmentTexelSize = in_ext->maxFragmentShadingRateAttachmentTexelSize;
24950             out_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio = in_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
24951             out_ext->primitiveFragmentShadingRateWithMultipleViewports = in_ext->primitiveFragmentShadingRateWithMultipleViewports;
24952             out_ext->layeredShadingRateAttachments = in_ext->layeredShadingRateAttachments;
24953             out_ext->fragmentShadingRateNonTrivialCombinerOps = in_ext->fragmentShadingRateNonTrivialCombinerOps;
24954             out_ext->maxFragmentSize = in_ext->maxFragmentSize;
24955             out_ext->maxFragmentSizeAspectRatio = in_ext->maxFragmentSizeAspectRatio;
24956             out_ext->maxFragmentShadingRateCoverageSamples = in_ext->maxFragmentShadingRateCoverageSamples;
24957             out_ext->maxFragmentShadingRateRasterizationSamples = in_ext->maxFragmentShadingRateRasterizationSamples;
24958             out_ext->fragmentShadingRateWithShaderDepthStencilWrites = in_ext->fragmentShadingRateWithShaderDepthStencilWrites;
24959             out_ext->fragmentShadingRateWithSampleMask = in_ext->fragmentShadingRateWithSampleMask;
24960             out_ext->fragmentShadingRateWithShaderSampleMask = in_ext->fragmentShadingRateWithShaderSampleMask;
24961             out_ext->fragmentShadingRateWithConservativeRasterization = in_ext->fragmentShadingRateWithConservativeRasterization;
24962             out_ext->fragmentShadingRateWithFragmentShaderInterlock = in_ext->fragmentShadingRateWithFragmentShaderInterlock;
24963             out_ext->fragmentShadingRateWithCustomSampleLocations = in_ext->fragmentShadingRateWithCustomSampleLocations;
24964             out_ext->fragmentShadingRateStrictMultiplyCombiner = in_ext->fragmentShadingRateStrictMultiplyCombiner;
24965             out_header = (void *)out_ext;
24966             break;
24967         }
24968         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
24969         {
24970             VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV);
24971             const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *)in_header;
24972             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
24973             out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount;
24974             out_header = (void *)out_ext;
24975             break;
24976         }
24977         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT:
24978         {
24979             VkPhysicalDeviceHostImageCopyPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT);
24980             const VkPhysicalDeviceHostImageCopyPropertiesEXT *in_ext = (const VkPhysicalDeviceHostImageCopyPropertiesEXT *)in_header;
24981             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT;
24982             out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount;
24983             out_ext->pCopySrcLayouts = PtrToUlong(in_ext->pCopySrcLayouts);
24984             out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount;
24985             out_ext->pCopyDstLayouts = PtrToUlong(in_ext->pCopyDstLayouts);
24986             memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t));
24987             out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements;
24988             out_header = (void *)out_ext;
24989             break;
24990         }
24991         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
24992         {
24993             VkPhysicalDeviceProvokingVertexPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT);
24994             const VkPhysicalDeviceProvokingVertexPropertiesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)in_header;
24995             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
24996             out_ext->provokingVertexModePerPipeline = in_ext->provokingVertexModePerPipeline;
24997             out_ext->transformFeedbackPreservesTriangleFanProvokingVertex = in_ext->transformFeedbackPreservesTriangleFanProvokingVertex;
24998             out_header = (void *)out_ext;
24999             break;
25000         }
25001         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
25002         {
25003             VkPhysicalDeviceDescriptorBufferPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT);
25004             const VkPhysicalDeviceDescriptorBufferPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferPropertiesEXT *)in_header;
25005             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
25006             out_ext->combinedImageSamplerDescriptorSingleArray = in_ext->combinedImageSamplerDescriptorSingleArray;
25007             out_ext->bufferlessPushDescriptors = in_ext->bufferlessPushDescriptors;
25008             out_ext->allowSamplerImageViewPostSubmitCreation = in_ext->allowSamplerImageViewPostSubmitCreation;
25009             out_ext->descriptorBufferOffsetAlignment = in_ext->descriptorBufferOffsetAlignment;
25010             out_ext->maxDescriptorBufferBindings = in_ext->maxDescriptorBufferBindings;
25011             out_ext->maxResourceDescriptorBufferBindings = in_ext->maxResourceDescriptorBufferBindings;
25012             out_ext->maxSamplerDescriptorBufferBindings = in_ext->maxSamplerDescriptorBufferBindings;
25013             out_ext->maxEmbeddedImmutableSamplerBindings = in_ext->maxEmbeddedImmutableSamplerBindings;
25014             out_ext->maxEmbeddedImmutableSamplers = in_ext->maxEmbeddedImmutableSamplers;
25015             out_ext->bufferCaptureReplayDescriptorDataSize = in_ext->bufferCaptureReplayDescriptorDataSize;
25016             out_ext->imageCaptureReplayDescriptorDataSize = in_ext->imageCaptureReplayDescriptorDataSize;
25017             out_ext->imageViewCaptureReplayDescriptorDataSize = in_ext->imageViewCaptureReplayDescriptorDataSize;
25018             out_ext->samplerCaptureReplayDescriptorDataSize = in_ext->samplerCaptureReplayDescriptorDataSize;
25019             out_ext->accelerationStructureCaptureReplayDescriptorDataSize = in_ext->accelerationStructureCaptureReplayDescriptorDataSize;
25020             out_ext->samplerDescriptorSize = in_ext->samplerDescriptorSize;
25021             out_ext->combinedImageSamplerDescriptorSize = in_ext->combinedImageSamplerDescriptorSize;
25022             out_ext->sampledImageDescriptorSize = in_ext->sampledImageDescriptorSize;
25023             out_ext->storageImageDescriptorSize = in_ext->storageImageDescriptorSize;
25024             out_ext->uniformTexelBufferDescriptorSize = in_ext->uniformTexelBufferDescriptorSize;
25025             out_ext->robustUniformTexelBufferDescriptorSize = in_ext->robustUniformTexelBufferDescriptorSize;
25026             out_ext->storageTexelBufferDescriptorSize = in_ext->storageTexelBufferDescriptorSize;
25027             out_ext->robustStorageTexelBufferDescriptorSize = in_ext->robustStorageTexelBufferDescriptorSize;
25028             out_ext->uniformBufferDescriptorSize = in_ext->uniformBufferDescriptorSize;
25029             out_ext->robustUniformBufferDescriptorSize = in_ext->robustUniformBufferDescriptorSize;
25030             out_ext->storageBufferDescriptorSize = in_ext->storageBufferDescriptorSize;
25031             out_ext->robustStorageBufferDescriptorSize = in_ext->robustStorageBufferDescriptorSize;
25032             out_ext->inputAttachmentDescriptorSize = in_ext->inputAttachmentDescriptorSize;
25033             out_ext->accelerationStructureDescriptorSize = in_ext->accelerationStructureDescriptorSize;
25034             out_ext->maxSamplerDescriptorBufferRange = in_ext->maxSamplerDescriptorBufferRange;
25035             out_ext->maxResourceDescriptorBufferRange = in_ext->maxResourceDescriptorBufferRange;
25036             out_ext->samplerDescriptorBufferAddressSpaceSize = in_ext->samplerDescriptorBufferAddressSpaceSize;
25037             out_ext->resourceDescriptorBufferAddressSpaceSize = in_ext->resourceDescriptorBufferAddressSpaceSize;
25038             out_ext->descriptorBufferAddressSpaceSize = in_ext->descriptorBufferAddressSpaceSize;
25039             out_header = (void *)out_ext;
25040             break;
25041         }
25042         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
25043         {
25044             VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT);
25045             const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *)in_header;
25046             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
25047             out_ext->combinedImageSamplerDensityMapDescriptorSize = in_ext->combinedImageSamplerDensityMapDescriptorSize;
25048             out_header = (void *)out_ext;
25049             break;
25050         }
25051         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
25052         {
25053             VkPhysicalDeviceShaderIntegerDotProductProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES);
25054             const VkPhysicalDeviceShaderIntegerDotProductProperties *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductProperties *)in_header;
25055             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
25056             out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated;
25057             out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated;
25058             out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated;
25059             out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated;
25060             out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated;
25061             out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
25062             out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated;
25063             out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated;
25064             out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated;
25065             out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated;
25066             out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated;
25067             out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated;
25068             out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated;
25069             out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated;
25070             out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated;
25071             out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
25072             out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
25073             out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
25074             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
25075             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
25076             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
25077             out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
25078             out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
25079             out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
25080             out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
25081             out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
25082             out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
25083             out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
25084             out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
25085             out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
25086             out_header = (void *)out_ext;
25087             break;
25088         }
25089         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
25090         {
25091             VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR);
25092             const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *)in_header;
25093             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
25094             out_ext->triStripVertexOrderIndependentOfProvokingVertex = in_ext->triStripVertexOrderIndependentOfProvokingVertex;
25095             out_header = (void *)out_ext;
25096             break;
25097         }
25098         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
25099         {
25100             VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT);
25101             const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)in_header;
25102             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
25103             out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking;
25104             out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration;
25105             out_header = (void *)out_ext;
25106             break;
25107         }
25108         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
25109         {
25110             VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT);
25111             const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *)in_header;
25112             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
25113             memcpy(out_ext->shaderModuleIdentifierAlgorithmUUID, in_ext->shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE * sizeof(uint8_t));
25114             out_header = (void *)out_ext;
25115             break;
25116         }
25117         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
25118         {
25119             VkPhysicalDeviceOpacityMicromapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT);
25120             const VkPhysicalDeviceOpacityMicromapPropertiesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapPropertiesEXT *)in_header;
25121             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
25122             out_ext->maxOpacity2StateSubdivisionLevel = in_ext->maxOpacity2StateSubdivisionLevel;
25123             out_ext->maxOpacity4StateSubdivisionLevel = in_ext->maxOpacity4StateSubdivisionLevel;
25124             out_header = (void *)out_ext;
25125             break;
25126         }
25127         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
25128         {
25129             VkPhysicalDevicePipelineRobustnessPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT);
25130             const VkPhysicalDevicePipelineRobustnessPropertiesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessPropertiesEXT *)in_header;
25131             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT;
25132             out_ext->defaultRobustnessStorageBuffers = in_ext->defaultRobustnessStorageBuffers;
25133             out_ext->defaultRobustnessUniformBuffers = in_ext->defaultRobustnessUniformBuffers;
25134             out_ext->defaultRobustnessVertexInputs = in_ext->defaultRobustnessVertexInputs;
25135             out_ext->defaultRobustnessImages = in_ext->defaultRobustnessImages;
25136             out_header = (void *)out_ext;
25137             break;
25138         }
25139         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
25140         {
25141             VkPhysicalDeviceImageProcessingPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM);
25142             const VkPhysicalDeviceImageProcessingPropertiesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingPropertiesQCOM *)in_header;
25143             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
25144             out_ext->maxWeightFilterPhases = in_ext->maxWeightFilterPhases;
25145             out_ext->maxWeightFilterDimension = in_ext->maxWeightFilterDimension;
25146             out_ext->maxBlockMatchRegion = in_ext->maxBlockMatchRegion;
25147             out_ext->maxBoxFilterBlockSize = in_ext->maxBoxFilterBlockSize;
25148             out_header = (void *)out_ext;
25149             break;
25150         }
25151         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
25152         {
25153             VkPhysicalDeviceOpticalFlowPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV);
25154             const VkPhysicalDeviceOpticalFlowPropertiesNV *in_ext = (const VkPhysicalDeviceOpticalFlowPropertiesNV *)in_header;
25155             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
25156             out_ext->supportedOutputGridSizes = in_ext->supportedOutputGridSizes;
25157             out_ext->supportedHintGridSizes = in_ext->supportedHintGridSizes;
25158             out_ext->hintSupported = in_ext->hintSupported;
25159             out_ext->costSupported = in_ext->costSupported;
25160             out_ext->bidirectionalFlowSupported = in_ext->bidirectionalFlowSupported;
25161             out_ext->globalFlowSupported = in_ext->globalFlowSupported;
25162             out_ext->minWidth = in_ext->minWidth;
25163             out_ext->minHeight = in_ext->minHeight;
25164             out_ext->maxWidth = in_ext->maxWidth;
25165             out_ext->maxHeight = in_ext->maxHeight;
25166             out_ext->maxNumRegionsOfInterest = in_ext->maxNumRegionsOfInterest;
25167             out_header = (void *)out_ext;
25168             break;
25169         }
25170         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
25171         {
25172             VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM);
25173             const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *)in_header;
25174             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
25175             out_ext->shaderCoreMask = in_ext->shaderCoreMask;
25176             out_ext->shaderCoreCount = in_ext->shaderCoreCount;
25177             out_ext->shaderWarpsPerCore = in_ext->shaderWarpsPerCore;
25178             out_header = (void *)out_ext;
25179             break;
25180         }
25181         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
25182         {
25183             VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV);
25184             const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *)in_header;
25185             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
25186             out_ext->rayTracingInvocationReorderReorderingHint = in_ext->rayTracingInvocationReorderReorderingHint;
25187             out_header = (void *)out_ext;
25188             break;
25189         }
25190         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
25191         {
25192             VkPhysicalDeviceShaderCorePropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM);
25193             const VkPhysicalDeviceShaderCorePropertiesARM *in_ext = (const VkPhysicalDeviceShaderCorePropertiesARM *)in_header;
25194             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM;
25195             out_ext->pixelRate = in_ext->pixelRate;
25196             out_ext->texelRate = in_ext->texelRate;
25197             out_ext->fmaRate = in_ext->fmaRate;
25198             out_header = (void *)out_ext;
25199             break;
25200         }
25201         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
25202         {
25203             VkPhysicalDeviceShaderObjectPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT);
25204             const VkPhysicalDeviceShaderObjectPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderObjectPropertiesEXT *)in_header;
25205             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
25206             memcpy(out_ext->shaderBinaryUUID, in_ext->shaderBinaryUUID, VK_UUID_SIZE * sizeof(uint8_t));
25207             out_ext->shaderBinaryVersion = in_ext->shaderBinaryVersion;
25208             out_header = (void *)out_ext;
25209             break;
25210         }
25211         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
25212         {
25213             VkPhysicalDeviceShaderTileImagePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT);
25214             const VkPhysicalDeviceShaderTileImagePropertiesEXT *in_ext = (const VkPhysicalDeviceShaderTileImagePropertiesEXT *)in_header;
25215             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
25216             out_ext->shaderTileImageCoherentReadAccelerated = in_ext->shaderTileImageCoherentReadAccelerated;
25217             out_ext->shaderTileImageReadSampleFromPixelRateInvocation = in_ext->shaderTileImageReadSampleFromPixelRateInvocation;
25218             out_ext->shaderTileImageReadFromHelperInvocation = in_ext->shaderTileImageReadFromHelperInvocation;
25219             out_header = (void *)out_ext;
25220             break;
25221         }
25222         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
25223         {
25224             VkPhysicalDeviceCooperativeMatrixPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR);
25225             const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *)in_header;
25226             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR;
25227             out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages;
25228             out_header = (void *)out_ext;
25229             break;
25230         }
25231         default:
25232             break;
25233         }
25234     }
25235 }
25236
25237 static inline void convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(const VkQueryPoolPerformanceCreateInfoKHR32 *in, VkQueryPoolPerformanceCreateInfoKHR *out)
25238 {
25239     if (!in) return;
25240
25241     out->sType = in->sType;
25242     out->pNext = NULL;
25243     out->queueFamilyIndex = in->queueFamilyIndex;
25244     out->counterIndexCount = in->counterIndexCount;
25245     out->pCounterIndices = (const uint32_t *)UlongToPtr(in->pCounterIndices);
25246     if (in->pNext)
25247         FIXME("Unexpected pNext\n");
25248 }
25249
25250 static inline void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, VkQueueFamilyProperties2 *out)
25251 {
25252     const VkBaseInStructure32 *in_header;
25253     VkBaseOutStructure *out_header = (void *)out;
25254
25255     if (!in) return;
25256
25257     out->sType = in->sType;
25258     out->pNext = NULL;
25259
25260     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
25261     {
25262         switch (in_header->sType)
25263         {
25264         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
25265         {
25266             VkQueueFamilyGlobalPriorityPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25267             const VkQueueFamilyGlobalPriorityPropertiesKHR32 *in_ext = (const VkQueueFamilyGlobalPriorityPropertiesKHR32 *)in_header;
25268             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
25269             out_ext->pNext = NULL;
25270             out_ext->priorityCount = in_ext->priorityCount;
25271             memcpy(out_ext->priorities, in_ext->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
25272             out_header->pNext = (void *)out_ext;
25273             out_header = (void *)out_ext;
25274             break;
25275         }
25276         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
25277         {
25278             VkQueueFamilyCheckpointPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25279             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
25280             out_ext->pNext = NULL;
25281             out_header->pNext = (void *)out_ext;
25282             out_header = (void *)out_ext;
25283             break;
25284         }
25285         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
25286         {
25287             VkQueueFamilyCheckpointProperties2NV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25288             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
25289             out_ext->pNext = NULL;
25290             out_header->pNext = (void *)out_ext;
25291             out_header = (void *)out_ext;
25292             break;
25293         }
25294         default:
25295             FIXME("Unhandled sType %u.\n", in_header->sType);
25296             break;
25297         }
25298     }
25299 }
25300
25301 static inline void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out)
25302 {
25303     const VkBaseInStructure *in_header;
25304     VkBaseOutStructure32 *out_header = (void *)out;
25305
25306     if (!in) return;
25307
25308     out->queueFamilyProperties = in->queueFamilyProperties;
25309
25310     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
25311     {
25312         switch (in_header->sType)
25313         {
25314         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
25315         {
25316             VkQueueFamilyGlobalPriorityPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR);
25317             const VkQueueFamilyGlobalPriorityPropertiesKHR *in_ext = (const VkQueueFamilyGlobalPriorityPropertiesKHR *)in_header;
25318             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
25319             out_ext->priorityCount = in_ext->priorityCount;
25320             memcpy(out_ext->priorities, in_ext->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
25321             out_header = (void *)out_ext;
25322             break;
25323         }
25324         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
25325         {
25326             VkQueueFamilyCheckpointPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV);
25327             const VkQueueFamilyCheckpointPropertiesNV *in_ext = (const VkQueueFamilyCheckpointPropertiesNV *)in_header;
25328             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
25329             out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask;
25330             out_header = (void *)out_ext;
25331             break;
25332         }
25333         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
25334         {
25335             VkQueueFamilyCheckpointProperties2NV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV);
25336             const VkQueueFamilyCheckpointProperties2NV *in_ext = (const VkQueueFamilyCheckpointProperties2NV *)in_header;
25337             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
25338             out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask;
25339             out_header = (void *)out_ext;
25340             break;
25341         }
25342         default:
25343             break;
25344         }
25345     }
25346 }
25347
25348 static inline VkQueueFamilyProperties2 *convert_VkQueueFamilyProperties2_array_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, uint32_t count)
25349 {
25350     VkQueueFamilyProperties2 *out;
25351     unsigned int i;
25352
25353     if (!in || !count) return NULL;
25354
25355     out = conversion_context_alloc(ctx, count * sizeof(*out));
25356     for (i = 0; i < count; i++)
25357     {
25358         convert_VkQueueFamilyProperties2_win32_to_host(ctx, &in[i], &out[i]);
25359     }
25360
25361     return out;
25362 }
25363
25364 static inline void convert_VkQueueFamilyProperties2_array_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out, uint32_t count)
25365 {
25366     unsigned int i;
25367
25368     if (!in) return;
25369
25370     for (i = 0; i < count; i++)
25371     {
25372         convert_VkQueueFamilyProperties2_host_to_win32(&in[i], &out[i]);
25373     }
25374 }
25375
25376 static inline void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(const VkPhysicalDeviceSparseImageFormatInfo232 *in, VkPhysicalDeviceSparseImageFormatInfo2 *out)
25377 {
25378     if (!in) return;
25379
25380     out->sType = in->sType;
25381     out->pNext = NULL;
25382     out->format = in->format;
25383     out->type = in->type;
25384     out->samples = in->samples;
25385     out->usage = in->usage;
25386     out->tiling = in->tiling;
25387     if (in->pNext)
25388         FIXME("Unexpected pNext\n");
25389 }
25390
25391 static inline void convert_VkSparseImageFormatProperties2_win32_to_host(const VkSparseImageFormatProperties232 *in, VkSparseImageFormatProperties2 *out)
25392 {
25393     if (!in) return;
25394
25395     out->sType = in->sType;
25396     out->pNext = NULL;
25397     if (in->pNext)
25398         FIXME("Unexpected pNext\n");
25399 }
25400
25401 static inline void convert_VkSparseImageFormatProperties2_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out)
25402 {
25403     if (!in) return;
25404
25405     out->properties = in->properties;
25406 }
25407
25408 static inline VkSparseImageFormatProperties2 *convert_VkSparseImageFormatProperties2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageFormatProperties232 *in, uint32_t count)
25409 {
25410     VkSparseImageFormatProperties2 *out;
25411     unsigned int i;
25412
25413     if (!in || !count) return NULL;
25414
25415     out = conversion_context_alloc(ctx, count * sizeof(*out));
25416     for (i = 0; i < count; i++)
25417     {
25418         convert_VkSparseImageFormatProperties2_win32_to_host(&in[i], &out[i]);
25419     }
25420
25421     return out;
25422 }
25423
25424 static inline void convert_VkSparseImageFormatProperties2_array_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out, uint32_t count)
25425 {
25426     unsigned int i;
25427
25428     if (!in) return;
25429
25430     for (i = 0; i < count; i++)
25431     {
25432         convert_VkSparseImageFormatProperties2_host_to_win32(&in[i], &out[i]);
25433     }
25434 }
25435
25436 static inline void convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(const VkFramebufferMixedSamplesCombinationNV32 *in, VkFramebufferMixedSamplesCombinationNV *out)
25437 {
25438     if (!in) return;
25439
25440     out->sType = in->sType;
25441     out->pNext = NULL;
25442     if (in->pNext)
25443         FIXME("Unexpected pNext\n");
25444 }
25445
25446 static inline void convert_VkFramebufferMixedSamplesCombinationNV_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out)
25447 {
25448     if (!in) return;
25449
25450     out->coverageReductionMode = in->coverageReductionMode;
25451     out->rasterizationSamples = in->rasterizationSamples;
25452     out->depthStencilSamples = in->depthStencilSamples;
25453     out->colorSamples = in->colorSamples;
25454 }
25455
25456 static inline VkFramebufferMixedSamplesCombinationNV *convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferMixedSamplesCombinationNV32 *in, uint32_t count)
25457 {
25458     VkFramebufferMixedSamplesCombinationNV *out;
25459     unsigned int i;
25460
25461     if (!in || !count) return NULL;
25462
25463     out = conversion_context_alloc(ctx, count * sizeof(*out));
25464     for (i = 0; i < count; i++)
25465     {
25466         convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(&in[i], &out[i]);
25467     }
25468
25469     return out;
25470 }
25471
25472 static inline void convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out, uint32_t count)
25473 {
25474     unsigned int i;
25475
25476     if (!in) return;
25477
25478     for (i = 0; i < count; i++)
25479     {
25480         convert_VkFramebufferMixedSamplesCombinationNV_host_to_win32(&in[i], &out[i]);
25481     }
25482 }
25483
25484 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
25485 {
25486     const VkBaseInStructure32 *in_header;
25487     VkBaseOutStructure *out_header = (void *)out;
25488
25489     if (!in) return;
25490
25491     out->sType = in->sType;
25492     out->pNext = NULL;
25493     out->surface = in->surface;
25494
25495     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
25496     {
25497         switch (in_header->sType)
25498         {
25499         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
25500         {
25501             VkSurfacePresentModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25502             const VkSurfacePresentModeEXT32 *in_ext = (const VkSurfacePresentModeEXT32 *)in_header;
25503             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT;
25504             out_ext->pNext = NULL;
25505             out_ext->presentMode = in_ext->presentMode;
25506             out_header->pNext = (void *)out_ext;
25507             out_header = (void *)out_ext;
25508             break;
25509         }
25510         default:
25511             FIXME("Unhandled sType %u.\n", in_header->sType);
25512             break;
25513         }
25514     }
25515 }
25516
25517 static inline void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceCapabilities2KHR32 *in, VkSurfaceCapabilities2KHR *out)
25518 {
25519     const VkBaseInStructure32 *in_header;
25520     VkBaseOutStructure *out_header = (void *)out;
25521
25522     if (!in) return;
25523
25524     out->sType = in->sType;
25525     out->pNext = NULL;
25526
25527     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
25528     {
25529         switch (in_header->sType)
25530         {
25531         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
25532         {
25533             VkSurfaceCapabilitiesPresentBarrierNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25534             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV;
25535             out_ext->pNext = NULL;
25536             out_header->pNext = (void *)out_ext;
25537             out_header = (void *)out_ext;
25538             break;
25539         }
25540         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
25541         {
25542             VkSurfacePresentScalingCapabilitiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25543             const VkSurfacePresentScalingCapabilitiesEXT32 *in_ext = (const VkSurfacePresentScalingCapabilitiesEXT32 *)in_header;
25544             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT;
25545             out_ext->pNext = NULL;
25546             out_ext->supportedPresentScaling = in_ext->supportedPresentScaling;
25547             out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX;
25548             out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY;
25549             out_ext->minScaledImageExtent = in_ext->minScaledImageExtent;
25550             out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent;
25551             out_header->pNext = (void *)out_ext;
25552             out_header = (void *)out_ext;
25553             break;
25554         }
25555         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
25556         {
25557             VkSurfacePresentModeCompatibilityEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25558             const VkSurfacePresentModeCompatibilityEXT32 *in_ext = (const VkSurfacePresentModeCompatibilityEXT32 *)in_header;
25559             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT;
25560             out_ext->pNext = NULL;
25561             out_ext->presentModeCount = in_ext->presentModeCount;
25562             out_ext->pPresentModes = (VkPresentModeKHR *)UlongToPtr(in_ext->pPresentModes);
25563             out_header->pNext = (void *)out_ext;
25564             out_header = (void *)out_ext;
25565             break;
25566         }
25567         default:
25568             FIXME("Unhandled sType %u.\n", in_header->sType);
25569             break;
25570         }
25571     }
25572 }
25573
25574 static inline void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapabilities2KHR *in, VkSurfaceCapabilities2KHR32 *out)
25575 {
25576     const VkBaseInStructure *in_header;
25577     VkBaseOutStructure32 *out_header = (void *)out;
25578
25579     if (!in) return;
25580
25581     out->surfaceCapabilities = in->surfaceCapabilities;
25582
25583     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
25584     {
25585         switch (in_header->sType)
25586         {
25587         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
25588         {
25589             VkSurfaceCapabilitiesPresentBarrierNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV);
25590             const VkSurfaceCapabilitiesPresentBarrierNV *in_ext = (const VkSurfaceCapabilitiesPresentBarrierNV *)in_header;
25591             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV;
25592             out_ext->presentBarrierSupported = in_ext->presentBarrierSupported;
25593             out_header = (void *)out_ext;
25594             break;
25595         }
25596         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
25597         {
25598             VkSurfacePresentScalingCapabilitiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT);
25599             const VkSurfacePresentScalingCapabilitiesEXT *in_ext = (const VkSurfacePresentScalingCapabilitiesEXT *)in_header;
25600             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT;
25601             out_ext->supportedPresentScaling = in_ext->supportedPresentScaling;
25602             out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX;
25603             out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY;
25604             out_ext->minScaledImageExtent = in_ext->minScaledImageExtent;
25605             out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent;
25606             out_header = (void *)out_ext;
25607             break;
25608         }
25609         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
25610         {
25611             VkSurfacePresentModeCompatibilityEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT);
25612             const VkSurfacePresentModeCompatibilityEXT *in_ext = (const VkSurfacePresentModeCompatibilityEXT *)in_header;
25613             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT;
25614             out_ext->presentModeCount = in_ext->presentModeCount;
25615             out_ext->pPresentModes = PtrToUlong(in_ext->pPresentModes);
25616             out_header = (void *)out_ext;
25617             break;
25618         }
25619         default:
25620             break;
25621         }
25622     }
25623 }
25624
25625 #ifdef _WIN64
25626 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win64_to_host(const VkPhysicalDeviceSurfaceInfo2KHR *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
25627 {
25628     if (!in) return;
25629
25630     out->sType = in->sType;
25631     out->pNext = in->pNext;
25632     out->surface = in->surface ? wine_surface_from_handle(in->surface)->driver_surface : 0;
25633 }
25634 #endif /* _WIN64 */
25635
25636 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
25637 {
25638     const VkBaseInStructure32 *in_header;
25639     VkBaseOutStructure *out_header = (void *)out;
25640
25641     if (!in) return;
25642
25643     out->sType = in->sType;
25644     out->pNext = NULL;
25645     out->surface = in->surface ? wine_surface_from_handle(in->surface)->driver_surface : 0;
25646
25647     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
25648     {
25649         switch (in_header->sType)
25650         {
25651         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
25652         {
25653             VkSurfacePresentModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25654             const VkSurfacePresentModeEXT32 *in_ext = (const VkSurfacePresentModeEXT32 *)in_header;
25655             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT;
25656             out_ext->pNext = NULL;
25657             out_ext->presentMode = in_ext->presentMode;
25658             out_header->pNext = (void *)out_ext;
25659             out_header = (void *)out_ext;
25660             break;
25661         }
25662         default:
25663             FIXME("Unhandled sType %u.\n", in_header->sType);
25664             break;
25665         }
25666     }
25667 }
25668
25669 static inline void convert_VkSurfaceFormat2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, VkSurfaceFormat2KHR *out)
25670 {
25671     const VkBaseInStructure32 *in_header;
25672     VkBaseOutStructure *out_header = (void *)out;
25673
25674     if (!in) return;
25675
25676     out->sType = in->sType;
25677     out->pNext = NULL;
25678
25679     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
25680     {
25681         switch (in_header->sType)
25682         {
25683         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
25684         {
25685             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25686             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
25687             out_ext->pNext = NULL;
25688             out_header->pNext = (void *)out_ext;
25689             out_header = (void *)out_ext;
25690             break;
25691         }
25692         default:
25693             FIXME("Unhandled sType %u.\n", in_header->sType);
25694             break;
25695         }
25696     }
25697 }
25698
25699 static inline void convert_VkSurfaceFormat2KHR_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out)
25700 {
25701     const VkBaseInStructure *in_header;
25702     VkBaseOutStructure32 *out_header = (void *)out;
25703
25704     if (!in) return;
25705
25706     out->surfaceFormat = in->surfaceFormat;
25707
25708     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
25709     {
25710         switch (in_header->sType)
25711         {
25712         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
25713         {
25714             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
25715             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
25716             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
25717             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
25718             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
25719             out_header = (void *)out_ext;
25720             break;
25721         }
25722         default:
25723             break;
25724         }
25725     }
25726 }
25727
25728 static inline VkSurfaceFormat2KHR *convert_VkSurfaceFormat2KHR_array_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, uint32_t count)
25729 {
25730     VkSurfaceFormat2KHR *out;
25731     unsigned int i;
25732
25733     if (!in || !count) return NULL;
25734
25735     out = conversion_context_alloc(ctx, count * sizeof(*out));
25736     for (i = 0; i < count; i++)
25737     {
25738         convert_VkSurfaceFormat2KHR_win32_to_host(ctx, &in[i], &out[i]);
25739     }
25740
25741     return out;
25742 }
25743
25744 static inline void convert_VkSurfaceFormat2KHR_array_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out, uint32_t count)
25745 {
25746     unsigned int i;
25747
25748     if (!in) return;
25749
25750     for (i = 0; i < count; i++)
25751     {
25752         convert_VkSurfaceFormat2KHR_host_to_win32(&in[i], &out[i]);
25753     }
25754 }
25755
25756 static inline void convert_VkPhysicalDeviceToolProperties_win32_to_host(const VkPhysicalDeviceToolProperties32 *in, VkPhysicalDeviceToolProperties *out)
25757 {
25758     if (!in) return;
25759
25760     out->sType = in->sType;
25761     out->pNext = NULL;
25762     if (in->pNext)
25763         FIXME("Unexpected pNext\n");
25764 }
25765
25766 static inline void convert_VkPhysicalDeviceToolProperties_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out)
25767 {
25768     if (!in) return;
25769
25770     memcpy(out->name, in->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
25771     memcpy(out->version, in->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
25772     out->purposes = in->purposes;
25773     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
25774     memcpy(out->layer, in->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
25775 }
25776
25777 static inline VkPhysicalDeviceToolProperties *convert_VkPhysicalDeviceToolProperties_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceToolProperties32 *in, uint32_t count)
25778 {
25779     VkPhysicalDeviceToolProperties *out;
25780     unsigned int i;
25781
25782     if (!in || !count) return NULL;
25783
25784     out = conversion_context_alloc(ctx, count * sizeof(*out));
25785     for (i = 0; i < count; i++)
25786     {
25787         convert_VkPhysicalDeviceToolProperties_win32_to_host(&in[i], &out[i]);
25788     }
25789
25790     return out;
25791 }
25792
25793 static inline void convert_VkPhysicalDeviceToolProperties_array_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out, uint32_t count)
25794 {
25795     unsigned int i;
25796
25797     if (!in) return;
25798
25799     for (i = 0; i < count; i++)
25800     {
25801         convert_VkPhysicalDeviceToolProperties_host_to_win32(&in[i], &out[i]);
25802     }
25803 }
25804
25805 static inline void convert_VkPipelineExecutableInfoKHR_win32_to_host(const VkPipelineExecutableInfoKHR32 *in, VkPipelineExecutableInfoKHR *out)
25806 {
25807     if (!in) return;
25808
25809     out->sType = in->sType;
25810     out->pNext = NULL;
25811     out->pipeline = in->pipeline;
25812     out->executableIndex = in->executableIndex;
25813     if (in->pNext)
25814         FIXME("Unexpected pNext\n");
25815 }
25816
25817 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_win32_to_host(const VkPipelineExecutableInternalRepresentationKHR32 *in, VkPipelineExecutableInternalRepresentationKHR *out)
25818 {
25819     if (!in) return;
25820
25821     out->sType = in->sType;
25822     out->pNext = NULL;
25823     if (in->pNext)
25824         FIXME("Unexpected pNext\n");
25825 }
25826
25827 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out)
25828 {
25829     if (!in) return;
25830
25831     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
25832     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
25833     out->isText = in->isText;
25834     out->dataSize = in->dataSize;
25835     out->pData = PtrToUlong(in->pData);
25836 }
25837
25838 static inline VkPipelineExecutableInternalRepresentationKHR *convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableInternalRepresentationKHR32 *in, uint32_t count)
25839 {
25840     VkPipelineExecutableInternalRepresentationKHR *out;
25841     unsigned int i;
25842
25843     if (!in || !count) return NULL;
25844
25845     out = conversion_context_alloc(ctx, count * sizeof(*out));
25846     for (i = 0; i < count; i++)
25847     {
25848         convert_VkPipelineExecutableInternalRepresentationKHR_win32_to_host(&in[i], &out[i]);
25849     }
25850
25851     return out;
25852 }
25853
25854 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out, uint32_t count)
25855 {
25856     unsigned int i;
25857
25858     if (!in) return;
25859
25860     for (i = 0; i < count; i++)
25861     {
25862         convert_VkPipelineExecutableInternalRepresentationKHR_host_to_win32(&in[i], &out[i]);
25863     }
25864 }
25865
25866 static inline void convert_VkPipelineInfoKHR_win32_to_host(const VkPipelineInfoKHR32 *in, VkPipelineInfoKHR *out)
25867 {
25868     if (!in) return;
25869
25870     out->sType = in->sType;
25871     out->pNext = NULL;
25872     out->pipeline = in->pipeline;
25873     if (in->pNext)
25874         FIXME("Unexpected pNext\n");
25875 }
25876
25877 static inline void convert_VkPipelineExecutablePropertiesKHR_win32_to_host(const VkPipelineExecutablePropertiesKHR32 *in, VkPipelineExecutablePropertiesKHR *out)
25878 {
25879     if (!in) return;
25880
25881     out->sType = in->sType;
25882     out->pNext = NULL;
25883     if (in->pNext)
25884         FIXME("Unexpected pNext\n");
25885 }
25886
25887 static inline void convert_VkPipelineExecutablePropertiesKHR_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out)
25888 {
25889     if (!in) return;
25890
25891     out->stages = in->stages;
25892     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
25893     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
25894     out->subgroupSize = in->subgroupSize;
25895 }
25896
25897 static inline VkPipelineExecutablePropertiesKHR *convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutablePropertiesKHR32 *in, uint32_t count)
25898 {
25899     VkPipelineExecutablePropertiesKHR *out;
25900     unsigned int i;
25901
25902     if (!in || !count) return NULL;
25903
25904     out = conversion_context_alloc(ctx, count * sizeof(*out));
25905     for (i = 0; i < count; i++)
25906     {
25907         convert_VkPipelineExecutablePropertiesKHR_win32_to_host(&in[i], &out[i]);
25908     }
25909
25910     return out;
25911 }
25912
25913 static inline void convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out, uint32_t count)
25914 {
25915     unsigned int i;
25916
25917     if (!in) return;
25918
25919     for (i = 0; i < count; i++)
25920     {
25921         convert_VkPipelineExecutablePropertiesKHR_host_to_win32(&in[i], &out[i]);
25922     }
25923 }
25924
25925 static inline void convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(const VkPipelineExecutableStatisticValueKHR *in, VkPipelineExecutableStatisticValueKHR32 *out, VkFlags selector)
25926 {
25927     if (!in) return;
25928
25929     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR)
25930         out->b32 = in->b32;
25931     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR)
25932         out->i64 = in->i64;
25933     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR)
25934         out->u64 = in->u64;
25935     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR)
25936         out->f64 = in->f64;
25937 }
25938
25939 static inline void convert_VkPipelineExecutableStatisticKHR_win32_to_host(const VkPipelineExecutableStatisticKHR32 *in, VkPipelineExecutableStatisticKHR *out)
25940 {
25941     if (!in) return;
25942
25943     out->sType = in->sType;
25944     out->pNext = NULL;
25945     if (in->pNext)
25946         FIXME("Unexpected pNext\n");
25947 }
25948
25949 static inline void convert_VkPipelineExecutableStatisticKHR_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out)
25950 {
25951     if (!in) return;
25952
25953     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
25954     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
25955     out->format = in->format;
25956     convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(&in->value, &out->value, in->format);
25957 }
25958
25959 static inline VkPipelineExecutableStatisticKHR *convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableStatisticKHR32 *in, uint32_t count)
25960 {
25961     VkPipelineExecutableStatisticKHR *out;
25962     unsigned int i;
25963
25964     if (!in || !count) return NULL;
25965
25966     out = conversion_context_alloc(ctx, count * sizeof(*out));
25967     for (i = 0; i < count; i++)
25968     {
25969         convert_VkPipelineExecutableStatisticKHR_win32_to_host(&in[i], &out[i]);
25970     }
25971
25972     return out;
25973 }
25974
25975 static inline void convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out, uint32_t count)
25976 {
25977     unsigned int i;
25978
25979     if (!in) return;
25980
25981     for (i = 0; i < count; i++)
25982     {
25983         convert_VkPipelineExecutableStatisticKHR_host_to_win32(&in[i], &out[i]);
25984     }
25985 }
25986
25987 static inline void convert_VkPipelineIndirectDeviceAddressInfoNV_win32_to_host(const VkPipelineIndirectDeviceAddressInfoNV32 *in, VkPipelineIndirectDeviceAddressInfoNV *out)
25988 {
25989     if (!in) return;
25990
25991     out->sType = in->sType;
25992     out->pNext = NULL;
25993     out->pipelineBindPoint = in->pipelineBindPoint;
25994     out->pipeline = in->pipeline;
25995     if (in->pNext)
25996         FIXME("Unexpected pNext\n");
25997 }
25998
25999 static inline void convert_VkPipelineInfoEXT_win32_to_host(const VkPipelineInfoEXT32 *in, VkPipelineInfoEXT *out)
26000 {
26001     if (!in) return;
26002
26003     out->sType = in->sType;
26004     out->pNext = NULL;
26005     out->pipeline = in->pipeline;
26006     if (in->pNext)
26007         FIXME("Unexpected pNext\n");
26008 }
26009
26010 static inline void convert_VkCheckpointData2NV_win32_to_host(const VkCheckpointData2NV32 *in, VkCheckpointData2NV *out)
26011 {
26012     if (!in) return;
26013
26014     out->sType = in->sType;
26015     out->pNext = NULL;
26016     if (in->pNext)
26017         FIXME("Unexpected pNext\n");
26018 }
26019
26020 static inline void convert_VkCheckpointData2NV_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out)
26021 {
26022     if (!in) return;
26023
26024     out->stage = in->stage;
26025     out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker);
26026 }
26027
26028 static inline VkCheckpointData2NV *convert_VkCheckpointData2NV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointData2NV32 *in, uint32_t count)
26029 {
26030     VkCheckpointData2NV *out;
26031     unsigned int i;
26032
26033     if (!in || !count) return NULL;
26034
26035     out = conversion_context_alloc(ctx, count * sizeof(*out));
26036     for (i = 0; i < count; i++)
26037     {
26038         convert_VkCheckpointData2NV_win32_to_host(&in[i], &out[i]);
26039     }
26040
26041     return out;
26042 }
26043
26044 static inline void convert_VkCheckpointData2NV_array_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out, uint32_t count)
26045 {
26046     unsigned int i;
26047
26048     if (!in) return;
26049
26050     for (i = 0; i < count; i++)
26051     {
26052         convert_VkCheckpointData2NV_host_to_win32(&in[i], &out[i]);
26053     }
26054 }
26055
26056 static inline void convert_VkCheckpointDataNV_win32_to_host(const VkCheckpointDataNV32 *in, VkCheckpointDataNV *out)
26057 {
26058     if (!in) return;
26059
26060     out->sType = in->sType;
26061     out->pNext = NULL;
26062     if (in->pNext)
26063         FIXME("Unexpected pNext\n");
26064 }
26065
26066 static inline void convert_VkCheckpointDataNV_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out)
26067 {
26068     if (!in) return;
26069
26070     out->stage = in->stage;
26071     out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker);
26072 }
26073
26074 static inline VkCheckpointDataNV *convert_VkCheckpointDataNV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointDataNV32 *in, uint32_t count)
26075 {
26076     VkCheckpointDataNV *out;
26077     unsigned int i;
26078
26079     if (!in || !count) return NULL;
26080
26081     out = conversion_context_alloc(ctx, count * sizeof(*out));
26082     for (i = 0; i < count; i++)
26083     {
26084         convert_VkCheckpointDataNV_win32_to_host(&in[i], &out[i]);
26085     }
26086
26087     return out;
26088 }
26089
26090 static inline void convert_VkCheckpointDataNV_array_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out, uint32_t count)
26091 {
26092     unsigned int i;
26093
26094     if (!in) return;
26095
26096     for (i = 0; i < count; i++)
26097     {
26098         convert_VkCheckpointDataNV_host_to_win32(&in[i], &out[i]);
26099     }
26100 }
26101
26102 static inline void convert_VkRenderingAreaInfoKHR_win32_to_host(const VkRenderingAreaInfoKHR32 *in, VkRenderingAreaInfoKHR *out)
26103 {
26104     if (!in) return;
26105
26106     out->sType = in->sType;
26107     out->pNext = NULL;
26108     out->viewMask = in->viewMask;
26109     out->colorAttachmentCount = in->colorAttachmentCount;
26110     out->pColorAttachmentFormats = (const VkFormat *)UlongToPtr(in->pColorAttachmentFormats);
26111     out->depthAttachmentFormat = in->depthAttachmentFormat;
26112     out->stencilAttachmentFormat = in->stencilAttachmentFormat;
26113     if (in->pNext)
26114         FIXME("Unexpected pNext\n");
26115 }
26116
26117 static inline void convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host(const VkSamplerCaptureDescriptorDataInfoEXT32 *in, VkSamplerCaptureDescriptorDataInfoEXT *out)
26118 {
26119     if (!in) return;
26120
26121     out->sType = in->sType;
26122     out->pNext = NULL;
26123     out->sampler = in->sampler;
26124     if (in->pNext)
26125         FIXME("Unexpected pNext\n");
26126 }
26127
26128 static inline void convert_VkShaderModuleIdentifierEXT_win32_to_host(const VkShaderModuleIdentifierEXT32 *in, VkShaderModuleIdentifierEXT *out)
26129 {
26130     if (!in) return;
26131
26132     out->sType = in->sType;
26133     out->pNext = NULL;
26134     if (in->pNext)
26135         FIXME("Unexpected pNext\n");
26136 }
26137
26138 static inline void convert_VkShaderModuleIdentifierEXT_host_to_win32(const VkShaderModuleIdentifierEXT *in, VkShaderModuleIdentifierEXT32 *out)
26139 {
26140     if (!in) return;
26141
26142     out->identifierSize = in->identifierSize;
26143     memcpy(out->identifier, in->identifier, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t));
26144 }
26145
26146 static inline void convert_VkInitializePerformanceApiInfoINTEL_win32_to_host(const VkInitializePerformanceApiInfoINTEL32 *in, VkInitializePerformanceApiInfoINTEL *out)
26147 {
26148     if (!in) return;
26149
26150     out->sType = in->sType;
26151     out->pNext = NULL;
26152     out->pUserData = (void *)UlongToPtr(in->pUserData);
26153     if (in->pNext)
26154         FIXME("Unexpected pNext\n");
26155 }
26156
26157 static inline void convert_VkMemoryMapInfoKHR_win32_to_unwrapped_host(const VkMemoryMapInfoKHR32 *in, VkMemoryMapInfoKHR *out)
26158 {
26159     if (!in) return;
26160
26161     out->sType = in->sType;
26162     out->pNext = NULL;
26163     out->flags = in->flags;
26164     out->memory = in->memory;
26165     out->offset = in->offset;
26166     out->size = in->size;
26167     if (in->pNext)
26168         FIXME("Unexpected pNext\n");
26169 }
26170
26171 #ifdef _WIN64
26172 static inline void convert_VkSparseMemoryBind_win64_to_host(const VkSparseMemoryBind *in, VkSparseMemoryBind *out)
26173 {
26174     if (!in) return;
26175
26176     out->resourceOffset = in->resourceOffset;
26177     out->size = in->size;
26178     out->memory = in->memory ? wine_device_memory_from_handle(in->memory)->memory : 0;
26179     out->memoryOffset = in->memoryOffset;
26180     out->flags = in->flags;
26181 }
26182 #endif /* _WIN64 */
26183
26184 static inline void convert_VkSparseMemoryBind_win32_to_host(const VkSparseMemoryBind32 *in, VkSparseMemoryBind *out)
26185 {
26186     if (!in) return;
26187
26188     out->resourceOffset = in->resourceOffset;
26189     out->size = in->size;
26190     out->memory = in->memory ? wine_device_memory_from_handle(in->memory)->memory : 0;
26191     out->memoryOffset = in->memoryOffset;
26192     out->flags = in->flags;
26193 }
26194
26195 #ifdef _WIN64
26196 static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win64_to_host(struct conversion_context *ctx, const VkSparseMemoryBind *in, uint32_t count)
26197 {
26198     VkSparseMemoryBind *out;
26199     unsigned int i;
26200
26201     if (!in || !count) return NULL;
26202
26203     out = conversion_context_alloc(ctx, count * sizeof(*out));
26204     for (i = 0; i < count; i++)
26205     {
26206         convert_VkSparseMemoryBind_win64_to_host(&in[i], &out[i]);
26207     }
26208
26209     return out;
26210 }
26211 #endif /* _WIN64 */
26212
26213 static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseMemoryBind32 *in, uint32_t count)
26214 {
26215     VkSparseMemoryBind *out;
26216     unsigned int i;
26217
26218     if (!in || !count) return NULL;
26219
26220     out = conversion_context_alloc(ctx, count * sizeof(*out));
26221     for (i = 0; i < count; i++)
26222     {
26223         convert_VkSparseMemoryBind_win32_to_host(&in[i], &out[i]);
26224     }
26225
26226     return out;
26227 }
26228
26229 #ifdef _WIN64
26230 static inline void convert_VkSparseBufferMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, VkSparseBufferMemoryBindInfo *out)
26231 {
26232     if (!in) return;
26233
26234     out->buffer = in->buffer;
26235     out->bindCount = in->bindCount;
26236     out->pBinds = convert_VkSparseMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount);
26237 }
26238 #endif /* _WIN64 */
26239
26240 static inline void convert_VkSparseBufferMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, VkSparseBufferMemoryBindInfo *out)
26241 {
26242     if (!in) return;
26243
26244     out->buffer = in->buffer;
26245     out->bindCount = in->bindCount;
26246     out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
26247 }
26248
26249 #ifdef _WIN64
26250 static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, uint32_t count)
26251 {
26252     VkSparseBufferMemoryBindInfo *out;
26253     unsigned int i;
26254
26255     if (!in || !count) return NULL;
26256
26257     out = conversion_context_alloc(ctx, count * sizeof(*out));
26258     for (i = 0; i < count; i++)
26259     {
26260         convert_VkSparseBufferMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
26261     }
26262
26263     return out;
26264 }
26265 #endif /* _WIN64 */
26266
26267 static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, uint32_t count)
26268 {
26269     VkSparseBufferMemoryBindInfo *out;
26270     unsigned int i;
26271
26272     if (!in || !count) return NULL;
26273
26274     out = conversion_context_alloc(ctx, count * sizeof(*out));
26275     for (i = 0; i < count; i++)
26276     {
26277         convert_VkSparseBufferMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
26278     }
26279
26280     return out;
26281 }
26282
26283 #ifdef _WIN64
26284 static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, VkSparseImageOpaqueMemoryBindInfo *out)
26285 {
26286     if (!in) return;
26287
26288     out->image = in->image;
26289     out->bindCount = in->bindCount;
26290     out->pBinds = convert_VkSparseMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount);
26291 }
26292 #endif /* _WIN64 */
26293
26294 static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, VkSparseImageOpaqueMemoryBindInfo *out)
26295 {
26296     if (!in) return;
26297
26298     out->image = in->image;
26299     out->bindCount = in->bindCount;
26300     out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
26301 }
26302
26303 #ifdef _WIN64
26304 static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, uint32_t count)
26305 {
26306     VkSparseImageOpaqueMemoryBindInfo *out;
26307     unsigned int i;
26308
26309     if (!in || !count) return NULL;
26310
26311     out = conversion_context_alloc(ctx, count * sizeof(*out));
26312     for (i = 0; i < count; i++)
26313     {
26314         convert_VkSparseImageOpaqueMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
26315     }
26316
26317     return out;
26318 }
26319 #endif /* _WIN64 */
26320
26321 static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, uint32_t count)
26322 {
26323     VkSparseImageOpaqueMemoryBindInfo *out;
26324     unsigned int i;
26325
26326     if (!in || !count) return NULL;
26327
26328     out = conversion_context_alloc(ctx, count * sizeof(*out));
26329     for (i = 0; i < count; i++)
26330     {
26331         convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
26332     }
26333
26334     return out;
26335 }
26336
26337 #ifdef _WIN64
26338 static inline void convert_VkSparseImageMemoryBind_win64_to_host(const VkSparseImageMemoryBind *in, VkSparseImageMemoryBind *out)
26339 {
26340     if (!in) return;
26341
26342     out->subresource = in->subresource;
26343     out->offset = in->offset;
26344     out->extent = in->extent;
26345     out->memory = in->memory ? wine_device_memory_from_handle(in->memory)->memory : 0;
26346     out->memoryOffset = in->memoryOffset;
26347     out->flags = in->flags;
26348 }
26349 #endif /* _WIN64 */
26350
26351 static inline void convert_VkSparseImageMemoryBind_win32_to_host(const VkSparseImageMemoryBind32 *in, VkSparseImageMemoryBind *out)
26352 {
26353     if (!in) return;
26354
26355     out->subresource = in->subresource;
26356     out->offset = in->offset;
26357     out->extent = in->extent;
26358     out->memory = in->memory ? wine_device_memory_from_handle(in->memory)->memory : 0;
26359     out->memoryOffset = in->memoryOffset;
26360     out->flags = in->flags;
26361 }
26362
26363 #ifdef _WIN64
26364 static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind *in, uint32_t count)
26365 {
26366     VkSparseImageMemoryBind *out;
26367     unsigned int i;
26368
26369     if (!in || !count) return NULL;
26370
26371     out = conversion_context_alloc(ctx, count * sizeof(*out));
26372     for (i = 0; i < count; i++)
26373     {
26374         convert_VkSparseImageMemoryBind_win64_to_host(&in[i], &out[i]);
26375     }
26376
26377     return out;
26378 }
26379 #endif /* _WIN64 */
26380
26381 static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind32 *in, uint32_t count)
26382 {
26383     VkSparseImageMemoryBind *out;
26384     unsigned int i;
26385
26386     if (!in || !count) return NULL;
26387
26388     out = conversion_context_alloc(ctx, count * sizeof(*out));
26389     for (i = 0; i < count; i++)
26390     {
26391         convert_VkSparseImageMemoryBind_win32_to_host(&in[i], &out[i]);
26392     }
26393
26394     return out;
26395 }
26396
26397 #ifdef _WIN64
26398 static inline void convert_VkSparseImageMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, VkSparseImageMemoryBindInfo *out)
26399 {
26400     if (!in) return;
26401
26402     out->image = in->image;
26403     out->bindCount = in->bindCount;
26404     out->pBinds = convert_VkSparseImageMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount);
26405 }
26406 #endif /* _WIN64 */
26407
26408 static inline void convert_VkSparseImageMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, VkSparseImageMemoryBindInfo *out)
26409 {
26410     if (!in) return;
26411
26412     out->image = in->image;
26413     out->bindCount = in->bindCount;
26414     out->pBinds = convert_VkSparseImageMemoryBind_array_win32_to_host(ctx, (const VkSparseImageMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
26415 }
26416
26417 #ifdef _WIN64
26418 static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, uint32_t count)
26419 {
26420     VkSparseImageMemoryBindInfo *out;
26421     unsigned int i;
26422
26423     if (!in || !count) return NULL;
26424
26425     out = conversion_context_alloc(ctx, count * sizeof(*out));
26426     for (i = 0; i < count; i++)
26427     {
26428         convert_VkSparseImageMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
26429     }
26430
26431     return out;
26432 }
26433 #endif /* _WIN64 */
26434
26435 static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, uint32_t count)
26436 {
26437     VkSparseImageMemoryBindInfo *out;
26438     unsigned int i;
26439
26440     if (!in || !count) return NULL;
26441
26442     out = conversion_context_alloc(ctx, count * sizeof(*out));
26443     for (i = 0; i < count; i++)
26444     {
26445         convert_VkSparseImageMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
26446     }
26447
26448     return out;
26449 }
26450
26451 #ifdef _WIN64
26452 static inline void convert_VkBindSparseInfo_win64_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, VkBindSparseInfo *out)
26453 {
26454     if (!in) return;
26455
26456     out->sType = in->sType;
26457     out->pNext = in->pNext;
26458     out->waitSemaphoreCount = in->waitSemaphoreCount;
26459     out->pWaitSemaphores = in->pWaitSemaphores;
26460     out->bufferBindCount = in->bufferBindCount;
26461     out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win64_to_host(ctx, in->pBufferBinds, in->bufferBindCount);
26462     out->imageOpaqueBindCount = in->imageOpaqueBindCount;
26463     out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win64_to_host(ctx, in->pImageOpaqueBinds, in->imageOpaqueBindCount);
26464     out->imageBindCount = in->imageBindCount;
26465     out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win64_to_host(ctx, in->pImageBinds, in->imageBindCount);
26466     out->signalSemaphoreCount = in->signalSemaphoreCount;
26467     out->pSignalSemaphores = in->pSignalSemaphores;
26468 }
26469 #endif /* _WIN64 */
26470
26471 static inline void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, VkBindSparseInfo *out)
26472 {
26473     const VkBaseInStructure32 *in_header;
26474     VkBaseOutStructure *out_header = (void *)out;
26475
26476     if (!in) return;
26477
26478     out->sType = in->sType;
26479     out->pNext = NULL;
26480     out->waitSemaphoreCount = in->waitSemaphoreCount;
26481     out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
26482     out->bufferBindCount = in->bufferBindCount;
26483     out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseBufferMemoryBindInfo32 *)UlongToPtr(in->pBufferBinds), in->bufferBindCount);
26484     out->imageOpaqueBindCount = in->imageOpaqueBindCount;
26485     out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseImageOpaqueMemoryBindInfo32 *)UlongToPtr(in->pImageOpaqueBinds), in->imageOpaqueBindCount);
26486     out->imageBindCount = in->imageBindCount;
26487     out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseImageMemoryBindInfo32 *)UlongToPtr(in->pImageBinds), in->imageBindCount);
26488     out->signalSemaphoreCount = in->signalSemaphoreCount;
26489     out->pSignalSemaphores = (const VkSemaphore *)UlongToPtr(in->pSignalSemaphores);
26490
26491     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
26492     {
26493         switch (in_header->sType)
26494         {
26495         case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
26496         {
26497             VkDeviceGroupBindSparseInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26498             const VkDeviceGroupBindSparseInfo32 *in_ext = (const VkDeviceGroupBindSparseInfo32 *)in_header;
26499             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO;
26500             out_ext->pNext = NULL;
26501             out_ext->resourceDeviceIndex = in_ext->resourceDeviceIndex;
26502             out_ext->memoryDeviceIndex = in_ext->memoryDeviceIndex;
26503             out_header->pNext = (void *)out_ext;
26504             out_header = (void *)out_ext;
26505             break;
26506         }
26507         case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
26508         {
26509             VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26510             const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header;
26511             out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
26512             out_ext->pNext = NULL;
26513             out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
26514             out_ext->pWaitSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pWaitSemaphoreValues);
26515             out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
26516             out_ext->pSignalSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pSignalSemaphoreValues);
26517             out_header->pNext = (void *)out_ext;
26518             out_header = (void *)out_ext;
26519             break;
26520         }
26521         default:
26522             FIXME("Unhandled sType %u.\n", in_header->sType);
26523             break;
26524         }
26525     }
26526 }
26527
26528 #ifdef _WIN64
26529 static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, uint32_t count)
26530 {
26531     VkBindSparseInfo *out;
26532     unsigned int i;
26533
26534     if (!in || !count) return NULL;
26535
26536     out = conversion_context_alloc(ctx, count * sizeof(*out));
26537     for (i = 0; i < count; i++)
26538     {
26539         convert_VkBindSparseInfo_win64_to_host(ctx, &in[i], &out[i]);
26540     }
26541
26542     return out;
26543 }
26544 #endif /* _WIN64 */
26545
26546 static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, uint32_t count)
26547 {
26548     VkBindSparseInfo *out;
26549     unsigned int i;
26550
26551     if (!in || !count) return NULL;
26552
26553     out = conversion_context_alloc(ctx, count * sizeof(*out));
26554     for (i = 0; i < count; i++)
26555     {
26556         convert_VkBindSparseInfo_win32_to_host(ctx, &in[i], &out[i]);
26557     }
26558
26559     return out;
26560 }
26561
26562 static inline void convert_VkPresentRegionKHR_win32_to_host(const VkPresentRegionKHR32 *in, VkPresentRegionKHR *out)
26563 {
26564     if (!in) return;
26565
26566     out->rectangleCount = in->rectangleCount;
26567     out->pRectangles = (const VkRectLayerKHR *)UlongToPtr(in->pRectangles);
26568 }
26569
26570 static inline const VkPresentRegionKHR *convert_VkPresentRegionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPresentRegionKHR32 *in, uint32_t count)
26571 {
26572     VkPresentRegionKHR *out;
26573     unsigned int i;
26574
26575     if (!in || !count) return NULL;
26576
26577     out = conversion_context_alloc(ctx, count * sizeof(*out));
26578     for (i = 0; i < count; i++)
26579     {
26580         convert_VkPresentRegionKHR_win32_to_host(&in[i], &out[i]);
26581     }
26582
26583     return out;
26584 }
26585
26586 static inline void convert_VkPresentInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPresentInfoKHR32 *in, VkPresentInfoKHR *out)
26587 {
26588     const VkBaseInStructure32 *in_header;
26589     VkBaseOutStructure *out_header = (void *)out;
26590
26591     if (!in) return;
26592
26593     out->sType = in->sType;
26594     out->pNext = NULL;
26595     out->waitSemaphoreCount = in->waitSemaphoreCount;
26596     out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
26597     out->swapchainCount = in->swapchainCount;
26598     out->pSwapchains = (const VkSwapchainKHR *)UlongToPtr(in->pSwapchains);
26599     out->pImageIndices = (const uint32_t *)UlongToPtr(in->pImageIndices);
26600     out->pResults = (VkResult *)UlongToPtr(in->pResults);
26601
26602     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
26603     {
26604         switch (in_header->sType)
26605         {
26606         case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
26607         {
26608             VkPresentRegionsKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26609             const VkPresentRegionsKHR32 *in_ext = (const VkPresentRegionsKHR32 *)in_header;
26610             out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR;
26611             out_ext->pNext = NULL;
26612             out_ext->swapchainCount = in_ext->swapchainCount;
26613             out_ext->pRegions = convert_VkPresentRegionKHR_array_win32_to_host(ctx, (const VkPresentRegionKHR32 *)UlongToPtr(in_ext->pRegions), in_ext->swapchainCount);
26614             out_header->pNext = (void *)out_ext;
26615             out_header = (void *)out_ext;
26616             break;
26617         }
26618         case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
26619         {
26620             VkDeviceGroupPresentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26621             const VkDeviceGroupPresentInfoKHR32 *in_ext = (const VkDeviceGroupPresentInfoKHR32 *)in_header;
26622             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR;
26623             out_ext->pNext = NULL;
26624             out_ext->swapchainCount = in_ext->swapchainCount;
26625             out_ext->pDeviceMasks = (const uint32_t *)UlongToPtr(in_ext->pDeviceMasks);
26626             out_ext->mode = in_ext->mode;
26627             out_header->pNext = (void *)out_ext;
26628             out_header = (void *)out_ext;
26629             break;
26630         }
26631         case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
26632         {
26633             VkPresentIdKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26634             const VkPresentIdKHR32 *in_ext = (const VkPresentIdKHR32 *)in_header;
26635             out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR;
26636             out_ext->pNext = NULL;
26637             out_ext->swapchainCount = in_ext->swapchainCount;
26638             out_ext->pPresentIds = (const uint64_t *)UlongToPtr(in_ext->pPresentIds);
26639             out_header->pNext = (void *)out_ext;
26640             out_header = (void *)out_ext;
26641             break;
26642         }
26643         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
26644         {
26645             VkSwapchainPresentFenceInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26646             const VkSwapchainPresentFenceInfoEXT32 *in_ext = (const VkSwapchainPresentFenceInfoEXT32 *)in_header;
26647             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT;
26648             out_ext->pNext = NULL;
26649             out_ext->swapchainCount = in_ext->swapchainCount;
26650             out_ext->pFences = (const VkFence *)UlongToPtr(in_ext->pFences);
26651             out_header->pNext = (void *)out_ext;
26652             out_header = (void *)out_ext;
26653             break;
26654         }
26655         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
26656         {
26657             VkSwapchainPresentModeInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26658             const VkSwapchainPresentModeInfoEXT32 *in_ext = (const VkSwapchainPresentModeInfoEXT32 *)in_header;
26659             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT;
26660             out_ext->pNext = NULL;
26661             out_ext->swapchainCount = in_ext->swapchainCount;
26662             out_ext->pPresentModes = (const VkPresentModeKHR *)UlongToPtr(in_ext->pPresentModes);
26663             out_header->pNext = (void *)out_ext;
26664             out_header = (void *)out_ext;
26665             break;
26666         }
26667         default:
26668             FIXME("Unhandled sType %u.\n", in_header->sType);
26669             break;
26670         }
26671     }
26672 }
26673
26674 #ifdef _WIN64
26675 static inline void convert_VkSubmitInfo_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, VkSubmitInfo *out)
26676 {
26677     if (!in) return;
26678
26679     out->sType = in->sType;
26680     out->pNext = in->pNext;
26681     out->waitSemaphoreCount = in->waitSemaphoreCount;
26682     out->pWaitSemaphores = in->pWaitSemaphores;
26683     out->pWaitDstStageMask = in->pWaitDstStageMask;
26684     out->commandBufferCount = in->commandBufferCount;
26685     out->pCommandBuffers = convert_VkCommandBuffer_array_win64_to_host(ctx, in->pCommandBuffers, in->commandBufferCount);
26686     out->signalSemaphoreCount = in->signalSemaphoreCount;
26687     out->pSignalSemaphores = in->pSignalSemaphores;
26688 }
26689 #endif /* _WIN64 */
26690
26691 static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, VkSubmitInfo *out)
26692 {
26693     const VkBaseInStructure32 *in_header;
26694     VkBaseOutStructure *out_header = (void *)out;
26695
26696     if (!in) return;
26697
26698     out->sType = in->sType;
26699     out->pNext = NULL;
26700     out->waitSemaphoreCount = in->waitSemaphoreCount;
26701     out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
26702     out->pWaitDstStageMask = (const VkPipelineStageFlags *)UlongToPtr(in->pWaitDstStageMask);
26703     out->commandBufferCount = in->commandBufferCount;
26704     out->pCommandBuffers = convert_VkCommandBuffer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->pCommandBuffers), in->commandBufferCount);
26705     out->signalSemaphoreCount = in->signalSemaphoreCount;
26706     out->pSignalSemaphores = (const VkSemaphore *)UlongToPtr(in->pSignalSemaphores);
26707
26708     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
26709     {
26710         switch (in_header->sType)
26711         {
26712         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
26713         {
26714             VkDeviceGroupSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26715             const VkDeviceGroupSubmitInfo32 *in_ext = (const VkDeviceGroupSubmitInfo32 *)in_header;
26716             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO;
26717             out_ext->pNext = NULL;
26718             out_ext->waitSemaphoreCount = in_ext->waitSemaphoreCount;
26719             out_ext->pWaitSemaphoreDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pWaitSemaphoreDeviceIndices);
26720             out_ext->commandBufferCount = in_ext->commandBufferCount;
26721             out_ext->pCommandBufferDeviceMasks = (const uint32_t *)UlongToPtr(in_ext->pCommandBufferDeviceMasks);
26722             out_ext->signalSemaphoreCount = in_ext->signalSemaphoreCount;
26723             out_ext->pSignalSemaphoreDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pSignalSemaphoreDeviceIndices);
26724             out_header->pNext = (void *)out_ext;
26725             out_header = (void *)out_ext;
26726             break;
26727         }
26728         case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
26729         {
26730             VkProtectedSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26731             const VkProtectedSubmitInfo32 *in_ext = (const VkProtectedSubmitInfo32 *)in_header;
26732             out_ext->sType = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO;
26733             out_ext->pNext = NULL;
26734             out_ext->protectedSubmit = in_ext->protectedSubmit;
26735             out_header->pNext = (void *)out_ext;
26736             out_header = (void *)out_ext;
26737             break;
26738         }
26739         case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
26740         {
26741             VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26742             const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header;
26743             out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
26744             out_ext->pNext = NULL;
26745             out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
26746             out_ext->pWaitSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pWaitSemaphoreValues);
26747             out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
26748             out_ext->pSignalSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pSignalSemaphoreValues);
26749             out_header->pNext = (void *)out_ext;
26750             out_header = (void *)out_ext;
26751             break;
26752         }
26753         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
26754         {
26755             VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26756             const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header;
26757             out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
26758             out_ext->pNext = NULL;
26759             out_ext->counterPassIndex = in_ext->counterPassIndex;
26760             out_header->pNext = (void *)out_ext;
26761             out_header = (void *)out_ext;
26762             break;
26763         }
26764         default:
26765             FIXME("Unhandled sType %u.\n", in_header->sType);
26766             break;
26767         }
26768     }
26769 }
26770
26771 #ifdef _WIN64
26772 static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, uint32_t count)
26773 {
26774     VkSubmitInfo *out;
26775     unsigned int i;
26776
26777     if (!in || !count) return NULL;
26778
26779     out = conversion_context_alloc(ctx, count * sizeof(*out));
26780     for (i = 0; i < count; i++)
26781     {
26782         convert_VkSubmitInfo_win64_to_host(ctx, &in[i], &out[i]);
26783     }
26784
26785     return out;
26786 }
26787 #endif /* _WIN64 */
26788
26789 static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, uint32_t count)
26790 {
26791     VkSubmitInfo *out;
26792     unsigned int i;
26793
26794     if (!in || !count) return NULL;
26795
26796     out = conversion_context_alloc(ctx, count * sizeof(*out));
26797     for (i = 0; i < count; i++)
26798     {
26799         convert_VkSubmitInfo_win32_to_host(ctx, &in[i], &out[i]);
26800     }
26801
26802     return out;
26803 }
26804
26805 static inline void convert_VkSemaphoreSubmitInfo_win32_to_host(const VkSemaphoreSubmitInfo32 *in, VkSemaphoreSubmitInfo *out)
26806 {
26807     if (!in) return;
26808
26809     out->sType = in->sType;
26810     out->pNext = NULL;
26811     out->semaphore = in->semaphore;
26812     out->value = in->value;
26813     out->stageMask = in->stageMask;
26814     out->deviceIndex = in->deviceIndex;
26815     if (in->pNext)
26816         FIXME("Unexpected pNext\n");
26817 }
26818
26819 static inline const VkSemaphoreSubmitInfo *convert_VkSemaphoreSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSemaphoreSubmitInfo32 *in, uint32_t count)
26820 {
26821     VkSemaphoreSubmitInfo *out;
26822     unsigned int i;
26823
26824     if (!in || !count) return NULL;
26825
26826     out = conversion_context_alloc(ctx, count * sizeof(*out));
26827     for (i = 0; i < count; i++)
26828     {
26829         convert_VkSemaphoreSubmitInfo_win32_to_host(&in[i], &out[i]);
26830     }
26831
26832     return out;
26833 }
26834
26835 #ifdef _WIN64
26836 static inline void convert_VkCommandBufferSubmitInfo_win64_to_host(const VkCommandBufferSubmitInfo *in, VkCommandBufferSubmitInfo *out)
26837 {
26838     if (!in) return;
26839
26840     out->sType = in->sType;
26841     out->pNext = in->pNext;
26842     out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->command_buffer;
26843     out->deviceMask = in->deviceMask;
26844 }
26845 #endif /* _WIN64 */
26846
26847 static inline void convert_VkCommandBufferSubmitInfo_win32_to_host(const VkCommandBufferSubmitInfo32 *in, VkCommandBufferSubmitInfo *out)
26848 {
26849     if (!in) return;
26850
26851     out->sType = in->sType;
26852     out->pNext = NULL;
26853     out->commandBuffer = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(in->commandBuffer))->command_buffer;
26854     out->deviceMask = in->deviceMask;
26855     if (in->pNext)
26856         FIXME("Unexpected pNext\n");
26857 }
26858
26859 #ifdef _WIN64
26860 static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo *in, uint32_t count)
26861 {
26862     VkCommandBufferSubmitInfo *out;
26863     unsigned int i;
26864
26865     if (!in || !count) return NULL;
26866
26867     out = conversion_context_alloc(ctx, count * sizeof(*out));
26868     for (i = 0; i < count; i++)
26869     {
26870         convert_VkCommandBufferSubmitInfo_win64_to_host(&in[i], &out[i]);
26871     }
26872
26873     return out;
26874 }
26875 #endif /* _WIN64 */
26876
26877 static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo32 *in, uint32_t count)
26878 {
26879     VkCommandBufferSubmitInfo *out;
26880     unsigned int i;
26881
26882     if (!in || !count) return NULL;
26883
26884     out = conversion_context_alloc(ctx, count * sizeof(*out));
26885     for (i = 0; i < count; i++)
26886     {
26887         convert_VkCommandBufferSubmitInfo_win32_to_host(&in[i], &out[i]);
26888     }
26889
26890     return out;
26891 }
26892
26893 #ifdef _WIN64
26894 static inline void convert_VkSubmitInfo2_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, VkSubmitInfo2 *out)
26895 {
26896     if (!in) return;
26897
26898     out->sType = in->sType;
26899     out->pNext = in->pNext;
26900     out->flags = in->flags;
26901     out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
26902     out->pWaitSemaphoreInfos = in->pWaitSemaphoreInfos;
26903     out->commandBufferInfoCount = in->commandBufferInfoCount;
26904     out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win64_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount);
26905     out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
26906     out->pSignalSemaphoreInfos = in->pSignalSemaphoreInfos;
26907 }
26908 #endif /* _WIN64 */
26909
26910 static inline void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, VkSubmitInfo2 *out)
26911 {
26912     const VkBaseInStructure32 *in_header;
26913     VkBaseOutStructure *out_header = (void *)out;
26914
26915     if (!in) return;
26916
26917     out->sType = in->sType;
26918     out->pNext = NULL;
26919     out->flags = in->flags;
26920     out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
26921     out->pWaitSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, (const VkSemaphoreSubmitInfo32 *)UlongToPtr(in->pWaitSemaphoreInfos), in->waitSemaphoreInfoCount);
26922     out->commandBufferInfoCount = in->commandBufferInfoCount;
26923     out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win32_to_host(ctx, (const VkCommandBufferSubmitInfo32 *)UlongToPtr(in->pCommandBufferInfos), in->commandBufferInfoCount);
26924     out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
26925     out->pSignalSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, (const VkSemaphoreSubmitInfo32 *)UlongToPtr(in->pSignalSemaphoreInfos), in->signalSemaphoreInfoCount);
26926
26927     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
26928     {
26929         switch (in_header->sType)
26930         {
26931         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
26932         {
26933             VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26934             const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header;
26935             out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
26936             out_ext->pNext = NULL;
26937             out_ext->counterPassIndex = in_ext->counterPassIndex;
26938             out_header->pNext = (void *)out_ext;
26939             out_header = (void *)out_ext;
26940             break;
26941         }
26942         default:
26943             FIXME("Unhandled sType %u.\n", in_header->sType);
26944             break;
26945         }
26946     }
26947 }
26948
26949 #ifdef _WIN64
26950 static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, uint32_t count)
26951 {
26952     VkSubmitInfo2 *out;
26953     unsigned int i;
26954
26955     if (!in || !count) return NULL;
26956
26957     out = conversion_context_alloc(ctx, count * sizeof(*out));
26958     for (i = 0; i < count; i++)
26959     {
26960         convert_VkSubmitInfo2_win64_to_host(ctx, &in[i], &out[i]);
26961     }
26962
26963     return out;
26964 }
26965 #endif /* _WIN64 */
26966
26967 static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, uint32_t count)
26968 {
26969     VkSubmitInfo2 *out;
26970     unsigned int i;
26971
26972     if (!in || !count) return NULL;
26973
26974     out = conversion_context_alloc(ctx, count * sizeof(*out));
26975     for (i = 0; i < count; i++)
26976     {
26977         convert_VkSubmitInfo2_win32_to_host(ctx, &in[i], &out[i]);
26978     }
26979
26980     return out;
26981 }
26982
26983 static inline void convert_VkReleaseSwapchainImagesInfoEXT_win32_to_host(const VkReleaseSwapchainImagesInfoEXT32 *in, VkReleaseSwapchainImagesInfoEXT *out)
26984 {
26985     if (!in) return;
26986
26987     out->sType = in->sType;
26988     out->pNext = NULL;
26989     out->swapchain = in->swapchain;
26990     out->imageIndexCount = in->imageIndexCount;
26991     out->pImageIndices = (const uint32_t *)UlongToPtr(in->pImageIndices);
26992     if (in->pNext)
26993         FIXME("Unexpected pNext\n");
26994 }
26995
26996 #ifdef _WIN64
26997 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(const VkDebugUtilsObjectNameInfoEXT *in, VkDebugUtilsObjectNameInfoEXT *out)
26998 {
26999     if (!in) return;
27000
27001     out->sType = in->sType;
27002     out->pNext = in->pNext;
27003     out->objectType = in->objectType;
27004     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
27005     out->pObjectName = in->pObjectName;
27006 }
27007 #endif /* _WIN64 */
27008
27009 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(const VkDebugUtilsObjectNameInfoEXT32 *in, VkDebugUtilsObjectNameInfoEXT *out)
27010 {
27011     if (!in) return;
27012
27013     out->sType = in->sType;
27014     out->pNext = NULL;
27015     out->objectType = in->objectType;
27016     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
27017     out->pObjectName = (const char *)UlongToPtr(in->pObjectName);
27018     if (in->pNext)
27019         FIXME("Unexpected pNext\n");
27020 }
27021
27022 #ifdef _WIN64
27023 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(const VkDebugUtilsObjectTagInfoEXT *in, VkDebugUtilsObjectTagInfoEXT *out)
27024 {
27025     if (!in) return;
27026
27027     out->sType = in->sType;
27028     out->pNext = in->pNext;
27029     out->objectType = in->objectType;
27030     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
27031     out->tagName = in->tagName;
27032     out->tagSize = in->tagSize;
27033     out->pTag = in->pTag;
27034 }
27035 #endif /* _WIN64 */
27036
27037 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(const VkDebugUtilsObjectTagInfoEXT32 *in, VkDebugUtilsObjectTagInfoEXT *out)
27038 {
27039     if (!in) return;
27040
27041     out->sType = in->sType;
27042     out->pNext = NULL;
27043     out->objectType = in->objectType;
27044     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
27045     out->tagName = in->tagName;
27046     out->tagSize = in->tagSize;
27047     out->pTag = (const void *)UlongToPtr(in->pTag);
27048     if (in->pNext)
27049         FIXME("Unexpected pNext\n");
27050 }
27051
27052 static inline void convert_VkHdrMetadataEXT_win32_to_host(const VkHdrMetadataEXT32 *in, VkHdrMetadataEXT *out)
27053 {
27054     if (!in) return;
27055
27056     out->sType = in->sType;
27057     out->pNext = NULL;
27058     out->displayPrimaryRed = in->displayPrimaryRed;
27059     out->displayPrimaryGreen = in->displayPrimaryGreen;
27060     out->displayPrimaryBlue = in->displayPrimaryBlue;
27061     out->whitePoint = in->whitePoint;
27062     out->maxLuminance = in->maxLuminance;
27063     out->minLuminance = in->minLuminance;
27064     out->maxContentLightLevel = in->maxContentLightLevel;
27065     out->maxFrameAverageLightLevel = in->maxFrameAverageLightLevel;
27066     if (in->pNext)
27067         FIXME("Unexpected pNext\n");
27068 }
27069
27070 static inline const VkHdrMetadataEXT *convert_VkHdrMetadataEXT_array_win32_to_host(struct conversion_context *ctx, const VkHdrMetadataEXT32 *in, uint32_t count)
27071 {
27072     VkHdrMetadataEXT *out;
27073     unsigned int i;
27074
27075     if (!in || !count) return NULL;
27076
27077     out = conversion_context_alloc(ctx, count * sizeof(*out));
27078     for (i = 0; i < count; i++)
27079     {
27080         convert_VkHdrMetadataEXT_win32_to_host(&in[i], &out[i]);
27081     }
27082
27083     return out;
27084 }
27085
27086 static inline void convert_VkSemaphoreSignalInfo_win32_to_host(const VkSemaphoreSignalInfo32 *in, VkSemaphoreSignalInfo *out)
27087 {
27088     if (!in) return;
27089
27090     out->sType = in->sType;
27091     out->pNext = NULL;
27092     out->semaphore = in->semaphore;
27093     out->value = in->value;
27094     if (in->pNext)
27095         FIXME("Unexpected pNext\n");
27096 }
27097
27098 static inline const VkDebugUtilsLabelEXT *convert_VkDebugUtilsLabelEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsLabelEXT32 *in, uint32_t count)
27099 {
27100     VkDebugUtilsLabelEXT *out;
27101     unsigned int i;
27102
27103     if (!in || !count) return NULL;
27104
27105     out = conversion_context_alloc(ctx, count * sizeof(*out));
27106     for (i = 0; i < count; i++)
27107     {
27108         convert_VkDebugUtilsLabelEXT_win32_to_host(&in[i], &out[i]);
27109     }
27110
27111     return out;
27112 }
27113
27114 #ifdef _WIN64
27115 static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT *in, uint32_t count)
27116 {
27117     VkDebugUtilsObjectNameInfoEXT *out;
27118     unsigned int i;
27119
27120     if (!in || !count) return NULL;
27121
27122     out = conversion_context_alloc(ctx, count * sizeof(*out));
27123     for (i = 0; i < count; i++)
27124     {
27125         convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(&in[i], &out[i]);
27126     }
27127
27128     return out;
27129 }
27130 #endif /* _WIN64 */
27131
27132 static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT32 *in, uint32_t count)
27133 {
27134     VkDebugUtilsObjectNameInfoEXT *out;
27135     unsigned int i;
27136
27137     if (!in || !count) return NULL;
27138
27139     out = conversion_context_alloc(ctx, count * sizeof(*out));
27140     for (i = 0; i < count; i++)
27141     {
27142         convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(&in[i], &out[i]);
27143     }
27144
27145     return out;
27146 }
27147
27148 #ifdef _WIN64
27149 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT *in, VkDebugUtilsMessengerCallbackDataEXT *out)
27150 {
27151     if (!in) return;
27152
27153     out->sType = in->sType;
27154     out->pNext = in->pNext;
27155     out->flags = in->flags;
27156     out->pMessageIdName = in->pMessageIdName;
27157     out->messageIdNumber = in->messageIdNumber;
27158     out->pMessage = in->pMessage;
27159     out->queueLabelCount = in->queueLabelCount;
27160     out->pQueueLabels = in->pQueueLabels;
27161     out->cmdBufLabelCount = in->cmdBufLabelCount;
27162     out->pCmdBufLabels = in->pCmdBufLabels;
27163     out->objectCount = in->objectCount;
27164     out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(ctx, in->pObjects, in->objectCount);
27165 }
27166 #endif /* _WIN64 */
27167
27168 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT32 *in, VkDebugUtilsMessengerCallbackDataEXT *out)
27169 {
27170     const VkBaseInStructure32 *in_header;
27171     VkBaseOutStructure *out_header = (void *)out;
27172
27173     if (!in) return;
27174
27175     out->sType = in->sType;
27176     out->pNext = NULL;
27177     out->flags = in->flags;
27178     out->pMessageIdName = (const char *)UlongToPtr(in->pMessageIdName);
27179     out->messageIdNumber = in->messageIdNumber;
27180     out->pMessage = (const char *)UlongToPtr(in->pMessage);
27181     out->queueLabelCount = in->queueLabelCount;
27182     out->pQueueLabels = convert_VkDebugUtilsLabelEXT_array_win32_to_host(ctx, (const VkDebugUtilsLabelEXT32 *)UlongToPtr(in->pQueueLabels), in->queueLabelCount);
27183     out->cmdBufLabelCount = in->cmdBufLabelCount;
27184     out->pCmdBufLabels = convert_VkDebugUtilsLabelEXT_array_win32_to_host(ctx, (const VkDebugUtilsLabelEXT32 *)UlongToPtr(in->pCmdBufLabels), in->cmdBufLabelCount);
27185     out->objectCount = in->objectCount;
27186     out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(ctx, (const VkDebugUtilsObjectNameInfoEXT32 *)UlongToPtr(in->pObjects), in->objectCount);
27187
27188     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
27189     {
27190         switch (in_header->sType)
27191         {
27192         case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
27193         {
27194             VkDeviceAddressBindingCallbackDataEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
27195             const VkDeviceAddressBindingCallbackDataEXT32 *in_ext = (const VkDeviceAddressBindingCallbackDataEXT32 *)in_header;
27196             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT;
27197             out_ext->pNext = NULL;
27198             out_ext->flags = in_ext->flags;
27199             out_ext->baseAddress = in_ext->baseAddress;
27200             out_ext->size = in_ext->size;
27201             out_ext->bindingType = in_ext->bindingType;
27202             out_header->pNext = (void *)out_ext;
27203             out_header = (void *)out_ext;
27204             break;
27205         }
27206         default:
27207             FIXME("Unhandled sType %u.\n", in_header->sType);
27208             break;
27209         }
27210     }
27211 }
27212
27213 static inline void convert_VkHostImageLayoutTransitionInfoEXT_win32_to_host(const VkHostImageLayoutTransitionInfoEXT32 *in, VkHostImageLayoutTransitionInfoEXT *out)
27214 {
27215     if (!in) return;
27216
27217     out->sType = in->sType;
27218     out->pNext = NULL;
27219     out->image = in->image;
27220     out->oldLayout = in->oldLayout;
27221     out->newLayout = in->newLayout;
27222     out->subresourceRange = in->subresourceRange;
27223     if (in->pNext)
27224         FIXME("Unexpected pNext\n");
27225 }
27226
27227 static inline const VkHostImageLayoutTransitionInfoEXT *convert_VkHostImageLayoutTransitionInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkHostImageLayoutTransitionInfoEXT32 *in, uint32_t count)
27228 {
27229     VkHostImageLayoutTransitionInfoEXT *out;
27230     unsigned int i;
27231
27232     if (!in || !count) return NULL;
27233
27234     out = conversion_context_alloc(ctx, count * sizeof(*out));
27235     for (i = 0; i < count; i++)
27236     {
27237         convert_VkHostImageLayoutTransitionInfoEXT_win32_to_host(&in[i], &out[i]);
27238     }
27239
27240     return out;
27241 }
27242
27243 static inline void convert_VkMemoryUnmapInfoKHR_win32_to_unwrapped_host(const VkMemoryUnmapInfoKHR32 *in, VkMemoryUnmapInfoKHR *out)
27244 {
27245     if (!in) return;
27246
27247     out->sType = in->sType;
27248     out->pNext = NULL;
27249     out->flags = in->flags;
27250     out->memory = in->memory;
27251     if (in->pNext)
27252         FIXME("Unexpected pNext\n");
27253 }
27254
27255 static inline void convert_VkCopyDescriptorSet_win32_to_host(const VkCopyDescriptorSet32 *in, VkCopyDescriptorSet *out)
27256 {
27257     if (!in) return;
27258
27259     out->sType = in->sType;
27260     out->pNext = NULL;
27261     out->srcSet = in->srcSet;
27262     out->srcBinding = in->srcBinding;
27263     out->srcArrayElement = in->srcArrayElement;
27264     out->dstSet = in->dstSet;
27265     out->dstBinding = in->dstBinding;
27266     out->dstArrayElement = in->dstArrayElement;
27267     out->descriptorCount = in->descriptorCount;
27268     if (in->pNext)
27269         FIXME("Unexpected pNext\n");
27270 }
27271
27272 static inline const VkCopyDescriptorSet *convert_VkCopyDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkCopyDescriptorSet32 *in, uint32_t count)
27273 {
27274     VkCopyDescriptorSet *out;
27275     unsigned int i;
27276
27277     if (!in || !count) return NULL;
27278
27279     out = conversion_context_alloc(ctx, count * sizeof(*out));
27280     for (i = 0; i < count; i++)
27281     {
27282         convert_VkCopyDescriptorSet_win32_to_host(&in[i], &out[i]);
27283     }
27284
27285     return out;
27286 }
27287
27288 static inline void convert_VkSemaphoreWaitInfo_win32_to_host(const VkSemaphoreWaitInfo32 *in, VkSemaphoreWaitInfo *out)
27289 {
27290     if (!in) return;
27291
27292     out->sType = in->sType;
27293     out->pNext = NULL;
27294     out->flags = in->flags;
27295     out->semaphoreCount = in->semaphoreCount;
27296     out->pSemaphores = (const VkSemaphore *)UlongToPtr(in->pSemaphores);
27297     out->pValues = (const uint64_t *)UlongToPtr(in->pValues);
27298     if (in->pNext)
27299         FIXME("Unexpected pNext\n");
27300 }
27301
27302 #ifdef _WIN64
27303 static NTSTATUS thunk64_vkAcquireNextImage2KHR(void *args)
27304 {
27305     struct vkAcquireNextImage2KHR_params *params = args;
27306
27307     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pImageIndex);
27308
27309     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pImageIndex);
27310     return STATUS_SUCCESS;
27311 }
27312 #endif /* _WIN64 */
27313
27314 static NTSTATUS thunk32_vkAcquireNextImage2KHR(void *args)
27315 {
27316     struct
27317     {
27318         PTR32 device;
27319         PTR32 pAcquireInfo;
27320         PTR32 pImageIndex;
27321         VkResult result;
27322     } *params = args;
27323     VkAcquireNextImageInfoKHR pAcquireInfo_host;
27324
27325     TRACE("%#x, %#x, %#x\n", params->device, params->pAcquireInfo, params->pImageIndex);
27326
27327     convert_VkAcquireNextImageInfoKHR_win32_to_host((const VkAcquireNextImageInfoKHR32 *)UlongToPtr(params->pAcquireInfo), &pAcquireInfo_host);
27328     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));
27329     return STATUS_SUCCESS;
27330 }
27331
27332 #ifdef _WIN64
27333 static NTSTATUS thunk64_vkAcquireNextImageKHR(void *args)
27334 {
27335     struct vkAcquireNextImageKHR_params *params = args;
27336
27337     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);
27338
27339     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);
27340     return STATUS_SUCCESS;
27341 }
27342 #endif /* _WIN64 */
27343
27344 static NTSTATUS thunk32_vkAcquireNextImageKHR(void *args)
27345 {
27346     struct
27347     {
27348         PTR32 device;
27349         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
27350         uint64_t DECLSPEC_ALIGN(8) timeout;
27351         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
27352         VkFence DECLSPEC_ALIGN(8) fence;
27353         PTR32 pImageIndex;
27354         VkResult result;
27355     } *params = args;
27356
27357     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);
27358
27359     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));
27360     return STATUS_SUCCESS;
27361 }
27362
27363 #ifdef _WIN64
27364 static NTSTATUS thunk64_vkAcquirePerformanceConfigurationINTEL(void *args)
27365 {
27366     struct vkAcquirePerformanceConfigurationINTEL_params *params = args;
27367
27368     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pConfiguration);
27369
27370     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pConfiguration);
27371     return STATUS_SUCCESS;
27372 }
27373 #endif /* _WIN64 */
27374
27375 static NTSTATUS thunk32_vkAcquirePerformanceConfigurationINTEL(void *args)
27376 {
27377     struct
27378     {
27379         PTR32 device;
27380         PTR32 pAcquireInfo;
27381         PTR32 pConfiguration;
27382         VkResult result;
27383     } *params = args;
27384     VkPerformanceConfigurationAcquireInfoINTEL pAcquireInfo_host;
27385
27386     TRACE("%#x, %#x, %#x\n", params->device, params->pAcquireInfo, params->pConfiguration);
27387
27388     convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host((const VkPerformanceConfigurationAcquireInfoINTEL32 *)UlongToPtr(params->pAcquireInfo), &pAcquireInfo_host);
27389     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));
27390     return STATUS_SUCCESS;
27391 }
27392
27393 #ifdef _WIN64
27394 static NTSTATUS thunk64_vkAcquireProfilingLockKHR(void *args)
27395 {
27396     struct vkAcquireProfilingLockKHR_params *params = args;
27397
27398     TRACE("%p, %p\n", params->device, params->pInfo);
27399
27400     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle(params->device)->device, params->pInfo);
27401     return STATUS_SUCCESS;
27402 }
27403 #endif /* _WIN64 */
27404
27405 static NTSTATUS thunk32_vkAcquireProfilingLockKHR(void *args)
27406 {
27407     struct
27408     {
27409         PTR32 device;
27410         PTR32 pInfo;
27411         VkResult result;
27412     } *params = args;
27413     VkAcquireProfilingLockInfoKHR pInfo_host;
27414
27415     TRACE("%#x, %#x\n", params->device, params->pInfo);
27416
27417     convert_VkAcquireProfilingLockInfoKHR_win32_to_host((const VkAcquireProfilingLockInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
27418     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
27419     return STATUS_SUCCESS;
27420 }
27421
27422 #ifdef _WIN64
27423 static NTSTATUS thunk64_vkAllocateCommandBuffers(void *args)
27424 {
27425     struct vkAllocateCommandBuffers_params *params = args;
27426
27427     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pCommandBuffers);
27428
27429     params->result = wine_vkAllocateCommandBuffers(params->device, params->pAllocateInfo, params->pCommandBuffers);
27430     return STATUS_SUCCESS;
27431 }
27432 #endif /* _WIN64 */
27433
27434 static NTSTATUS thunk32_vkAllocateCommandBuffers(void *args)
27435 {
27436     struct
27437     {
27438         PTR32 device;
27439         PTR32 pAllocateInfo;
27440         PTR32 pCommandBuffers;
27441         VkResult result;
27442     } *params = args;
27443     VkCommandBufferAllocateInfo pAllocateInfo_host;
27444     VkCommandBuffer *pCommandBuffers_host;
27445     struct conversion_context local_ctx;
27446     struct conversion_context *ctx = &local_ctx;
27447
27448     TRACE("%#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pCommandBuffers);
27449
27450     init_conversion_context(ctx);
27451     convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host((const VkCommandBufferAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
27452     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_unwrapped_host(ctx, (PTR32 *)UlongToPtr(params->pCommandBuffers), ((const VkCommandBufferAllocateInfo32 *)UlongToPtr(params->pAllocateInfo))->commandBufferCount);
27453     params->result = wine_vkAllocateCommandBuffers((VkDevice)UlongToPtr(params->device), &pAllocateInfo_host, pCommandBuffers_host);
27454     free_conversion_context(ctx);
27455     return STATUS_SUCCESS;
27456 }
27457
27458 #ifdef _WIN64
27459 static NTSTATUS thunk64_vkAllocateDescriptorSets(void *args)
27460 {
27461     struct vkAllocateDescriptorSets_params *params = args;
27462
27463     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pDescriptorSets);
27464
27465     params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle(params->device)->device, params->pAllocateInfo, params->pDescriptorSets);
27466     return STATUS_SUCCESS;
27467 }
27468 #endif /* _WIN64 */
27469
27470 static NTSTATUS thunk32_vkAllocateDescriptorSets(void *args)
27471 {
27472     struct
27473     {
27474         PTR32 device;
27475         PTR32 pAllocateInfo;
27476         PTR32 pDescriptorSets;
27477         VkResult result;
27478     } *params = args;
27479     VkDescriptorSetAllocateInfo pAllocateInfo_host;
27480     struct conversion_context local_ctx;
27481     struct conversion_context *ctx = &local_ctx;
27482
27483     TRACE("%#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pDescriptorSets);
27484
27485     init_conversion_context(ctx);
27486     convert_VkDescriptorSetAllocateInfo_win32_to_host(ctx, (const VkDescriptorSetAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
27487     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));
27488     free_conversion_context(ctx);
27489     return STATUS_SUCCESS;
27490 }
27491
27492 #ifdef _WIN64
27493 static NTSTATUS thunk64_vkAllocateMemory(void *args)
27494 {
27495     struct vkAllocateMemory_params *params = args;
27496
27497     TRACE("%p, %p, %p, %p\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
27498
27499     params->result = wine_vkAllocateMemory(params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
27500     return STATUS_SUCCESS;
27501 }
27502 #endif /* _WIN64 */
27503
27504 static NTSTATUS thunk32_vkAllocateMemory(void *args)
27505 {
27506     struct
27507     {
27508         PTR32 device;
27509         PTR32 pAllocateInfo;
27510         PTR32 pAllocator;
27511         PTR32 pMemory;
27512         VkResult result;
27513     } *params = args;
27514     VkMemoryAllocateInfo pAllocateInfo_host;
27515     struct conversion_context local_ctx;
27516     struct conversion_context *ctx = &local_ctx;
27517
27518     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
27519
27520     init_conversion_context(ctx);
27521     convert_VkMemoryAllocateInfo_win32_to_host(ctx, (const VkMemoryAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
27522     params->result = wine_vkAllocateMemory((VkDevice)UlongToPtr(params->device), &pAllocateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDeviceMemory *)UlongToPtr(params->pMemory));
27523     free_conversion_context(ctx);
27524     return STATUS_SUCCESS;
27525 }
27526
27527 #ifdef _WIN64
27528 static NTSTATUS thunk64_vkBeginCommandBuffer(void *args)
27529 {
27530     struct vkBeginCommandBuffer_params *params = args;
27531
27532     TRACE("%p, %p\n", params->commandBuffer, params->pBeginInfo);
27533
27534     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBeginInfo);
27535     return STATUS_SUCCESS;
27536 }
27537 #endif /* _WIN64 */
27538
27539 static NTSTATUS thunk32_vkBeginCommandBuffer(void *args)
27540 {
27541     struct
27542     {
27543         PTR32 commandBuffer;
27544         PTR32 pBeginInfo;
27545         VkResult result;
27546     } *params = args;
27547     VkCommandBufferBeginInfo pBeginInfo_host;
27548     struct conversion_context local_ctx;
27549     struct conversion_context *ctx = &local_ctx;
27550
27551     TRACE("%#x, %#x\n", params->commandBuffer, params->pBeginInfo);
27552
27553     init_conversion_context(ctx);
27554     convert_VkCommandBufferBeginInfo_win32_to_host(ctx, (const VkCommandBufferBeginInfo32 *)UlongToPtr(params->pBeginInfo), &pBeginInfo_host);
27555     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);
27556     free_conversion_context(ctx);
27557     return STATUS_SUCCESS;
27558 }
27559
27560 #ifdef _WIN64
27561 static NTSTATUS thunk64_vkBindAccelerationStructureMemoryNV(void *args)
27562 {
27563     struct vkBindAccelerationStructureMemoryNV_params *params = args;
27564     const VkBindAccelerationStructureMemoryInfoNV *pBindInfos_host;
27565     struct conversion_context local_ctx;
27566     struct conversion_context *ctx = &local_ctx;
27567
27568     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
27569
27570     init_conversion_context(ctx);
27571     pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoNV_array_win64_to_host(ctx, params->pBindInfos, params->bindInfoCount);
27572     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
27573     free_conversion_context(ctx);
27574     return STATUS_SUCCESS;
27575 }
27576 #endif /* _WIN64 */
27577
27578 static NTSTATUS thunk32_vkBindAccelerationStructureMemoryNV(void *args)
27579 {
27580     struct
27581     {
27582         PTR32 device;
27583         uint32_t bindInfoCount;
27584         PTR32 pBindInfos;
27585         VkResult result;
27586     } *params = args;
27587     const VkBindAccelerationStructureMemoryInfoNV *pBindInfos_host;
27588     struct conversion_context local_ctx;
27589     struct conversion_context *ctx = &local_ctx;
27590
27591     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
27592
27593     init_conversion_context(ctx);
27594     pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(ctx, (const VkBindAccelerationStructureMemoryInfoNV32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
27595     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);
27596     free_conversion_context(ctx);
27597     return STATUS_SUCCESS;
27598 }
27599
27600 #ifdef _WIN64
27601 static NTSTATUS thunk64_vkBindBufferMemory(void *args)
27602 {
27603     struct vkBindBufferMemory_params *params = args;
27604
27605     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));
27606
27607     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);
27608     return STATUS_SUCCESS;
27609 }
27610 #endif /* _WIN64 */
27611
27612 static NTSTATUS thunk32_vkBindBufferMemory(void *args)
27613 {
27614     struct
27615     {
27616         PTR32 device;
27617         VkBuffer DECLSPEC_ALIGN(8) buffer;
27618         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
27619         VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
27620         VkResult result;
27621     } *params = args;
27622
27623     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));
27624
27625     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);
27626     return STATUS_SUCCESS;
27627 }
27628
27629 #ifdef _WIN64
27630 static NTSTATUS thunk64_vkBindBufferMemory2(void *args)
27631 {
27632     struct vkBindBufferMemory2_params *params = args;
27633     const VkBindBufferMemoryInfo *pBindInfos_host;
27634     struct conversion_context local_ctx;
27635     struct conversion_context *ctx = &local_ctx;
27636
27637     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
27638
27639     init_conversion_context(ctx);
27640     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win64_to_host(ctx, params->pBindInfos, params->bindInfoCount);
27641     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
27642     free_conversion_context(ctx);
27643     return STATUS_SUCCESS;
27644 }
27645 #endif /* _WIN64 */
27646
27647 static NTSTATUS thunk32_vkBindBufferMemory2(void *args)
27648 {
27649     struct
27650     {
27651         PTR32 device;
27652         uint32_t bindInfoCount;
27653         PTR32 pBindInfos;
27654         VkResult result;
27655     } *params = args;
27656     const VkBindBufferMemoryInfo *pBindInfos_host;
27657     struct conversion_context local_ctx;
27658     struct conversion_context *ctx = &local_ctx;
27659
27660     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
27661
27662     init_conversion_context(ctx);
27663     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(ctx, (const VkBindBufferMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
27664     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);
27665     free_conversion_context(ctx);
27666     return STATUS_SUCCESS;
27667 }
27668
27669 #ifdef _WIN64
27670 static NTSTATUS thunk64_vkBindBufferMemory2KHR(void *args)
27671 {
27672     struct vkBindBufferMemory2KHR_params *params = args;
27673     const VkBindBufferMemoryInfo *pBindInfos_host;
27674     struct conversion_context local_ctx;
27675     struct conversion_context *ctx = &local_ctx;
27676
27677     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
27678
27679     init_conversion_context(ctx);
27680     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win64_to_host(ctx, params->pBindInfos, params->bindInfoCount);
27681     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
27682     free_conversion_context(ctx);
27683     return STATUS_SUCCESS;
27684 }
27685 #endif /* _WIN64 */
27686
27687 static NTSTATUS thunk32_vkBindBufferMemory2KHR(void *args)
27688 {
27689     struct
27690     {
27691         PTR32 device;
27692         uint32_t bindInfoCount;
27693         PTR32 pBindInfos;
27694         VkResult result;
27695     } *params = args;
27696     const VkBindBufferMemoryInfo *pBindInfos_host;
27697     struct conversion_context local_ctx;
27698     struct conversion_context *ctx = &local_ctx;
27699
27700     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
27701
27702     init_conversion_context(ctx);
27703     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(ctx, (const VkBindBufferMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
27704     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);
27705     free_conversion_context(ctx);
27706     return STATUS_SUCCESS;
27707 }
27708
27709 #ifdef _WIN64
27710 static NTSTATUS thunk64_vkBindImageMemory(void *args)
27711 {
27712     struct vkBindImageMemory_params *params = args;
27713
27714     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));
27715
27716     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);
27717     return STATUS_SUCCESS;
27718 }
27719 #endif /* _WIN64 */
27720
27721 static NTSTATUS thunk32_vkBindImageMemory(void *args)
27722 {
27723     struct
27724     {
27725         PTR32 device;
27726         VkImage DECLSPEC_ALIGN(8) image;
27727         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
27728         VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
27729         VkResult result;
27730     } *params = args;
27731
27732     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));
27733
27734     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);
27735     return STATUS_SUCCESS;
27736 }
27737
27738 #ifdef _WIN64
27739 static NTSTATUS thunk64_vkBindImageMemory2(void *args)
27740 {
27741     struct vkBindImageMemory2_params *params = args;
27742     const VkBindImageMemoryInfo *pBindInfos_host;
27743     struct conversion_context local_ctx;
27744     struct conversion_context *ctx = &local_ctx;
27745
27746     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
27747
27748     init_conversion_context(ctx);
27749     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win64_to_host(ctx, params->pBindInfos, params->bindInfoCount);
27750     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
27751     free_conversion_context(ctx);
27752     return STATUS_SUCCESS;
27753 }
27754 #endif /* _WIN64 */
27755
27756 static NTSTATUS thunk32_vkBindImageMemory2(void *args)
27757 {
27758     struct
27759     {
27760         PTR32 device;
27761         uint32_t bindInfoCount;
27762         PTR32 pBindInfos;
27763         VkResult result;
27764     } *params = args;
27765     const VkBindImageMemoryInfo *pBindInfos_host;
27766     struct conversion_context local_ctx;
27767     struct conversion_context *ctx = &local_ctx;
27768
27769     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
27770
27771     init_conversion_context(ctx);
27772     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(ctx, (const VkBindImageMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
27773     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);
27774     free_conversion_context(ctx);
27775     return STATUS_SUCCESS;
27776 }
27777
27778 #ifdef _WIN64
27779 static NTSTATUS thunk64_vkBindImageMemory2KHR(void *args)
27780 {
27781     struct vkBindImageMemory2KHR_params *params = args;
27782     const VkBindImageMemoryInfo *pBindInfos_host;
27783     struct conversion_context local_ctx;
27784     struct conversion_context *ctx = &local_ctx;
27785
27786     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
27787
27788     init_conversion_context(ctx);
27789     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win64_to_host(ctx, params->pBindInfos, params->bindInfoCount);
27790     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
27791     free_conversion_context(ctx);
27792     return STATUS_SUCCESS;
27793 }
27794 #endif /* _WIN64 */
27795
27796 static NTSTATUS thunk32_vkBindImageMemory2KHR(void *args)
27797 {
27798     struct
27799     {
27800         PTR32 device;
27801         uint32_t bindInfoCount;
27802         PTR32 pBindInfos;
27803         VkResult result;
27804     } *params = args;
27805     const VkBindImageMemoryInfo *pBindInfos_host;
27806     struct conversion_context local_ctx;
27807     struct conversion_context *ctx = &local_ctx;
27808
27809     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
27810
27811     init_conversion_context(ctx);
27812     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(ctx, (const VkBindImageMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
27813     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);
27814     free_conversion_context(ctx);
27815     return STATUS_SUCCESS;
27816 }
27817
27818 #ifdef _WIN64
27819 static NTSTATUS thunk64_vkBindOpticalFlowSessionImageNV(void *args)
27820 {
27821     struct vkBindOpticalFlowSessionImageNV_params *params = args;
27822
27823     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);
27824
27825     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);
27826     return STATUS_SUCCESS;
27827 }
27828 #endif /* _WIN64 */
27829
27830 static NTSTATUS thunk32_vkBindOpticalFlowSessionImageNV(void *args)
27831 {
27832     struct
27833     {
27834         PTR32 device;
27835         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
27836         VkOpticalFlowSessionBindingPointNV bindingPoint;
27837         VkImageView DECLSPEC_ALIGN(8) view;
27838         VkImageLayout layout;
27839         VkResult result;
27840     } *params = args;
27841
27842     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);
27843
27844     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);
27845     return STATUS_SUCCESS;
27846 }
27847
27848 #ifdef _WIN64
27849 static NTSTATUS thunk64_vkBuildAccelerationStructuresKHR(void *args)
27850 {
27851     struct vkBuildAccelerationStructuresKHR_params *params = args;
27852
27853     TRACE("%p, 0x%s, %u, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);
27854
27855     params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildAccelerationStructuresKHR(wine_device_from_handle(params->device)->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
27856     return STATUS_SUCCESS;
27857 }
27858 #endif /* _WIN64 */
27859
27860 static NTSTATUS thunk32_vkBuildAccelerationStructuresKHR(void *args)
27861 {
27862     struct
27863     {
27864         PTR32 device;
27865         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
27866         uint32_t infoCount;
27867         PTR32 pInfos;
27868         PTR32 ppBuildRangeInfos;
27869         VkResult result;
27870     } *params = args;
27871     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
27872     struct conversion_context local_ctx;
27873     struct conversion_context *ctx = &local_ctx;
27874
27875     TRACE("%#x, 0x%s, %u, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);
27876
27877     if (params->deferredOperation == VK_NULL_HANDLE)
27878         init_conversion_context(ctx);
27879     else
27880         ctx = &wine_deferred_operation_from_handle(params->deferredOperation)->ctx;
27881     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
27882     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBuildAccelerationStructuresKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, params->infoCount, pInfos_host, (const VkAccelerationStructureBuildRangeInfoKHR * const*)UlongToPtr(params->ppBuildRangeInfos));
27883     if (params->deferredOperation == VK_NULL_HANDLE)
27884         free_conversion_context(ctx);
27885     return STATUS_SUCCESS;
27886 }
27887
27888 #ifdef _WIN64
27889 static NTSTATUS thunk64_vkBuildMicromapsEXT(void *args)
27890 {
27891     struct vkBuildMicromapsEXT_params *params = args;
27892
27893     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
27894
27895     params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildMicromapsEXT(wine_device_from_handle(params->device)->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, params->infoCount, params->pInfos);
27896     return STATUS_SUCCESS;
27897 }
27898 #endif /* _WIN64 */
27899
27900 static NTSTATUS thunk32_vkBuildMicromapsEXT(void *args)
27901 {
27902     struct
27903     {
27904         PTR32 device;
27905         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
27906         uint32_t infoCount;
27907         PTR32 pInfos;
27908         VkResult result;
27909     } *params = args;
27910     const VkMicromapBuildInfoEXT *pInfos_host;
27911     struct conversion_context local_ctx;
27912     struct conversion_context *ctx = &local_ctx;
27913
27914     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
27915
27916     if (params->deferredOperation == VK_NULL_HANDLE)
27917         init_conversion_context(ctx);
27918     else
27919         ctx = &wine_deferred_operation_from_handle(params->deferredOperation)->ctx;
27920     pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pInfos), params->infoCount);
27921     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBuildMicromapsEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, params->infoCount, pInfos_host);
27922     if (params->deferredOperation == VK_NULL_HANDLE)
27923         free_conversion_context(ctx);
27924     return STATUS_SUCCESS;
27925 }
27926
27927 #ifdef _WIN64
27928 static void thunk64_vkCmdBeginConditionalRenderingEXT(void *args)
27929 {
27930     struct vkCmdBeginConditionalRenderingEXT_params *params = args;
27931
27932     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pConditionalRenderingBegin);
27933 }
27934 #endif /* _WIN64 */
27935
27936 static void thunk32_vkCmdBeginConditionalRenderingEXT(void *args)
27937 {
27938     struct
27939     {
27940         PTR32 commandBuffer;
27941         PTR32 pConditionalRenderingBegin;
27942     } *params = args;
27943     VkConditionalRenderingBeginInfoEXT pConditionalRenderingBegin_host;
27944
27945     convert_VkConditionalRenderingBeginInfoEXT_win32_to_host((const VkConditionalRenderingBeginInfoEXT32 *)UlongToPtr(params->pConditionalRenderingBegin), &pConditionalRenderingBegin_host);
27946     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);
27947 }
27948
27949 #ifdef _WIN64
27950 static void thunk64_vkCmdBeginDebugUtilsLabelEXT(void *args)
27951 {
27952     struct vkCmdBeginDebugUtilsLabelEXT_params *params = args;
27953
27954     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
27955 }
27956 #endif /* _WIN64 */
27957
27958 static void thunk32_vkCmdBeginDebugUtilsLabelEXT(void *args)
27959 {
27960     struct
27961     {
27962         PTR32 commandBuffer;
27963         PTR32 pLabelInfo;
27964     } *params = args;
27965     VkDebugUtilsLabelEXT pLabelInfo_host;
27966
27967     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
27968     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);
27969 }
27970
27971 #ifdef _WIN64
27972 static void thunk64_vkCmdBeginQuery(void *args)
27973 {
27974     struct vkCmdBeginQuery_params *params = args;
27975
27976     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);
27977 }
27978 #endif /* _WIN64 */
27979
27980 static void thunk32_vkCmdBeginQuery(void *args)
27981 {
27982     struct
27983     {
27984         PTR32 commandBuffer;
27985         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
27986         uint32_t query;
27987         VkQueryControlFlags flags;
27988     } *params = args;
27989
27990     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);
27991 }
27992
27993 #ifdef _WIN64
27994 static void thunk64_vkCmdBeginQueryIndexedEXT(void *args)
27995 {
27996     struct vkCmdBeginQueryIndexedEXT_params *params = args;
27997
27998     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);
27999 }
28000 #endif /* _WIN64 */
28001
28002 static void thunk32_vkCmdBeginQueryIndexedEXT(void *args)
28003 {
28004     struct
28005     {
28006         PTR32 commandBuffer;
28007         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
28008         uint32_t query;
28009         VkQueryControlFlags flags;
28010         uint32_t index;
28011     } *params = args;
28012
28013     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);
28014 }
28015
28016 #ifdef _WIN64
28017 static void thunk64_vkCmdBeginRenderPass(void *args)
28018 {
28019     struct vkCmdBeginRenderPass_params *params = args;
28020
28021     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->contents);
28022 }
28023 #endif /* _WIN64 */
28024
28025 static void thunk32_vkCmdBeginRenderPass(void *args)
28026 {
28027     struct
28028     {
28029         PTR32 commandBuffer;
28030         PTR32 pRenderPassBegin;
28031         VkSubpassContents contents;
28032     } *params = args;
28033     VkRenderPassBeginInfo pRenderPassBegin_host;
28034     struct conversion_context local_ctx;
28035     struct conversion_context *ctx = &local_ctx;
28036
28037     init_conversion_context(ctx);
28038     convert_VkRenderPassBeginInfo_win32_to_host(ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
28039     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);
28040     free_conversion_context(ctx);
28041 }
28042
28043 #ifdef _WIN64
28044 static void thunk64_vkCmdBeginRenderPass2(void *args)
28045 {
28046     struct vkCmdBeginRenderPass2_params *params = args;
28047
28048     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
28049 }
28050 #endif /* _WIN64 */
28051
28052 static void thunk32_vkCmdBeginRenderPass2(void *args)
28053 {
28054     struct
28055     {
28056         PTR32 commandBuffer;
28057         PTR32 pRenderPassBegin;
28058         PTR32 pSubpassBeginInfo;
28059     } *params = args;
28060     VkRenderPassBeginInfo pRenderPassBegin_host;
28061     VkSubpassBeginInfo pSubpassBeginInfo_host;
28062     struct conversion_context local_ctx;
28063     struct conversion_context *ctx = &local_ctx;
28064
28065     init_conversion_context(ctx);
28066     convert_VkRenderPassBeginInfo_win32_to_host(ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
28067     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
28068     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);
28069     free_conversion_context(ctx);
28070 }
28071
28072 #ifdef _WIN64
28073 static void thunk64_vkCmdBeginRenderPass2KHR(void *args)
28074 {
28075     struct vkCmdBeginRenderPass2KHR_params *params = args;
28076
28077     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
28078 }
28079 #endif /* _WIN64 */
28080
28081 static void thunk32_vkCmdBeginRenderPass2KHR(void *args)
28082 {
28083     struct
28084     {
28085         PTR32 commandBuffer;
28086         PTR32 pRenderPassBegin;
28087         PTR32 pSubpassBeginInfo;
28088     } *params = args;
28089     VkRenderPassBeginInfo pRenderPassBegin_host;
28090     VkSubpassBeginInfo pSubpassBeginInfo_host;
28091     struct conversion_context local_ctx;
28092     struct conversion_context *ctx = &local_ctx;
28093
28094     init_conversion_context(ctx);
28095     convert_VkRenderPassBeginInfo_win32_to_host(ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
28096     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
28097     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);
28098     free_conversion_context(ctx);
28099 }
28100
28101 #ifdef _WIN64
28102 static void thunk64_vkCmdBeginRendering(void *args)
28103 {
28104     struct vkCmdBeginRendering_params *params = args;
28105
28106     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
28107 }
28108 #endif /* _WIN64 */
28109
28110 static void thunk32_vkCmdBeginRendering(void *args)
28111 {
28112     struct
28113     {
28114         PTR32 commandBuffer;
28115         PTR32 pRenderingInfo;
28116     } *params = args;
28117     VkRenderingInfo pRenderingInfo_host;
28118     struct conversion_context local_ctx;
28119     struct conversion_context *ctx = &local_ctx;
28120
28121     init_conversion_context(ctx);
28122     convert_VkRenderingInfo_win32_to_host(ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
28123     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);
28124     free_conversion_context(ctx);
28125 }
28126
28127 #ifdef _WIN64
28128 static void thunk64_vkCmdBeginRenderingKHR(void *args)
28129 {
28130     struct vkCmdBeginRenderingKHR_params *params = args;
28131
28132     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
28133 }
28134 #endif /* _WIN64 */
28135
28136 static void thunk32_vkCmdBeginRenderingKHR(void *args)
28137 {
28138     struct
28139     {
28140         PTR32 commandBuffer;
28141         PTR32 pRenderingInfo;
28142     } *params = args;
28143     VkRenderingInfo pRenderingInfo_host;
28144     struct conversion_context local_ctx;
28145     struct conversion_context *ctx = &local_ctx;
28146
28147     init_conversion_context(ctx);
28148     convert_VkRenderingInfo_win32_to_host(ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
28149     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);
28150     free_conversion_context(ctx);
28151 }
28152
28153 #ifdef _WIN64
28154 static void thunk64_vkCmdBeginTransformFeedbackEXT(void *args)
28155 {
28156     struct vkCmdBeginTransformFeedbackEXT_params *params = args;
28157
28158     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);
28159 }
28160 #endif /* _WIN64 */
28161
28162 static void thunk32_vkCmdBeginTransformFeedbackEXT(void *args)
28163 {
28164     struct
28165     {
28166         PTR32 commandBuffer;
28167         uint32_t firstCounterBuffer;
28168         uint32_t counterBufferCount;
28169         PTR32 pCounterBuffers;
28170         PTR32 pCounterBufferOffsets;
28171     } *params = args;
28172
28173     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));
28174 }
28175
28176 #ifdef _WIN64
28177 static void thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
28178 {
28179     struct vkCmdBindDescriptorBufferEmbeddedSamplersEXT_params *params = args;
28180
28181     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);
28182 }
28183 #endif /* _WIN64 */
28184
28185 static void thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
28186 {
28187     struct
28188     {
28189         PTR32 commandBuffer;
28190         VkPipelineBindPoint pipelineBindPoint;
28191         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
28192         uint32_t set;
28193     } *params = args;
28194
28195     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);
28196 }
28197
28198 #ifdef _WIN64
28199 static void thunk64_vkCmdBindDescriptorBuffersEXT(void *args)
28200 {
28201     struct vkCmdBindDescriptorBuffersEXT_params *params = args;
28202
28203     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorBuffersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->bufferCount, params->pBindingInfos);
28204 }
28205 #endif /* _WIN64 */
28206
28207 static void thunk32_vkCmdBindDescriptorBuffersEXT(void *args)
28208 {
28209     struct
28210     {
28211         PTR32 commandBuffer;
28212         uint32_t bufferCount;
28213         PTR32 pBindingInfos;
28214     } *params = args;
28215     const VkDescriptorBufferBindingInfoEXT *pBindingInfos_host;
28216     struct conversion_context local_ctx;
28217     struct conversion_context *ctx = &local_ctx;
28218
28219     init_conversion_context(ctx);
28220     pBindingInfos_host = convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(ctx, (const VkDescriptorBufferBindingInfoEXT32 *)UlongToPtr(params->pBindingInfos), params->bufferCount);
28221     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);
28222     free_conversion_context(ctx);
28223 }
28224
28225 #ifdef _WIN64
28226 static void thunk64_vkCmdBindDescriptorSets(void *args)
28227 {
28228     struct vkCmdBindDescriptorSets_params *params = args;
28229
28230     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);
28231 }
28232 #endif /* _WIN64 */
28233
28234 static void thunk32_vkCmdBindDescriptorSets(void *args)
28235 {
28236     struct
28237     {
28238         PTR32 commandBuffer;
28239         VkPipelineBindPoint pipelineBindPoint;
28240         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
28241         uint32_t firstSet;
28242         uint32_t descriptorSetCount;
28243         PTR32 pDescriptorSets;
28244         uint32_t dynamicOffsetCount;
28245         PTR32 pDynamicOffsets;
28246     } *params = args;
28247
28248     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));
28249 }
28250
28251 #ifdef _WIN64
28252 static void thunk64_vkCmdBindIndexBuffer(void *args)
28253 {
28254     struct vkCmdBindIndexBuffer_params *params = args;
28255
28256     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);
28257 }
28258 #endif /* _WIN64 */
28259
28260 static void thunk32_vkCmdBindIndexBuffer(void *args)
28261 {
28262     struct
28263     {
28264         PTR32 commandBuffer;
28265         VkBuffer DECLSPEC_ALIGN(8) buffer;
28266         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28267         VkIndexType indexType;
28268     } *params = args;
28269
28270     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);
28271 }
28272
28273 #ifdef _WIN64
28274 static void thunk64_vkCmdBindIndexBuffer2KHR(void *args)
28275 {
28276     struct vkCmdBindIndexBuffer2KHR_params *params = args;
28277
28278     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindIndexBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->size, params->indexType);
28279 }
28280 #endif /* _WIN64 */
28281
28282 static void thunk32_vkCmdBindIndexBuffer2KHR(void *args)
28283 {
28284     struct
28285     {
28286         PTR32 commandBuffer;
28287         VkBuffer DECLSPEC_ALIGN(8) buffer;
28288         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28289         VkDeviceSize DECLSPEC_ALIGN(8) size;
28290         VkIndexType indexType;
28291     } *params = args;
28292
28293     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindIndexBuffer2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->size, params->indexType);
28294 }
28295
28296 #ifdef _WIN64
28297 static void thunk64_vkCmdBindInvocationMaskHUAWEI(void *args)
28298 {
28299     struct vkCmdBindInvocationMaskHUAWEI_params *params = args;
28300
28301     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
28302 }
28303 #endif /* _WIN64 */
28304
28305 static void thunk32_vkCmdBindInvocationMaskHUAWEI(void *args)
28306 {
28307     struct
28308     {
28309         PTR32 commandBuffer;
28310         VkImageView DECLSPEC_ALIGN(8) imageView;
28311         VkImageLayout imageLayout;
28312     } *params = args;
28313
28314     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);
28315 }
28316
28317 #ifdef _WIN64
28318 static void thunk64_vkCmdBindPipeline(void *args)
28319 {
28320     struct vkCmdBindPipeline_params *params = args;
28321
28322     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipeline(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline);
28323 }
28324 #endif /* _WIN64 */
28325
28326 static void thunk32_vkCmdBindPipeline(void *args)
28327 {
28328     struct
28329     {
28330         PTR32 commandBuffer;
28331         VkPipelineBindPoint pipelineBindPoint;
28332         VkPipeline DECLSPEC_ALIGN(8) pipeline;
28333     } *params = args;
28334
28335     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);
28336 }
28337
28338 #ifdef _WIN64
28339 static void thunk64_vkCmdBindPipelineShaderGroupNV(void *args)
28340 {
28341     struct vkCmdBindPipelineShaderGroupNV_params *params = args;
28342
28343     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);
28344 }
28345 #endif /* _WIN64 */
28346
28347 static void thunk32_vkCmdBindPipelineShaderGroupNV(void *args)
28348 {
28349     struct
28350     {
28351         PTR32 commandBuffer;
28352         VkPipelineBindPoint pipelineBindPoint;
28353         VkPipeline DECLSPEC_ALIGN(8) pipeline;
28354         uint32_t groupIndex;
28355     } *params = args;
28356
28357     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);
28358 }
28359
28360 #ifdef _WIN64
28361 static void thunk64_vkCmdBindShadersEXT(void *args)
28362 {
28363     struct vkCmdBindShadersEXT_params *params = args;
28364
28365     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);
28366 }
28367 #endif /* _WIN64 */
28368
28369 static void thunk32_vkCmdBindShadersEXT(void *args)
28370 {
28371     struct
28372     {
28373         PTR32 commandBuffer;
28374         uint32_t stageCount;
28375         PTR32 pStages;
28376         PTR32 pShaders;
28377     } *params = args;
28378
28379     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));
28380 }
28381
28382 #ifdef _WIN64
28383 static void thunk64_vkCmdBindShadingRateImageNV(void *args)
28384 {
28385     struct vkCmdBindShadingRateImageNV_params *params = args;
28386
28387     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindShadingRateImageNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
28388 }
28389 #endif /* _WIN64 */
28390
28391 static void thunk32_vkCmdBindShadingRateImageNV(void *args)
28392 {
28393     struct
28394     {
28395         PTR32 commandBuffer;
28396         VkImageView DECLSPEC_ALIGN(8) imageView;
28397         VkImageLayout imageLayout;
28398     } *params = args;
28399
28400     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);
28401 }
28402
28403 #ifdef _WIN64
28404 static void thunk64_vkCmdBindTransformFeedbackBuffersEXT(void *args)
28405 {
28406     struct vkCmdBindTransformFeedbackBuffersEXT_params *params = args;
28407
28408     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);
28409 }
28410 #endif /* _WIN64 */
28411
28412 static void thunk32_vkCmdBindTransformFeedbackBuffersEXT(void *args)
28413 {
28414     struct
28415     {
28416         PTR32 commandBuffer;
28417         uint32_t firstBinding;
28418         uint32_t bindingCount;
28419         PTR32 pBuffers;
28420         PTR32 pOffsets;
28421         PTR32 pSizes;
28422     } *params = args;
28423
28424     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));
28425 }
28426
28427 #ifdef _WIN64
28428 static void thunk64_vkCmdBindVertexBuffers(void *args)
28429 {
28430     struct vkCmdBindVertexBuffers_params *params = args;
28431
28432     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);
28433 }
28434 #endif /* _WIN64 */
28435
28436 static void thunk32_vkCmdBindVertexBuffers(void *args)
28437 {
28438     struct
28439     {
28440         PTR32 commandBuffer;
28441         uint32_t firstBinding;
28442         uint32_t bindingCount;
28443         PTR32 pBuffers;
28444         PTR32 pOffsets;
28445     } *params = args;
28446
28447     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));
28448 }
28449
28450 #ifdef _WIN64
28451 static void thunk64_vkCmdBindVertexBuffers2(void *args)
28452 {
28453     struct vkCmdBindVertexBuffers2_params *params = args;
28454
28455     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);
28456 }
28457 #endif /* _WIN64 */
28458
28459 static void thunk32_vkCmdBindVertexBuffers2(void *args)
28460 {
28461     struct
28462     {
28463         PTR32 commandBuffer;
28464         uint32_t firstBinding;
28465         uint32_t bindingCount;
28466         PTR32 pBuffers;
28467         PTR32 pOffsets;
28468         PTR32 pSizes;
28469         PTR32 pStrides;
28470     } *params = args;
28471
28472     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));
28473 }
28474
28475 #ifdef _WIN64
28476 static void thunk64_vkCmdBindVertexBuffers2EXT(void *args)
28477 {
28478     struct vkCmdBindVertexBuffers2EXT_params *params = args;
28479
28480     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);
28481 }
28482 #endif /* _WIN64 */
28483
28484 static void thunk32_vkCmdBindVertexBuffers2EXT(void *args)
28485 {
28486     struct
28487     {
28488         PTR32 commandBuffer;
28489         uint32_t firstBinding;
28490         uint32_t bindingCount;
28491         PTR32 pBuffers;
28492         PTR32 pOffsets;
28493         PTR32 pSizes;
28494         PTR32 pStrides;
28495     } *params = args;
28496
28497     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));
28498 }
28499
28500 #ifdef _WIN64
28501 static void thunk64_vkCmdBlitImage(void *args)
28502 {
28503     struct vkCmdBlitImage_params *params = args;
28504
28505     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);
28506 }
28507 #endif /* _WIN64 */
28508
28509 static void thunk32_vkCmdBlitImage(void *args)
28510 {
28511     struct
28512     {
28513         PTR32 commandBuffer;
28514         VkImage DECLSPEC_ALIGN(8) srcImage;
28515         VkImageLayout srcImageLayout;
28516         VkImage DECLSPEC_ALIGN(8) dstImage;
28517         VkImageLayout dstImageLayout;
28518         uint32_t regionCount;
28519         PTR32 pRegions;
28520         VkFilter filter;
28521     } *params = args;
28522
28523     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);
28524 }
28525
28526 #ifdef _WIN64
28527 static void thunk64_vkCmdBlitImage2(void *args)
28528 {
28529     struct vkCmdBlitImage2_params *params = args;
28530
28531     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
28532 }
28533 #endif /* _WIN64 */
28534
28535 static void thunk32_vkCmdBlitImage2(void *args)
28536 {
28537     struct
28538     {
28539         PTR32 commandBuffer;
28540         PTR32 pBlitImageInfo;
28541     } *params = args;
28542     VkBlitImageInfo2 pBlitImageInfo_host;
28543     struct conversion_context local_ctx;
28544     struct conversion_context *ctx = &local_ctx;
28545
28546     init_conversion_context(ctx);
28547     convert_VkBlitImageInfo2_win32_to_host(ctx, (const VkBlitImageInfo232 *)UlongToPtr(params->pBlitImageInfo), &pBlitImageInfo_host);
28548     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);
28549     free_conversion_context(ctx);
28550 }
28551
28552 #ifdef _WIN64
28553 static void thunk64_vkCmdBlitImage2KHR(void *args)
28554 {
28555     struct vkCmdBlitImage2KHR_params *params = args;
28556
28557     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
28558 }
28559 #endif /* _WIN64 */
28560
28561 static void thunk32_vkCmdBlitImage2KHR(void *args)
28562 {
28563     struct
28564     {
28565         PTR32 commandBuffer;
28566         PTR32 pBlitImageInfo;
28567     } *params = args;
28568     VkBlitImageInfo2 pBlitImageInfo_host;
28569     struct conversion_context local_ctx;
28570     struct conversion_context *ctx = &local_ctx;
28571
28572     init_conversion_context(ctx);
28573     convert_VkBlitImageInfo2_win32_to_host(ctx, (const VkBlitImageInfo232 *)UlongToPtr(params->pBlitImageInfo), &pBlitImageInfo_host);
28574     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);
28575     free_conversion_context(ctx);
28576 }
28577
28578 #ifdef _WIN64
28579 static void thunk64_vkCmdBuildAccelerationStructureNV(void *args)
28580 {
28581     struct vkCmdBuildAccelerationStructureNV_params *params = args;
28582
28583     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);
28584 }
28585 #endif /* _WIN64 */
28586
28587 static void thunk32_vkCmdBuildAccelerationStructureNV(void *args)
28588 {
28589     struct
28590     {
28591         PTR32 commandBuffer;
28592         PTR32 pInfo;
28593         VkBuffer DECLSPEC_ALIGN(8) instanceData;
28594         VkDeviceSize DECLSPEC_ALIGN(8) instanceOffset;
28595         VkBool32 update;
28596         VkAccelerationStructureNV DECLSPEC_ALIGN(8) dst;
28597         VkAccelerationStructureNV DECLSPEC_ALIGN(8) src;
28598         VkBuffer DECLSPEC_ALIGN(8) scratch;
28599         VkDeviceSize DECLSPEC_ALIGN(8) scratchOffset;
28600     } *params = args;
28601     VkAccelerationStructureInfoNV pInfo_host;
28602     struct conversion_context local_ctx;
28603     struct conversion_context *ctx = &local_ctx;
28604
28605     init_conversion_context(ctx);
28606     convert_VkAccelerationStructureInfoNV_win32_to_host(ctx, (const VkAccelerationStructureInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
28607     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);
28608     free_conversion_context(ctx);
28609 }
28610
28611 #ifdef _WIN64
28612 static void thunk64_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
28613 {
28614     struct vkCmdBuildAccelerationStructuresIndirectKHR_params *params = args;
28615
28616     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);
28617 }
28618 #endif /* _WIN64 */
28619
28620 static void thunk32_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
28621 {
28622     struct
28623     {
28624         PTR32 commandBuffer;
28625         uint32_t infoCount;
28626         PTR32 pInfos;
28627         PTR32 pIndirectDeviceAddresses;
28628         PTR32 pIndirectStrides;
28629         PTR32 ppMaxPrimitiveCounts;
28630     } *params = args;
28631     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
28632     struct conversion_context local_ctx;
28633     struct conversion_context *ctx = &local_ctx;
28634
28635     init_conversion_context(ctx);
28636     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
28637     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));
28638     free_conversion_context(ctx);
28639 }
28640
28641 #ifdef _WIN64
28642 static void thunk64_vkCmdBuildAccelerationStructuresKHR(void *args)
28643 {
28644     struct vkCmdBuildAccelerationStructuresKHR_params *params = args;
28645
28646     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);
28647 }
28648 #endif /* _WIN64 */
28649
28650 static void thunk32_vkCmdBuildAccelerationStructuresKHR(void *args)
28651 {
28652     struct
28653     {
28654         PTR32 commandBuffer;
28655         uint32_t infoCount;
28656         PTR32 pInfos;
28657         PTR32 ppBuildRangeInfos;
28658     } *params = args;
28659     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
28660     struct conversion_context local_ctx;
28661     struct conversion_context *ctx = &local_ctx;
28662
28663     init_conversion_context(ctx);
28664     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
28665     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));
28666     free_conversion_context(ctx);
28667 }
28668
28669 #ifdef _WIN64
28670 static void thunk64_vkCmdBuildMicromapsEXT(void *args)
28671 {
28672     struct vkCmdBuildMicromapsEXT_params *params = args;
28673
28674     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos);
28675 }
28676 #endif /* _WIN64 */
28677
28678 static void thunk32_vkCmdBuildMicromapsEXT(void *args)
28679 {
28680     struct
28681     {
28682         PTR32 commandBuffer;
28683         uint32_t infoCount;
28684         PTR32 pInfos;
28685     } *params = args;
28686     const VkMicromapBuildInfoEXT *pInfos_host;
28687     struct conversion_context local_ctx;
28688     struct conversion_context *ctx = &local_ctx;
28689
28690     init_conversion_context(ctx);
28691     pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pInfos), params->infoCount);
28692     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);
28693     free_conversion_context(ctx);
28694 }
28695
28696 #ifdef _WIN64
28697 static void thunk64_vkCmdClearAttachments(void *args)
28698 {
28699     struct vkCmdClearAttachments_params *params = args;
28700
28701     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);
28702 }
28703 #endif /* _WIN64 */
28704
28705 static void thunk32_vkCmdClearAttachments(void *args)
28706 {
28707     struct
28708     {
28709         PTR32 commandBuffer;
28710         uint32_t attachmentCount;
28711         PTR32 pAttachments;
28712         uint32_t rectCount;
28713         PTR32 pRects;
28714     } *params = args;
28715
28716     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));
28717 }
28718
28719 #ifdef _WIN64
28720 static void thunk64_vkCmdClearColorImage(void *args)
28721 {
28722     struct vkCmdClearColorImage_params *params = args;
28723
28724     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);
28725 }
28726 #endif /* _WIN64 */
28727
28728 static void thunk32_vkCmdClearColorImage(void *args)
28729 {
28730     struct
28731     {
28732         PTR32 commandBuffer;
28733         VkImage DECLSPEC_ALIGN(8) image;
28734         VkImageLayout imageLayout;
28735         PTR32 pColor;
28736         uint32_t rangeCount;
28737         PTR32 pRanges;
28738     } *params = args;
28739
28740     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));
28741 }
28742
28743 #ifdef _WIN64
28744 static void thunk64_vkCmdClearDepthStencilImage(void *args)
28745 {
28746     struct vkCmdClearDepthStencilImage_params *params = args;
28747
28748     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);
28749 }
28750 #endif /* _WIN64 */
28751
28752 static void thunk32_vkCmdClearDepthStencilImage(void *args)
28753 {
28754     struct
28755     {
28756         PTR32 commandBuffer;
28757         VkImage DECLSPEC_ALIGN(8) image;
28758         VkImageLayout imageLayout;
28759         PTR32 pDepthStencil;
28760         uint32_t rangeCount;
28761         PTR32 pRanges;
28762     } *params = args;
28763
28764     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));
28765 }
28766
28767 #ifdef _WIN64
28768 static void thunk64_vkCmdCopyAccelerationStructureKHR(void *args)
28769 {
28770     struct vkCmdCopyAccelerationStructureKHR_params *params = args;
28771
28772     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
28773 }
28774 #endif /* _WIN64 */
28775
28776 static void thunk32_vkCmdCopyAccelerationStructureKHR(void *args)
28777 {
28778     struct
28779     {
28780         PTR32 commandBuffer;
28781         PTR32 pInfo;
28782     } *params = args;
28783     VkCopyAccelerationStructureInfoKHR pInfo_host;
28784
28785     convert_VkCopyAccelerationStructureInfoKHR_win32_to_host((const VkCopyAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
28786     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);
28787 }
28788
28789 #ifdef _WIN64
28790 static void thunk64_vkCmdCopyAccelerationStructureNV(void *args)
28791 {
28792     struct vkCmdCopyAccelerationStructureNV_params *params = args;
28793
28794     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);
28795 }
28796 #endif /* _WIN64 */
28797
28798 static void thunk32_vkCmdCopyAccelerationStructureNV(void *args)
28799 {
28800     struct
28801     {
28802         PTR32 commandBuffer;
28803         VkAccelerationStructureNV DECLSPEC_ALIGN(8) dst;
28804         VkAccelerationStructureNV DECLSPEC_ALIGN(8) src;
28805         VkCopyAccelerationStructureModeKHR mode;
28806     } *params = args;
28807
28808     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);
28809 }
28810
28811 #ifdef _WIN64
28812 static void thunk64_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
28813 {
28814     struct vkCmdCopyAccelerationStructureToMemoryKHR_params *params = args;
28815
28816     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
28817 }
28818 #endif /* _WIN64 */
28819
28820 static void thunk32_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
28821 {
28822     struct
28823     {
28824         PTR32 commandBuffer;
28825         PTR32 pInfo;
28826     } *params = args;
28827     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;
28828
28829     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host((const VkCopyAccelerationStructureToMemoryInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
28830     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);
28831 }
28832
28833 #ifdef _WIN64
28834 static void thunk64_vkCmdCopyBuffer(void *args)
28835 {
28836     struct vkCmdCopyBuffer_params *params = args;
28837
28838     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);
28839 }
28840 #endif /* _WIN64 */
28841
28842 static void thunk32_vkCmdCopyBuffer(void *args)
28843 {
28844     struct
28845     {
28846         PTR32 commandBuffer;
28847         VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
28848         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
28849         uint32_t regionCount;
28850         PTR32 pRegions;
28851     } *params = args;
28852     const VkBufferCopy *pRegions_host;
28853     struct conversion_context local_ctx;
28854     struct conversion_context *ctx = &local_ctx;
28855
28856     init_conversion_context(ctx);
28857     pRegions_host = convert_VkBufferCopy_array_win32_to_host(ctx, (const VkBufferCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
28858     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);
28859     free_conversion_context(ctx);
28860 }
28861
28862 #ifdef _WIN64
28863 static void thunk64_vkCmdCopyBuffer2(void *args)
28864 {
28865     struct vkCmdCopyBuffer2_params *params = args;
28866
28867     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
28868 }
28869 #endif /* _WIN64 */
28870
28871 static void thunk32_vkCmdCopyBuffer2(void *args)
28872 {
28873     struct
28874     {
28875         PTR32 commandBuffer;
28876         PTR32 pCopyBufferInfo;
28877     } *params = args;
28878     VkCopyBufferInfo2 pCopyBufferInfo_host;
28879     struct conversion_context local_ctx;
28880     struct conversion_context *ctx = &local_ctx;
28881
28882     init_conversion_context(ctx);
28883     convert_VkCopyBufferInfo2_win32_to_host(ctx, (const VkCopyBufferInfo232 *)UlongToPtr(params->pCopyBufferInfo), &pCopyBufferInfo_host);
28884     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);
28885     free_conversion_context(ctx);
28886 }
28887
28888 #ifdef _WIN64
28889 static void thunk64_vkCmdCopyBuffer2KHR(void *args)
28890 {
28891     struct vkCmdCopyBuffer2KHR_params *params = args;
28892
28893     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
28894 }
28895 #endif /* _WIN64 */
28896
28897 static void thunk32_vkCmdCopyBuffer2KHR(void *args)
28898 {
28899     struct
28900     {
28901         PTR32 commandBuffer;
28902         PTR32 pCopyBufferInfo;
28903     } *params = args;
28904     VkCopyBufferInfo2 pCopyBufferInfo_host;
28905     struct conversion_context local_ctx;
28906     struct conversion_context *ctx = &local_ctx;
28907
28908     init_conversion_context(ctx);
28909     convert_VkCopyBufferInfo2_win32_to_host(ctx, (const VkCopyBufferInfo232 *)UlongToPtr(params->pCopyBufferInfo), &pCopyBufferInfo_host);
28910     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);
28911     free_conversion_context(ctx);
28912 }
28913
28914 #ifdef _WIN64
28915 static void thunk64_vkCmdCopyBufferToImage(void *args)
28916 {
28917     struct vkCmdCopyBufferToImage_params *params = args;
28918
28919     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);
28920 }
28921 #endif /* _WIN64 */
28922
28923 static void thunk32_vkCmdCopyBufferToImage(void *args)
28924 {
28925     struct
28926     {
28927         PTR32 commandBuffer;
28928         VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
28929         VkImage DECLSPEC_ALIGN(8) dstImage;
28930         VkImageLayout dstImageLayout;
28931         uint32_t regionCount;
28932         PTR32 pRegions;
28933     } *params = args;
28934     const VkBufferImageCopy *pRegions_host;
28935     struct conversion_context local_ctx;
28936     struct conversion_context *ctx = &local_ctx;
28937
28938     init_conversion_context(ctx);
28939     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(ctx, (const VkBufferImageCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
28940     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);
28941     free_conversion_context(ctx);
28942 }
28943
28944 #ifdef _WIN64
28945 static void thunk64_vkCmdCopyBufferToImage2(void *args)
28946 {
28947     struct vkCmdCopyBufferToImage2_params *params = args;
28948
28949     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
28950 }
28951 #endif /* _WIN64 */
28952
28953 static void thunk32_vkCmdCopyBufferToImage2(void *args)
28954 {
28955     struct
28956     {
28957         PTR32 commandBuffer;
28958         PTR32 pCopyBufferToImageInfo;
28959     } *params = args;
28960     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
28961     struct conversion_context local_ctx;
28962     struct conversion_context *ctx = &local_ctx;
28963
28964     init_conversion_context(ctx);
28965     convert_VkCopyBufferToImageInfo2_win32_to_host(ctx, (const VkCopyBufferToImageInfo232 *)UlongToPtr(params->pCopyBufferToImageInfo), &pCopyBufferToImageInfo_host);
28966     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);
28967     free_conversion_context(ctx);
28968 }
28969
28970 #ifdef _WIN64
28971 static void thunk64_vkCmdCopyBufferToImage2KHR(void *args)
28972 {
28973     struct vkCmdCopyBufferToImage2KHR_params *params = args;
28974
28975     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
28976 }
28977 #endif /* _WIN64 */
28978
28979 static void thunk32_vkCmdCopyBufferToImage2KHR(void *args)
28980 {
28981     struct
28982     {
28983         PTR32 commandBuffer;
28984         PTR32 pCopyBufferToImageInfo;
28985     } *params = args;
28986     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
28987     struct conversion_context local_ctx;
28988     struct conversion_context *ctx = &local_ctx;
28989
28990     init_conversion_context(ctx);
28991     convert_VkCopyBufferToImageInfo2_win32_to_host(ctx, (const VkCopyBufferToImageInfo232 *)UlongToPtr(params->pCopyBufferToImageInfo), &pCopyBufferToImageInfo_host);
28992     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);
28993     free_conversion_context(ctx);
28994 }
28995
28996 #ifdef _WIN64
28997 static void thunk64_vkCmdCopyImage(void *args)
28998 {
28999     struct vkCmdCopyImage_params *params = args;
29000
29001     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);
29002 }
29003 #endif /* _WIN64 */
29004
29005 static void thunk32_vkCmdCopyImage(void *args)
29006 {
29007     struct
29008     {
29009         PTR32 commandBuffer;
29010         VkImage DECLSPEC_ALIGN(8) srcImage;
29011         VkImageLayout srcImageLayout;
29012         VkImage DECLSPEC_ALIGN(8) dstImage;
29013         VkImageLayout dstImageLayout;
29014         uint32_t regionCount;
29015         PTR32 pRegions;
29016     } *params = args;
29017
29018     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));
29019 }
29020
29021 #ifdef _WIN64
29022 static void thunk64_vkCmdCopyImage2(void *args)
29023 {
29024     struct vkCmdCopyImage2_params *params = args;
29025
29026     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
29027 }
29028 #endif /* _WIN64 */
29029
29030 static void thunk32_vkCmdCopyImage2(void *args)
29031 {
29032     struct
29033     {
29034         PTR32 commandBuffer;
29035         PTR32 pCopyImageInfo;
29036     } *params = args;
29037     VkCopyImageInfo2 pCopyImageInfo_host;
29038     struct conversion_context local_ctx;
29039     struct conversion_context *ctx = &local_ctx;
29040
29041     init_conversion_context(ctx);
29042     convert_VkCopyImageInfo2_win32_to_host(ctx, (const VkCopyImageInfo232 *)UlongToPtr(params->pCopyImageInfo), &pCopyImageInfo_host);
29043     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);
29044     free_conversion_context(ctx);
29045 }
29046
29047 #ifdef _WIN64
29048 static void thunk64_vkCmdCopyImage2KHR(void *args)
29049 {
29050     struct vkCmdCopyImage2KHR_params *params = args;
29051
29052     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
29053 }
29054 #endif /* _WIN64 */
29055
29056 static void thunk32_vkCmdCopyImage2KHR(void *args)
29057 {
29058     struct
29059     {
29060         PTR32 commandBuffer;
29061         PTR32 pCopyImageInfo;
29062     } *params = args;
29063     VkCopyImageInfo2 pCopyImageInfo_host;
29064     struct conversion_context local_ctx;
29065     struct conversion_context *ctx = &local_ctx;
29066
29067     init_conversion_context(ctx);
29068     convert_VkCopyImageInfo2_win32_to_host(ctx, (const VkCopyImageInfo232 *)UlongToPtr(params->pCopyImageInfo), &pCopyImageInfo_host);
29069     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);
29070     free_conversion_context(ctx);
29071 }
29072
29073 #ifdef _WIN64
29074 static void thunk64_vkCmdCopyImageToBuffer(void *args)
29075 {
29076     struct vkCmdCopyImageToBuffer_params *params = args;
29077
29078     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);
29079 }
29080 #endif /* _WIN64 */
29081
29082 static void thunk32_vkCmdCopyImageToBuffer(void *args)
29083 {
29084     struct
29085     {
29086         PTR32 commandBuffer;
29087         VkImage DECLSPEC_ALIGN(8) srcImage;
29088         VkImageLayout srcImageLayout;
29089         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
29090         uint32_t regionCount;
29091         PTR32 pRegions;
29092     } *params = args;
29093     const VkBufferImageCopy *pRegions_host;
29094     struct conversion_context local_ctx;
29095     struct conversion_context *ctx = &local_ctx;
29096
29097     init_conversion_context(ctx);
29098     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(ctx, (const VkBufferImageCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
29099     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);
29100     free_conversion_context(ctx);
29101 }
29102
29103 #ifdef _WIN64
29104 static void thunk64_vkCmdCopyImageToBuffer2(void *args)
29105 {
29106     struct vkCmdCopyImageToBuffer2_params *params = args;
29107
29108     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
29109 }
29110 #endif /* _WIN64 */
29111
29112 static void thunk32_vkCmdCopyImageToBuffer2(void *args)
29113 {
29114     struct
29115     {
29116         PTR32 commandBuffer;
29117         PTR32 pCopyImageToBufferInfo;
29118     } *params = args;
29119     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
29120     struct conversion_context local_ctx;
29121     struct conversion_context *ctx = &local_ctx;
29122
29123     init_conversion_context(ctx);
29124     convert_VkCopyImageToBufferInfo2_win32_to_host(ctx, (const VkCopyImageToBufferInfo232 *)UlongToPtr(params->pCopyImageToBufferInfo), &pCopyImageToBufferInfo_host);
29125     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);
29126     free_conversion_context(ctx);
29127 }
29128
29129 #ifdef _WIN64
29130 static void thunk64_vkCmdCopyImageToBuffer2KHR(void *args)
29131 {
29132     struct vkCmdCopyImageToBuffer2KHR_params *params = args;
29133
29134     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
29135 }
29136 #endif /* _WIN64 */
29137
29138 static void thunk32_vkCmdCopyImageToBuffer2KHR(void *args)
29139 {
29140     struct
29141     {
29142         PTR32 commandBuffer;
29143         PTR32 pCopyImageToBufferInfo;
29144     } *params = args;
29145     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
29146     struct conversion_context local_ctx;
29147     struct conversion_context *ctx = &local_ctx;
29148
29149     init_conversion_context(ctx);
29150     convert_VkCopyImageToBufferInfo2_win32_to_host(ctx, (const VkCopyImageToBufferInfo232 *)UlongToPtr(params->pCopyImageToBufferInfo), &pCopyImageToBufferInfo_host);
29151     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);
29152     free_conversion_context(ctx);
29153 }
29154
29155 #ifdef _WIN64
29156 static void thunk64_vkCmdCopyMemoryIndirectNV(void *args)
29157 {
29158     struct vkCmdCopyMemoryIndirectNV_params *params = args;
29159
29160     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);
29161 }
29162 #endif /* _WIN64 */
29163
29164 static void thunk32_vkCmdCopyMemoryIndirectNV(void *args)
29165 {
29166     struct
29167     {
29168         PTR32 commandBuffer;
29169         VkDeviceAddress DECLSPEC_ALIGN(8) copyBufferAddress;
29170         uint32_t copyCount;
29171         uint32_t stride;
29172     } *params = args;
29173
29174     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);
29175 }
29176
29177 #ifdef _WIN64
29178 static void thunk64_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
29179 {
29180     struct vkCmdCopyMemoryToAccelerationStructureKHR_params *params = args;
29181
29182     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
29183 }
29184 #endif /* _WIN64 */
29185
29186 static void thunk32_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
29187 {
29188     struct
29189     {
29190         PTR32 commandBuffer;
29191         PTR32 pInfo;
29192     } *params = args;
29193     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;
29194
29195     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host((const VkCopyMemoryToAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
29196     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);
29197 }
29198
29199 #ifdef _WIN64
29200 static void thunk64_vkCmdCopyMemoryToImageIndirectNV(void *args)
29201 {
29202     struct vkCmdCopyMemoryToImageIndirectNV_params *params = args;
29203
29204     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);
29205 }
29206 #endif /* _WIN64 */
29207
29208 static void thunk32_vkCmdCopyMemoryToImageIndirectNV(void *args)
29209 {
29210     struct
29211     {
29212         PTR32 commandBuffer;
29213         VkDeviceAddress DECLSPEC_ALIGN(8) copyBufferAddress;
29214         uint32_t copyCount;
29215         uint32_t stride;
29216         VkImage DECLSPEC_ALIGN(8) dstImage;
29217         VkImageLayout dstImageLayout;
29218         PTR32 pImageSubresources;
29219     } *params = args;
29220
29221     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));
29222 }
29223
29224 #ifdef _WIN64
29225 static void thunk64_vkCmdCopyMemoryToMicromapEXT(void *args)
29226 {
29227     struct vkCmdCopyMemoryToMicromapEXT_params *params = args;
29228
29229     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
29230 }
29231 #endif /* _WIN64 */
29232
29233 static void thunk32_vkCmdCopyMemoryToMicromapEXT(void *args)
29234 {
29235     struct
29236     {
29237         PTR32 commandBuffer;
29238         PTR32 pInfo;
29239     } *params = args;
29240     VkCopyMemoryToMicromapInfoEXT pInfo_host;
29241
29242     convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host((const VkCopyMemoryToMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
29243     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);
29244 }
29245
29246 #ifdef _WIN64
29247 static void thunk64_vkCmdCopyMicromapEXT(void *args)
29248 {
29249     struct vkCmdCopyMicromapEXT_params *params = args;
29250
29251     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
29252 }
29253 #endif /* _WIN64 */
29254
29255 static void thunk32_vkCmdCopyMicromapEXT(void *args)
29256 {
29257     struct
29258     {
29259         PTR32 commandBuffer;
29260         PTR32 pInfo;
29261     } *params = args;
29262     VkCopyMicromapInfoEXT pInfo_host;
29263
29264     convert_VkCopyMicromapInfoEXT_win32_to_host((const VkCopyMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
29265     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);
29266 }
29267
29268 #ifdef _WIN64
29269 static void thunk64_vkCmdCopyMicromapToMemoryEXT(void *args)
29270 {
29271     struct vkCmdCopyMicromapToMemoryEXT_params *params = args;
29272
29273     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
29274 }
29275 #endif /* _WIN64 */
29276
29277 static void thunk32_vkCmdCopyMicromapToMemoryEXT(void *args)
29278 {
29279     struct
29280     {
29281         PTR32 commandBuffer;
29282         PTR32 pInfo;
29283     } *params = args;
29284     VkCopyMicromapToMemoryInfoEXT pInfo_host;
29285
29286     convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host((const VkCopyMicromapToMemoryInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
29287     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);
29288 }
29289
29290 #ifdef _WIN64
29291 static void thunk64_vkCmdCopyQueryPoolResults(void *args)
29292 {
29293     struct vkCmdCopyQueryPoolResults_params *params = args;
29294
29295     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);
29296 }
29297 #endif /* _WIN64 */
29298
29299 static void thunk32_vkCmdCopyQueryPoolResults(void *args)
29300 {
29301     struct
29302     {
29303         PTR32 commandBuffer;
29304         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
29305         uint32_t firstQuery;
29306         uint32_t queryCount;
29307         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
29308         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
29309         VkDeviceSize DECLSPEC_ALIGN(8) stride;
29310         VkQueryResultFlags flags;
29311     } *params = args;
29312
29313     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);
29314 }
29315
29316 #ifdef _WIN64
29317 static void thunk64_vkCmdCuLaunchKernelNVX(void *args)
29318 {
29319     struct vkCmdCuLaunchKernelNVX_params *params = args;
29320
29321     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLaunchInfo);
29322 }
29323 #endif /* _WIN64 */
29324
29325 static void thunk32_vkCmdCuLaunchKernelNVX(void *args)
29326 {
29327     struct
29328     {
29329         PTR32 commandBuffer;
29330         PTR32 pLaunchInfo;
29331     } *params = args;
29332     VkCuLaunchInfoNVX pLaunchInfo_host;
29333
29334     convert_VkCuLaunchInfoNVX_win32_to_host((const VkCuLaunchInfoNVX32 *)UlongToPtr(params->pLaunchInfo), &pLaunchInfo_host);
29335     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);
29336 }
29337
29338 #ifdef _WIN64
29339 static void thunk64_vkCmdDebugMarkerBeginEXT(void *args)
29340 {
29341     struct vkCmdDebugMarkerBeginEXT_params *params = args;
29342
29343     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerBeginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
29344 }
29345 #endif /* _WIN64 */
29346
29347 static void thunk32_vkCmdDebugMarkerBeginEXT(void *args)
29348 {
29349     struct
29350     {
29351         PTR32 commandBuffer;
29352         PTR32 pMarkerInfo;
29353     } *params = args;
29354     VkDebugMarkerMarkerInfoEXT pMarkerInfo_host;
29355
29356     convert_VkDebugMarkerMarkerInfoEXT_win32_to_host((const VkDebugMarkerMarkerInfoEXT32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
29357     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);
29358 }
29359
29360 #ifdef _WIN64
29361 static void thunk64_vkCmdDebugMarkerEndEXT(void *args)
29362 {
29363     struct vkCmdDebugMarkerEndEXT_params *params = args;
29364
29365     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
29366 }
29367 #endif /* _WIN64 */
29368
29369 static void thunk32_vkCmdDebugMarkerEndEXT(void *args)
29370 {
29371     struct
29372     {
29373         PTR32 commandBuffer;
29374     } *params = args;
29375
29376     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
29377 }
29378
29379 #ifdef _WIN64
29380 static void thunk64_vkCmdDebugMarkerInsertEXT(void *args)
29381 {
29382     struct vkCmdDebugMarkerInsertEXT_params *params = args;
29383
29384     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerInsertEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
29385 }
29386 #endif /* _WIN64 */
29387
29388 static void thunk32_vkCmdDebugMarkerInsertEXT(void *args)
29389 {
29390     struct
29391     {
29392         PTR32 commandBuffer;
29393         PTR32 pMarkerInfo;
29394     } *params = args;
29395     VkDebugMarkerMarkerInfoEXT pMarkerInfo_host;
29396
29397     convert_VkDebugMarkerMarkerInfoEXT_win32_to_host((const VkDebugMarkerMarkerInfoEXT32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
29398     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);
29399 }
29400
29401 #ifdef _WIN64
29402 static void thunk64_vkCmdDecompressMemoryIndirectCountNV(void *args)
29403 {
29404     struct vkCmdDecompressMemoryIndirectCountNV_params *params = args;
29405
29406     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);
29407 }
29408 #endif /* _WIN64 */
29409
29410 static void thunk32_vkCmdDecompressMemoryIndirectCountNV(void *args)
29411 {
29412     struct
29413     {
29414         PTR32 commandBuffer;
29415         VkDeviceAddress DECLSPEC_ALIGN(8) indirectCommandsAddress;
29416         VkDeviceAddress DECLSPEC_ALIGN(8) indirectCommandsCountAddress;
29417         uint32_t stride;
29418     } *params = args;
29419
29420     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);
29421 }
29422
29423 #ifdef _WIN64
29424 static void thunk64_vkCmdDecompressMemoryNV(void *args)
29425 {
29426     struct vkCmdDecompressMemoryNV_params *params = args;
29427
29428     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
29429 }
29430 #endif /* _WIN64 */
29431
29432 static void thunk32_vkCmdDecompressMemoryNV(void *args)
29433 {
29434     struct
29435     {
29436         PTR32 commandBuffer;
29437         uint32_t decompressRegionCount;
29438         PTR32 pDecompressMemoryRegions;
29439     } *params = args;
29440     const VkDecompressMemoryRegionNV *pDecompressMemoryRegions_host;
29441     struct conversion_context local_ctx;
29442     struct conversion_context *ctx = &local_ctx;
29443
29444     init_conversion_context(ctx);
29445     pDecompressMemoryRegions_host = convert_VkDecompressMemoryRegionNV_array_win32_to_host(ctx, (const VkDecompressMemoryRegionNV32 *)UlongToPtr(params->pDecompressMemoryRegions), params->decompressRegionCount);
29446     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);
29447     free_conversion_context(ctx);
29448 }
29449
29450 #ifdef _WIN64
29451 static void thunk64_vkCmdDispatch(void *args)
29452 {
29453     struct vkCmdDispatch_params *params = args;
29454
29455     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);
29456 }
29457 #endif /* _WIN64 */
29458
29459 static void thunk32_vkCmdDispatch(void *args)
29460 {
29461     struct
29462     {
29463         PTR32 commandBuffer;
29464         uint32_t groupCountX;
29465         uint32_t groupCountY;
29466         uint32_t groupCountZ;
29467     } *params = args;
29468
29469     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);
29470 }
29471
29472 #ifdef _WIN64
29473 static void thunk64_vkCmdDispatchBase(void *args)
29474 {
29475     struct vkCmdDispatchBase_params *params = args;
29476
29477     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);
29478 }
29479 #endif /* _WIN64 */
29480
29481 static void thunk32_vkCmdDispatchBase(void *args)
29482 {
29483     struct
29484     {
29485         PTR32 commandBuffer;
29486         uint32_t baseGroupX;
29487         uint32_t baseGroupY;
29488         uint32_t baseGroupZ;
29489         uint32_t groupCountX;
29490         uint32_t groupCountY;
29491         uint32_t groupCountZ;
29492     } *params = args;
29493
29494     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);
29495 }
29496
29497 #ifdef _WIN64
29498 static void thunk64_vkCmdDispatchBaseKHR(void *args)
29499 {
29500     struct vkCmdDispatchBaseKHR_params *params = args;
29501
29502     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);
29503 }
29504 #endif /* _WIN64 */
29505
29506 static void thunk32_vkCmdDispatchBaseKHR(void *args)
29507 {
29508     struct
29509     {
29510         PTR32 commandBuffer;
29511         uint32_t baseGroupX;
29512         uint32_t baseGroupY;
29513         uint32_t baseGroupZ;
29514         uint32_t groupCountX;
29515         uint32_t groupCountY;
29516         uint32_t groupCountZ;
29517     } *params = args;
29518
29519     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);
29520 }
29521
29522 #ifdef _WIN64
29523 static void thunk64_vkCmdDispatchIndirect(void *args)
29524 {
29525     struct vkCmdDispatchIndirect_params *params = args;
29526
29527     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset);
29528 }
29529 #endif /* _WIN64 */
29530
29531 static void thunk32_vkCmdDispatchIndirect(void *args)
29532 {
29533     struct
29534     {
29535         PTR32 commandBuffer;
29536         VkBuffer DECLSPEC_ALIGN(8) buffer;
29537         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29538     } *params = args;
29539
29540     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);
29541 }
29542
29543 #ifdef _WIN64
29544 static void thunk64_vkCmdDraw(void *args)
29545 {
29546     struct vkCmdDraw_params *params = args;
29547
29548     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);
29549 }
29550 #endif /* _WIN64 */
29551
29552 static void thunk32_vkCmdDraw(void *args)
29553 {
29554     struct
29555     {
29556         PTR32 commandBuffer;
29557         uint32_t vertexCount;
29558         uint32_t instanceCount;
29559         uint32_t firstVertex;
29560         uint32_t firstInstance;
29561     } *params = args;
29562
29563     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);
29564 }
29565
29566 #ifdef _WIN64
29567 static void thunk64_vkCmdDrawClusterHUAWEI(void *args)
29568 {
29569     struct vkCmdDrawClusterHUAWEI_params *params = args;
29570
29571     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);
29572 }
29573 #endif /* _WIN64 */
29574
29575 static void thunk32_vkCmdDrawClusterHUAWEI(void *args)
29576 {
29577     struct
29578     {
29579         PTR32 commandBuffer;
29580         uint32_t groupCountX;
29581         uint32_t groupCountY;
29582         uint32_t groupCountZ;
29583     } *params = args;
29584
29585     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);
29586 }
29587
29588 #ifdef _WIN64
29589 static void thunk64_vkCmdDrawClusterIndirectHUAWEI(void *args)
29590 {
29591     struct vkCmdDrawClusterIndirectHUAWEI_params *params = args;
29592
29593     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawClusterIndirectHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset);
29594 }
29595 #endif /* _WIN64 */
29596
29597 static void thunk32_vkCmdDrawClusterIndirectHUAWEI(void *args)
29598 {
29599     struct
29600     {
29601         PTR32 commandBuffer;
29602         VkBuffer DECLSPEC_ALIGN(8) buffer;
29603         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29604     } *params = args;
29605
29606     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);
29607 }
29608
29609 #ifdef _WIN64
29610 static void thunk64_vkCmdDrawIndexed(void *args)
29611 {
29612     struct vkCmdDrawIndexed_params *params = args;
29613
29614     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);
29615 }
29616 #endif /* _WIN64 */
29617
29618 static void thunk32_vkCmdDrawIndexed(void *args)
29619 {
29620     struct
29621     {
29622         PTR32 commandBuffer;
29623         uint32_t indexCount;
29624         uint32_t instanceCount;
29625         uint32_t firstIndex;
29626         int32_t vertexOffset;
29627         uint32_t firstInstance;
29628     } *params = args;
29629
29630     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);
29631 }
29632
29633 #ifdef _WIN64
29634 static void thunk64_vkCmdDrawIndexedIndirect(void *args)
29635 {
29636     struct vkCmdDrawIndexedIndirect_params *params = args;
29637
29638     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);
29639 }
29640 #endif /* _WIN64 */
29641
29642 static void thunk32_vkCmdDrawIndexedIndirect(void *args)
29643 {
29644     struct
29645     {
29646         PTR32 commandBuffer;
29647         VkBuffer DECLSPEC_ALIGN(8) buffer;
29648         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29649         uint32_t drawCount;
29650         uint32_t stride;
29651     } *params = args;
29652
29653     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);
29654 }
29655
29656 #ifdef _WIN64
29657 static void thunk64_vkCmdDrawIndexedIndirectCount(void *args)
29658 {
29659     struct vkCmdDrawIndexedIndirectCount_params *params = args;
29660
29661     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);
29662 }
29663 #endif /* _WIN64 */
29664
29665 static void thunk32_vkCmdDrawIndexedIndirectCount(void *args)
29666 {
29667     struct
29668     {
29669         PTR32 commandBuffer;
29670         VkBuffer DECLSPEC_ALIGN(8) buffer;
29671         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29672         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
29673         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
29674         uint32_t maxDrawCount;
29675         uint32_t stride;
29676     } *params = args;
29677
29678     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);
29679 }
29680
29681 #ifdef _WIN64
29682 static void thunk64_vkCmdDrawIndexedIndirectCountAMD(void *args)
29683 {
29684     struct vkCmdDrawIndexedIndirectCountAMD_params *params = args;
29685
29686     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);
29687 }
29688 #endif /* _WIN64 */
29689
29690 static void thunk32_vkCmdDrawIndexedIndirectCountAMD(void *args)
29691 {
29692     struct
29693     {
29694         PTR32 commandBuffer;
29695         VkBuffer DECLSPEC_ALIGN(8) buffer;
29696         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29697         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
29698         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
29699         uint32_t maxDrawCount;
29700         uint32_t stride;
29701     } *params = args;
29702
29703     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);
29704 }
29705
29706 #ifdef _WIN64
29707 static void thunk64_vkCmdDrawIndexedIndirectCountKHR(void *args)
29708 {
29709     struct vkCmdDrawIndexedIndirectCountKHR_params *params = args;
29710
29711     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);
29712 }
29713 #endif /* _WIN64 */
29714
29715 static void thunk32_vkCmdDrawIndexedIndirectCountKHR(void *args)
29716 {
29717     struct
29718     {
29719         PTR32 commandBuffer;
29720         VkBuffer DECLSPEC_ALIGN(8) buffer;
29721         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29722         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
29723         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
29724         uint32_t maxDrawCount;
29725         uint32_t stride;
29726     } *params = args;
29727
29728     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);
29729 }
29730
29731 #ifdef _WIN64
29732 static void thunk64_vkCmdDrawIndirect(void *args)
29733 {
29734     struct vkCmdDrawIndirect_params *params = args;
29735
29736     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);
29737 }
29738 #endif /* _WIN64 */
29739
29740 static void thunk32_vkCmdDrawIndirect(void *args)
29741 {
29742     struct
29743     {
29744         PTR32 commandBuffer;
29745         VkBuffer DECLSPEC_ALIGN(8) buffer;
29746         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29747         uint32_t drawCount;
29748         uint32_t stride;
29749     } *params = args;
29750
29751     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);
29752 }
29753
29754 #ifdef _WIN64
29755 static void thunk64_vkCmdDrawIndirectByteCountEXT(void *args)
29756 {
29757     struct vkCmdDrawIndirectByteCountEXT_params *params = args;
29758
29759     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);
29760 }
29761 #endif /* _WIN64 */
29762
29763 static void thunk32_vkCmdDrawIndirectByteCountEXT(void *args)
29764 {
29765     struct
29766     {
29767         PTR32 commandBuffer;
29768         uint32_t instanceCount;
29769         uint32_t firstInstance;
29770         VkBuffer DECLSPEC_ALIGN(8) counterBuffer;
29771         VkDeviceSize DECLSPEC_ALIGN(8) counterBufferOffset;
29772         uint32_t counterOffset;
29773         uint32_t vertexStride;
29774     } *params = args;
29775
29776     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);
29777 }
29778
29779 #ifdef _WIN64
29780 static void thunk64_vkCmdDrawIndirectCount(void *args)
29781 {
29782     struct vkCmdDrawIndirectCount_params *params = args;
29783
29784     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);
29785 }
29786 #endif /* _WIN64 */
29787
29788 static void thunk32_vkCmdDrawIndirectCount(void *args)
29789 {
29790     struct
29791     {
29792         PTR32 commandBuffer;
29793         VkBuffer DECLSPEC_ALIGN(8) buffer;
29794         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29795         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
29796         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
29797         uint32_t maxDrawCount;
29798         uint32_t stride;
29799     } *params = args;
29800
29801     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);
29802 }
29803
29804 #ifdef _WIN64
29805 static void thunk64_vkCmdDrawIndirectCountAMD(void *args)
29806 {
29807     struct vkCmdDrawIndirectCountAMD_params *params = args;
29808
29809     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);
29810 }
29811 #endif /* _WIN64 */
29812
29813 static void thunk32_vkCmdDrawIndirectCountAMD(void *args)
29814 {
29815     struct
29816     {
29817         PTR32 commandBuffer;
29818         VkBuffer DECLSPEC_ALIGN(8) buffer;
29819         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29820         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
29821         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
29822         uint32_t maxDrawCount;
29823         uint32_t stride;
29824     } *params = args;
29825
29826     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);
29827 }
29828
29829 #ifdef _WIN64
29830 static void thunk64_vkCmdDrawIndirectCountKHR(void *args)
29831 {
29832     struct vkCmdDrawIndirectCountKHR_params *params = args;
29833
29834     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);
29835 }
29836 #endif /* _WIN64 */
29837
29838 static void thunk32_vkCmdDrawIndirectCountKHR(void *args)
29839 {
29840     struct
29841     {
29842         PTR32 commandBuffer;
29843         VkBuffer DECLSPEC_ALIGN(8) buffer;
29844         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29845         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
29846         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
29847         uint32_t maxDrawCount;
29848         uint32_t stride;
29849     } *params = args;
29850
29851     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);
29852 }
29853
29854 #ifdef _WIN64
29855 static void thunk64_vkCmdDrawMeshTasksEXT(void *args)
29856 {
29857     struct vkCmdDrawMeshTasksEXT_params *params = args;
29858
29859     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);
29860 }
29861 #endif /* _WIN64 */
29862
29863 static void thunk32_vkCmdDrawMeshTasksEXT(void *args)
29864 {
29865     struct
29866     {
29867         PTR32 commandBuffer;
29868         uint32_t groupCountX;
29869         uint32_t groupCountY;
29870         uint32_t groupCountZ;
29871     } *params = args;
29872
29873     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);
29874 }
29875
29876 #ifdef _WIN64
29877 static void thunk64_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
29878 {
29879     struct vkCmdDrawMeshTasksIndirectCountEXT_params *params = args;
29880
29881     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);
29882 }
29883 #endif /* _WIN64 */
29884
29885 static void thunk32_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
29886 {
29887     struct
29888     {
29889         PTR32 commandBuffer;
29890         VkBuffer DECLSPEC_ALIGN(8) buffer;
29891         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29892         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
29893         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
29894         uint32_t maxDrawCount;
29895         uint32_t stride;
29896     } *params = args;
29897
29898     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);
29899 }
29900
29901 #ifdef _WIN64
29902 static void thunk64_vkCmdDrawMeshTasksIndirectCountNV(void *args)
29903 {
29904     struct vkCmdDrawMeshTasksIndirectCountNV_params *params = args;
29905
29906     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);
29907 }
29908 #endif /* _WIN64 */
29909
29910 static void thunk32_vkCmdDrawMeshTasksIndirectCountNV(void *args)
29911 {
29912     struct
29913     {
29914         PTR32 commandBuffer;
29915         VkBuffer DECLSPEC_ALIGN(8) buffer;
29916         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29917         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
29918         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
29919         uint32_t maxDrawCount;
29920         uint32_t stride;
29921     } *params = args;
29922
29923     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);
29924 }
29925
29926 #ifdef _WIN64
29927 static void thunk64_vkCmdDrawMeshTasksIndirectEXT(void *args)
29928 {
29929     struct vkCmdDrawMeshTasksIndirectEXT_params *params = args;
29930
29931     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);
29932 }
29933 #endif /* _WIN64 */
29934
29935 static void thunk32_vkCmdDrawMeshTasksIndirectEXT(void *args)
29936 {
29937     struct
29938     {
29939         PTR32 commandBuffer;
29940         VkBuffer DECLSPEC_ALIGN(8) buffer;
29941         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29942         uint32_t drawCount;
29943         uint32_t stride;
29944     } *params = args;
29945
29946     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);
29947 }
29948
29949 #ifdef _WIN64
29950 static void thunk64_vkCmdDrawMeshTasksIndirectNV(void *args)
29951 {
29952     struct vkCmdDrawMeshTasksIndirectNV_params *params = args;
29953
29954     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);
29955 }
29956 #endif /* _WIN64 */
29957
29958 static void thunk32_vkCmdDrawMeshTasksIndirectNV(void *args)
29959 {
29960     struct
29961     {
29962         PTR32 commandBuffer;
29963         VkBuffer DECLSPEC_ALIGN(8) buffer;
29964         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29965         uint32_t drawCount;
29966         uint32_t stride;
29967     } *params = args;
29968
29969     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);
29970 }
29971
29972 #ifdef _WIN64
29973 static void thunk64_vkCmdDrawMeshTasksNV(void *args)
29974 {
29975     struct vkCmdDrawMeshTasksNV_params *params = args;
29976
29977     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->taskCount, params->firstTask);
29978 }
29979 #endif /* _WIN64 */
29980
29981 static void thunk32_vkCmdDrawMeshTasksNV(void *args)
29982 {
29983     struct
29984     {
29985         PTR32 commandBuffer;
29986         uint32_t taskCount;
29987         uint32_t firstTask;
29988     } *params = args;
29989
29990     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);
29991 }
29992
29993 #ifdef _WIN64
29994 static void thunk64_vkCmdDrawMultiEXT(void *args)
29995 {
29996     struct vkCmdDrawMultiEXT_params *params = args;
29997
29998     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);
29999 }
30000 #endif /* _WIN64 */
30001
30002 static void thunk32_vkCmdDrawMultiEXT(void *args)
30003 {
30004     struct
30005     {
30006         PTR32 commandBuffer;
30007         uint32_t drawCount;
30008         PTR32 pVertexInfo;
30009         uint32_t instanceCount;
30010         uint32_t firstInstance;
30011         uint32_t stride;
30012     } *params = args;
30013
30014     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);
30015 }
30016
30017 #ifdef _WIN64
30018 static void thunk64_vkCmdDrawMultiIndexedEXT(void *args)
30019 {
30020     struct vkCmdDrawMultiIndexedEXT_params *params = args;
30021
30022     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);
30023 }
30024 #endif /* _WIN64 */
30025
30026 static void thunk32_vkCmdDrawMultiIndexedEXT(void *args)
30027 {
30028     struct
30029     {
30030         PTR32 commandBuffer;
30031         uint32_t drawCount;
30032         PTR32 pIndexInfo;
30033         uint32_t instanceCount;
30034         uint32_t firstInstance;
30035         uint32_t stride;
30036         PTR32 pVertexOffset;
30037     } *params = args;
30038
30039     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));
30040 }
30041
30042 #ifdef _WIN64
30043 static void thunk64_vkCmdEndConditionalRenderingEXT(void *args)
30044 {
30045     struct vkCmdEndConditionalRenderingEXT_params *params = args;
30046
30047     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
30048 }
30049 #endif /* _WIN64 */
30050
30051 static void thunk32_vkCmdEndConditionalRenderingEXT(void *args)
30052 {
30053     struct
30054     {
30055         PTR32 commandBuffer;
30056     } *params = args;
30057
30058     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
30059 }
30060
30061 #ifdef _WIN64
30062 static void thunk64_vkCmdEndDebugUtilsLabelEXT(void *args)
30063 {
30064     struct vkCmdEndDebugUtilsLabelEXT_params *params = args;
30065
30066     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
30067 }
30068 #endif /* _WIN64 */
30069
30070 static void thunk32_vkCmdEndDebugUtilsLabelEXT(void *args)
30071 {
30072     struct
30073     {
30074         PTR32 commandBuffer;
30075     } *params = args;
30076
30077     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
30078 }
30079
30080 #ifdef _WIN64
30081 static void thunk64_vkCmdEndQuery(void *args)
30082 {
30083     struct vkCmdEndQuery_params *params = args;
30084
30085     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query);
30086 }
30087 #endif /* _WIN64 */
30088
30089 static void thunk32_vkCmdEndQuery(void *args)
30090 {
30091     struct
30092     {
30093         PTR32 commandBuffer;
30094         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
30095         uint32_t query;
30096     } *params = args;
30097
30098     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);
30099 }
30100
30101 #ifdef _WIN64
30102 static void thunk64_vkCmdEndQueryIndexedEXT(void *args)
30103 {
30104     struct vkCmdEndQueryIndexedEXT_params *params = args;
30105
30106     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);
30107 }
30108 #endif /* _WIN64 */
30109
30110 static void thunk32_vkCmdEndQueryIndexedEXT(void *args)
30111 {
30112     struct
30113     {
30114         PTR32 commandBuffer;
30115         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
30116         uint32_t query;
30117         uint32_t index;
30118     } *params = args;
30119
30120     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);
30121 }
30122
30123 #ifdef _WIN64
30124 static void thunk64_vkCmdEndRenderPass(void *args)
30125 {
30126     struct vkCmdEndRenderPass_params *params = args;
30127
30128     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
30129 }
30130 #endif /* _WIN64 */
30131
30132 static void thunk32_vkCmdEndRenderPass(void *args)
30133 {
30134     struct
30135     {
30136         PTR32 commandBuffer;
30137     } *params = args;
30138
30139     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
30140 }
30141
30142 #ifdef _WIN64
30143 static void thunk64_vkCmdEndRenderPass2(void *args)
30144 {
30145     struct vkCmdEndRenderPass2_params *params = args;
30146
30147     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
30148 }
30149 #endif /* _WIN64 */
30150
30151 static void thunk32_vkCmdEndRenderPass2(void *args)
30152 {
30153     struct
30154     {
30155         PTR32 commandBuffer;
30156         PTR32 pSubpassEndInfo;
30157     } *params = args;
30158     VkSubpassEndInfo pSubpassEndInfo_host;
30159     struct conversion_context local_ctx;
30160     struct conversion_context *ctx = &local_ctx;
30161
30162     init_conversion_context(ctx);
30163     convert_VkSubpassEndInfo_win32_to_host(ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
30164     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);
30165     free_conversion_context(ctx);
30166 }
30167
30168 #ifdef _WIN64
30169 static void thunk64_vkCmdEndRenderPass2KHR(void *args)
30170 {
30171     struct vkCmdEndRenderPass2KHR_params *params = args;
30172
30173     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
30174 }
30175 #endif /* _WIN64 */
30176
30177 static void thunk32_vkCmdEndRenderPass2KHR(void *args)
30178 {
30179     struct
30180     {
30181         PTR32 commandBuffer;
30182         PTR32 pSubpassEndInfo;
30183     } *params = args;
30184     VkSubpassEndInfo pSubpassEndInfo_host;
30185     struct conversion_context local_ctx;
30186     struct conversion_context *ctx = &local_ctx;
30187
30188     init_conversion_context(ctx);
30189     convert_VkSubpassEndInfo_win32_to_host(ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
30190     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);
30191     free_conversion_context(ctx);
30192 }
30193
30194 #ifdef _WIN64
30195 static void thunk64_vkCmdEndRendering(void *args)
30196 {
30197     struct vkCmdEndRendering_params *params = args;
30198
30199     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
30200 }
30201 #endif /* _WIN64 */
30202
30203 static void thunk32_vkCmdEndRendering(void *args)
30204 {
30205     struct
30206     {
30207         PTR32 commandBuffer;
30208     } *params = args;
30209
30210     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
30211 }
30212
30213 #ifdef _WIN64
30214 static void thunk64_vkCmdEndRenderingKHR(void *args)
30215 {
30216     struct vkCmdEndRenderingKHR_params *params = args;
30217
30218     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
30219 }
30220 #endif /* _WIN64 */
30221
30222 static void thunk32_vkCmdEndRenderingKHR(void *args)
30223 {
30224     struct
30225     {
30226         PTR32 commandBuffer;
30227     } *params = args;
30228
30229     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
30230 }
30231
30232 #ifdef _WIN64
30233 static void thunk64_vkCmdEndTransformFeedbackEXT(void *args)
30234 {
30235     struct vkCmdEndTransformFeedbackEXT_params *params = args;
30236
30237     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);
30238 }
30239 #endif /* _WIN64 */
30240
30241 static void thunk32_vkCmdEndTransformFeedbackEXT(void *args)
30242 {
30243     struct
30244     {
30245         PTR32 commandBuffer;
30246         uint32_t firstCounterBuffer;
30247         uint32_t counterBufferCount;
30248         PTR32 pCounterBuffers;
30249         PTR32 pCounterBufferOffsets;
30250     } *params = args;
30251
30252     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));
30253 }
30254
30255 #ifdef _WIN64
30256 static void thunk64_vkCmdExecuteCommands(void *args)
30257 {
30258     struct vkCmdExecuteCommands_params *params = args;
30259     const VkCommandBuffer *pCommandBuffers_host;
30260     struct conversion_context local_ctx;
30261     struct conversion_context *ctx = &local_ctx;
30262
30263     init_conversion_context(ctx);
30264     pCommandBuffers_host = convert_VkCommandBuffer_array_win64_to_host(ctx, params->pCommandBuffers, params->commandBufferCount);
30265     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->commandBufferCount, pCommandBuffers_host);
30266     free_conversion_context(ctx);
30267 }
30268 #endif /* _WIN64 */
30269
30270 static void thunk32_vkCmdExecuteCommands(void *args)
30271 {
30272     struct
30273     {
30274         PTR32 commandBuffer;
30275         uint32_t commandBufferCount;
30276         PTR32 pCommandBuffers;
30277     } *params = args;
30278     const VkCommandBuffer *pCommandBuffers_host;
30279     struct conversion_context local_ctx;
30280     struct conversion_context *ctx = &local_ctx;
30281
30282     init_conversion_context(ctx);
30283     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(params->pCommandBuffers), params->commandBufferCount);
30284     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);
30285     free_conversion_context(ctx);
30286 }
30287
30288 #ifdef _WIN64
30289 static void thunk64_vkCmdExecuteGeneratedCommandsNV(void *args)
30290 {
30291     struct vkCmdExecuteGeneratedCommandsNV_params *params = args;
30292
30293     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
30294 }
30295 #endif /* _WIN64 */
30296
30297 static void thunk32_vkCmdExecuteGeneratedCommandsNV(void *args)
30298 {
30299     struct
30300     {
30301         PTR32 commandBuffer;
30302         VkBool32 isPreprocessed;
30303         PTR32 pGeneratedCommandsInfo;
30304     } *params = args;
30305     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
30306     struct conversion_context local_ctx;
30307     struct conversion_context *ctx = &local_ctx;
30308
30309     init_conversion_context(ctx);
30310     convert_VkGeneratedCommandsInfoNV_win32_to_host(ctx, (const VkGeneratedCommandsInfoNV32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
30311     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);
30312     free_conversion_context(ctx);
30313 }
30314
30315 #ifdef _WIN64
30316 static void thunk64_vkCmdFillBuffer(void *args)
30317 {
30318     struct vkCmdFillBuffer_params *params = args;
30319
30320     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);
30321 }
30322 #endif /* _WIN64 */
30323
30324 static void thunk32_vkCmdFillBuffer(void *args)
30325 {
30326     struct
30327     {
30328         PTR32 commandBuffer;
30329         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
30330         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
30331         VkDeviceSize DECLSPEC_ALIGN(8) size;
30332         uint32_t data;
30333     } *params = args;
30334
30335     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);
30336 }
30337
30338 #ifdef _WIN64
30339 static void thunk64_vkCmdInsertDebugUtilsLabelEXT(void *args)
30340 {
30341     struct vkCmdInsertDebugUtilsLabelEXT_params *params = args;
30342
30343     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
30344 }
30345 #endif /* _WIN64 */
30346
30347 static void thunk32_vkCmdInsertDebugUtilsLabelEXT(void *args)
30348 {
30349     struct
30350     {
30351         PTR32 commandBuffer;
30352         PTR32 pLabelInfo;
30353     } *params = args;
30354     VkDebugUtilsLabelEXT pLabelInfo_host;
30355
30356     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
30357     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);
30358 }
30359
30360 #ifdef _WIN64
30361 static void thunk64_vkCmdNextSubpass(void *args)
30362 {
30363     struct vkCmdNextSubpass_params *params = args;
30364
30365     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->contents);
30366 }
30367 #endif /* _WIN64 */
30368
30369 static void thunk32_vkCmdNextSubpass(void *args)
30370 {
30371     struct
30372     {
30373         PTR32 commandBuffer;
30374         VkSubpassContents contents;
30375     } *params = args;
30376
30377     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);
30378 }
30379
30380 #ifdef _WIN64
30381 static void thunk64_vkCmdNextSubpass2(void *args)
30382 {
30383     struct vkCmdNextSubpass2_params *params = args;
30384
30385     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
30386 }
30387 #endif /* _WIN64 */
30388
30389 static void thunk32_vkCmdNextSubpass2(void *args)
30390 {
30391     struct
30392     {
30393         PTR32 commandBuffer;
30394         PTR32 pSubpassBeginInfo;
30395         PTR32 pSubpassEndInfo;
30396     } *params = args;
30397     VkSubpassBeginInfo pSubpassBeginInfo_host;
30398     VkSubpassEndInfo pSubpassEndInfo_host;
30399     struct conversion_context local_ctx;
30400     struct conversion_context *ctx = &local_ctx;
30401
30402     init_conversion_context(ctx);
30403     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
30404     convert_VkSubpassEndInfo_win32_to_host(ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
30405     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);
30406     free_conversion_context(ctx);
30407 }
30408
30409 #ifdef _WIN64
30410 static void thunk64_vkCmdNextSubpass2KHR(void *args)
30411 {
30412     struct vkCmdNextSubpass2KHR_params *params = args;
30413
30414     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
30415 }
30416 #endif /* _WIN64 */
30417
30418 static void thunk32_vkCmdNextSubpass2KHR(void *args)
30419 {
30420     struct
30421     {
30422         PTR32 commandBuffer;
30423         PTR32 pSubpassBeginInfo;
30424         PTR32 pSubpassEndInfo;
30425     } *params = args;
30426     VkSubpassBeginInfo pSubpassBeginInfo_host;
30427     VkSubpassEndInfo pSubpassEndInfo_host;
30428     struct conversion_context local_ctx;
30429     struct conversion_context *ctx = &local_ctx;
30430
30431     init_conversion_context(ctx);
30432     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
30433     convert_VkSubpassEndInfo_win32_to_host(ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
30434     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);
30435     free_conversion_context(ctx);
30436 }
30437
30438 #ifdef _WIN64
30439 static void thunk64_vkCmdOpticalFlowExecuteNV(void *args)
30440 {
30441     struct vkCmdOpticalFlowExecuteNV_params *params = args;
30442
30443     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->session, params->pExecuteInfo);
30444 }
30445 #endif /* _WIN64 */
30446
30447 static void thunk32_vkCmdOpticalFlowExecuteNV(void *args)
30448 {
30449     struct
30450     {
30451         PTR32 commandBuffer;
30452         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
30453         PTR32 pExecuteInfo;
30454     } *params = args;
30455     VkOpticalFlowExecuteInfoNV pExecuteInfo_host;
30456
30457     convert_VkOpticalFlowExecuteInfoNV_win32_to_host((const VkOpticalFlowExecuteInfoNV32 *)UlongToPtr(params->pExecuteInfo), &pExecuteInfo_host);
30458     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);
30459 }
30460
30461 #ifdef _WIN64
30462 static void thunk64_vkCmdPipelineBarrier(void *args)
30463 {
30464     struct vkCmdPipelineBarrier_params *params = args;
30465
30466     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);
30467 }
30468 #endif /* _WIN64 */
30469
30470 static void thunk32_vkCmdPipelineBarrier(void *args)
30471 {
30472     struct
30473     {
30474         PTR32 commandBuffer;
30475         VkPipelineStageFlags srcStageMask;
30476         VkPipelineStageFlags dstStageMask;
30477         VkDependencyFlags dependencyFlags;
30478         uint32_t memoryBarrierCount;
30479         PTR32 pMemoryBarriers;
30480         uint32_t bufferMemoryBarrierCount;
30481         PTR32 pBufferMemoryBarriers;
30482         uint32_t imageMemoryBarrierCount;
30483         PTR32 pImageMemoryBarriers;
30484     } *params = args;
30485     const VkMemoryBarrier *pMemoryBarriers_host;
30486     const VkBufferMemoryBarrier *pBufferMemoryBarriers_host;
30487     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
30488     struct conversion_context local_ctx;
30489     struct conversion_context *ctx = &local_ctx;
30490
30491     init_conversion_context(ctx);
30492     pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(ctx, (const VkMemoryBarrier32 *)UlongToPtr(params->pMemoryBarriers), params->memoryBarrierCount);
30493     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(ctx, (const VkBufferMemoryBarrier32 *)UlongToPtr(params->pBufferMemoryBarriers), params->bufferMemoryBarrierCount);
30494     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(ctx, (const VkImageMemoryBarrier32 *)UlongToPtr(params->pImageMemoryBarriers), params->imageMemoryBarrierCount);
30495     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);
30496     free_conversion_context(ctx);
30497 }
30498
30499 #ifdef _WIN64
30500 static void thunk64_vkCmdPipelineBarrier2(void *args)
30501 {
30502     struct vkCmdPipelineBarrier2_params *params = args;
30503
30504     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
30505 }
30506 #endif /* _WIN64 */
30507
30508 static void thunk32_vkCmdPipelineBarrier2(void *args)
30509 {
30510     struct
30511     {
30512         PTR32 commandBuffer;
30513         PTR32 pDependencyInfo;
30514     } *params = args;
30515     VkDependencyInfo pDependencyInfo_host;
30516     struct conversion_context local_ctx;
30517     struct conversion_context *ctx = &local_ctx;
30518
30519     init_conversion_context(ctx);
30520     convert_VkDependencyInfo_win32_to_host(ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
30521     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);
30522     free_conversion_context(ctx);
30523 }
30524
30525 #ifdef _WIN64
30526 static void thunk64_vkCmdPipelineBarrier2KHR(void *args)
30527 {
30528     struct vkCmdPipelineBarrier2KHR_params *params = args;
30529
30530     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
30531 }
30532 #endif /* _WIN64 */
30533
30534 static void thunk32_vkCmdPipelineBarrier2KHR(void *args)
30535 {
30536     struct
30537     {
30538         PTR32 commandBuffer;
30539         PTR32 pDependencyInfo;
30540     } *params = args;
30541     VkDependencyInfo pDependencyInfo_host;
30542     struct conversion_context local_ctx;
30543     struct conversion_context *ctx = &local_ctx;
30544
30545     init_conversion_context(ctx);
30546     convert_VkDependencyInfo_win32_to_host(ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
30547     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);
30548     free_conversion_context(ctx);
30549 }
30550
30551 #ifdef _WIN64
30552 static void thunk64_vkCmdPreprocessGeneratedCommandsNV(void *args)
30553 {
30554     struct vkCmdPreprocessGeneratedCommandsNV_params *params = args;
30555
30556     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pGeneratedCommandsInfo);
30557 }
30558 #endif /* _WIN64 */
30559
30560 static void thunk32_vkCmdPreprocessGeneratedCommandsNV(void *args)
30561 {
30562     struct
30563     {
30564         PTR32 commandBuffer;
30565         PTR32 pGeneratedCommandsInfo;
30566     } *params = args;
30567     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
30568     struct conversion_context local_ctx;
30569     struct conversion_context *ctx = &local_ctx;
30570
30571     init_conversion_context(ctx);
30572     convert_VkGeneratedCommandsInfoNV_win32_to_host(ctx, (const VkGeneratedCommandsInfoNV32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
30573     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);
30574     free_conversion_context(ctx);
30575 }
30576
30577 #ifdef _WIN64
30578 static void thunk64_vkCmdPushConstants(void *args)
30579 {
30580     struct vkCmdPushConstants_params *params = args;
30581
30582     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);
30583 }
30584 #endif /* _WIN64 */
30585
30586 static void thunk32_vkCmdPushConstants(void *args)
30587 {
30588     struct
30589     {
30590         PTR32 commandBuffer;
30591         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
30592         VkShaderStageFlags stageFlags;
30593         uint32_t offset;
30594         uint32_t size;
30595         PTR32 pValues;
30596     } *params = args;
30597
30598     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));
30599 }
30600
30601 #ifdef _WIN64
30602 static void thunk64_vkCmdPushDescriptorSetKHR(void *args)
30603 {
30604     struct vkCmdPushDescriptorSetKHR_params *params = args;
30605
30606     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);
30607 }
30608 #endif /* _WIN64 */
30609
30610 static void thunk32_vkCmdPushDescriptorSetKHR(void *args)
30611 {
30612     struct
30613     {
30614         PTR32 commandBuffer;
30615         VkPipelineBindPoint pipelineBindPoint;
30616         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
30617         uint32_t set;
30618         uint32_t descriptorWriteCount;
30619         PTR32 pDescriptorWrites;
30620     } *params = args;
30621     const VkWriteDescriptorSet *pDescriptorWrites_host;
30622     struct conversion_context local_ctx;
30623     struct conversion_context *ctx = &local_ctx;
30624
30625     init_conversion_context(ctx);
30626     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(ctx, (const VkWriteDescriptorSet32 *)UlongToPtr(params->pDescriptorWrites), params->descriptorWriteCount);
30627     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);
30628     free_conversion_context(ctx);
30629 }
30630
30631 #ifdef _WIN64
30632 static void thunk64_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
30633 {
30634     struct vkCmdPushDescriptorSetWithTemplateKHR_params *params = args;
30635
30636     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);
30637 }
30638 #endif /* _WIN64 */
30639
30640 static void thunk32_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
30641 {
30642     struct
30643     {
30644         PTR32 commandBuffer;
30645         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
30646         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
30647         uint32_t set;
30648         PTR32 pData;
30649     } *params = args;
30650
30651     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));
30652 }
30653
30654 #ifdef _WIN64
30655 static void thunk64_vkCmdResetEvent(void *args)
30656 {
30657     struct vkCmdResetEvent_params *params = args;
30658
30659     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
30660 }
30661 #endif /* _WIN64 */
30662
30663 static void thunk32_vkCmdResetEvent(void *args)
30664 {
30665     struct
30666     {
30667         PTR32 commandBuffer;
30668         VkEvent DECLSPEC_ALIGN(8) event;
30669         VkPipelineStageFlags stageMask;
30670     } *params = args;
30671
30672     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);
30673 }
30674
30675 #ifdef _WIN64
30676 static void thunk64_vkCmdResetEvent2(void *args)
30677 {
30678     struct vkCmdResetEvent2_params *params = args;
30679
30680     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
30681 }
30682 #endif /* _WIN64 */
30683
30684 static void thunk32_vkCmdResetEvent2(void *args)
30685 {
30686     struct
30687     {
30688         PTR32 commandBuffer;
30689         VkEvent DECLSPEC_ALIGN(8) event;
30690         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
30691     } *params = args;
30692
30693     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);
30694 }
30695
30696 #ifdef _WIN64
30697 static void thunk64_vkCmdResetEvent2KHR(void *args)
30698 {
30699     struct vkCmdResetEvent2KHR_params *params = args;
30700
30701     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
30702 }
30703 #endif /* _WIN64 */
30704
30705 static void thunk32_vkCmdResetEvent2KHR(void *args)
30706 {
30707     struct
30708     {
30709         PTR32 commandBuffer;
30710         VkEvent DECLSPEC_ALIGN(8) event;
30711         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
30712     } *params = args;
30713
30714     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);
30715 }
30716
30717 #ifdef _WIN64
30718 static void thunk64_vkCmdResetQueryPool(void *args)
30719 {
30720     struct vkCmdResetQueryPool_params *params = args;
30721
30722     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);
30723 }
30724 #endif /* _WIN64 */
30725
30726 static void thunk32_vkCmdResetQueryPool(void *args)
30727 {
30728     struct
30729     {
30730         PTR32 commandBuffer;
30731         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
30732         uint32_t firstQuery;
30733         uint32_t queryCount;
30734     } *params = args;
30735
30736     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);
30737 }
30738
30739 #ifdef _WIN64
30740 static void thunk64_vkCmdResolveImage(void *args)
30741 {
30742     struct vkCmdResolveImage_params *params = args;
30743
30744     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);
30745 }
30746 #endif /* _WIN64 */
30747
30748 static void thunk32_vkCmdResolveImage(void *args)
30749 {
30750     struct
30751     {
30752         PTR32 commandBuffer;
30753         VkImage DECLSPEC_ALIGN(8) srcImage;
30754         VkImageLayout srcImageLayout;
30755         VkImage DECLSPEC_ALIGN(8) dstImage;
30756         VkImageLayout dstImageLayout;
30757         uint32_t regionCount;
30758         PTR32 pRegions;
30759     } *params = args;
30760
30761     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));
30762 }
30763
30764 #ifdef _WIN64
30765 static void thunk64_vkCmdResolveImage2(void *args)
30766 {
30767     struct vkCmdResolveImage2_params *params = args;
30768
30769     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
30770 }
30771 #endif /* _WIN64 */
30772
30773 static void thunk32_vkCmdResolveImage2(void *args)
30774 {
30775     struct
30776     {
30777         PTR32 commandBuffer;
30778         PTR32 pResolveImageInfo;
30779     } *params = args;
30780     VkResolveImageInfo2 pResolveImageInfo_host;
30781     struct conversion_context local_ctx;
30782     struct conversion_context *ctx = &local_ctx;
30783
30784     init_conversion_context(ctx);
30785     convert_VkResolveImageInfo2_win32_to_host(ctx, (const VkResolveImageInfo232 *)UlongToPtr(params->pResolveImageInfo), &pResolveImageInfo_host);
30786     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);
30787     free_conversion_context(ctx);
30788 }
30789
30790 #ifdef _WIN64
30791 static void thunk64_vkCmdResolveImage2KHR(void *args)
30792 {
30793     struct vkCmdResolveImage2KHR_params *params = args;
30794
30795     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
30796 }
30797 #endif /* _WIN64 */
30798
30799 static void thunk32_vkCmdResolveImage2KHR(void *args)
30800 {
30801     struct
30802     {
30803         PTR32 commandBuffer;
30804         PTR32 pResolveImageInfo;
30805     } *params = args;
30806     VkResolveImageInfo2 pResolveImageInfo_host;
30807     struct conversion_context local_ctx;
30808     struct conversion_context *ctx = &local_ctx;
30809
30810     init_conversion_context(ctx);
30811     convert_VkResolveImageInfo2_win32_to_host(ctx, (const VkResolveImageInfo232 *)UlongToPtr(params->pResolveImageInfo), &pResolveImageInfo_host);
30812     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);
30813     free_conversion_context(ctx);
30814 }
30815
30816 #ifdef _WIN64
30817 static void thunk64_vkCmdSetAlphaToCoverageEnableEXT(void *args)
30818 {
30819     struct vkCmdSetAlphaToCoverageEnableEXT_params *params = args;
30820
30821     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToCoverageEnable);
30822 }
30823 #endif /* _WIN64 */
30824
30825 static void thunk32_vkCmdSetAlphaToCoverageEnableEXT(void *args)
30826 {
30827     struct
30828     {
30829         PTR32 commandBuffer;
30830         VkBool32 alphaToCoverageEnable;
30831     } *params = args;
30832
30833     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);
30834 }
30835
30836 #ifdef _WIN64
30837 static void thunk64_vkCmdSetAlphaToOneEnableEXT(void *args)
30838 {
30839     struct vkCmdSetAlphaToOneEnableEXT_params *params = args;
30840
30841     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToOneEnable);
30842 }
30843 #endif /* _WIN64 */
30844
30845 static void thunk32_vkCmdSetAlphaToOneEnableEXT(void *args)
30846 {
30847     struct
30848     {
30849         PTR32 commandBuffer;
30850         VkBool32 alphaToOneEnable;
30851     } *params = args;
30852
30853     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);
30854 }
30855
30856 #ifdef _WIN64
30857 static void thunk64_vkCmdSetAttachmentFeedbackLoopEnableEXT(void *args)
30858 {
30859     struct vkCmdSetAttachmentFeedbackLoopEnableEXT_params *params = args;
30860
30861     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAttachmentFeedbackLoopEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->aspectMask);
30862 }
30863 #endif /* _WIN64 */
30864
30865 static void thunk32_vkCmdSetAttachmentFeedbackLoopEnableEXT(void *args)
30866 {
30867     struct
30868     {
30869         PTR32 commandBuffer;
30870         VkImageAspectFlags aspectMask;
30871     } *params = args;
30872
30873     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);
30874 }
30875
30876 #ifdef _WIN64
30877 static void thunk64_vkCmdSetBlendConstants(void *args)
30878 {
30879     struct vkCmdSetBlendConstants_params *params = args;
30880
30881     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->blendConstants);
30882 }
30883 #endif /* _WIN64 */
30884
30885 static void thunk32_vkCmdSetBlendConstants(void *args)
30886 {
30887     struct
30888     {
30889         PTR32 commandBuffer;
30890         PTR32 blendConstants;
30891     } *params = args;
30892
30893     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));
30894 }
30895
30896 #ifdef _WIN64
30897 static void thunk64_vkCmdSetCheckpointNV(void *args)
30898 {
30899     struct vkCmdSetCheckpointNV_params *params = args;
30900
30901     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCheckpointMarker);
30902 }
30903 #endif /* _WIN64 */
30904
30905 static void thunk32_vkCmdSetCheckpointNV(void *args)
30906 {
30907     struct
30908     {
30909         PTR32 commandBuffer;
30910         PTR32 pCheckpointMarker;
30911     } *params = args;
30912
30913     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));
30914 }
30915
30916 #ifdef _WIN64
30917 static void thunk64_vkCmdSetCoarseSampleOrderNV(void *args)
30918 {
30919     struct vkCmdSetCoarseSampleOrderNV_params *params = args;
30920
30921     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);
30922 }
30923 #endif /* _WIN64 */
30924
30925 static void thunk32_vkCmdSetCoarseSampleOrderNV(void *args)
30926 {
30927     struct
30928     {
30929         PTR32 commandBuffer;
30930         VkCoarseSampleOrderTypeNV sampleOrderType;
30931         uint32_t customSampleOrderCount;
30932         PTR32 pCustomSampleOrders;
30933     } *params = args;
30934     const VkCoarseSampleOrderCustomNV *pCustomSampleOrders_host;
30935     struct conversion_context local_ctx;
30936     struct conversion_context *ctx = &local_ctx;
30937
30938     init_conversion_context(ctx);
30939     pCustomSampleOrders_host = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(params->pCustomSampleOrders), params->customSampleOrderCount);
30940     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);
30941     free_conversion_context(ctx);
30942 }
30943
30944 #ifdef _WIN64
30945 static void thunk64_vkCmdSetColorBlendAdvancedEXT(void *args)
30946 {
30947     struct vkCmdSetColorBlendAdvancedEXT_params *params = args;
30948
30949     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);
30950 }
30951 #endif /* _WIN64 */
30952
30953 static void thunk32_vkCmdSetColorBlendAdvancedEXT(void *args)
30954 {
30955     struct
30956     {
30957         PTR32 commandBuffer;
30958         uint32_t firstAttachment;
30959         uint32_t attachmentCount;
30960         PTR32 pColorBlendAdvanced;
30961     } *params = args;
30962
30963     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));
30964 }
30965
30966 #ifdef _WIN64
30967 static void thunk64_vkCmdSetColorBlendEnableEXT(void *args)
30968 {
30969     struct vkCmdSetColorBlendEnableEXT_params *params = args;
30970
30971     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);
30972 }
30973 #endif /* _WIN64 */
30974
30975 static void thunk32_vkCmdSetColorBlendEnableEXT(void *args)
30976 {
30977     struct
30978     {
30979         PTR32 commandBuffer;
30980         uint32_t firstAttachment;
30981         uint32_t attachmentCount;
30982         PTR32 pColorBlendEnables;
30983     } *params = args;
30984
30985     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));
30986 }
30987
30988 #ifdef _WIN64
30989 static void thunk64_vkCmdSetColorBlendEquationEXT(void *args)
30990 {
30991     struct vkCmdSetColorBlendEquationEXT_params *params = args;
30992
30993     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);
30994 }
30995 #endif /* _WIN64 */
30996
30997 static void thunk32_vkCmdSetColorBlendEquationEXT(void *args)
30998 {
30999     struct
31000     {
31001         PTR32 commandBuffer;
31002         uint32_t firstAttachment;
31003         uint32_t attachmentCount;
31004         PTR32 pColorBlendEquations;
31005     } *params = args;
31006
31007     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));
31008 }
31009
31010 #ifdef _WIN64
31011 static void thunk64_vkCmdSetColorWriteEnableEXT(void *args)
31012 {
31013     struct vkCmdSetColorWriteEnableEXT_params *params = args;
31014
31015     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
31016 }
31017 #endif /* _WIN64 */
31018
31019 static void thunk32_vkCmdSetColorWriteEnableEXT(void *args)
31020 {
31021     struct
31022     {
31023         PTR32 commandBuffer;
31024         uint32_t attachmentCount;
31025         PTR32 pColorWriteEnables;
31026     } *params = args;
31027
31028     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));
31029 }
31030
31031 #ifdef _WIN64
31032 static void thunk64_vkCmdSetColorWriteMaskEXT(void *args)
31033 {
31034     struct vkCmdSetColorWriteMaskEXT_params *params = args;
31035
31036     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);
31037 }
31038 #endif /* _WIN64 */
31039
31040 static void thunk32_vkCmdSetColorWriteMaskEXT(void *args)
31041 {
31042     struct
31043     {
31044         PTR32 commandBuffer;
31045         uint32_t firstAttachment;
31046         uint32_t attachmentCount;
31047         PTR32 pColorWriteMasks;
31048     } *params = args;
31049
31050     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));
31051 }
31052
31053 #ifdef _WIN64
31054 static void thunk64_vkCmdSetConservativeRasterizationModeEXT(void *args)
31055 {
31056     struct vkCmdSetConservativeRasterizationModeEXT_params *params = args;
31057
31058     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->conservativeRasterizationMode);
31059 }
31060 #endif /* _WIN64 */
31061
31062 static void thunk32_vkCmdSetConservativeRasterizationModeEXT(void *args)
31063 {
31064     struct
31065     {
31066         PTR32 commandBuffer;
31067         VkConservativeRasterizationModeEXT conservativeRasterizationMode;
31068     } *params = args;
31069
31070     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);
31071 }
31072
31073 #ifdef _WIN64
31074 static void thunk64_vkCmdSetCoverageModulationModeNV(void *args)
31075 {
31076     struct vkCmdSetCoverageModulationModeNV_params *params = args;
31077
31078     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationMode);
31079 }
31080 #endif /* _WIN64 */
31081
31082 static void thunk32_vkCmdSetCoverageModulationModeNV(void *args)
31083 {
31084     struct
31085     {
31086         PTR32 commandBuffer;
31087         VkCoverageModulationModeNV coverageModulationMode;
31088     } *params = args;
31089
31090     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);
31091 }
31092
31093 #ifdef _WIN64
31094 static void thunk64_vkCmdSetCoverageModulationTableEnableNV(void *args)
31095 {
31096     struct vkCmdSetCoverageModulationTableEnableNV_params *params = args;
31097
31098     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableEnable);
31099 }
31100 #endif /* _WIN64 */
31101
31102 static void thunk32_vkCmdSetCoverageModulationTableEnableNV(void *args)
31103 {
31104     struct
31105     {
31106         PTR32 commandBuffer;
31107         VkBool32 coverageModulationTableEnable;
31108     } *params = args;
31109
31110     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);
31111 }
31112
31113 #ifdef _WIN64
31114 static void thunk64_vkCmdSetCoverageModulationTableNV(void *args)
31115 {
31116     struct vkCmdSetCoverageModulationTableNV_params *params = args;
31117
31118     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
31119 }
31120 #endif /* _WIN64 */
31121
31122 static void thunk32_vkCmdSetCoverageModulationTableNV(void *args)
31123 {
31124     struct
31125     {
31126         PTR32 commandBuffer;
31127         uint32_t coverageModulationTableCount;
31128         PTR32 pCoverageModulationTable;
31129     } *params = args;
31130
31131     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));
31132 }
31133
31134 #ifdef _WIN64
31135 static void thunk64_vkCmdSetCoverageReductionModeNV(void *args)
31136 {
31137     struct vkCmdSetCoverageReductionModeNV_params *params = args;
31138
31139     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageReductionMode);
31140 }
31141 #endif /* _WIN64 */
31142
31143 static void thunk32_vkCmdSetCoverageReductionModeNV(void *args)
31144 {
31145     struct
31146     {
31147         PTR32 commandBuffer;
31148         VkCoverageReductionModeNV coverageReductionMode;
31149     } *params = args;
31150
31151     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);
31152 }
31153
31154 #ifdef _WIN64
31155 static void thunk64_vkCmdSetCoverageToColorEnableNV(void *args)
31156 {
31157     struct vkCmdSetCoverageToColorEnableNV_params *params = args;
31158
31159     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorEnable);
31160 }
31161 #endif /* _WIN64 */
31162
31163 static void thunk32_vkCmdSetCoverageToColorEnableNV(void *args)
31164 {
31165     struct
31166     {
31167         PTR32 commandBuffer;
31168         VkBool32 coverageToColorEnable;
31169     } *params = args;
31170
31171     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);
31172 }
31173
31174 #ifdef _WIN64
31175 static void thunk64_vkCmdSetCoverageToColorLocationNV(void *args)
31176 {
31177     struct vkCmdSetCoverageToColorLocationNV_params *params = args;
31178
31179     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorLocation);
31180 }
31181 #endif /* _WIN64 */
31182
31183 static void thunk32_vkCmdSetCoverageToColorLocationNV(void *args)
31184 {
31185     struct
31186     {
31187         PTR32 commandBuffer;
31188         uint32_t coverageToColorLocation;
31189     } *params = args;
31190
31191     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);
31192 }
31193
31194 #ifdef _WIN64
31195 static void thunk64_vkCmdSetCullMode(void *args)
31196 {
31197     struct vkCmdSetCullMode_params *params = args;
31198
31199     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
31200 }
31201 #endif /* _WIN64 */
31202
31203 static void thunk32_vkCmdSetCullMode(void *args)
31204 {
31205     struct
31206     {
31207         PTR32 commandBuffer;
31208         VkCullModeFlags cullMode;
31209     } *params = args;
31210
31211     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);
31212 }
31213
31214 #ifdef _WIN64
31215 static void thunk64_vkCmdSetCullModeEXT(void *args)
31216 {
31217     struct vkCmdSetCullModeEXT_params *params = args;
31218
31219     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
31220 }
31221 #endif /* _WIN64 */
31222
31223 static void thunk32_vkCmdSetCullModeEXT(void *args)
31224 {
31225     struct
31226     {
31227         PTR32 commandBuffer;
31228         VkCullModeFlags cullMode;
31229     } *params = args;
31230
31231     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);
31232 }
31233
31234 #ifdef _WIN64
31235 static void thunk64_vkCmdSetDepthBias(void *args)
31236 {
31237     struct vkCmdSetDepthBias_params *params = args;
31238
31239     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);
31240 }
31241 #endif /* _WIN64 */
31242
31243 static void thunk32_vkCmdSetDepthBias(void *args)
31244 {
31245     struct
31246     {
31247         PTR32 commandBuffer;
31248         float depthBiasConstantFactor;
31249         float depthBiasClamp;
31250         float depthBiasSlopeFactor;
31251     } *params = args;
31252
31253     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);
31254 }
31255
31256 #ifdef _WIN64
31257 static void thunk64_vkCmdSetDepthBias2EXT(void *args)
31258 {
31259     struct vkCmdSetDepthBias2EXT_params *params = args;
31260
31261     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBias2EXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDepthBiasInfo);
31262 }
31263 #endif /* _WIN64 */
31264
31265 static void thunk32_vkCmdSetDepthBias2EXT(void *args)
31266 {
31267     struct
31268     {
31269         PTR32 commandBuffer;
31270         PTR32 pDepthBiasInfo;
31271     } *params = args;
31272     VkDepthBiasInfoEXT pDepthBiasInfo_host;
31273     struct conversion_context local_ctx;
31274     struct conversion_context *ctx = &local_ctx;
31275
31276     init_conversion_context(ctx);
31277     convert_VkDepthBiasInfoEXT_win32_to_host(ctx, (const VkDepthBiasInfoEXT32 *)UlongToPtr(params->pDepthBiasInfo), &pDepthBiasInfo_host);
31278     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBias2EXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pDepthBiasInfo_host);
31279     free_conversion_context(ctx);
31280 }
31281
31282 #ifdef _WIN64
31283 static void thunk64_vkCmdSetDepthBiasEnable(void *args)
31284 {
31285     struct vkCmdSetDepthBiasEnable_params *params = args;
31286
31287     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
31288 }
31289 #endif /* _WIN64 */
31290
31291 static void thunk32_vkCmdSetDepthBiasEnable(void *args)
31292 {
31293     struct
31294     {
31295         PTR32 commandBuffer;
31296         VkBool32 depthBiasEnable;
31297     } *params = args;
31298
31299     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);
31300 }
31301
31302 #ifdef _WIN64
31303 static void thunk64_vkCmdSetDepthBiasEnableEXT(void *args)
31304 {
31305     struct vkCmdSetDepthBiasEnableEXT_params *params = args;
31306
31307     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
31308 }
31309 #endif /* _WIN64 */
31310
31311 static void thunk32_vkCmdSetDepthBiasEnableEXT(void *args)
31312 {
31313     struct
31314     {
31315         PTR32 commandBuffer;
31316         VkBool32 depthBiasEnable;
31317     } *params = args;
31318
31319     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);
31320 }
31321
31322 #ifdef _WIN64
31323 static void thunk64_vkCmdSetDepthBounds(void *args)
31324 {
31325     struct vkCmdSetDepthBounds_params *params = args;
31326
31327     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
31328 }
31329 #endif /* _WIN64 */
31330
31331 static void thunk32_vkCmdSetDepthBounds(void *args)
31332 {
31333     struct
31334     {
31335         PTR32 commandBuffer;
31336         float minDepthBounds;
31337         float maxDepthBounds;
31338     } *params = args;
31339
31340     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);
31341 }
31342
31343 #ifdef _WIN64
31344 static void thunk64_vkCmdSetDepthBoundsTestEnable(void *args)
31345 {
31346     struct vkCmdSetDepthBoundsTestEnable_params *params = args;
31347
31348     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
31349 }
31350 #endif /* _WIN64 */
31351
31352 static void thunk32_vkCmdSetDepthBoundsTestEnable(void *args)
31353 {
31354     struct
31355     {
31356         PTR32 commandBuffer;
31357         VkBool32 depthBoundsTestEnable;
31358     } *params = args;
31359
31360     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);
31361 }
31362
31363 #ifdef _WIN64
31364 static void thunk64_vkCmdSetDepthBoundsTestEnableEXT(void *args)
31365 {
31366     struct vkCmdSetDepthBoundsTestEnableEXT_params *params = args;
31367
31368     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
31369 }
31370 #endif /* _WIN64 */
31371
31372 static void thunk32_vkCmdSetDepthBoundsTestEnableEXT(void *args)
31373 {
31374     struct
31375     {
31376         PTR32 commandBuffer;
31377         VkBool32 depthBoundsTestEnable;
31378     } *params = args;
31379
31380     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);
31381 }
31382
31383 #ifdef _WIN64
31384 static void thunk64_vkCmdSetDepthClampEnableEXT(void *args)
31385 {
31386     struct vkCmdSetDepthClampEnableEXT_params *params = args;
31387
31388     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClampEnable);
31389 }
31390 #endif /* _WIN64 */
31391
31392 static void thunk32_vkCmdSetDepthClampEnableEXT(void *args)
31393 {
31394     struct
31395     {
31396         PTR32 commandBuffer;
31397         VkBool32 depthClampEnable;
31398     } *params = args;
31399
31400     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);
31401 }
31402
31403 #ifdef _WIN64
31404 static void thunk64_vkCmdSetDepthClipEnableEXT(void *args)
31405 {
31406     struct vkCmdSetDepthClipEnableEXT_params *params = args;
31407
31408     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClipEnable);
31409 }
31410 #endif /* _WIN64 */
31411
31412 static void thunk32_vkCmdSetDepthClipEnableEXT(void *args)
31413 {
31414     struct
31415     {
31416         PTR32 commandBuffer;
31417         VkBool32 depthClipEnable;
31418     } *params = args;
31419
31420     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);
31421 }
31422
31423 #ifdef _WIN64
31424 static void thunk64_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
31425 {
31426     struct vkCmdSetDepthClipNegativeOneToOneEXT_params *params = args;
31427
31428     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->negativeOneToOne);
31429 }
31430 #endif /* _WIN64 */
31431
31432 static void thunk32_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
31433 {
31434     struct
31435     {
31436         PTR32 commandBuffer;
31437         VkBool32 negativeOneToOne;
31438     } *params = args;
31439
31440     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);
31441 }
31442
31443 #ifdef _WIN64
31444 static void thunk64_vkCmdSetDepthCompareOp(void *args)
31445 {
31446     struct vkCmdSetDepthCompareOp_params *params = args;
31447
31448     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
31449 }
31450 #endif /* _WIN64 */
31451
31452 static void thunk32_vkCmdSetDepthCompareOp(void *args)
31453 {
31454     struct
31455     {
31456         PTR32 commandBuffer;
31457         VkCompareOp depthCompareOp;
31458     } *params = args;
31459
31460     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);
31461 }
31462
31463 #ifdef _WIN64
31464 static void thunk64_vkCmdSetDepthCompareOpEXT(void *args)
31465 {
31466     struct vkCmdSetDepthCompareOpEXT_params *params = args;
31467
31468     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
31469 }
31470 #endif /* _WIN64 */
31471
31472 static void thunk32_vkCmdSetDepthCompareOpEXT(void *args)
31473 {
31474     struct
31475     {
31476         PTR32 commandBuffer;
31477         VkCompareOp depthCompareOp;
31478     } *params = args;
31479
31480     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);
31481 }
31482
31483 #ifdef _WIN64
31484 static void thunk64_vkCmdSetDepthTestEnable(void *args)
31485 {
31486     struct vkCmdSetDepthTestEnable_params *params = args;
31487
31488     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
31489 }
31490 #endif /* _WIN64 */
31491
31492 static void thunk32_vkCmdSetDepthTestEnable(void *args)
31493 {
31494     struct
31495     {
31496         PTR32 commandBuffer;
31497         VkBool32 depthTestEnable;
31498     } *params = args;
31499
31500     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);
31501 }
31502
31503 #ifdef _WIN64
31504 static void thunk64_vkCmdSetDepthTestEnableEXT(void *args)
31505 {
31506     struct vkCmdSetDepthTestEnableEXT_params *params = args;
31507
31508     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
31509 }
31510 #endif /* _WIN64 */
31511
31512 static void thunk32_vkCmdSetDepthTestEnableEXT(void *args)
31513 {
31514     struct
31515     {
31516         PTR32 commandBuffer;
31517         VkBool32 depthTestEnable;
31518     } *params = args;
31519
31520     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);
31521 }
31522
31523 #ifdef _WIN64
31524 static void thunk64_vkCmdSetDepthWriteEnable(void *args)
31525 {
31526     struct vkCmdSetDepthWriteEnable_params *params = args;
31527
31528     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
31529 }
31530 #endif /* _WIN64 */
31531
31532 static void thunk32_vkCmdSetDepthWriteEnable(void *args)
31533 {
31534     struct
31535     {
31536         PTR32 commandBuffer;
31537         VkBool32 depthWriteEnable;
31538     } *params = args;
31539
31540     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);
31541 }
31542
31543 #ifdef _WIN64
31544 static void thunk64_vkCmdSetDepthWriteEnableEXT(void *args)
31545 {
31546     struct vkCmdSetDepthWriteEnableEXT_params *params = args;
31547
31548     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
31549 }
31550 #endif /* _WIN64 */
31551
31552 static void thunk32_vkCmdSetDepthWriteEnableEXT(void *args)
31553 {
31554     struct
31555     {
31556         PTR32 commandBuffer;
31557         VkBool32 depthWriteEnable;
31558     } *params = args;
31559
31560     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);
31561 }
31562
31563 #ifdef _WIN64
31564 static void thunk64_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
31565 {
31566     struct vkCmdSetDescriptorBufferOffsetsEXT_params *params = args;
31567
31568     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);
31569 }
31570 #endif /* _WIN64 */
31571
31572 static void thunk32_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
31573 {
31574     struct
31575     {
31576         PTR32 commandBuffer;
31577         VkPipelineBindPoint pipelineBindPoint;
31578         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
31579         uint32_t firstSet;
31580         uint32_t setCount;
31581         PTR32 pBufferIndices;
31582         PTR32 pOffsets;
31583     } *params = args;
31584
31585     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));
31586 }
31587
31588 #ifdef _WIN64
31589 static void thunk64_vkCmdSetDeviceMask(void *args)
31590 {
31591     struct vkCmdSetDeviceMask_params *params = args;
31592
31593     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
31594 }
31595 #endif /* _WIN64 */
31596
31597 static void thunk32_vkCmdSetDeviceMask(void *args)
31598 {
31599     struct
31600     {
31601         PTR32 commandBuffer;
31602         uint32_t deviceMask;
31603     } *params = args;
31604
31605     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);
31606 }
31607
31608 #ifdef _WIN64
31609 static void thunk64_vkCmdSetDeviceMaskKHR(void *args)
31610 {
31611     struct vkCmdSetDeviceMaskKHR_params *params = args;
31612
31613     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
31614 }
31615 #endif /* _WIN64 */
31616
31617 static void thunk32_vkCmdSetDeviceMaskKHR(void *args)
31618 {
31619     struct
31620     {
31621         PTR32 commandBuffer;
31622         uint32_t deviceMask;
31623     } *params = args;
31624
31625     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);
31626 }
31627
31628 #ifdef _WIN64
31629 static void thunk64_vkCmdSetDiscardRectangleEXT(void *args)
31630 {
31631     struct vkCmdSetDiscardRectangleEXT_params *params = args;
31632
31633     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);
31634 }
31635 #endif /* _WIN64 */
31636
31637 static void thunk32_vkCmdSetDiscardRectangleEXT(void *args)
31638 {
31639     struct
31640     {
31641         PTR32 commandBuffer;
31642         uint32_t firstDiscardRectangle;
31643         uint32_t discardRectangleCount;
31644         PTR32 pDiscardRectangles;
31645     } *params = args;
31646
31647     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));
31648 }
31649
31650 #ifdef _WIN64
31651 static void thunk64_vkCmdSetDiscardRectangleEnableEXT(void *args)
31652 {
31653     struct vkCmdSetDiscardRectangleEnableEXT_params *params = args;
31654
31655     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDiscardRectangleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->discardRectangleEnable);
31656 }
31657 #endif /* _WIN64 */
31658
31659 static void thunk32_vkCmdSetDiscardRectangleEnableEXT(void *args)
31660 {
31661     struct
31662     {
31663         PTR32 commandBuffer;
31664         VkBool32 discardRectangleEnable;
31665     } *params = args;
31666
31667     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);
31668 }
31669
31670 #ifdef _WIN64
31671 static void thunk64_vkCmdSetDiscardRectangleModeEXT(void *args)
31672 {
31673     struct vkCmdSetDiscardRectangleModeEXT_params *params = args;
31674
31675     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDiscardRectangleModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->discardRectangleMode);
31676 }
31677 #endif /* _WIN64 */
31678
31679 static void thunk32_vkCmdSetDiscardRectangleModeEXT(void *args)
31680 {
31681     struct
31682     {
31683         PTR32 commandBuffer;
31684         VkDiscardRectangleModeEXT discardRectangleMode;
31685     } *params = args;
31686
31687     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);
31688 }
31689
31690 #ifdef _WIN64
31691 static void thunk64_vkCmdSetEvent(void *args)
31692 {
31693     struct vkCmdSetEvent_params *params = args;
31694
31695     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
31696 }
31697 #endif /* _WIN64 */
31698
31699 static void thunk32_vkCmdSetEvent(void *args)
31700 {
31701     struct
31702     {
31703         PTR32 commandBuffer;
31704         VkEvent DECLSPEC_ALIGN(8) event;
31705         VkPipelineStageFlags stageMask;
31706     } *params = args;
31707
31708     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);
31709 }
31710
31711 #ifdef _WIN64
31712 static void thunk64_vkCmdSetEvent2(void *args)
31713 {
31714     struct vkCmdSetEvent2_params *params = args;
31715
31716     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
31717 }
31718 #endif /* _WIN64 */
31719
31720 static void thunk32_vkCmdSetEvent2(void *args)
31721 {
31722     struct
31723     {
31724         PTR32 commandBuffer;
31725         VkEvent DECLSPEC_ALIGN(8) event;
31726         PTR32 pDependencyInfo;
31727     } *params = args;
31728     VkDependencyInfo pDependencyInfo_host;
31729     struct conversion_context local_ctx;
31730     struct conversion_context *ctx = &local_ctx;
31731
31732     init_conversion_context(ctx);
31733     convert_VkDependencyInfo_win32_to_host(ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
31734     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);
31735     free_conversion_context(ctx);
31736 }
31737
31738 #ifdef _WIN64
31739 static void thunk64_vkCmdSetEvent2KHR(void *args)
31740 {
31741     struct vkCmdSetEvent2KHR_params *params = args;
31742
31743     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
31744 }
31745 #endif /* _WIN64 */
31746
31747 static void thunk32_vkCmdSetEvent2KHR(void *args)
31748 {
31749     struct
31750     {
31751         PTR32 commandBuffer;
31752         VkEvent DECLSPEC_ALIGN(8) event;
31753         PTR32 pDependencyInfo;
31754     } *params = args;
31755     VkDependencyInfo pDependencyInfo_host;
31756     struct conversion_context local_ctx;
31757     struct conversion_context *ctx = &local_ctx;
31758
31759     init_conversion_context(ctx);
31760     convert_VkDependencyInfo_win32_to_host(ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
31761     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);
31762     free_conversion_context(ctx);
31763 }
31764
31765 #ifdef _WIN64
31766 static void thunk64_vkCmdSetExclusiveScissorEnableNV(void *args)
31767 {
31768     struct vkCmdSetExclusiveScissorEnableNV_params *params = args;
31769
31770     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);
31771 }
31772 #endif /* _WIN64 */
31773
31774 static void thunk32_vkCmdSetExclusiveScissorEnableNV(void *args)
31775 {
31776     struct
31777     {
31778         PTR32 commandBuffer;
31779         uint32_t firstExclusiveScissor;
31780         uint32_t exclusiveScissorCount;
31781         PTR32 pExclusiveScissorEnables;
31782     } *params = args;
31783
31784     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));
31785 }
31786
31787 #ifdef _WIN64
31788 static void thunk64_vkCmdSetExclusiveScissorNV(void *args)
31789 {
31790     struct vkCmdSetExclusiveScissorNV_params *params = args;
31791
31792     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);
31793 }
31794 #endif /* _WIN64 */
31795
31796 static void thunk32_vkCmdSetExclusiveScissorNV(void *args)
31797 {
31798     struct
31799     {
31800         PTR32 commandBuffer;
31801         uint32_t firstExclusiveScissor;
31802         uint32_t exclusiveScissorCount;
31803         PTR32 pExclusiveScissors;
31804     } *params = args;
31805
31806     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));
31807 }
31808
31809 #ifdef _WIN64
31810 static void thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
31811 {
31812     struct vkCmdSetExtraPrimitiveOverestimationSizeEXT_params *params = args;
31813
31814     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->extraPrimitiveOverestimationSize);
31815 }
31816 #endif /* _WIN64 */
31817
31818 static void thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
31819 {
31820     struct
31821     {
31822         PTR32 commandBuffer;
31823         float extraPrimitiveOverestimationSize;
31824     } *params = args;
31825
31826     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);
31827 }
31828
31829 #ifdef _WIN64
31830 static void thunk64_vkCmdSetFragmentShadingRateEnumNV(void *args)
31831 {
31832     struct vkCmdSetFragmentShadingRateEnumNV_params *params = args;
31833
31834     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRate, params->combinerOps);
31835 }
31836 #endif /* _WIN64 */
31837
31838 static void thunk32_vkCmdSetFragmentShadingRateEnumNV(void *args)
31839 {
31840     struct
31841     {
31842         PTR32 commandBuffer;
31843         VkFragmentShadingRateNV shadingRate;
31844         PTR32 combinerOps;
31845     } *params = args;
31846
31847     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));
31848 }
31849
31850 #ifdef _WIN64
31851 static void thunk64_vkCmdSetFragmentShadingRateKHR(void *args)
31852 {
31853     struct vkCmdSetFragmentShadingRateKHR_params *params = args;
31854
31855     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pFragmentSize, params->combinerOps);
31856 }
31857 #endif /* _WIN64 */
31858
31859 static void thunk32_vkCmdSetFragmentShadingRateKHR(void *args)
31860 {
31861     struct
31862     {
31863         PTR32 commandBuffer;
31864         PTR32 pFragmentSize;
31865         PTR32 combinerOps;
31866     } *params = args;
31867
31868     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));
31869 }
31870
31871 #ifdef _WIN64
31872 static void thunk64_vkCmdSetFrontFace(void *args)
31873 {
31874     struct vkCmdSetFrontFace_params *params = args;
31875
31876     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
31877 }
31878 #endif /* _WIN64 */
31879
31880 static void thunk32_vkCmdSetFrontFace(void *args)
31881 {
31882     struct
31883     {
31884         PTR32 commandBuffer;
31885         VkFrontFace frontFace;
31886     } *params = args;
31887
31888     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);
31889 }
31890
31891 #ifdef _WIN64
31892 static void thunk64_vkCmdSetFrontFaceEXT(void *args)
31893 {
31894     struct vkCmdSetFrontFaceEXT_params *params = args;
31895
31896     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
31897 }
31898 #endif /* _WIN64 */
31899
31900 static void thunk32_vkCmdSetFrontFaceEXT(void *args)
31901 {
31902     struct
31903     {
31904         PTR32 commandBuffer;
31905         VkFrontFace frontFace;
31906     } *params = args;
31907
31908     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);
31909 }
31910
31911 #ifdef _WIN64
31912 static void thunk64_vkCmdSetLineRasterizationModeEXT(void *args)
31913 {
31914     struct vkCmdSetLineRasterizationModeEXT_params *params = args;
31915
31916     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineRasterizationMode);
31917 }
31918 #endif /* _WIN64 */
31919
31920 static void thunk32_vkCmdSetLineRasterizationModeEXT(void *args)
31921 {
31922     struct
31923     {
31924         PTR32 commandBuffer;
31925         VkLineRasterizationModeEXT lineRasterizationMode;
31926     } *params = args;
31927
31928     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);
31929 }
31930
31931 #ifdef _WIN64
31932 static void thunk64_vkCmdSetLineStippleEXT(void *args)
31933 {
31934     struct vkCmdSetLineStippleEXT_params *params = args;
31935
31936     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
31937 }
31938 #endif /* _WIN64 */
31939
31940 static void thunk32_vkCmdSetLineStippleEXT(void *args)
31941 {
31942     struct
31943     {
31944         PTR32 commandBuffer;
31945         uint32_t lineStippleFactor;
31946         uint16_t lineStipplePattern;
31947     } *params = args;
31948
31949     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);
31950 }
31951
31952 #ifdef _WIN64
31953 static void thunk64_vkCmdSetLineStippleEnableEXT(void *args)
31954 {
31955     struct vkCmdSetLineStippleEnableEXT_params *params = args;
31956
31957     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stippledLineEnable);
31958 }
31959 #endif /* _WIN64 */
31960
31961 static void thunk32_vkCmdSetLineStippleEnableEXT(void *args)
31962 {
31963     struct
31964     {
31965         PTR32 commandBuffer;
31966         VkBool32 stippledLineEnable;
31967     } *params = args;
31968
31969     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);
31970 }
31971
31972 #ifdef _WIN64
31973 static void thunk64_vkCmdSetLineWidth(void *args)
31974 {
31975     struct vkCmdSetLineWidth_params *params = args;
31976
31977     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineWidth);
31978 }
31979 #endif /* _WIN64 */
31980
31981 static void thunk32_vkCmdSetLineWidth(void *args)
31982 {
31983     struct
31984     {
31985         PTR32 commandBuffer;
31986         float lineWidth;
31987     } *params = args;
31988
31989     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);
31990 }
31991
31992 #ifdef _WIN64
31993 static void thunk64_vkCmdSetLogicOpEXT(void *args)
31994 {
31995     struct vkCmdSetLogicOpEXT_params *params = args;
31996
31997     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOp);
31998 }
31999 #endif /* _WIN64 */
32000
32001 static void thunk32_vkCmdSetLogicOpEXT(void *args)
32002 {
32003     struct
32004     {
32005         PTR32 commandBuffer;
32006         VkLogicOp logicOp;
32007     } *params = args;
32008
32009     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);
32010 }
32011
32012 #ifdef _WIN64
32013 static void thunk64_vkCmdSetLogicOpEnableEXT(void *args)
32014 {
32015     struct vkCmdSetLogicOpEnableEXT_params *params = args;
32016
32017     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOpEnable);
32018 }
32019 #endif /* _WIN64 */
32020
32021 static void thunk32_vkCmdSetLogicOpEnableEXT(void *args)
32022 {
32023     struct
32024     {
32025         PTR32 commandBuffer;
32026         VkBool32 logicOpEnable;
32027     } *params = args;
32028
32029     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);
32030 }
32031
32032 #ifdef _WIN64
32033 static void thunk64_vkCmdSetPatchControlPointsEXT(void *args)
32034 {
32035     struct vkCmdSetPatchControlPointsEXT_params *params = args;
32036
32037     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->patchControlPoints);
32038 }
32039 #endif /* _WIN64 */
32040
32041 static void thunk32_vkCmdSetPatchControlPointsEXT(void *args)
32042 {
32043     struct
32044     {
32045         PTR32 commandBuffer;
32046         uint32_t patchControlPoints;
32047     } *params = args;
32048
32049     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);
32050 }
32051
32052 #ifdef _WIN64
32053 static NTSTATUS thunk64_vkCmdSetPerformanceMarkerINTEL(void *args)
32054 {
32055     struct vkCmdSetPerformanceMarkerINTEL_params *params = args;
32056
32057     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
32058
32059     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
32060     return STATUS_SUCCESS;
32061 }
32062 #endif /* _WIN64 */
32063
32064 static NTSTATUS thunk32_vkCmdSetPerformanceMarkerINTEL(void *args)
32065 {
32066     struct
32067     {
32068         PTR32 commandBuffer;
32069         PTR32 pMarkerInfo;
32070         VkResult result;
32071     } *params = args;
32072     VkPerformanceMarkerInfoINTEL pMarkerInfo_host;
32073
32074     TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);
32075
32076     convert_VkPerformanceMarkerInfoINTEL_win32_to_host((const VkPerformanceMarkerInfoINTEL32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
32077     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);
32078     return STATUS_SUCCESS;
32079 }
32080
32081 #ifdef _WIN64
32082 static NTSTATUS thunk64_vkCmdSetPerformanceOverrideINTEL(void *args)
32083 {
32084     struct vkCmdSetPerformanceOverrideINTEL_params *params = args;
32085
32086     TRACE("%p, %p\n", params->commandBuffer, params->pOverrideInfo);
32087
32088     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pOverrideInfo);
32089     return STATUS_SUCCESS;
32090 }
32091 #endif /* _WIN64 */
32092
32093 static NTSTATUS thunk32_vkCmdSetPerformanceOverrideINTEL(void *args)
32094 {
32095     struct
32096     {
32097         PTR32 commandBuffer;
32098         PTR32 pOverrideInfo;
32099         VkResult result;
32100     } *params = args;
32101     VkPerformanceOverrideInfoINTEL pOverrideInfo_host;
32102
32103     TRACE("%#x, %#x\n", params->commandBuffer, params->pOverrideInfo);
32104
32105     convert_VkPerformanceOverrideInfoINTEL_win32_to_host((const VkPerformanceOverrideInfoINTEL32 *)UlongToPtr(params->pOverrideInfo), &pOverrideInfo_host);
32106     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);
32107     return STATUS_SUCCESS;
32108 }
32109
32110 #ifdef _WIN64
32111 static NTSTATUS thunk64_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
32112 {
32113     struct vkCmdSetPerformanceStreamMarkerINTEL_params *params = args;
32114
32115     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
32116
32117     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
32118     return STATUS_SUCCESS;
32119 }
32120 #endif /* _WIN64 */
32121
32122 static NTSTATUS thunk32_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
32123 {
32124     struct
32125     {
32126         PTR32 commandBuffer;
32127         PTR32 pMarkerInfo;
32128         VkResult result;
32129     } *params = args;
32130     VkPerformanceStreamMarkerInfoINTEL pMarkerInfo_host;
32131
32132     TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);
32133
32134     convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host((const VkPerformanceStreamMarkerInfoINTEL32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
32135     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);
32136     return STATUS_SUCCESS;
32137 }
32138
32139 #ifdef _WIN64
32140 static void thunk64_vkCmdSetPolygonModeEXT(void *args)
32141 {
32142     struct vkCmdSetPolygonModeEXT_params *params = args;
32143
32144     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->polygonMode);
32145 }
32146 #endif /* _WIN64 */
32147
32148 static void thunk32_vkCmdSetPolygonModeEXT(void *args)
32149 {
32150     struct
32151     {
32152         PTR32 commandBuffer;
32153         VkPolygonMode polygonMode;
32154     } *params = args;
32155
32156     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);
32157 }
32158
32159 #ifdef _WIN64
32160 static void thunk64_vkCmdSetPrimitiveRestartEnable(void *args)
32161 {
32162     struct vkCmdSetPrimitiveRestartEnable_params *params = args;
32163
32164     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
32165 }
32166 #endif /* _WIN64 */
32167
32168 static void thunk32_vkCmdSetPrimitiveRestartEnable(void *args)
32169 {
32170     struct
32171     {
32172         PTR32 commandBuffer;
32173         VkBool32 primitiveRestartEnable;
32174     } *params = args;
32175
32176     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);
32177 }
32178
32179 #ifdef _WIN64
32180 static void thunk64_vkCmdSetPrimitiveRestartEnableEXT(void *args)
32181 {
32182     struct vkCmdSetPrimitiveRestartEnableEXT_params *params = args;
32183
32184     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
32185 }
32186 #endif /* _WIN64 */
32187
32188 static void thunk32_vkCmdSetPrimitiveRestartEnableEXT(void *args)
32189 {
32190     struct
32191     {
32192         PTR32 commandBuffer;
32193         VkBool32 primitiveRestartEnable;
32194     } *params = args;
32195
32196     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);
32197 }
32198
32199 #ifdef _WIN64
32200 static void thunk64_vkCmdSetPrimitiveTopology(void *args)
32201 {
32202     struct vkCmdSetPrimitiveTopology_params *params = args;
32203
32204     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
32205 }
32206 #endif /* _WIN64 */
32207
32208 static void thunk32_vkCmdSetPrimitiveTopology(void *args)
32209 {
32210     struct
32211     {
32212         PTR32 commandBuffer;
32213         VkPrimitiveTopology primitiveTopology;
32214     } *params = args;
32215
32216     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);
32217 }
32218
32219 #ifdef _WIN64
32220 static void thunk64_vkCmdSetPrimitiveTopologyEXT(void *args)
32221 {
32222     struct vkCmdSetPrimitiveTopologyEXT_params *params = args;
32223
32224     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
32225 }
32226 #endif /* _WIN64 */
32227
32228 static void thunk32_vkCmdSetPrimitiveTopologyEXT(void *args)
32229 {
32230     struct
32231     {
32232         PTR32 commandBuffer;
32233         VkPrimitiveTopology primitiveTopology;
32234     } *params = args;
32235
32236     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);
32237 }
32238
32239 #ifdef _WIN64
32240 static void thunk64_vkCmdSetProvokingVertexModeEXT(void *args)
32241 {
32242     struct vkCmdSetProvokingVertexModeEXT_params *params = args;
32243
32244     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->provokingVertexMode);
32245 }
32246 #endif /* _WIN64 */
32247
32248 static void thunk32_vkCmdSetProvokingVertexModeEXT(void *args)
32249 {
32250     struct
32251     {
32252         PTR32 commandBuffer;
32253         VkProvokingVertexModeEXT provokingVertexMode;
32254     } *params = args;
32255
32256     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);
32257 }
32258
32259 #ifdef _WIN64
32260 static void thunk64_vkCmdSetRasterizationSamplesEXT(void *args)
32261 {
32262     struct vkCmdSetRasterizationSamplesEXT_params *params = args;
32263
32264     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationSamples);
32265 }
32266 #endif /* _WIN64 */
32267
32268 static void thunk32_vkCmdSetRasterizationSamplesEXT(void *args)
32269 {
32270     struct
32271     {
32272         PTR32 commandBuffer;
32273         VkSampleCountFlagBits rasterizationSamples;
32274     } *params = args;
32275
32276     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);
32277 }
32278
32279 #ifdef _WIN64
32280 static void thunk64_vkCmdSetRasterizationStreamEXT(void *args)
32281 {
32282     struct vkCmdSetRasterizationStreamEXT_params *params = args;
32283
32284     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationStream);
32285 }
32286 #endif /* _WIN64 */
32287
32288 static void thunk32_vkCmdSetRasterizationStreamEXT(void *args)
32289 {
32290     struct
32291     {
32292         PTR32 commandBuffer;
32293         uint32_t rasterizationStream;
32294     } *params = args;
32295
32296     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);
32297 }
32298
32299 #ifdef _WIN64
32300 static void thunk64_vkCmdSetRasterizerDiscardEnable(void *args)
32301 {
32302     struct vkCmdSetRasterizerDiscardEnable_params *params = args;
32303
32304     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
32305 }
32306 #endif /* _WIN64 */
32307
32308 static void thunk32_vkCmdSetRasterizerDiscardEnable(void *args)
32309 {
32310     struct
32311     {
32312         PTR32 commandBuffer;
32313         VkBool32 rasterizerDiscardEnable;
32314     } *params = args;
32315
32316     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);
32317 }
32318
32319 #ifdef _WIN64
32320 static void thunk64_vkCmdSetRasterizerDiscardEnableEXT(void *args)
32321 {
32322     struct vkCmdSetRasterizerDiscardEnableEXT_params *params = args;
32323
32324     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
32325 }
32326 #endif /* _WIN64 */
32327
32328 static void thunk32_vkCmdSetRasterizerDiscardEnableEXT(void *args)
32329 {
32330     struct
32331     {
32332         PTR32 commandBuffer;
32333         VkBool32 rasterizerDiscardEnable;
32334     } *params = args;
32335
32336     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);
32337 }
32338
32339 #ifdef _WIN64
32340 static void thunk64_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
32341 {
32342     struct vkCmdSetRayTracingPipelineStackSizeKHR_params *params = args;
32343
32344     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStackSize);
32345 }
32346 #endif /* _WIN64 */
32347
32348 static void thunk32_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
32349 {
32350     struct
32351     {
32352         PTR32 commandBuffer;
32353         uint32_t pipelineStackSize;
32354     } *params = args;
32355
32356     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);
32357 }
32358
32359 #ifdef _WIN64
32360 static void thunk64_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
32361 {
32362     struct vkCmdSetRepresentativeFragmentTestEnableNV_params *params = args;
32363
32364     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->representativeFragmentTestEnable);
32365 }
32366 #endif /* _WIN64 */
32367
32368 static void thunk32_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
32369 {
32370     struct
32371     {
32372         PTR32 commandBuffer;
32373         VkBool32 representativeFragmentTestEnable;
32374     } *params = args;
32375
32376     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);
32377 }
32378
32379 #ifdef _WIN64
32380 static void thunk64_vkCmdSetSampleLocationsEXT(void *args)
32381 {
32382     struct vkCmdSetSampleLocationsEXT_params *params = args;
32383
32384     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSampleLocationsInfo);
32385 }
32386 #endif /* _WIN64 */
32387
32388 static void thunk32_vkCmdSetSampleLocationsEXT(void *args)
32389 {
32390     struct
32391     {
32392         PTR32 commandBuffer;
32393         PTR32 pSampleLocationsInfo;
32394     } *params = args;
32395     VkSampleLocationsInfoEXT pSampleLocationsInfo_host;
32396
32397     convert_VkSampleLocationsInfoEXT_win32_to_host((const VkSampleLocationsInfoEXT32 *)UlongToPtr(params->pSampleLocationsInfo), &pSampleLocationsInfo_host);
32398     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);
32399 }
32400
32401 #ifdef _WIN64
32402 static void thunk64_vkCmdSetSampleLocationsEnableEXT(void *args)
32403 {
32404     struct vkCmdSetSampleLocationsEnableEXT_params *params = args;
32405
32406     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleLocationsEnable);
32407 }
32408 #endif /* _WIN64 */
32409
32410 static void thunk32_vkCmdSetSampleLocationsEnableEXT(void *args)
32411 {
32412     struct
32413     {
32414         PTR32 commandBuffer;
32415         VkBool32 sampleLocationsEnable;
32416     } *params = args;
32417
32418     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);
32419 }
32420
32421 #ifdef _WIN64
32422 static void thunk64_vkCmdSetSampleMaskEXT(void *args)
32423 {
32424     struct vkCmdSetSampleMaskEXT_params *params = args;
32425
32426     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->samples, params->pSampleMask);
32427 }
32428 #endif /* _WIN64 */
32429
32430 static void thunk32_vkCmdSetSampleMaskEXT(void *args)
32431 {
32432     struct
32433     {
32434         PTR32 commandBuffer;
32435         VkSampleCountFlagBits samples;
32436         PTR32 pSampleMask;
32437     } *params = args;
32438
32439     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));
32440 }
32441
32442 #ifdef _WIN64
32443 static void thunk64_vkCmdSetScissor(void *args)
32444 {
32445     struct vkCmdSetScissor_params *params = args;
32446
32447     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);
32448 }
32449 #endif /* _WIN64 */
32450
32451 static void thunk32_vkCmdSetScissor(void *args)
32452 {
32453     struct
32454     {
32455         PTR32 commandBuffer;
32456         uint32_t firstScissor;
32457         uint32_t scissorCount;
32458         PTR32 pScissors;
32459     } *params = args;
32460
32461     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));
32462 }
32463
32464 #ifdef _WIN64
32465 static void thunk64_vkCmdSetScissorWithCount(void *args)
32466 {
32467     struct vkCmdSetScissorWithCount_params *params = args;
32468
32469     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
32470 }
32471 #endif /* _WIN64 */
32472
32473 static void thunk32_vkCmdSetScissorWithCount(void *args)
32474 {
32475     struct
32476     {
32477         PTR32 commandBuffer;
32478         uint32_t scissorCount;
32479         PTR32 pScissors;
32480     } *params = args;
32481
32482     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));
32483 }
32484
32485 #ifdef _WIN64
32486 static void thunk64_vkCmdSetScissorWithCountEXT(void *args)
32487 {
32488     struct vkCmdSetScissorWithCountEXT_params *params = args;
32489
32490     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
32491 }
32492 #endif /* _WIN64 */
32493
32494 static void thunk32_vkCmdSetScissorWithCountEXT(void *args)
32495 {
32496     struct
32497     {
32498         PTR32 commandBuffer;
32499         uint32_t scissorCount;
32500         PTR32 pScissors;
32501     } *params = args;
32502
32503     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));
32504 }
32505
32506 #ifdef _WIN64
32507 static void thunk64_vkCmdSetShadingRateImageEnableNV(void *args)
32508 {
32509     struct vkCmdSetShadingRateImageEnableNV_params *params = args;
32510
32511     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRateImageEnable);
32512 }
32513 #endif /* _WIN64 */
32514
32515 static void thunk32_vkCmdSetShadingRateImageEnableNV(void *args)
32516 {
32517     struct
32518     {
32519         PTR32 commandBuffer;
32520         VkBool32 shadingRateImageEnable;
32521     } *params = args;
32522
32523     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);
32524 }
32525
32526 #ifdef _WIN64
32527 static void thunk64_vkCmdSetStencilCompareMask(void *args)
32528 {
32529     struct vkCmdSetStencilCompareMask_params *params = args;
32530
32531     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->compareMask);
32532 }
32533 #endif /* _WIN64 */
32534
32535 static void thunk32_vkCmdSetStencilCompareMask(void *args)
32536 {
32537     struct
32538     {
32539         PTR32 commandBuffer;
32540         VkStencilFaceFlags faceMask;
32541         uint32_t compareMask;
32542     } *params = args;
32543
32544     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);
32545 }
32546
32547 #ifdef _WIN64
32548 static void thunk64_vkCmdSetStencilOp(void *args)
32549 {
32550     struct vkCmdSetStencilOp_params *params = args;
32551
32552     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);
32553 }
32554 #endif /* _WIN64 */
32555
32556 static void thunk32_vkCmdSetStencilOp(void *args)
32557 {
32558     struct
32559     {
32560         PTR32 commandBuffer;
32561         VkStencilFaceFlags faceMask;
32562         VkStencilOp failOp;
32563         VkStencilOp passOp;
32564         VkStencilOp depthFailOp;
32565         VkCompareOp compareOp;
32566     } *params = args;
32567
32568     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);
32569 }
32570
32571 #ifdef _WIN64
32572 static void thunk64_vkCmdSetStencilOpEXT(void *args)
32573 {
32574     struct vkCmdSetStencilOpEXT_params *params = args;
32575
32576     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);
32577 }
32578 #endif /* _WIN64 */
32579
32580 static void thunk32_vkCmdSetStencilOpEXT(void *args)
32581 {
32582     struct
32583     {
32584         PTR32 commandBuffer;
32585         VkStencilFaceFlags faceMask;
32586         VkStencilOp failOp;
32587         VkStencilOp passOp;
32588         VkStencilOp depthFailOp;
32589         VkCompareOp compareOp;
32590     } *params = args;
32591
32592     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);
32593 }
32594
32595 #ifdef _WIN64
32596 static void thunk64_vkCmdSetStencilReference(void *args)
32597 {
32598     struct vkCmdSetStencilReference_params *params = args;
32599
32600     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->reference);
32601 }
32602 #endif /* _WIN64 */
32603
32604 static void thunk32_vkCmdSetStencilReference(void *args)
32605 {
32606     struct
32607     {
32608         PTR32 commandBuffer;
32609         VkStencilFaceFlags faceMask;
32610         uint32_t reference;
32611     } *params = args;
32612
32613     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);
32614 }
32615
32616 #ifdef _WIN64
32617 static void thunk64_vkCmdSetStencilTestEnable(void *args)
32618 {
32619     struct vkCmdSetStencilTestEnable_params *params = args;
32620
32621     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
32622 }
32623 #endif /* _WIN64 */
32624
32625 static void thunk32_vkCmdSetStencilTestEnable(void *args)
32626 {
32627     struct
32628     {
32629         PTR32 commandBuffer;
32630         VkBool32 stencilTestEnable;
32631     } *params = args;
32632
32633     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);
32634 }
32635
32636 #ifdef _WIN64
32637 static void thunk64_vkCmdSetStencilTestEnableEXT(void *args)
32638 {
32639     struct vkCmdSetStencilTestEnableEXT_params *params = args;
32640
32641     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
32642 }
32643 #endif /* _WIN64 */
32644
32645 static void thunk32_vkCmdSetStencilTestEnableEXT(void *args)
32646 {
32647     struct
32648     {
32649         PTR32 commandBuffer;
32650         VkBool32 stencilTestEnable;
32651     } *params = args;
32652
32653     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);
32654 }
32655
32656 #ifdef _WIN64
32657 static void thunk64_vkCmdSetStencilWriteMask(void *args)
32658 {
32659     struct vkCmdSetStencilWriteMask_params *params = args;
32660
32661     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
32662 }
32663 #endif /* _WIN64 */
32664
32665 static void thunk32_vkCmdSetStencilWriteMask(void *args)
32666 {
32667     struct
32668     {
32669         PTR32 commandBuffer;
32670         VkStencilFaceFlags faceMask;
32671         uint32_t writeMask;
32672     } *params = args;
32673
32674     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);
32675 }
32676
32677 #ifdef _WIN64
32678 static void thunk64_vkCmdSetTessellationDomainOriginEXT(void *args)
32679 {
32680     struct vkCmdSetTessellationDomainOriginEXT_params *params = args;
32681
32682     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->domainOrigin);
32683 }
32684 #endif /* _WIN64 */
32685
32686 static void thunk32_vkCmdSetTessellationDomainOriginEXT(void *args)
32687 {
32688     struct
32689     {
32690         PTR32 commandBuffer;
32691         VkTessellationDomainOrigin domainOrigin;
32692     } *params = args;
32693
32694     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);
32695 }
32696
32697 #ifdef _WIN64
32698 static void thunk64_vkCmdSetVertexInputEXT(void *args)
32699 {
32700     struct vkCmdSetVertexInputEXT_params *params = args;
32701
32702     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);
32703 }
32704 #endif /* _WIN64 */
32705
32706 static void thunk32_vkCmdSetVertexInputEXT(void *args)
32707 {
32708     struct
32709     {
32710         PTR32 commandBuffer;
32711         uint32_t vertexBindingDescriptionCount;
32712         PTR32 pVertexBindingDescriptions;
32713         uint32_t vertexAttributeDescriptionCount;
32714         PTR32 pVertexAttributeDescriptions;
32715     } *params = args;
32716     const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions_host;
32717     const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions_host;
32718     struct conversion_context local_ctx;
32719     struct conversion_context *ctx = &local_ctx;
32720
32721     init_conversion_context(ctx);
32722     pVertexBindingDescriptions_host = convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(ctx, (const VkVertexInputBindingDescription2EXT32 *)UlongToPtr(params->pVertexBindingDescriptions), params->vertexBindingDescriptionCount);
32723     pVertexAttributeDescriptions_host = convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(ctx, (const VkVertexInputAttributeDescription2EXT32 *)UlongToPtr(params->pVertexAttributeDescriptions), params->vertexAttributeDescriptionCount);
32724     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);
32725     free_conversion_context(ctx);
32726 }
32727
32728 #ifdef _WIN64
32729 static void thunk64_vkCmdSetViewport(void *args)
32730 {
32731     struct vkCmdSetViewport_params *params = args;
32732
32733     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);
32734 }
32735 #endif /* _WIN64 */
32736
32737 static void thunk32_vkCmdSetViewport(void *args)
32738 {
32739     struct
32740     {
32741         PTR32 commandBuffer;
32742         uint32_t firstViewport;
32743         uint32_t viewportCount;
32744         PTR32 pViewports;
32745     } *params = args;
32746
32747     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));
32748 }
32749
32750 #ifdef _WIN64
32751 static void thunk64_vkCmdSetViewportShadingRatePaletteNV(void *args)
32752 {
32753     struct vkCmdSetViewportShadingRatePaletteNV_params *params = args;
32754
32755     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);
32756 }
32757 #endif /* _WIN64 */
32758
32759 static void thunk32_vkCmdSetViewportShadingRatePaletteNV(void *args)
32760 {
32761     struct
32762     {
32763         PTR32 commandBuffer;
32764         uint32_t firstViewport;
32765         uint32_t viewportCount;
32766         PTR32 pShadingRatePalettes;
32767     } *params = args;
32768     const VkShadingRatePaletteNV *pShadingRatePalettes_host;
32769     struct conversion_context local_ctx;
32770     struct conversion_context *ctx = &local_ctx;
32771
32772     init_conversion_context(ctx);
32773     pShadingRatePalettes_host = convert_VkShadingRatePaletteNV_array_win32_to_host(ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(params->pShadingRatePalettes), params->viewportCount);
32774     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);
32775     free_conversion_context(ctx);
32776 }
32777
32778 #ifdef _WIN64
32779 static void thunk64_vkCmdSetViewportSwizzleNV(void *args)
32780 {
32781     struct vkCmdSetViewportSwizzleNV_params *params = args;
32782
32783     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);
32784 }
32785 #endif /* _WIN64 */
32786
32787 static void thunk32_vkCmdSetViewportSwizzleNV(void *args)
32788 {
32789     struct
32790     {
32791         PTR32 commandBuffer;
32792         uint32_t firstViewport;
32793         uint32_t viewportCount;
32794         PTR32 pViewportSwizzles;
32795     } *params = args;
32796
32797     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));
32798 }
32799
32800 #ifdef _WIN64
32801 static void thunk64_vkCmdSetViewportWScalingEnableNV(void *args)
32802 {
32803     struct vkCmdSetViewportWScalingEnableNV_params *params = args;
32804
32805     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportWScalingEnable);
32806 }
32807 #endif /* _WIN64 */
32808
32809 static void thunk32_vkCmdSetViewportWScalingEnableNV(void *args)
32810 {
32811     struct
32812     {
32813         PTR32 commandBuffer;
32814         VkBool32 viewportWScalingEnable;
32815     } *params = args;
32816
32817     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);
32818 }
32819
32820 #ifdef _WIN64
32821 static void thunk64_vkCmdSetViewportWScalingNV(void *args)
32822 {
32823     struct vkCmdSetViewportWScalingNV_params *params = args;
32824
32825     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);
32826 }
32827 #endif /* _WIN64 */
32828
32829 static void thunk32_vkCmdSetViewportWScalingNV(void *args)
32830 {
32831     struct
32832     {
32833         PTR32 commandBuffer;
32834         uint32_t firstViewport;
32835         uint32_t viewportCount;
32836         PTR32 pViewportWScalings;
32837     } *params = args;
32838
32839     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));
32840 }
32841
32842 #ifdef _WIN64
32843 static void thunk64_vkCmdSetViewportWithCount(void *args)
32844 {
32845     struct vkCmdSetViewportWithCount_params *params = args;
32846
32847     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
32848 }
32849 #endif /* _WIN64 */
32850
32851 static void thunk32_vkCmdSetViewportWithCount(void *args)
32852 {
32853     struct
32854     {
32855         PTR32 commandBuffer;
32856         uint32_t viewportCount;
32857         PTR32 pViewports;
32858     } *params = args;
32859
32860     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));
32861 }
32862
32863 #ifdef _WIN64
32864 static void thunk64_vkCmdSetViewportWithCountEXT(void *args)
32865 {
32866     struct vkCmdSetViewportWithCountEXT_params *params = args;
32867
32868     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
32869 }
32870 #endif /* _WIN64 */
32871
32872 static void thunk32_vkCmdSetViewportWithCountEXT(void *args)
32873 {
32874     struct
32875     {
32876         PTR32 commandBuffer;
32877         uint32_t viewportCount;
32878         PTR32 pViewports;
32879     } *params = args;
32880
32881     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));
32882 }
32883
32884 #ifdef _WIN64
32885 static void thunk64_vkCmdSubpassShadingHUAWEI(void *args)
32886 {
32887     struct vkCmdSubpassShadingHUAWEI_params *params = args;
32888
32889     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
32890 }
32891 #endif /* _WIN64 */
32892
32893 static void thunk32_vkCmdSubpassShadingHUAWEI(void *args)
32894 {
32895     struct
32896     {
32897         PTR32 commandBuffer;
32898     } *params = args;
32899
32900     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
32901 }
32902
32903 #ifdef _WIN64
32904 static void thunk64_vkCmdTraceRaysIndirect2KHR(void *args)
32905 {
32906     struct vkCmdTraceRaysIndirect2KHR_params *params = args;
32907
32908     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectDeviceAddress);
32909 }
32910 #endif /* _WIN64 */
32911
32912 static void thunk32_vkCmdTraceRaysIndirect2KHR(void *args)
32913 {
32914     struct
32915     {
32916         PTR32 commandBuffer;
32917         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
32918     } *params = args;
32919
32920     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);
32921 }
32922
32923 #ifdef _WIN64
32924 static void thunk64_vkCmdTraceRaysIndirectKHR(void *args)
32925 {
32926     struct vkCmdTraceRaysIndirectKHR_params *params = args;
32927
32928     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);
32929 }
32930 #endif /* _WIN64 */
32931
32932 static void thunk32_vkCmdTraceRaysIndirectKHR(void *args)
32933 {
32934     struct
32935     {
32936         PTR32 commandBuffer;
32937         PTR32 pRaygenShaderBindingTable;
32938         PTR32 pMissShaderBindingTable;
32939         PTR32 pHitShaderBindingTable;
32940         PTR32 pCallableShaderBindingTable;
32941         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
32942     } *params = args;
32943     VkStridedDeviceAddressRegionKHR pRaygenShaderBindingTable_host;
32944     VkStridedDeviceAddressRegionKHR pMissShaderBindingTable_host;
32945     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
32946     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;
32947
32948     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pRaygenShaderBindingTable), &pRaygenShaderBindingTable_host);
32949     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pMissShaderBindingTable), &pMissShaderBindingTable_host);
32950     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pHitShaderBindingTable), &pHitShaderBindingTable_host);
32951     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pCallableShaderBindingTable), &pCallableShaderBindingTable_host);
32952     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);
32953 }
32954
32955 #ifdef _WIN64
32956 static void thunk64_vkCmdTraceRaysKHR(void *args)
32957 {
32958     struct vkCmdTraceRaysKHR_params *params = args;
32959
32960     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);
32961 }
32962 #endif /* _WIN64 */
32963
32964 static void thunk32_vkCmdTraceRaysKHR(void *args)
32965 {
32966     struct
32967     {
32968         PTR32 commandBuffer;
32969         PTR32 pRaygenShaderBindingTable;
32970         PTR32 pMissShaderBindingTable;
32971         PTR32 pHitShaderBindingTable;
32972         PTR32 pCallableShaderBindingTable;
32973         uint32_t width;
32974         uint32_t height;
32975         uint32_t depth;
32976     } *params = args;
32977     VkStridedDeviceAddressRegionKHR pRaygenShaderBindingTable_host;
32978     VkStridedDeviceAddressRegionKHR pMissShaderBindingTable_host;
32979     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
32980     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;
32981
32982     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pRaygenShaderBindingTable), &pRaygenShaderBindingTable_host);
32983     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pMissShaderBindingTable), &pMissShaderBindingTable_host);
32984     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pHitShaderBindingTable), &pHitShaderBindingTable_host);
32985     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pCallableShaderBindingTable), &pCallableShaderBindingTable_host);
32986     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);
32987 }
32988
32989 #ifdef _WIN64
32990 static void thunk64_vkCmdTraceRaysNV(void *args)
32991 {
32992     struct vkCmdTraceRaysNV_params *params = args;
32993
32994     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);
32995 }
32996 #endif /* _WIN64 */
32997
32998 static void thunk32_vkCmdTraceRaysNV(void *args)
32999 {
33000     struct
33001     {
33002         PTR32 commandBuffer;
33003         VkBuffer DECLSPEC_ALIGN(8) raygenShaderBindingTableBuffer;
33004         VkDeviceSize DECLSPEC_ALIGN(8) raygenShaderBindingOffset;
33005         VkBuffer DECLSPEC_ALIGN(8) missShaderBindingTableBuffer;
33006         VkDeviceSize DECLSPEC_ALIGN(8) missShaderBindingOffset;
33007         VkDeviceSize DECLSPEC_ALIGN(8) missShaderBindingStride;
33008         VkBuffer DECLSPEC_ALIGN(8) hitShaderBindingTableBuffer;
33009         VkDeviceSize DECLSPEC_ALIGN(8) hitShaderBindingOffset;
33010         VkDeviceSize DECLSPEC_ALIGN(8) hitShaderBindingStride;
33011         VkBuffer DECLSPEC_ALIGN(8) callableShaderBindingTableBuffer;
33012         VkDeviceSize DECLSPEC_ALIGN(8) callableShaderBindingOffset;
33013         VkDeviceSize DECLSPEC_ALIGN(8) callableShaderBindingStride;
33014         uint32_t width;
33015         uint32_t height;
33016         uint32_t depth;
33017     } *params = args;
33018
33019     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);
33020 }
33021
33022 #ifdef _WIN64
33023 static void thunk64_vkCmdUpdateBuffer(void *args)
33024 {
33025     struct vkCmdUpdateBuffer_params *params = args;
33026
33027     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);
33028 }
33029 #endif /* _WIN64 */
33030
33031 static void thunk32_vkCmdUpdateBuffer(void *args)
33032 {
33033     struct
33034     {
33035         PTR32 commandBuffer;
33036         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
33037         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
33038         VkDeviceSize DECLSPEC_ALIGN(8) dataSize;
33039         PTR32 pData;
33040     } *params = args;
33041
33042     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));
33043 }
33044
33045 #ifdef _WIN64
33046 static void thunk64_vkCmdUpdatePipelineIndirectBufferNV(void *args)
33047 {
33048     struct vkCmdUpdatePipelineIndirectBufferNV_params *params = args;
33049
33050     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdUpdatePipelineIndirectBufferNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline);
33051 }
33052 #endif /* _WIN64 */
33053
33054 static void thunk32_vkCmdUpdatePipelineIndirectBufferNV(void *args)
33055 {
33056     struct
33057     {
33058         PTR32 commandBuffer;
33059         VkPipelineBindPoint pipelineBindPoint;
33060         VkPipeline DECLSPEC_ALIGN(8) pipeline;
33061     } *params = args;
33062
33063     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdUpdatePipelineIndirectBufferNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->pipeline);
33064 }
33065
33066 #ifdef _WIN64
33067 static void thunk64_vkCmdWaitEvents(void *args)
33068 {
33069     struct vkCmdWaitEvents_params *params = args;
33070
33071     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);
33072 }
33073 #endif /* _WIN64 */
33074
33075 static void thunk32_vkCmdWaitEvents(void *args)
33076 {
33077     struct
33078     {
33079         PTR32 commandBuffer;
33080         uint32_t eventCount;
33081         PTR32 pEvents;
33082         VkPipelineStageFlags srcStageMask;
33083         VkPipelineStageFlags dstStageMask;
33084         uint32_t memoryBarrierCount;
33085         PTR32 pMemoryBarriers;
33086         uint32_t bufferMemoryBarrierCount;
33087         PTR32 pBufferMemoryBarriers;
33088         uint32_t imageMemoryBarrierCount;
33089         PTR32 pImageMemoryBarriers;
33090     } *params = args;
33091     const VkMemoryBarrier *pMemoryBarriers_host;
33092     const VkBufferMemoryBarrier *pBufferMemoryBarriers_host;
33093     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
33094     struct conversion_context local_ctx;
33095     struct conversion_context *ctx = &local_ctx;
33096
33097     init_conversion_context(ctx);
33098     pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(ctx, (const VkMemoryBarrier32 *)UlongToPtr(params->pMemoryBarriers), params->memoryBarrierCount);
33099     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(ctx, (const VkBufferMemoryBarrier32 *)UlongToPtr(params->pBufferMemoryBarriers), params->bufferMemoryBarrierCount);
33100     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(ctx, (const VkImageMemoryBarrier32 *)UlongToPtr(params->pImageMemoryBarriers), params->imageMemoryBarrierCount);
33101     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);
33102     free_conversion_context(ctx);
33103 }
33104
33105 #ifdef _WIN64
33106 static void thunk64_vkCmdWaitEvents2(void *args)
33107 {
33108     struct vkCmdWaitEvents2_params *params = args;
33109
33110     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);
33111 }
33112 #endif /* _WIN64 */
33113
33114 static void thunk32_vkCmdWaitEvents2(void *args)
33115 {
33116     struct
33117     {
33118         PTR32 commandBuffer;
33119         uint32_t eventCount;
33120         PTR32 pEvents;
33121         PTR32 pDependencyInfos;
33122     } *params = args;
33123     const VkDependencyInfo *pDependencyInfos_host;
33124     struct conversion_context local_ctx;
33125     struct conversion_context *ctx = &local_ctx;
33126
33127     init_conversion_context(ctx);
33128     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfos), params->eventCount);
33129     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);
33130     free_conversion_context(ctx);
33131 }
33132
33133 #ifdef _WIN64
33134 static void thunk64_vkCmdWaitEvents2KHR(void *args)
33135 {
33136     struct vkCmdWaitEvents2KHR_params *params = args;
33137
33138     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);
33139 }
33140 #endif /* _WIN64 */
33141
33142 static void thunk32_vkCmdWaitEvents2KHR(void *args)
33143 {
33144     struct
33145     {
33146         PTR32 commandBuffer;
33147         uint32_t eventCount;
33148         PTR32 pEvents;
33149         PTR32 pDependencyInfos;
33150     } *params = args;
33151     const VkDependencyInfo *pDependencyInfos_host;
33152     struct conversion_context local_ctx;
33153     struct conversion_context *ctx = &local_ctx;
33154
33155     init_conversion_context(ctx);
33156     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfos), params->eventCount);
33157     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);
33158     free_conversion_context(ctx);
33159 }
33160
33161 #ifdef _WIN64
33162 static void thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
33163 {
33164     struct vkCmdWriteAccelerationStructuresPropertiesKHR_params *params = args;
33165
33166     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);
33167 }
33168 #endif /* _WIN64 */
33169
33170 static void thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
33171 {
33172     struct
33173     {
33174         PTR32 commandBuffer;
33175         uint32_t accelerationStructureCount;
33176         PTR32 pAccelerationStructures;
33177         VkQueryType queryType;
33178         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
33179         uint32_t firstQuery;
33180     } *params = args;
33181
33182     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);
33183 }
33184
33185 #ifdef _WIN64
33186 static void thunk64_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
33187 {
33188     struct vkCmdWriteAccelerationStructuresPropertiesNV_params *params = args;
33189
33190     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);
33191 }
33192 #endif /* _WIN64 */
33193
33194 static void thunk32_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
33195 {
33196     struct
33197     {
33198         PTR32 commandBuffer;
33199         uint32_t accelerationStructureCount;
33200         PTR32 pAccelerationStructures;
33201         VkQueryType queryType;
33202         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
33203         uint32_t firstQuery;
33204     } *params = args;
33205
33206     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);
33207 }
33208
33209 #ifdef _WIN64
33210 static void thunk64_vkCmdWriteBufferMarker2AMD(void *args)
33211 {
33212     struct vkCmdWriteBufferMarker2AMD_params *params = args;
33213
33214     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);
33215 }
33216 #endif /* _WIN64 */
33217
33218 static void thunk32_vkCmdWriteBufferMarker2AMD(void *args)
33219 {
33220     struct
33221     {
33222         PTR32 commandBuffer;
33223         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
33224         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
33225         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
33226         uint32_t marker;
33227     } *params = args;
33228
33229     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);
33230 }
33231
33232 #ifdef _WIN64
33233 static void thunk64_vkCmdWriteBufferMarkerAMD(void *args)
33234 {
33235     struct vkCmdWriteBufferMarkerAMD_params *params = args;
33236
33237     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);
33238 }
33239 #endif /* _WIN64 */
33240
33241 static void thunk32_vkCmdWriteBufferMarkerAMD(void *args)
33242 {
33243     struct
33244     {
33245         PTR32 commandBuffer;
33246         VkPipelineStageFlagBits pipelineStage;
33247         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
33248         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
33249         uint32_t marker;
33250     } *params = args;
33251
33252     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);
33253 }
33254
33255 #ifdef _WIN64
33256 static void thunk64_vkCmdWriteMicromapsPropertiesEXT(void *args)
33257 {
33258     struct vkCmdWriteMicromapsPropertiesEXT_params *params = args;
33259
33260     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);
33261 }
33262 #endif /* _WIN64 */
33263
33264 static void thunk32_vkCmdWriteMicromapsPropertiesEXT(void *args)
33265 {
33266     struct
33267     {
33268         PTR32 commandBuffer;
33269         uint32_t micromapCount;
33270         PTR32 pMicromaps;
33271         VkQueryType queryType;
33272         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
33273         uint32_t firstQuery;
33274     } *params = args;
33275
33276     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);
33277 }
33278
33279 #ifdef _WIN64
33280 static void thunk64_vkCmdWriteTimestamp(void *args)
33281 {
33282     struct vkCmdWriteTimestamp_params *params = args;
33283
33284     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);
33285 }
33286 #endif /* _WIN64 */
33287
33288 static void thunk32_vkCmdWriteTimestamp(void *args)
33289 {
33290     struct
33291     {
33292         PTR32 commandBuffer;
33293         VkPipelineStageFlagBits pipelineStage;
33294         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
33295         uint32_t query;
33296     } *params = args;
33297
33298     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);
33299 }
33300
33301 #ifdef _WIN64
33302 static void thunk64_vkCmdWriteTimestamp2(void *args)
33303 {
33304     struct vkCmdWriteTimestamp2_params *params = args;
33305
33306     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);
33307 }
33308 #endif /* _WIN64 */
33309
33310 static void thunk32_vkCmdWriteTimestamp2(void *args)
33311 {
33312     struct
33313     {
33314         PTR32 commandBuffer;
33315         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
33316         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
33317         uint32_t query;
33318     } *params = args;
33319
33320     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);
33321 }
33322
33323 #ifdef _WIN64
33324 static void thunk64_vkCmdWriteTimestamp2KHR(void *args)
33325 {
33326     struct vkCmdWriteTimestamp2KHR_params *params = args;
33327
33328     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);
33329 }
33330 #endif /* _WIN64 */
33331
33332 static void thunk32_vkCmdWriteTimestamp2KHR(void *args)
33333 {
33334     struct
33335     {
33336         PTR32 commandBuffer;
33337         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
33338         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
33339         uint32_t query;
33340     } *params = args;
33341
33342     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);
33343 }
33344
33345 #ifdef _WIN64
33346 static NTSTATUS thunk64_vkCompileDeferredNV(void *args)
33347 {
33348     struct vkCompileDeferredNV_params *params = args;
33349
33350     TRACE("%p, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);
33351
33352     params->result = wine_device_from_handle(params->device)->funcs.p_vkCompileDeferredNV(wine_device_from_handle(params->device)->device, params->pipeline, params->shader);
33353     return STATUS_SUCCESS;
33354 }
33355 #endif /* _WIN64 */
33356
33357 static NTSTATUS thunk32_vkCompileDeferredNV(void *args)
33358 {
33359     struct
33360     {
33361         PTR32 device;
33362         VkPipeline DECLSPEC_ALIGN(8) pipeline;
33363         uint32_t shader;
33364         VkResult result;
33365     } *params = args;
33366
33367     TRACE("%#x, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);
33368
33369     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);
33370     return STATUS_SUCCESS;
33371 }
33372
33373 #ifdef _WIN64
33374 static NTSTATUS thunk64_vkCopyAccelerationStructureKHR(void *args)
33375 {
33376     struct vkCopyAccelerationStructureKHR_params *params = args;
33377
33378     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
33379
33380     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, params->pInfo);
33381     return STATUS_SUCCESS;
33382 }
33383 #endif /* _WIN64 */
33384
33385 static NTSTATUS thunk32_vkCopyAccelerationStructureKHR(void *args)
33386 {
33387     struct
33388     {
33389         PTR32 device;
33390         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
33391         PTR32 pInfo;
33392         VkResult result;
33393     } *params = args;
33394     VkCopyAccelerationStructureInfoKHR pInfo_host;
33395
33396     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
33397
33398     convert_VkCopyAccelerationStructureInfoKHR_win32_to_host((const VkCopyAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
33399     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, &pInfo_host);
33400     return STATUS_SUCCESS;
33401 }
33402
33403 #ifdef _WIN64
33404 static NTSTATUS thunk64_vkCopyAccelerationStructureToMemoryKHR(void *args)
33405 {
33406     struct vkCopyAccelerationStructureToMemoryKHR_params *params = args;
33407
33408     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
33409
33410     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle(params->device)->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, params->pInfo);
33411     return STATUS_SUCCESS;
33412 }
33413 #endif /* _WIN64 */
33414
33415 static NTSTATUS thunk32_vkCopyAccelerationStructureToMemoryKHR(void *args)
33416 {
33417     struct
33418     {
33419         PTR32 device;
33420         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
33421         PTR32 pInfo;
33422         VkResult result;
33423     } *params = args;
33424     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;
33425
33426     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
33427
33428     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host((const VkCopyAccelerationStructureToMemoryInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
33429     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, &pInfo_host);
33430     return STATUS_SUCCESS;
33431 }
33432
33433 #ifdef _WIN64
33434 static NTSTATUS thunk64_vkCopyImageToImageEXT(void *args)
33435 {
33436     struct vkCopyImageToImageEXT_params *params = args;
33437
33438     TRACE("%p, %p\n", params->device, params->pCopyImageToImageInfo);
33439
33440     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyImageToImageEXT(wine_device_from_handle(params->device)->device, params->pCopyImageToImageInfo);
33441     return STATUS_SUCCESS;
33442 }
33443 #endif /* _WIN64 */
33444
33445 static NTSTATUS thunk32_vkCopyImageToImageEXT(void *args)
33446 {
33447     struct
33448     {
33449         PTR32 device;
33450         PTR32 pCopyImageToImageInfo;
33451         VkResult result;
33452     } *params = args;
33453     VkCopyImageToImageInfoEXT pCopyImageToImageInfo_host;
33454     struct conversion_context local_ctx;
33455     struct conversion_context *ctx = &local_ctx;
33456
33457     TRACE("%#x, %#x\n", params->device, params->pCopyImageToImageInfo);
33458
33459     init_conversion_context(ctx);
33460     convert_VkCopyImageToImageInfoEXT_win32_to_host(ctx, (const VkCopyImageToImageInfoEXT32 *)UlongToPtr(params->pCopyImageToImageInfo), &pCopyImageToImageInfo_host);
33461     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyImageToImageEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCopyImageToImageInfo_host);
33462     free_conversion_context(ctx);
33463     return STATUS_SUCCESS;
33464 }
33465
33466 #ifdef _WIN64
33467 static NTSTATUS thunk64_vkCopyImageToMemoryEXT(void *args)
33468 {
33469     struct vkCopyImageToMemoryEXT_params *params = args;
33470
33471     TRACE("%p, %p\n", params->device, params->pCopyImageToMemoryInfo);
33472
33473     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyImageToMemoryEXT(wine_device_from_handle(params->device)->device, params->pCopyImageToMemoryInfo);
33474     return STATUS_SUCCESS;
33475 }
33476 #endif /* _WIN64 */
33477
33478 static NTSTATUS thunk32_vkCopyImageToMemoryEXT(void *args)
33479 {
33480     struct
33481     {
33482         PTR32 device;
33483         PTR32 pCopyImageToMemoryInfo;
33484         VkResult result;
33485     } *params = args;
33486     VkCopyImageToMemoryInfoEXT pCopyImageToMemoryInfo_host;
33487     struct conversion_context local_ctx;
33488     struct conversion_context *ctx = &local_ctx;
33489
33490     TRACE("%#x, %#x\n", params->device, params->pCopyImageToMemoryInfo);
33491
33492     init_conversion_context(ctx);
33493     convert_VkCopyImageToMemoryInfoEXT_win32_to_host(ctx, (const VkCopyImageToMemoryInfoEXT32 *)UlongToPtr(params->pCopyImageToMemoryInfo), &pCopyImageToMemoryInfo_host);
33494     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyImageToMemoryEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCopyImageToMemoryInfo_host);
33495     free_conversion_context(ctx);
33496     return STATUS_SUCCESS;
33497 }
33498
33499 #ifdef _WIN64
33500 static NTSTATUS thunk64_vkCopyMemoryToAccelerationStructureKHR(void *args)
33501 {
33502     struct vkCopyMemoryToAccelerationStructureKHR_params *params = args;
33503
33504     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
33505
33506     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, params->pInfo);
33507     return STATUS_SUCCESS;
33508 }
33509 #endif /* _WIN64 */
33510
33511 static NTSTATUS thunk32_vkCopyMemoryToAccelerationStructureKHR(void *args)
33512 {
33513     struct
33514     {
33515         PTR32 device;
33516         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
33517         PTR32 pInfo;
33518         VkResult result;
33519     } *params = args;
33520     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;
33521
33522     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
33523
33524     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host((const VkCopyMemoryToAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
33525     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, &pInfo_host);
33526     return STATUS_SUCCESS;
33527 }
33528
33529 #ifdef _WIN64
33530 static NTSTATUS thunk64_vkCopyMemoryToImageEXT(void *args)
33531 {
33532     struct vkCopyMemoryToImageEXT_params *params = args;
33533
33534     TRACE("%p, %p\n", params->device, params->pCopyMemoryToImageInfo);
33535
33536     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToImageEXT(wine_device_from_handle(params->device)->device, params->pCopyMemoryToImageInfo);
33537     return STATUS_SUCCESS;
33538 }
33539 #endif /* _WIN64 */
33540
33541 static NTSTATUS thunk32_vkCopyMemoryToImageEXT(void *args)
33542 {
33543     struct
33544     {
33545         PTR32 device;
33546         PTR32 pCopyMemoryToImageInfo;
33547         VkResult result;
33548     } *params = args;
33549     VkCopyMemoryToImageInfoEXT pCopyMemoryToImageInfo_host;
33550     struct conversion_context local_ctx;
33551     struct conversion_context *ctx = &local_ctx;
33552
33553     TRACE("%#x, %#x\n", params->device, params->pCopyMemoryToImageInfo);
33554
33555     init_conversion_context(ctx);
33556     convert_VkCopyMemoryToImageInfoEXT_win32_to_host(ctx, (const VkCopyMemoryToImageInfoEXT32 *)UlongToPtr(params->pCopyMemoryToImageInfo), &pCopyMemoryToImageInfo_host);
33557     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMemoryToImageEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCopyMemoryToImageInfo_host);
33558     free_conversion_context(ctx);
33559     return STATUS_SUCCESS;
33560 }
33561
33562 #ifdef _WIN64
33563 static NTSTATUS thunk64_vkCopyMemoryToMicromapEXT(void *args)
33564 {
33565     struct vkCopyMemoryToMicromapEXT_params *params = args;
33566
33567     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
33568
33569     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, params->pInfo);
33570     return STATUS_SUCCESS;
33571 }
33572 #endif /* _WIN64 */
33573
33574 static NTSTATUS thunk32_vkCopyMemoryToMicromapEXT(void *args)
33575 {
33576     struct
33577     {
33578         PTR32 device;
33579         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
33580         PTR32 pInfo;
33581         VkResult result;
33582     } *params = args;
33583     VkCopyMemoryToMicromapInfoEXT pInfo_host;
33584
33585     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
33586
33587     convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host((const VkCopyMemoryToMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
33588     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMemoryToMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, &pInfo_host);
33589     return STATUS_SUCCESS;
33590 }
33591
33592 #ifdef _WIN64
33593 static NTSTATUS thunk64_vkCopyMicromapEXT(void *args)
33594 {
33595     struct vkCopyMicromapEXT_params *params = args;
33596
33597     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
33598
33599     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, params->pInfo);
33600     return STATUS_SUCCESS;
33601 }
33602 #endif /* _WIN64 */
33603
33604 static NTSTATUS thunk32_vkCopyMicromapEXT(void *args)
33605 {
33606     struct
33607     {
33608         PTR32 device;
33609         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
33610         PTR32 pInfo;
33611         VkResult result;
33612     } *params = args;
33613     VkCopyMicromapInfoEXT pInfo_host;
33614
33615     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
33616
33617     convert_VkCopyMicromapInfoEXT_win32_to_host((const VkCopyMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
33618     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, &pInfo_host);
33619     return STATUS_SUCCESS;
33620 }
33621
33622 #ifdef _WIN64
33623 static NTSTATUS thunk64_vkCopyMicromapToMemoryEXT(void *args)
33624 {
33625     struct vkCopyMicromapToMemoryEXT_params *params = args;
33626
33627     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
33628
33629     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapToMemoryEXT(wine_device_from_handle(params->device)->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, params->pInfo);
33630     return STATUS_SUCCESS;
33631 }
33632 #endif /* _WIN64 */
33633
33634 static NTSTATUS thunk32_vkCopyMicromapToMemoryEXT(void *args)
33635 {
33636     struct
33637     {
33638         PTR32 device;
33639         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
33640         PTR32 pInfo;
33641         VkResult result;
33642     } *params = args;
33643     VkCopyMicromapToMemoryInfoEXT pInfo_host;
33644
33645     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
33646
33647     convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host((const VkCopyMicromapToMemoryInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
33648     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMicromapToMemoryEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, &pInfo_host);
33649     return STATUS_SUCCESS;
33650 }
33651
33652 #ifdef _WIN64
33653 static NTSTATUS thunk64_vkCreateAccelerationStructureKHR(void *args)
33654 {
33655     struct vkCreateAccelerationStructureKHR_params *params = args;
33656
33657     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
33658
33659     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
33660     return STATUS_SUCCESS;
33661 }
33662 #endif /* _WIN64 */
33663
33664 static NTSTATUS thunk32_vkCreateAccelerationStructureKHR(void *args)
33665 {
33666     struct
33667     {
33668         PTR32 device;
33669         PTR32 pCreateInfo;
33670         PTR32 pAllocator;
33671         PTR32 pAccelerationStructure;
33672         VkResult result;
33673     } *params = args;
33674     VkAccelerationStructureCreateInfoKHR pCreateInfo_host;
33675     struct conversion_context local_ctx;
33676     struct conversion_context *ctx = &local_ctx;
33677
33678     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
33679
33680     init_conversion_context(ctx);
33681     convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(ctx, (const VkAccelerationStructureCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33682     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));
33683     free_conversion_context(ctx);
33684     return STATUS_SUCCESS;
33685 }
33686
33687 #ifdef _WIN64
33688 static NTSTATUS thunk64_vkCreateAccelerationStructureNV(void *args)
33689 {
33690     struct vkCreateAccelerationStructureNV_params *params = args;
33691
33692     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
33693
33694     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
33695     return STATUS_SUCCESS;
33696 }
33697 #endif /* _WIN64 */
33698
33699 static NTSTATUS thunk32_vkCreateAccelerationStructureNV(void *args)
33700 {
33701     struct
33702     {
33703         PTR32 device;
33704         PTR32 pCreateInfo;
33705         PTR32 pAllocator;
33706         PTR32 pAccelerationStructure;
33707         VkResult result;
33708     } *params = args;
33709     VkAccelerationStructureCreateInfoNV pCreateInfo_host;
33710     struct conversion_context local_ctx;
33711     struct conversion_context *ctx = &local_ctx;
33712
33713     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
33714
33715     init_conversion_context(ctx);
33716     convert_VkAccelerationStructureCreateInfoNV_win32_to_host(ctx, (const VkAccelerationStructureCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33717     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));
33718     free_conversion_context(ctx);
33719     return STATUS_SUCCESS;
33720 }
33721
33722 #ifdef _WIN64
33723 static NTSTATUS thunk64_vkCreateBuffer(void *args)
33724 {
33725     struct vkCreateBuffer_params *params = args;
33726
33727     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
33728
33729     params->result = wine_vkCreateBuffer(params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
33730     return STATUS_SUCCESS;
33731 }
33732 #endif /* _WIN64 */
33733
33734 static NTSTATUS thunk32_vkCreateBuffer(void *args)
33735 {
33736     struct
33737     {
33738         PTR32 device;
33739         PTR32 pCreateInfo;
33740         PTR32 pAllocator;
33741         PTR32 pBuffer;
33742         VkResult result;
33743     } *params = args;
33744     VkBufferCreateInfo pCreateInfo_host;
33745     struct conversion_context local_ctx;
33746     struct conversion_context *ctx = &local_ctx;
33747
33748     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
33749
33750     init_conversion_context(ctx);
33751     convert_VkBufferCreateInfo_win32_to_host(ctx, (const VkBufferCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33752     params->result = wine_vkCreateBuffer((VkDevice)UlongToPtr(params->device), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkBuffer *)UlongToPtr(params->pBuffer));
33753     free_conversion_context(ctx);
33754     return STATUS_SUCCESS;
33755 }
33756
33757 #ifdef _WIN64
33758 static NTSTATUS thunk64_vkCreateBufferView(void *args)
33759 {
33760     struct vkCreateBufferView_params *params = args;
33761
33762     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
33763
33764     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBufferView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
33765     return STATUS_SUCCESS;
33766 }
33767 #endif /* _WIN64 */
33768
33769 static NTSTATUS thunk32_vkCreateBufferView(void *args)
33770 {
33771     struct
33772     {
33773         PTR32 device;
33774         PTR32 pCreateInfo;
33775         PTR32 pAllocator;
33776         PTR32 pView;
33777         VkResult result;
33778     } *params = args;
33779     VkBufferViewCreateInfo pCreateInfo_host;
33780     struct conversion_context local_ctx;
33781     struct conversion_context *ctx = &local_ctx;
33782
33783     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
33784
33785     init_conversion_context(ctx);
33786     convert_VkBufferViewCreateInfo_win32_to_host(ctx, (const VkBufferViewCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33787     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));
33788     free_conversion_context(ctx);
33789     return STATUS_SUCCESS;
33790 }
33791
33792 #ifdef _WIN64
33793 static NTSTATUS thunk64_vkCreateCommandPool(void *args)
33794 {
33795     struct vkCreateCommandPool_params *params = args;
33796
33797     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);
33798
33799     params->result = wine_vkCreateCommandPool(params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool, params->client_ptr);
33800     return STATUS_SUCCESS;
33801 }
33802 #endif /* _WIN64 */
33803
33804 static NTSTATUS thunk32_vkCreateCommandPool(void *args)
33805 {
33806     struct
33807     {
33808         PTR32 device;
33809         PTR32 pCreateInfo;
33810         PTR32 pAllocator;
33811         PTR32 pCommandPool;
33812         PTR32 client_ptr;
33813         VkResult result;
33814     } *params = args;
33815     VkCommandPoolCreateInfo pCreateInfo_host;
33816
33817     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);
33818
33819     convert_VkCommandPoolCreateInfo_win32_to_host((const VkCommandPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33820     params->result = wine_vkCreateCommandPool((VkDevice)UlongToPtr(params->device), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkCommandPool *)UlongToPtr(params->pCommandPool), UlongToPtr(params->client_ptr));
33821     return STATUS_SUCCESS;
33822 }
33823
33824 #ifdef _WIN64
33825 static NTSTATUS thunk64_vkCreateComputePipelines(void *args)
33826 {
33827     struct vkCreateComputePipelines_params *params = args;
33828     const VkComputePipelineCreateInfo *pCreateInfos_host;
33829     struct conversion_context local_ctx;
33830     struct conversion_context *ctx = &local_ctx;
33831
33832     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33833
33834     init_conversion_context(ctx);
33835     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win64_to_host(ctx, params->pCreateInfos, params->createInfoCount);
33836     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);
33837     free_conversion_context(ctx);
33838     return STATUS_SUCCESS;
33839 }
33840 #endif /* _WIN64 */
33841
33842 static NTSTATUS thunk32_vkCreateComputePipelines(void *args)
33843 {
33844     struct
33845     {
33846         PTR32 device;
33847         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
33848         uint32_t createInfoCount;
33849         PTR32 pCreateInfos;
33850         PTR32 pAllocator;
33851         PTR32 pPipelines;
33852         VkResult result;
33853     } *params = args;
33854     const VkComputePipelineCreateInfo *pCreateInfos_host;
33855     struct conversion_context local_ctx;
33856     struct conversion_context *ctx = &local_ctx;
33857
33858     TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33859
33860     init_conversion_context(ctx);
33861     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win32_to_host(ctx, (const VkComputePipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33862     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));
33863     convert_VkComputePipelineCreateInfo_array_host_to_win32(pCreateInfos_host, (const VkComputePipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33864     free_conversion_context(ctx);
33865     return STATUS_SUCCESS;
33866 }
33867
33868 #ifdef _WIN64
33869 static NTSTATUS thunk64_vkCreateCuFunctionNVX(void *args)
33870 {
33871     struct vkCreateCuFunctionNVX_params *params = args;
33872
33873     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);
33874
33875     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFunction);
33876     return STATUS_SUCCESS;
33877 }
33878 #endif /* _WIN64 */
33879
33880 static NTSTATUS thunk32_vkCreateCuFunctionNVX(void *args)
33881 {
33882     struct
33883     {
33884         PTR32 device;
33885         PTR32 pCreateInfo;
33886         PTR32 pAllocator;
33887         PTR32 pFunction;
33888         VkResult result;
33889     } *params = args;
33890     VkCuFunctionCreateInfoNVX pCreateInfo_host;
33891
33892     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);
33893
33894     convert_VkCuFunctionCreateInfoNVX_win32_to_host((const VkCuFunctionCreateInfoNVX32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33895     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));
33896     return STATUS_SUCCESS;
33897 }
33898
33899 #ifdef _WIN64
33900 static NTSTATUS thunk64_vkCreateCuModuleNVX(void *args)
33901 {
33902     struct vkCreateCuModuleNVX_params *params = args;
33903
33904     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);
33905
33906     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pModule);
33907     return STATUS_SUCCESS;
33908 }
33909 #endif /* _WIN64 */
33910
33911 static NTSTATUS thunk32_vkCreateCuModuleNVX(void *args)
33912 {
33913     struct
33914     {
33915         PTR32 device;
33916         PTR32 pCreateInfo;
33917         PTR32 pAllocator;
33918         PTR32 pModule;
33919         VkResult result;
33920     } *params = args;
33921     VkCuModuleCreateInfoNVX pCreateInfo_host;
33922
33923     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);
33924
33925     convert_VkCuModuleCreateInfoNVX_win32_to_host((const VkCuModuleCreateInfoNVX32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33926     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));
33927     return STATUS_SUCCESS;
33928 }
33929
33930 #ifdef _WIN64
33931 static NTSTATUS thunk64_vkCreateDebugReportCallbackEXT(void *args)
33932 {
33933     struct vkCreateDebugReportCallbackEXT_params *params = args;
33934
33935     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
33936
33937     params->result = wine_vkCreateDebugReportCallbackEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
33938     return STATUS_SUCCESS;
33939 }
33940 #endif /* _WIN64 */
33941
33942 static NTSTATUS thunk32_vkCreateDebugReportCallbackEXT(void *args)
33943 {
33944     struct
33945     {
33946         PTR32 instance;
33947         PTR32 pCreateInfo;
33948         PTR32 pAllocator;
33949         PTR32 pCallback;
33950         VkResult result;
33951     } *params = args;
33952     VkDebugReportCallbackCreateInfoEXT pCreateInfo_host;
33953
33954     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
33955
33956     convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host((const VkDebugReportCallbackCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33957     params->result = wine_vkCreateDebugReportCallbackEXT((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDebugReportCallbackEXT *)UlongToPtr(params->pCallback));
33958     return STATUS_SUCCESS;
33959 }
33960
33961 #ifdef _WIN64
33962 static NTSTATUS thunk64_vkCreateDebugUtilsMessengerEXT(void *args)
33963 {
33964     struct vkCreateDebugUtilsMessengerEXT_params *params = args;
33965
33966     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
33967
33968     params->result = wine_vkCreateDebugUtilsMessengerEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
33969     return STATUS_SUCCESS;
33970 }
33971 #endif /* _WIN64 */
33972
33973 static NTSTATUS thunk32_vkCreateDebugUtilsMessengerEXT(void *args)
33974 {
33975     struct
33976     {
33977         PTR32 instance;
33978         PTR32 pCreateInfo;
33979         PTR32 pAllocator;
33980         PTR32 pMessenger;
33981         VkResult result;
33982     } *params = args;
33983     VkDebugUtilsMessengerCreateInfoEXT pCreateInfo_host;
33984
33985     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
33986
33987     convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host((const VkDebugUtilsMessengerCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33988     params->result = wine_vkCreateDebugUtilsMessengerEXT((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDebugUtilsMessengerEXT *)UlongToPtr(params->pMessenger));
33989     return STATUS_SUCCESS;
33990 }
33991
33992 #ifdef _WIN64
33993 static NTSTATUS thunk64_vkCreateDeferredOperationKHR(void *args)
33994 {
33995     struct vkCreateDeferredOperationKHR_params *params = args;
33996
33997     TRACE("%p, %p, %p\n", params->device, params->pAllocator, params->pDeferredOperation);
33998
33999     params->result = wine_vkCreateDeferredOperationKHR(params->device, params->pAllocator, params->pDeferredOperation);
34000     return STATUS_SUCCESS;
34001 }
34002 #endif /* _WIN64 */
34003
34004 static NTSTATUS thunk32_vkCreateDeferredOperationKHR(void *args)
34005 {
34006     struct
34007     {
34008         PTR32 device;
34009         PTR32 pAllocator;
34010         PTR32 pDeferredOperation;
34011         VkResult result;
34012     } *params = args;
34013
34014     TRACE("%#x, %#x, %#x\n", params->device, params->pAllocator, params->pDeferredOperation);
34015
34016     params->result = wine_vkCreateDeferredOperationKHR((VkDevice)UlongToPtr(params->device), (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDeferredOperationKHR *)UlongToPtr(params->pDeferredOperation));
34017     return STATUS_SUCCESS;
34018 }
34019
34020 #ifdef _WIN64
34021 static NTSTATUS thunk64_vkCreateDescriptorPool(void *args)
34022 {
34023     struct vkCreateDescriptorPool_params *params = args;
34024
34025     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);
34026
34027     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorPool);
34028     return STATUS_SUCCESS;
34029 }
34030 #endif /* _WIN64 */
34031
34032 static NTSTATUS thunk32_vkCreateDescriptorPool(void *args)
34033 {
34034     struct
34035     {
34036         PTR32 device;
34037         PTR32 pCreateInfo;
34038         PTR32 pAllocator;
34039         PTR32 pDescriptorPool;
34040         VkResult result;
34041     } *params = args;
34042     VkDescriptorPoolCreateInfo pCreateInfo_host;
34043     struct conversion_context local_ctx;
34044     struct conversion_context *ctx = &local_ctx;
34045
34046     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);
34047
34048     init_conversion_context(ctx);
34049     convert_VkDescriptorPoolCreateInfo_win32_to_host(ctx, (const VkDescriptorPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34050     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));
34051     free_conversion_context(ctx);
34052     return STATUS_SUCCESS;
34053 }
34054
34055 #ifdef _WIN64
34056 static NTSTATUS thunk64_vkCreateDescriptorSetLayout(void *args)
34057 {
34058     struct vkCreateDescriptorSetLayout_params *params = args;
34059
34060     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);
34061
34062     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSetLayout);
34063     return STATUS_SUCCESS;
34064 }
34065 #endif /* _WIN64 */
34066
34067 static NTSTATUS thunk32_vkCreateDescriptorSetLayout(void *args)
34068 {
34069     struct
34070     {
34071         PTR32 device;
34072         PTR32 pCreateInfo;
34073         PTR32 pAllocator;
34074         PTR32 pSetLayout;
34075         VkResult result;
34076     } *params = args;
34077     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
34078     struct conversion_context local_ctx;
34079     struct conversion_context *ctx = &local_ctx;
34080
34081     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);
34082
34083     init_conversion_context(ctx);
34084     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34085     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));
34086     free_conversion_context(ctx);
34087     return STATUS_SUCCESS;
34088 }
34089
34090 #ifdef _WIN64
34091 static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplate(void *args)
34092 {
34093     struct vkCreateDescriptorUpdateTemplate_params *params = args;
34094
34095     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
34096
34097     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
34098     return STATUS_SUCCESS;
34099 }
34100 #endif /* _WIN64 */
34101
34102 static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplate(void *args)
34103 {
34104     struct
34105     {
34106         PTR32 device;
34107         PTR32 pCreateInfo;
34108         PTR32 pAllocator;
34109         PTR32 pDescriptorUpdateTemplate;
34110         VkResult result;
34111     } *params = args;
34112     VkDescriptorUpdateTemplateCreateInfo pCreateInfo_host;
34113     struct conversion_context local_ctx;
34114     struct conversion_context *ctx = &local_ctx;
34115
34116     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
34117
34118     init_conversion_context(ctx);
34119     convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(ctx, (const VkDescriptorUpdateTemplateCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34120     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));
34121     free_conversion_context(ctx);
34122     return STATUS_SUCCESS;
34123 }
34124
34125 #ifdef _WIN64
34126 static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplateKHR(void *args)
34127 {
34128     struct vkCreateDescriptorUpdateTemplateKHR_params *params = args;
34129
34130     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
34131
34132     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
34133     return STATUS_SUCCESS;
34134 }
34135 #endif /* _WIN64 */
34136
34137 static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplateKHR(void *args)
34138 {
34139     struct
34140     {
34141         PTR32 device;
34142         PTR32 pCreateInfo;
34143         PTR32 pAllocator;
34144         PTR32 pDescriptorUpdateTemplate;
34145         VkResult result;
34146     } *params = args;
34147     VkDescriptorUpdateTemplateCreateInfo pCreateInfo_host;
34148     struct conversion_context local_ctx;
34149     struct conversion_context *ctx = &local_ctx;
34150
34151     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
34152
34153     init_conversion_context(ctx);
34154     convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(ctx, (const VkDescriptorUpdateTemplateCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34155     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));
34156     free_conversion_context(ctx);
34157     return STATUS_SUCCESS;
34158 }
34159
34160 #ifdef _WIN64
34161 static NTSTATUS thunk64_vkCreateDevice(void *args)
34162 {
34163     struct vkCreateDevice_params *params = args;
34164     VkDeviceCreateInfo pCreateInfo_host;
34165     struct conversion_context local_ctx;
34166     struct conversion_context *ctx = &local_ctx;
34167
34168     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);
34169
34170     init_conversion_context(ctx);
34171     convert_VkDeviceCreateInfo_win64_to_host(ctx, params->pCreateInfo, &pCreateInfo_host);
34172     params->result = wine_vkCreateDevice(params->physicalDevice, &pCreateInfo_host, params->pAllocator, params->pDevice, params->client_ptr);
34173     free_conversion_context(ctx);
34174     return STATUS_SUCCESS;
34175 }
34176 #endif /* _WIN64 */
34177
34178 static NTSTATUS thunk32_vkCreateDevice(void *args)
34179 {
34180     struct
34181     {
34182         PTR32 physicalDevice;
34183         PTR32 pCreateInfo;
34184         PTR32 pAllocator;
34185         PTR32 pDevice;
34186         PTR32 client_ptr;
34187         VkResult result;
34188     } *params = args;
34189     VkDeviceCreateInfo pCreateInfo_host;
34190     VkDevice pDevice_host;
34191     struct conversion_context local_ctx;
34192     struct conversion_context *ctx = &local_ctx;
34193
34194     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);
34195
34196     init_conversion_context(ctx);
34197     convert_VkDeviceCreateInfo_win32_to_host(ctx, (const VkDeviceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34198     pDevice_host = UlongToPtr(*(PTR32 *)UlongToPtr(params->pDevice));
34199     params->result = wine_vkCreateDevice((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), &pDevice_host, UlongToPtr(params->client_ptr));
34200     *(PTR32 *)UlongToPtr(params->pDevice) = PtrToUlong(pDevice_host);
34201     free_conversion_context(ctx);
34202     return STATUS_SUCCESS;
34203 }
34204
34205 #ifdef _WIN64
34206 static NTSTATUS thunk64_vkCreateEvent(void *args)
34207 {
34208     struct vkCreateEvent_params *params = args;
34209
34210     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);
34211
34212     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateEvent(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pEvent);
34213     return STATUS_SUCCESS;
34214 }
34215 #endif /* _WIN64 */
34216
34217 static NTSTATUS thunk32_vkCreateEvent(void *args)
34218 {
34219     struct
34220     {
34221         PTR32 device;
34222         PTR32 pCreateInfo;
34223         PTR32 pAllocator;
34224         PTR32 pEvent;
34225         VkResult result;
34226     } *params = args;
34227     VkEventCreateInfo pCreateInfo_host;
34228
34229     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);
34230
34231     convert_VkEventCreateInfo_win32_to_host((const VkEventCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34232     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));
34233     return STATUS_SUCCESS;
34234 }
34235
34236 #ifdef _WIN64
34237 static NTSTATUS thunk64_vkCreateFence(void *args)
34238 {
34239     struct vkCreateFence_params *params = args;
34240
34241     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);
34242
34243     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFence(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFence);
34244     return STATUS_SUCCESS;
34245 }
34246 #endif /* _WIN64 */
34247
34248 static NTSTATUS thunk32_vkCreateFence(void *args)
34249 {
34250     struct
34251     {
34252         PTR32 device;
34253         PTR32 pCreateInfo;
34254         PTR32 pAllocator;
34255         PTR32 pFence;
34256         VkResult result;
34257     } *params = args;
34258     VkFenceCreateInfo pCreateInfo_host;
34259     struct conversion_context local_ctx;
34260     struct conversion_context *ctx = &local_ctx;
34261
34262     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);
34263
34264     init_conversion_context(ctx);
34265     convert_VkFenceCreateInfo_win32_to_host(ctx, (const VkFenceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34266     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));
34267     free_conversion_context(ctx);
34268     return STATUS_SUCCESS;
34269 }
34270
34271 #ifdef _WIN64
34272 static NTSTATUS thunk64_vkCreateFramebuffer(void *args)
34273 {
34274     struct vkCreateFramebuffer_params *params = args;
34275
34276     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);
34277
34278     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFramebuffer(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFramebuffer);
34279     return STATUS_SUCCESS;
34280 }
34281 #endif /* _WIN64 */
34282
34283 static NTSTATUS thunk32_vkCreateFramebuffer(void *args)
34284 {
34285     struct
34286     {
34287         PTR32 device;
34288         PTR32 pCreateInfo;
34289         PTR32 pAllocator;
34290         PTR32 pFramebuffer;
34291         VkResult result;
34292     } *params = args;
34293     VkFramebufferCreateInfo pCreateInfo_host;
34294     struct conversion_context local_ctx;
34295     struct conversion_context *ctx = &local_ctx;
34296
34297     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);
34298
34299     init_conversion_context(ctx);
34300     convert_VkFramebufferCreateInfo_win32_to_host(ctx, (const VkFramebufferCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34301     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));
34302     free_conversion_context(ctx);
34303     return STATUS_SUCCESS;
34304 }
34305
34306 #ifdef _WIN64
34307 static NTSTATUS thunk64_vkCreateGraphicsPipelines(void *args)
34308 {
34309     struct vkCreateGraphicsPipelines_params *params = args;
34310     const VkGraphicsPipelineCreateInfo *pCreateInfos_host;
34311     struct conversion_context local_ctx;
34312     struct conversion_context *ctx = &local_ctx;
34313
34314     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
34315
34316     init_conversion_context(ctx);
34317     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(ctx, params->pCreateInfos, params->createInfoCount);
34318     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);
34319     free_conversion_context(ctx);
34320     return STATUS_SUCCESS;
34321 }
34322 #endif /* _WIN64 */
34323
34324 static NTSTATUS thunk32_vkCreateGraphicsPipelines(void *args)
34325 {
34326     struct
34327     {
34328         PTR32 device;
34329         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
34330         uint32_t createInfoCount;
34331         PTR32 pCreateInfos;
34332         PTR32 pAllocator;
34333         PTR32 pPipelines;
34334         VkResult result;
34335     } *params = args;
34336     const VkGraphicsPipelineCreateInfo *pCreateInfos_host;
34337     struct conversion_context local_ctx;
34338     struct conversion_context *ctx = &local_ctx;
34339
34340     TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
34341
34342     init_conversion_context(ctx);
34343     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(ctx, (const VkGraphicsPipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
34344     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));
34345     convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(pCreateInfos_host, (const VkGraphicsPipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
34346     free_conversion_context(ctx);
34347     return STATUS_SUCCESS;
34348 }
34349
34350 #ifdef _WIN64
34351 static NTSTATUS thunk64_vkCreateImage(void *args)
34352 {
34353     struct vkCreateImage_params *params = args;
34354
34355     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);
34356
34357     params->result = wine_vkCreateImage(params->device, params->pCreateInfo, params->pAllocator, params->pImage);
34358     return STATUS_SUCCESS;
34359 }
34360 #endif /* _WIN64 */
34361
34362 static NTSTATUS thunk32_vkCreateImage(void *args)
34363 {
34364     struct
34365     {
34366         PTR32 device;
34367         PTR32 pCreateInfo;
34368         PTR32 pAllocator;
34369         PTR32 pImage;
34370         VkResult result;
34371     } *params = args;
34372     VkImageCreateInfo pCreateInfo_host;
34373     struct conversion_context local_ctx;
34374     struct conversion_context *ctx = &local_ctx;
34375
34376     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);
34377
34378     init_conversion_context(ctx);
34379     convert_VkImageCreateInfo_win32_to_host(ctx, (const VkImageCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34380     params->result = wine_vkCreateImage((VkDevice)UlongToPtr(params->device), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkImage *)UlongToPtr(params->pImage));
34381     free_conversion_context(ctx);
34382     return STATUS_SUCCESS;
34383 }
34384
34385 #ifdef _WIN64
34386 static NTSTATUS thunk64_vkCreateImageView(void *args)
34387 {
34388     struct vkCreateImageView_params *params = args;
34389
34390     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
34391
34392     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImageView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
34393     return STATUS_SUCCESS;
34394 }
34395 #endif /* _WIN64 */
34396
34397 static NTSTATUS thunk32_vkCreateImageView(void *args)
34398 {
34399     struct
34400     {
34401         PTR32 device;
34402         PTR32 pCreateInfo;
34403         PTR32 pAllocator;
34404         PTR32 pView;
34405         VkResult result;
34406     } *params = args;
34407     VkImageViewCreateInfo pCreateInfo_host;
34408     struct conversion_context local_ctx;
34409     struct conversion_context *ctx = &local_ctx;
34410
34411     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
34412
34413     init_conversion_context(ctx);
34414     convert_VkImageViewCreateInfo_win32_to_host(ctx, (const VkImageViewCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34415     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));
34416     free_conversion_context(ctx);
34417     return STATUS_SUCCESS;
34418 }
34419
34420 #ifdef _WIN64
34421 static NTSTATUS thunk64_vkCreateIndirectCommandsLayoutNV(void *args)
34422 {
34423     struct vkCreateIndirectCommandsLayoutNV_params *params = args;
34424
34425     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
34426
34427     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pIndirectCommandsLayout);
34428     return STATUS_SUCCESS;
34429 }
34430 #endif /* _WIN64 */
34431
34432 static NTSTATUS thunk32_vkCreateIndirectCommandsLayoutNV(void *args)
34433 {
34434     struct
34435     {
34436         PTR32 device;
34437         PTR32 pCreateInfo;
34438         PTR32 pAllocator;
34439         PTR32 pIndirectCommandsLayout;
34440         VkResult result;
34441     } *params = args;
34442     VkIndirectCommandsLayoutCreateInfoNV pCreateInfo_host;
34443     struct conversion_context local_ctx;
34444     struct conversion_context *ctx = &local_ctx;
34445
34446     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
34447
34448     init_conversion_context(ctx);
34449     convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(ctx, (const VkIndirectCommandsLayoutCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34450     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));
34451     free_conversion_context(ctx);
34452     return STATUS_SUCCESS;
34453 }
34454
34455 #ifdef _WIN64
34456 static NTSTATUS thunk64_vkCreateInstance(void *args)
34457 {
34458     struct vkCreateInstance_params *params = args;
34459     VkInstanceCreateInfo pCreateInfo_host;
34460     struct conversion_context local_ctx;
34461     struct conversion_context *ctx = &local_ctx;
34462
34463     TRACE("%p, %p, %p\n", params->pCreateInfo, params->pAllocator, params->pInstance);
34464
34465     init_conversion_context(ctx);
34466     convert_VkInstanceCreateInfo_win64_to_host(ctx, params->pCreateInfo, &pCreateInfo_host);
34467     params->result = wine_vkCreateInstance(&pCreateInfo_host, params->pAllocator, params->pInstance, params->client_ptr);
34468     free_conversion_context(ctx);
34469     return STATUS_SUCCESS;
34470 }
34471 #endif /* _WIN64 */
34472
34473 static NTSTATUS thunk32_vkCreateInstance(void *args)
34474 {
34475     struct
34476     {
34477         PTR32 pCreateInfo;
34478         PTR32 pAllocator;
34479         PTR32 pInstance;
34480         PTR32 client_ptr;
34481         VkResult result;
34482     } *params = args;
34483     VkInstanceCreateInfo pCreateInfo_host;
34484     VkInstance pInstance_host;
34485     struct conversion_context local_ctx;
34486     struct conversion_context *ctx = &local_ctx;
34487
34488     TRACE("%#x, %#x, %#x\n", params->pCreateInfo, params->pAllocator, params->pInstance);
34489
34490     init_conversion_context(ctx);
34491     convert_VkInstanceCreateInfo_win32_to_host(ctx, (const VkInstanceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34492     pInstance_host = UlongToPtr(*(PTR32 *)UlongToPtr(params->pInstance));
34493     params->result = wine_vkCreateInstance(&pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), &pInstance_host, UlongToPtr(params->client_ptr));
34494     *(PTR32 *)UlongToPtr(params->pInstance) = PtrToUlong(pInstance_host);
34495     free_conversion_context(ctx);
34496     return STATUS_SUCCESS;
34497 }
34498
34499 #ifdef _WIN64
34500 static NTSTATUS thunk64_vkCreateMicromapEXT(void *args)
34501 {
34502     struct vkCreateMicromapEXT_params *params = args;
34503
34504     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
34505
34506     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateMicromapEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pMicromap);
34507     return STATUS_SUCCESS;
34508 }
34509 #endif /* _WIN64 */
34510
34511 static NTSTATUS thunk32_vkCreateMicromapEXT(void *args)
34512 {
34513     struct
34514     {
34515         PTR32 device;
34516         PTR32 pCreateInfo;
34517         PTR32 pAllocator;
34518         PTR32 pMicromap;
34519         VkResult result;
34520     } *params = args;
34521     VkMicromapCreateInfoEXT pCreateInfo_host;
34522
34523     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
34524
34525     convert_VkMicromapCreateInfoEXT_win32_to_host((const VkMicromapCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34526     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));
34527     return STATUS_SUCCESS;
34528 }
34529
34530 #ifdef _WIN64
34531 static NTSTATUS thunk64_vkCreateOpticalFlowSessionNV(void *args)
34532 {
34533     struct vkCreateOpticalFlowSessionNV_params *params = args;
34534
34535     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
34536
34537     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSession);
34538     return STATUS_SUCCESS;
34539 }
34540 #endif /* _WIN64 */
34541
34542 static NTSTATUS thunk32_vkCreateOpticalFlowSessionNV(void *args)
34543 {
34544     struct
34545     {
34546         PTR32 device;
34547         PTR32 pCreateInfo;
34548         PTR32 pAllocator;
34549         PTR32 pSession;
34550         VkResult result;
34551     } *params = args;
34552     VkOpticalFlowSessionCreateInfoNV pCreateInfo_host;
34553     struct conversion_context local_ctx;
34554     struct conversion_context *ctx = &local_ctx;
34555
34556     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
34557
34558     init_conversion_context(ctx);
34559     convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(ctx, (const VkOpticalFlowSessionCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34560     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));
34561     free_conversion_context(ctx);
34562     return STATUS_SUCCESS;
34563 }
34564
34565 #ifdef _WIN64
34566 static NTSTATUS thunk64_vkCreatePipelineCache(void *args)
34567 {
34568     struct vkCreatePipelineCache_params *params = args;
34569
34570     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);
34571
34572     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineCache(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineCache);
34573     return STATUS_SUCCESS;
34574 }
34575 #endif /* _WIN64 */
34576
34577 static NTSTATUS thunk32_vkCreatePipelineCache(void *args)
34578 {
34579     struct
34580     {
34581         PTR32 device;
34582         PTR32 pCreateInfo;
34583         PTR32 pAllocator;
34584         PTR32 pPipelineCache;
34585         VkResult result;
34586     } *params = args;
34587     VkPipelineCacheCreateInfo pCreateInfo_host;
34588
34589     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);
34590
34591     convert_VkPipelineCacheCreateInfo_win32_to_host((const VkPipelineCacheCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34592     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));
34593     return STATUS_SUCCESS;
34594 }
34595
34596 #ifdef _WIN64
34597 static NTSTATUS thunk64_vkCreatePipelineLayout(void *args)
34598 {
34599     struct vkCreatePipelineLayout_params *params = args;
34600
34601     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);
34602
34603     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineLayout);
34604     return STATUS_SUCCESS;
34605 }
34606 #endif /* _WIN64 */
34607
34608 static NTSTATUS thunk32_vkCreatePipelineLayout(void *args)
34609 {
34610     struct
34611     {
34612         PTR32 device;
34613         PTR32 pCreateInfo;
34614         PTR32 pAllocator;
34615         PTR32 pPipelineLayout;
34616         VkResult result;
34617     } *params = args;
34618     VkPipelineLayoutCreateInfo pCreateInfo_host;
34619
34620     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);
34621
34622     convert_VkPipelineLayoutCreateInfo_win32_to_host((const VkPipelineLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34623     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));
34624     return STATUS_SUCCESS;
34625 }
34626
34627 #ifdef _WIN64
34628 static NTSTATUS thunk64_vkCreatePrivateDataSlot(void *args)
34629 {
34630     struct vkCreatePrivateDataSlot_params *params = args;
34631
34632     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
34633
34634     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
34635     return STATUS_SUCCESS;
34636 }
34637 #endif /* _WIN64 */
34638
34639 static NTSTATUS thunk32_vkCreatePrivateDataSlot(void *args)
34640 {
34641     struct
34642     {
34643         PTR32 device;
34644         PTR32 pCreateInfo;
34645         PTR32 pAllocator;
34646         PTR32 pPrivateDataSlot;
34647         VkResult result;
34648     } *params = args;
34649     VkPrivateDataSlotCreateInfo pCreateInfo_host;
34650
34651     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
34652
34653     convert_VkPrivateDataSlotCreateInfo_win32_to_host((const VkPrivateDataSlotCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34654     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));
34655     return STATUS_SUCCESS;
34656 }
34657
34658 #ifdef _WIN64
34659 static NTSTATUS thunk64_vkCreatePrivateDataSlotEXT(void *args)
34660 {
34661     struct vkCreatePrivateDataSlotEXT_params *params = args;
34662
34663     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
34664
34665     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
34666     return STATUS_SUCCESS;
34667 }
34668 #endif /* _WIN64 */
34669
34670 static NTSTATUS thunk32_vkCreatePrivateDataSlotEXT(void *args)
34671 {
34672     struct
34673     {
34674         PTR32 device;
34675         PTR32 pCreateInfo;
34676         PTR32 pAllocator;
34677         PTR32 pPrivateDataSlot;
34678         VkResult result;
34679     } *params = args;
34680     VkPrivateDataSlotCreateInfo pCreateInfo_host;
34681
34682     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
34683
34684     convert_VkPrivateDataSlotCreateInfo_win32_to_host((const VkPrivateDataSlotCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34685     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));
34686     return STATUS_SUCCESS;
34687 }
34688
34689 #ifdef _WIN64
34690 static NTSTATUS thunk64_vkCreateQueryPool(void *args)
34691 {
34692     struct vkCreateQueryPool_params *params = args;
34693
34694     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);
34695
34696     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateQueryPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pQueryPool);
34697     return STATUS_SUCCESS;
34698 }
34699 #endif /* _WIN64 */
34700
34701 static NTSTATUS thunk32_vkCreateQueryPool(void *args)
34702 {
34703     struct
34704     {
34705         PTR32 device;
34706         PTR32 pCreateInfo;
34707         PTR32 pAllocator;
34708         PTR32 pQueryPool;
34709         VkResult result;
34710     } *params = args;
34711     VkQueryPoolCreateInfo pCreateInfo_host;
34712     struct conversion_context local_ctx;
34713     struct conversion_context *ctx = &local_ctx;
34714
34715     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);
34716
34717     init_conversion_context(ctx);
34718     convert_VkQueryPoolCreateInfo_win32_to_host(ctx, (const VkQueryPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34719     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));
34720     free_conversion_context(ctx);
34721     return STATUS_SUCCESS;
34722 }
34723
34724 #ifdef _WIN64
34725 static NTSTATUS thunk64_vkCreateRayTracingPipelinesKHR(void *args)
34726 {
34727     struct vkCreateRayTracingPipelinesKHR_params *params = args;
34728     const VkRayTracingPipelineCreateInfoKHR *pCreateInfos_host;
34729     struct conversion_context local_ctx;
34730     struct conversion_context *ctx = &local_ctx;
34731
34732     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);
34733
34734     if (params->deferredOperation == VK_NULL_HANDLE)
34735         init_conversion_context(ctx);
34736     else
34737         ctx = &wine_deferred_operation_from_handle(params->deferredOperation)->ctx;
34738     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(ctx, params->pCreateInfos, params->createInfoCount);
34739     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRayTracingPipelinesKHR(wine_device_from_handle(params->device)->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, params->pPipelines);
34740     if (params->deferredOperation == VK_NULL_HANDLE)
34741         free_conversion_context(ctx);
34742     return STATUS_SUCCESS;
34743 }
34744 #endif /* _WIN64 */
34745
34746 static NTSTATUS thunk32_vkCreateRayTracingPipelinesKHR(void *args)
34747 {
34748     struct
34749     {
34750         PTR32 device;
34751         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
34752         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
34753         uint32_t createInfoCount;
34754         PTR32 pCreateInfos;
34755         PTR32 pAllocator;
34756         PTR32 pPipelines;
34757         VkResult result;
34758     } *params = args;
34759     const VkRayTracingPipelineCreateInfoKHR *pCreateInfos_host;
34760     struct conversion_context local_ctx;
34761     struct conversion_context *ctx = &local_ctx;
34762
34763     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);
34764
34765     if (params->deferredOperation == VK_NULL_HANDLE)
34766         init_conversion_context(ctx);
34767     else
34768         ctx = &wine_deferred_operation_from_handle(params->deferredOperation)->ctx;
34769     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(ctx, (const VkRayTracingPipelineCreateInfoKHR32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
34770     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateRayTracingPipelinesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->deferred_operation : 0, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, (VkPipeline *)UlongToPtr(params->pPipelines));
34771     convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(pCreateInfos_host, (const VkRayTracingPipelineCreateInfoKHR32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
34772     if (params->deferredOperation == VK_NULL_HANDLE)
34773         free_conversion_context(ctx);
34774     return STATUS_SUCCESS;
34775 }
34776
34777 #ifdef _WIN64
34778 static NTSTATUS thunk64_vkCreateRayTracingPipelinesNV(void *args)
34779 {
34780     struct vkCreateRayTracingPipelinesNV_params *params = args;
34781     const VkRayTracingPipelineCreateInfoNV *pCreateInfos_host;
34782     struct conversion_context local_ctx;
34783     struct conversion_context *ctx = &local_ctx;
34784
34785     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
34786
34787     init_conversion_context(ctx);
34788     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(ctx, params->pCreateInfos, params->createInfoCount);
34789     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);
34790     free_conversion_context(ctx);
34791     return STATUS_SUCCESS;
34792 }
34793 #endif /* _WIN64 */
34794
34795 static NTSTATUS thunk32_vkCreateRayTracingPipelinesNV(void *args)
34796 {
34797     struct
34798     {
34799         PTR32 device;
34800         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
34801         uint32_t createInfoCount;
34802         PTR32 pCreateInfos;
34803         PTR32 pAllocator;
34804         PTR32 pPipelines;
34805         VkResult result;
34806     } *params = args;
34807     const VkRayTracingPipelineCreateInfoNV *pCreateInfos_host;
34808     struct conversion_context local_ctx;
34809     struct conversion_context *ctx = &local_ctx;
34810
34811     TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
34812
34813     init_conversion_context(ctx);
34814     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(ctx, (const VkRayTracingPipelineCreateInfoNV32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
34815     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));
34816     convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(pCreateInfos_host, (const VkRayTracingPipelineCreateInfoNV32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
34817     free_conversion_context(ctx);
34818     return STATUS_SUCCESS;
34819 }
34820
34821 #ifdef _WIN64
34822 static NTSTATUS thunk64_vkCreateRenderPass(void *args)
34823 {
34824     struct vkCreateRenderPass_params *params = args;
34825
34826     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
34827
34828     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
34829     return STATUS_SUCCESS;
34830 }
34831 #endif /* _WIN64 */
34832
34833 static NTSTATUS thunk32_vkCreateRenderPass(void *args)
34834 {
34835     struct
34836     {
34837         PTR32 device;
34838         PTR32 pCreateInfo;
34839         PTR32 pAllocator;
34840         PTR32 pRenderPass;
34841         VkResult result;
34842     } *params = args;
34843     VkRenderPassCreateInfo pCreateInfo_host;
34844     struct conversion_context local_ctx;
34845     struct conversion_context *ctx = &local_ctx;
34846
34847     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
34848
34849     init_conversion_context(ctx);
34850     convert_VkRenderPassCreateInfo_win32_to_host(ctx, (const VkRenderPassCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34851     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));
34852     free_conversion_context(ctx);
34853     return STATUS_SUCCESS;
34854 }
34855
34856 #ifdef _WIN64
34857 static NTSTATUS thunk64_vkCreateRenderPass2(void *args)
34858 {
34859     struct vkCreateRenderPass2_params *params = args;
34860
34861     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
34862
34863     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
34864     return STATUS_SUCCESS;
34865 }
34866 #endif /* _WIN64 */
34867
34868 static NTSTATUS thunk32_vkCreateRenderPass2(void *args)
34869 {
34870     struct
34871     {
34872         PTR32 device;
34873         PTR32 pCreateInfo;
34874         PTR32 pAllocator;
34875         PTR32 pRenderPass;
34876         VkResult result;
34877     } *params = args;
34878     VkRenderPassCreateInfo2 pCreateInfo_host;
34879     struct conversion_context local_ctx;
34880     struct conversion_context *ctx = &local_ctx;
34881
34882     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
34883
34884     init_conversion_context(ctx);
34885     convert_VkRenderPassCreateInfo2_win32_to_host(ctx, (const VkRenderPassCreateInfo232 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34886     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));
34887     free_conversion_context(ctx);
34888     return STATUS_SUCCESS;
34889 }
34890
34891 #ifdef _WIN64
34892 static NTSTATUS thunk64_vkCreateRenderPass2KHR(void *args)
34893 {
34894     struct vkCreateRenderPass2KHR_params *params = args;
34895
34896     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
34897
34898     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
34899     return STATUS_SUCCESS;
34900 }
34901 #endif /* _WIN64 */
34902
34903 static NTSTATUS thunk32_vkCreateRenderPass2KHR(void *args)
34904 {
34905     struct
34906     {
34907         PTR32 device;
34908         PTR32 pCreateInfo;
34909         PTR32 pAllocator;
34910         PTR32 pRenderPass;
34911         VkResult result;
34912     } *params = args;
34913     VkRenderPassCreateInfo2 pCreateInfo_host;
34914     struct conversion_context local_ctx;
34915     struct conversion_context *ctx = &local_ctx;
34916
34917     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
34918
34919     init_conversion_context(ctx);
34920     convert_VkRenderPassCreateInfo2_win32_to_host(ctx, (const VkRenderPassCreateInfo232 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34921     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));
34922     free_conversion_context(ctx);
34923     return STATUS_SUCCESS;
34924 }
34925
34926 #ifdef _WIN64
34927 static NTSTATUS thunk64_vkCreateSampler(void *args)
34928 {
34929     struct vkCreateSampler_params *params = args;
34930
34931     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);
34932
34933     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSampler(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSampler);
34934     return STATUS_SUCCESS;
34935 }
34936 #endif /* _WIN64 */
34937
34938 static NTSTATUS thunk32_vkCreateSampler(void *args)
34939 {
34940     struct
34941     {
34942         PTR32 device;
34943         PTR32 pCreateInfo;
34944         PTR32 pAllocator;
34945         PTR32 pSampler;
34946         VkResult result;
34947     } *params = args;
34948     VkSamplerCreateInfo pCreateInfo_host;
34949     struct conversion_context local_ctx;
34950     struct conversion_context *ctx = &local_ctx;
34951
34952     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);
34953
34954     init_conversion_context(ctx);
34955     convert_VkSamplerCreateInfo_win32_to_host(ctx, (const VkSamplerCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34956     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));
34957     free_conversion_context(ctx);
34958     return STATUS_SUCCESS;
34959 }
34960
34961 #ifdef _WIN64
34962 static NTSTATUS thunk64_vkCreateSamplerYcbcrConversion(void *args)
34963 {
34964     struct vkCreateSamplerYcbcrConversion_params *params = args;
34965
34966     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
34967
34968     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
34969     return STATUS_SUCCESS;
34970 }
34971 #endif /* _WIN64 */
34972
34973 static NTSTATUS thunk32_vkCreateSamplerYcbcrConversion(void *args)
34974 {
34975     struct
34976     {
34977         PTR32 device;
34978         PTR32 pCreateInfo;
34979         PTR32 pAllocator;
34980         PTR32 pYcbcrConversion;
34981         VkResult result;
34982     } *params = args;
34983     VkSamplerYcbcrConversionCreateInfo pCreateInfo_host;
34984
34985     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
34986
34987     convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host((const VkSamplerYcbcrConversionCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34988     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));
34989     return STATUS_SUCCESS;
34990 }
34991
34992 #ifdef _WIN64
34993 static NTSTATUS thunk64_vkCreateSamplerYcbcrConversionKHR(void *args)
34994 {
34995     struct vkCreateSamplerYcbcrConversionKHR_params *params = args;
34996
34997     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
34998
34999     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
35000     return STATUS_SUCCESS;
35001 }
35002 #endif /* _WIN64 */
35003
35004 static NTSTATUS thunk32_vkCreateSamplerYcbcrConversionKHR(void *args)
35005 {
35006     struct
35007     {
35008         PTR32 device;
35009         PTR32 pCreateInfo;
35010         PTR32 pAllocator;
35011         PTR32 pYcbcrConversion;
35012         VkResult result;
35013     } *params = args;
35014     VkSamplerYcbcrConversionCreateInfo pCreateInfo_host;
35015
35016     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
35017
35018     convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host((const VkSamplerYcbcrConversionCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
35019     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));
35020     return STATUS_SUCCESS;
35021 }
35022
35023 #ifdef _WIN64
35024 static NTSTATUS thunk64_vkCreateSemaphore(void *args)
35025 {
35026     struct vkCreateSemaphore_params *params = args;
35027
35028     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);
35029
35030     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSemaphore(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSemaphore);
35031     return STATUS_SUCCESS;
35032 }
35033 #endif /* _WIN64 */
35034
35035 static NTSTATUS thunk32_vkCreateSemaphore(void *args)
35036 {
35037     struct
35038     {
35039         PTR32 device;
35040         PTR32 pCreateInfo;
35041         PTR32 pAllocator;
35042         PTR32 pSemaphore;
35043         VkResult result;
35044     } *params = args;
35045     VkSemaphoreCreateInfo pCreateInfo_host;
35046     struct conversion_context local_ctx;
35047     struct conversion_context *ctx = &local_ctx;
35048
35049     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);
35050
35051     init_conversion_context(ctx);
35052     convert_VkSemaphoreCreateInfo_win32_to_host(ctx, (const VkSemaphoreCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
35053     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));
35054     free_conversion_context(ctx);
35055     return STATUS_SUCCESS;
35056 }
35057
35058 #ifdef _WIN64
35059 static NTSTATUS thunk64_vkCreateShaderModule(void *args)
35060 {
35061     struct vkCreateShaderModule_params *params = args;
35062
35063     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);
35064
35065     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateShaderModule(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pShaderModule);
35066     return STATUS_SUCCESS;
35067 }
35068 #endif /* _WIN64 */
35069
35070 static NTSTATUS thunk32_vkCreateShaderModule(void *args)
35071 {
35072     struct
35073     {
35074         PTR32 device;
35075         PTR32 pCreateInfo;
35076         PTR32 pAllocator;
35077         PTR32 pShaderModule;
35078         VkResult result;
35079     } *params = args;
35080     VkShaderModuleCreateInfo pCreateInfo_host;
35081     struct conversion_context local_ctx;
35082     struct conversion_context *ctx = &local_ctx;
35083
35084     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);
35085
35086     init_conversion_context(ctx);
35087     convert_VkShaderModuleCreateInfo_win32_to_host(ctx, (const VkShaderModuleCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
35088     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));
35089     free_conversion_context(ctx);
35090     return STATUS_SUCCESS;
35091 }
35092
35093 #ifdef _WIN64
35094 static NTSTATUS thunk64_vkCreateShadersEXT(void *args)
35095 {
35096     struct vkCreateShadersEXT_params *params = args;
35097
35098     TRACE("%p, %u, %p, %p, %p\n", params->device, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pShaders);
35099
35100     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);
35101     return STATUS_SUCCESS;
35102 }
35103 #endif /* _WIN64 */
35104
35105 static NTSTATUS thunk32_vkCreateShadersEXT(void *args)
35106 {
35107     struct
35108     {
35109         PTR32 device;
35110         uint32_t createInfoCount;
35111         PTR32 pCreateInfos;
35112         PTR32 pAllocator;
35113         PTR32 pShaders;
35114         VkResult result;
35115     } *params = args;
35116     const VkShaderCreateInfoEXT *pCreateInfos_host;
35117     struct conversion_context local_ctx;
35118     struct conversion_context *ctx = &local_ctx;
35119
35120     TRACE("%#x, %u, %#x, %#x, %#x\n", params->device, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pShaders);
35121
35122     init_conversion_context(ctx);
35123     pCreateInfos_host = convert_VkShaderCreateInfoEXT_array_win32_to_host(ctx, (const VkShaderCreateInfoEXT32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
35124     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));
35125     free_conversion_context(ctx);
35126     return STATUS_SUCCESS;
35127 }
35128
35129 #ifdef _WIN64
35130 static NTSTATUS thunk64_vkCreateSwapchainKHR(void *args)
35131 {
35132     struct vkCreateSwapchainKHR_params *params = args;
35133     VkSwapchainCreateInfoKHR pCreateInfo_host;
35134
35135     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);
35136
35137     convert_VkSwapchainCreateInfoKHR_win64_to_host(params->pCreateInfo, &pCreateInfo_host);
35138     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSwapchain);
35139     return STATUS_SUCCESS;
35140 }
35141 #endif /* _WIN64 */
35142
35143 static NTSTATUS thunk32_vkCreateSwapchainKHR(void *args)
35144 {
35145     struct
35146     {
35147         PTR32 device;
35148         PTR32 pCreateInfo;
35149         PTR32 pAllocator;
35150         PTR32 pSwapchain;
35151         VkResult result;
35152     } *params = args;
35153     VkSwapchainCreateInfoKHR pCreateInfo_host;
35154     struct conversion_context local_ctx;
35155     struct conversion_context *ctx = &local_ctx;
35156
35157     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);
35158
35159     init_conversion_context(ctx);
35160     convert_VkSwapchainCreateInfoKHR_win32_to_host(ctx, (const VkSwapchainCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
35161     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));
35162     free_conversion_context(ctx);
35163     return STATUS_SUCCESS;
35164 }
35165
35166 #ifdef _WIN64
35167 static NTSTATUS thunk64_vkCreateValidationCacheEXT(void *args)
35168 {
35169     struct vkCreateValidationCacheEXT_params *params = args;
35170
35171     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);
35172
35173     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pValidationCache);
35174     return STATUS_SUCCESS;
35175 }
35176 #endif /* _WIN64 */
35177
35178 static NTSTATUS thunk32_vkCreateValidationCacheEXT(void *args)
35179 {
35180     struct
35181     {
35182         PTR32 device;
35183         PTR32 pCreateInfo;
35184         PTR32 pAllocator;
35185         PTR32 pValidationCache;
35186         VkResult result;
35187     } *params = args;
35188     VkValidationCacheCreateInfoEXT pCreateInfo_host;
35189
35190     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);
35191
35192     convert_VkValidationCacheCreateInfoEXT_win32_to_host((const VkValidationCacheCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
35193     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));
35194     return STATUS_SUCCESS;
35195 }
35196
35197 #ifdef _WIN64
35198 static NTSTATUS thunk64_vkCreateWin32SurfaceKHR(void *args)
35199 {
35200     struct vkCreateWin32SurfaceKHR_params *params = args;
35201
35202     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
35203
35204     params->result = wine_vkCreateWin32SurfaceKHR(params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
35205     return STATUS_SUCCESS;
35206 }
35207 #endif /* _WIN64 */
35208
35209 static NTSTATUS thunk32_vkCreateWin32SurfaceKHR(void *args)
35210 {
35211     struct
35212     {
35213         PTR32 instance;
35214         PTR32 pCreateInfo;
35215         PTR32 pAllocator;
35216         PTR32 pSurface;
35217         VkResult result;
35218     } *params = args;
35219     VkWin32SurfaceCreateInfoKHR pCreateInfo_host;
35220
35221     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
35222
35223     convert_VkWin32SurfaceCreateInfoKHR_win32_to_host((const VkWin32SurfaceCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
35224     params->result = wine_vkCreateWin32SurfaceKHR((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkSurfaceKHR *)UlongToPtr(params->pSurface));
35225     return STATUS_SUCCESS;
35226 }
35227
35228 #ifdef _WIN64
35229 static NTSTATUS thunk64_vkDebugMarkerSetObjectNameEXT(void *args)
35230 {
35231     struct vkDebugMarkerSetObjectNameEXT_params *params = args;
35232     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;
35233
35234     TRACE("%p, %p\n", params->device, params->pNameInfo);
35235
35236     convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(params->pNameInfo, &pNameInfo_host);
35237     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
35238     return STATUS_SUCCESS;
35239 }
35240 #endif /* _WIN64 */
35241
35242 static NTSTATUS thunk32_vkDebugMarkerSetObjectNameEXT(void *args)
35243 {
35244     struct
35245     {
35246         PTR32 device;
35247         PTR32 pNameInfo;
35248         VkResult result;
35249     } *params = args;
35250     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;
35251
35252     TRACE("%#x, %#x\n", params->device, params->pNameInfo);
35253
35254     convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host((const VkDebugMarkerObjectNameInfoEXT32 *)UlongToPtr(params->pNameInfo), &pNameInfo_host);
35255     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pNameInfo_host);
35256     return STATUS_SUCCESS;
35257 }
35258
35259 #ifdef _WIN64
35260 static NTSTATUS thunk64_vkDebugMarkerSetObjectTagEXT(void *args)
35261 {
35262     struct vkDebugMarkerSetObjectTagEXT_params *params = args;
35263     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;
35264
35265     TRACE("%p, %p\n", params->device, params->pTagInfo);
35266
35267     convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(params->pTagInfo, &pTagInfo_host);
35268     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
35269     return STATUS_SUCCESS;
35270 }
35271 #endif /* _WIN64 */
35272
35273 static NTSTATUS thunk32_vkDebugMarkerSetObjectTagEXT(void *args)
35274 {
35275     struct
35276     {
35277         PTR32 device;
35278         PTR32 pTagInfo;
35279         VkResult result;
35280     } *params = args;
35281     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;
35282
35283     TRACE("%#x, %#x\n", params->device, params->pTagInfo);
35284
35285     convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host((const VkDebugMarkerObjectTagInfoEXT32 *)UlongToPtr(params->pTagInfo), &pTagInfo_host);
35286     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pTagInfo_host);
35287     return STATUS_SUCCESS;
35288 }
35289
35290 #ifdef _WIN64
35291 static NTSTATUS thunk64_vkDebugReportMessageEXT(void *args)
35292 {
35293     struct vkDebugReportMessageEXT_params *params = args;
35294
35295     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);
35296
35297     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);
35298     return STATUS_SUCCESS;
35299 }
35300 #endif /* _WIN64 */
35301
35302 static NTSTATUS thunk32_vkDebugReportMessageEXT(void *args)
35303 {
35304     struct
35305     {
35306         PTR32 instance;
35307         VkDebugReportFlagsEXT flags;
35308         VkDebugReportObjectTypeEXT objectType;
35309         uint64_t DECLSPEC_ALIGN(8) object;
35310         PTR32 location;
35311         int32_t messageCode;
35312         PTR32 pLayerPrefix;
35313         PTR32 pMessage;
35314     } *params = args;
35315
35316     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);
35317
35318     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));
35319     return STATUS_SUCCESS;
35320 }
35321
35322 #ifdef _WIN64
35323 static NTSTATUS thunk64_vkDeferredOperationJoinKHR(void *args)
35324 {
35325     struct vkDeferredOperationJoinKHR_params *params = args;
35326
35327     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
35328
35329     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle(params->device)->device, wine_deferred_operation_from_handle(params->operation)->deferred_operation);
35330     return STATUS_SUCCESS;
35331 }
35332 #endif /* _WIN64 */
35333
35334 static NTSTATUS thunk32_vkDeferredOperationJoinKHR(void *args)
35335 {
35336     struct
35337     {
35338         PTR32 device;
35339         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
35340         VkResult result;
35341     } *params = args;
35342
35343     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
35344
35345     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, wine_deferred_operation_from_handle(params->operation)->deferred_operation);
35346     return STATUS_SUCCESS;
35347 }
35348
35349 #ifdef _WIN64
35350 static NTSTATUS thunk64_vkDestroyAccelerationStructureKHR(void *args)
35351 {
35352     struct vkDestroyAccelerationStructureKHR_params *params = args;
35353
35354     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
35355
35356     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
35357     return STATUS_SUCCESS;
35358 }
35359 #endif /* _WIN64 */
35360
35361 static NTSTATUS thunk32_vkDestroyAccelerationStructureKHR(void *args)
35362 {
35363     struct
35364     {
35365         PTR32 device;
35366         VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
35367         PTR32 pAllocator;
35368     } *params = args;
35369
35370     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
35371
35372     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->accelerationStructure, NULL);
35373     return STATUS_SUCCESS;
35374 }
35375
35376 #ifdef _WIN64
35377 static NTSTATUS thunk64_vkDestroyAccelerationStructureNV(void *args)
35378 {
35379     struct vkDestroyAccelerationStructureNV_params *params = args;
35380
35381     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
35382
35383     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
35384     return STATUS_SUCCESS;
35385 }
35386 #endif /* _WIN64 */
35387
35388 static NTSTATUS thunk32_vkDestroyAccelerationStructureNV(void *args)
35389 {
35390     struct
35391     {
35392         PTR32 device;
35393         VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
35394         PTR32 pAllocator;
35395     } *params = args;
35396
35397     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
35398
35399     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyAccelerationStructureNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->accelerationStructure, NULL);
35400     return STATUS_SUCCESS;
35401 }
35402
35403 #ifdef _WIN64
35404 static NTSTATUS thunk64_vkDestroyBuffer(void *args)
35405 {
35406     struct vkDestroyBuffer_params *params = args;
35407
35408     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pAllocator);
35409
35410     wine_device_from_handle(params->device)->funcs.p_vkDestroyBuffer(wine_device_from_handle(params->device)->device, params->buffer, NULL);
35411     return STATUS_SUCCESS;
35412 }
35413 #endif /* _WIN64 */
35414
35415 static NTSTATUS thunk32_vkDestroyBuffer(void *args)
35416 {
35417     struct
35418     {
35419         PTR32 device;
35420         VkBuffer DECLSPEC_ALIGN(8) buffer;
35421         PTR32 pAllocator;
35422     } *params = args;
35423
35424     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->buffer), params->pAllocator);
35425
35426     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyBuffer(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buffer, NULL);
35427     return STATUS_SUCCESS;
35428 }
35429
35430 #ifdef _WIN64
35431 static NTSTATUS thunk64_vkDestroyBufferView(void *args)
35432 {
35433     struct vkDestroyBufferView_params *params = args;
35434
35435     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->bufferView), params->pAllocator);
35436
35437     wine_device_from_handle(params->device)->funcs.p_vkDestroyBufferView(wine_device_from_handle(params->device)->device, params->bufferView, NULL);
35438     return STATUS_SUCCESS;
35439 }
35440 #endif /* _WIN64 */
35441
35442 static NTSTATUS thunk32_vkDestroyBufferView(void *args)
35443 {
35444     struct
35445     {
35446         PTR32 device;
35447         VkBufferView DECLSPEC_ALIGN(8) bufferView;
35448         PTR32 pAllocator;
35449     } *params = args;
35450
35451     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->bufferView), params->pAllocator);
35452
35453     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyBufferView(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bufferView, NULL);
35454     return STATUS_SUCCESS;
35455 }
35456
35457 #ifdef _WIN64
35458 static NTSTATUS thunk64_vkDestroyCommandPool(void *args)
35459 {
35460     struct vkDestroyCommandPool_params *params = args;
35461
35462     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->pAllocator);
35463
35464     wine_vkDestroyCommandPool(params->device, params->commandPool, params->pAllocator);
35465     return STATUS_SUCCESS;
35466 }
35467 #endif /* _WIN64 */
35468
35469 static NTSTATUS thunk32_vkDestroyCommandPool(void *args)
35470 {
35471     struct
35472     {
35473         PTR32 device;
35474         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
35475         PTR32 pAllocator;
35476     } *params = args;
35477
35478     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->pAllocator);
35479
35480     wine_vkDestroyCommandPool((VkDevice)UlongToPtr(params->device), params->commandPool, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
35481     return STATUS_SUCCESS;
35482 }
35483
35484 #ifdef _WIN64
35485 static NTSTATUS thunk64_vkDestroyCuFunctionNVX(void *args)
35486 {
35487     struct vkDestroyCuFunctionNVX_params *params = args;
35488
35489     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator);
35490
35491     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuFunctionNVX(wine_device_from_handle(params->device)->device, params->function, NULL);
35492     return STATUS_SUCCESS;
35493 }
35494 #endif /* _WIN64 */
35495
35496 static NTSTATUS thunk32_vkDestroyCuFunctionNVX(void *args)
35497 {
35498     struct
35499     {
35500         PTR32 device;
35501         VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
35502         PTR32 pAllocator;
35503     } *params = args;
35504
35505     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator);
35506
35507     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyCuFunctionNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->function, NULL);
35508     return STATUS_SUCCESS;
35509 }
35510
35511 #ifdef _WIN64
35512 static NTSTATUS thunk64_vkDestroyCuModuleNVX(void *args)
35513 {
35514     struct vkDestroyCuModuleNVX_params *params = args;
35515
35516     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator);
35517
35518     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuModuleNVX(wine_device_from_handle(params->device)->device, params->module, NULL);
35519     return STATUS_SUCCESS;
35520 }
35521 #endif /* _WIN64 */
35522
35523 static NTSTATUS thunk32_vkDestroyCuModuleNVX(void *args)
35524 {
35525     struct
35526     {
35527         PTR32 device;
35528         VkCuModuleNVX DECLSPEC_ALIGN(8) module;
35529         PTR32 pAllocator;
35530     } *params = args;
35531
35532     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator);
35533
35534     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyCuModuleNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->module, NULL);
35535     return STATUS_SUCCESS;
35536 }
35537
35538 #ifdef _WIN64
35539 static NTSTATUS thunk64_vkDestroyDebugReportCallbackEXT(void *args)
35540 {
35541     struct vkDestroyDebugReportCallbackEXT_params *params = args;
35542
35543     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->callback), params->pAllocator);
35544
35545     wine_vkDestroyDebugReportCallbackEXT(params->instance, params->callback, params->pAllocator);
35546     return STATUS_SUCCESS;
35547 }
35548 #endif /* _WIN64 */
35549
35550 static NTSTATUS thunk32_vkDestroyDebugReportCallbackEXT(void *args)
35551 {
35552     struct
35553     {
35554         PTR32 instance;
35555         VkDebugReportCallbackEXT DECLSPEC_ALIGN(8) callback;
35556         PTR32 pAllocator;
35557     } *params = args;
35558
35559     TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->callback), params->pAllocator);
35560
35561     wine_vkDestroyDebugReportCallbackEXT((VkInstance)UlongToPtr(params->instance), params->callback, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
35562     return STATUS_SUCCESS;
35563 }
35564
35565 #ifdef _WIN64
35566 static NTSTATUS thunk64_vkDestroyDebugUtilsMessengerEXT(void *args)
35567 {
35568     struct vkDestroyDebugUtilsMessengerEXT_params *params = args;
35569
35570     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->messenger), params->pAllocator);
35571
35572     wine_vkDestroyDebugUtilsMessengerEXT(params->instance, params->messenger, params->pAllocator);
35573     return STATUS_SUCCESS;
35574 }
35575 #endif /* _WIN64 */
35576
35577 static NTSTATUS thunk32_vkDestroyDebugUtilsMessengerEXT(void *args)
35578 {
35579     struct
35580     {
35581         PTR32 instance;
35582         VkDebugUtilsMessengerEXT DECLSPEC_ALIGN(8) messenger;
35583         PTR32 pAllocator;
35584     } *params = args;
35585
35586     TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->messenger), params->pAllocator);
35587
35588     wine_vkDestroyDebugUtilsMessengerEXT((VkInstance)UlongToPtr(params->instance), params->messenger, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
35589     return STATUS_SUCCESS;
35590 }
35591
35592 #ifdef _WIN64
35593 static NTSTATUS thunk64_vkDestroyDeferredOperationKHR(void *args)
35594 {
35595     struct vkDestroyDeferredOperationKHR_params *params = args;
35596
35597     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->operation), params->pAllocator);
35598
35599     wine_vkDestroyDeferredOperationKHR(params->device, params->operation, params->pAllocator);
35600     return STATUS_SUCCESS;
35601 }
35602 #endif /* _WIN64 */
35603
35604 static NTSTATUS thunk32_vkDestroyDeferredOperationKHR(void *args)
35605 {
35606     struct
35607     {
35608         PTR32 device;
35609         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
35610         PTR32 pAllocator;
35611     } *params = args;
35612
35613     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->operation), params->pAllocator);
35614
35615     wine_vkDestroyDeferredOperationKHR((VkDevice)UlongToPtr(params->device), params->operation, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
35616     return STATUS_SUCCESS;
35617 }
35618
35619 #ifdef _WIN64
35620 static NTSTATUS thunk64_vkDestroyDescriptorPool(void *args)
35621 {
35622     struct vkDestroyDescriptorPool_params *params = args;
35623
35624     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->pAllocator);
35625
35626     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, NULL);
35627     return STATUS_SUCCESS;
35628 }
35629 #endif /* _WIN64 */
35630
35631 static NTSTATUS thunk32_vkDestroyDescriptorPool(void *args)
35632 {
35633     struct
35634     {
35635         PTR32 device;
35636         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
35637         PTR32 pAllocator;
35638     } *params = args;
35639
35640     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->pAllocator);
35641
35642     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorPool, NULL);
35643     return STATUS_SUCCESS;
35644 }
35645
35646 #ifdef _WIN64
35647 static NTSTATUS thunk64_vkDestroyDescriptorSetLayout(void *args)
35648 {
35649     struct vkDestroyDescriptorSetLayout_params *params = args;
35650
35651     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSetLayout), params->pAllocator);
35652
35653     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->descriptorSetLayout, NULL);
35654     return STATUS_SUCCESS;
35655 }
35656 #endif /* _WIN64 */
35657
35658 static NTSTATUS thunk32_vkDestroyDescriptorSetLayout(void *args)
35659 {
35660     struct
35661     {
35662         PTR32 device;
35663         VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
35664         PTR32 pAllocator;
35665     } *params = args;
35666
35667     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSetLayout), params->pAllocator);
35668
35669     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorSetLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorSetLayout, NULL);
35670     return STATUS_SUCCESS;
35671 }
35672
35673 #ifdef _WIN64
35674 static NTSTATUS thunk64_vkDestroyDescriptorUpdateTemplate(void *args)
35675 {
35676     struct vkDestroyDescriptorUpdateTemplate_params *params = args;
35677
35678     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
35679
35680     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
35681     return STATUS_SUCCESS;
35682 }
35683 #endif /* _WIN64 */
35684
35685 static NTSTATUS thunk32_vkDestroyDescriptorUpdateTemplate(void *args)
35686 {
35687     struct
35688     {
35689         PTR32 device;
35690         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
35691         PTR32 pAllocator;
35692     } *params = args;
35693
35694     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
35695
35696     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorUpdateTemplate(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorUpdateTemplate, NULL);
35697     return STATUS_SUCCESS;
35698 }
35699
35700 #ifdef _WIN64
35701 static NTSTATUS thunk64_vkDestroyDescriptorUpdateTemplateKHR(void *args)
35702 {
35703     struct vkDestroyDescriptorUpdateTemplateKHR_params *params = args;
35704
35705     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
35706
35707     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
35708     return STATUS_SUCCESS;
35709 }
35710 #endif /* _WIN64 */
35711
35712 static NTSTATUS thunk32_vkDestroyDescriptorUpdateTemplateKHR(void *args)
35713 {
35714     struct
35715     {
35716         PTR32 device;
35717         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
35718         PTR32 pAllocator;
35719     } *params = args;
35720
35721     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
35722
35723     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorUpdateTemplate, NULL);
35724     return STATUS_SUCCESS;
35725 }
35726
35727 #ifdef _WIN64
35728 static NTSTATUS thunk64_vkDestroyDevice(void *args)
35729 {
35730     struct vkDestroyDevice_params *params = args;
35731
35732     TRACE("%p, %p\n", params->device, params->pAllocator);
35733
35734     if (!params->device)
35735         return STATUS_SUCCESS;
35736
35737     wine_vkDestroyDevice(params->device, params->pAllocator);
35738     return STATUS_SUCCESS;
35739 }
35740 #endif /* _WIN64 */
35741
35742 static NTSTATUS thunk32_vkDestroyDevice(void *args)
35743 {
35744     struct
35745     {
35746         PTR32 device;
35747         PTR32 pAllocator;
35748     } *params = args;
35749
35750     TRACE("%#x, %#x\n", params->device, params->pAllocator);
35751
35752     if (!params->device)
35753         return STATUS_SUCCESS;
35754
35755     wine_vkDestroyDevice((VkDevice)UlongToPtr(params->device), (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
35756     return STATUS_SUCCESS;
35757 }
35758
35759 #ifdef _WIN64
35760 static NTSTATUS thunk64_vkDestroyEvent(void *args)
35761 {
35762     struct vkDestroyEvent_params *params = args;
35763
35764     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->event), params->pAllocator);
35765
35766     wine_device_from_handle(params->device)->funcs.p_vkDestroyEvent(wine_device_from_handle(params->device)->device, params->event, NULL);
35767     return STATUS_SUCCESS;
35768 }
35769 #endif /* _WIN64 */
35770
35771 static NTSTATUS thunk32_vkDestroyEvent(void *args)
35772 {
35773     struct
35774     {
35775         PTR32 device;
35776         VkEvent DECLSPEC_ALIGN(8) event;
35777         PTR32 pAllocator;
35778     } *params = args;
35779
35780     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->event), params->pAllocator);
35781
35782     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event, NULL);
35783     return STATUS_SUCCESS;
35784 }
35785
35786 #ifdef _WIN64
35787 static NTSTATUS thunk64_vkDestroyFence(void *args)
35788 {
35789     struct vkDestroyFence_params *params = args;
35790
35791     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
35792
35793     wine_device_from_handle(params->device)->funcs.p_vkDestroyFence(wine_device_from_handle(params->device)->device, params->fence, NULL);
35794     return STATUS_SUCCESS;
35795 }
35796 #endif /* _WIN64 */
35797
35798 static NTSTATUS thunk32_vkDestroyFence(void *args)
35799 {
35800     struct
35801     {
35802         PTR32 device;
35803         VkFence DECLSPEC_ALIGN(8) fence;
35804         PTR32 pAllocator;
35805     } *params = args;
35806
35807     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
35808
35809     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyFence(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->fence, NULL);
35810     return STATUS_SUCCESS;
35811 }
35812
35813 #ifdef _WIN64
35814 static NTSTATUS thunk64_vkDestroyFramebuffer(void *args)
35815 {
35816     struct vkDestroyFramebuffer_params *params = args;
35817
35818     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pAllocator);
35819
35820     wine_device_from_handle(params->device)->funcs.p_vkDestroyFramebuffer(wine_device_from_handle(params->device)->device, params->framebuffer, NULL);
35821     return STATUS_SUCCESS;
35822 }
35823 #endif /* _WIN64 */
35824
35825 static NTSTATUS thunk32_vkDestroyFramebuffer(void *args)
35826 {
35827     struct
35828     {
35829         PTR32 device;
35830         VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
35831         PTR32 pAllocator;
35832     } *params = args;
35833
35834     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pAllocator);
35835
35836     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyFramebuffer(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->framebuffer, NULL);
35837     return STATUS_SUCCESS;
35838 }
35839
35840 #ifdef _WIN64
35841 static NTSTATUS thunk64_vkDestroyImage(void *args)
35842 {
35843     struct vkDestroyImage_params *params = args;
35844
35845     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pAllocator);
35846
35847     wine_device_from_handle(params->device)->funcs.p_vkDestroyImage(wine_device_from_handle(params->device)->device, params->image, NULL);
35848     return STATUS_SUCCESS;
35849 }
35850 #endif /* _WIN64 */
35851
35852 static NTSTATUS thunk32_vkDestroyImage(void *args)
35853 {
35854     struct
35855     {
35856         PTR32 device;
35857         VkImage DECLSPEC_ALIGN(8) image;
35858         PTR32 pAllocator;
35859     } *params = args;
35860
35861     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pAllocator);
35862
35863     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyImage(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, NULL);
35864     return STATUS_SUCCESS;
35865 }
35866
35867 #ifdef _WIN64
35868 static NTSTATUS thunk64_vkDestroyImageView(void *args)
35869 {
35870     struct vkDestroyImageView_params *params = args;
35871
35872     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pAllocator);
35873
35874     wine_device_from_handle(params->device)->funcs.p_vkDestroyImageView(wine_device_from_handle(params->device)->device, params->imageView, NULL);
35875     return STATUS_SUCCESS;
35876 }
35877 #endif /* _WIN64 */
35878
35879 static NTSTATUS thunk32_vkDestroyImageView(void *args)
35880 {
35881     struct
35882     {
35883         PTR32 device;
35884         VkImageView DECLSPEC_ALIGN(8) imageView;
35885         PTR32 pAllocator;
35886     } *params = args;
35887
35888     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->imageView), params->pAllocator);
35889
35890     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyImageView(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->imageView, NULL);
35891     return STATUS_SUCCESS;
35892 }
35893
35894 #ifdef _WIN64
35895 static NTSTATUS thunk64_vkDestroyIndirectCommandsLayoutNV(void *args)
35896 {
35897     struct vkDestroyIndirectCommandsLayoutNV_params *params = args;
35898
35899     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
35900
35901     wine_device_from_handle(params->device)->funcs.p_vkDestroyIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->indirectCommandsLayout, NULL);
35902     return STATUS_SUCCESS;
35903 }
35904 #endif /* _WIN64 */
35905
35906 static NTSTATUS thunk32_vkDestroyIndirectCommandsLayoutNV(void *args)
35907 {
35908     struct
35909     {
35910         PTR32 device;
35911         VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
35912         PTR32 pAllocator;
35913     } *params = args;
35914
35915     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
35916
35917     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyIndirectCommandsLayoutNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->indirectCommandsLayout, NULL);
35918     return STATUS_SUCCESS;
35919 }
35920
35921 #ifdef _WIN64
35922 static NTSTATUS thunk64_vkDestroyInstance(void *args)
35923 {
35924     struct vkDestroyInstance_params *params = args;
35925
35926     TRACE("%p, %p\n", params->instance, params->pAllocator);
35927
35928     if (!params->instance)
35929         return STATUS_SUCCESS;
35930
35931     wine_vkDestroyInstance(params->instance, params->pAllocator);
35932     return STATUS_SUCCESS;
35933 }
35934 #endif /* _WIN64 */
35935
35936 static NTSTATUS thunk32_vkDestroyInstance(void *args)
35937 {
35938     struct
35939     {
35940         PTR32 instance;
35941         PTR32 pAllocator;
35942     } *params = args;
35943
35944     TRACE("%#x, %#x\n", params->instance, params->pAllocator);
35945
35946     if (!params->instance)
35947         return STATUS_SUCCESS;
35948
35949     wine_vkDestroyInstance((VkInstance)UlongToPtr(params->instance), (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
35950     return STATUS_SUCCESS;
35951 }
35952
35953 #ifdef _WIN64
35954 static NTSTATUS thunk64_vkDestroyMicromapEXT(void *args)
35955 {
35956     struct vkDestroyMicromapEXT_params *params = args;
35957
35958     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
35959
35960     wine_device_from_handle(params->device)->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle(params->device)->device, params->micromap, NULL);
35961     return STATUS_SUCCESS;
35962 }
35963 #endif /* _WIN64 */
35964
35965 static NTSTATUS thunk32_vkDestroyMicromapEXT(void *args)
35966 {
35967     struct
35968     {
35969         PTR32 device;
35970         VkMicromapEXT DECLSPEC_ALIGN(8) micromap;
35971         PTR32 pAllocator;
35972     } *params = args;
35973
35974     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
35975
35976     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->micromap, NULL);
35977     return STATUS_SUCCESS;
35978 }
35979
35980 #ifdef _WIN64
35981 static NTSTATUS thunk64_vkDestroyOpticalFlowSessionNV(void *args)
35982 {
35983     struct vkDestroyOpticalFlowSessionNV_params *params = args;
35984
35985     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
35986
35987     wine_device_from_handle(params->device)->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->session, NULL);
35988     return STATUS_SUCCESS;
35989 }
35990 #endif /* _WIN64 */
35991
35992 static NTSTATUS thunk32_vkDestroyOpticalFlowSessionNV(void *args)
35993 {
35994     struct
35995     {
35996         PTR32 device;
35997         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
35998         PTR32 pAllocator;
35999     } *params = args;
36000
36001     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
36002
36003     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->session, NULL);
36004     return STATUS_SUCCESS;
36005 }
36006
36007 #ifdef _WIN64
36008 static NTSTATUS thunk64_vkDestroyPipeline(void *args)
36009 {
36010     struct vkDestroyPipeline_params *params = args;
36011
36012     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->pAllocator);
36013
36014     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipeline(wine_device_from_handle(params->device)->device, params->pipeline, NULL);
36015     return STATUS_SUCCESS;
36016 }
36017 #endif /* _WIN64 */
36018
36019 static NTSTATUS thunk32_vkDestroyPipeline(void *args)
36020 {
36021     struct
36022     {
36023         PTR32 device;
36024         VkPipeline DECLSPEC_ALIGN(8) pipeline;
36025         PTR32 pAllocator;
36026     } *params = args;
36027
36028     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->pAllocator);
36029
36030     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipeline(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, NULL);
36031     return STATUS_SUCCESS;
36032 }
36033
36034 #ifdef _WIN64
36035 static NTSTATUS thunk64_vkDestroyPipelineCache(void *args)
36036 {
36037     struct vkDestroyPipelineCache_params *params = args;
36038
36039     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pAllocator);
36040
36041     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineCache(wine_device_from_handle(params->device)->device, params->pipelineCache, NULL);
36042     return STATUS_SUCCESS;
36043 }
36044 #endif /* _WIN64 */
36045
36046 static NTSTATUS thunk32_vkDestroyPipelineCache(void *args)
36047 {
36048     struct
36049     {
36050         PTR32 device;
36051         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
36052         PTR32 pAllocator;
36053     } *params = args;
36054
36055     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pAllocator);
36056
36057     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipelineCache(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineCache, NULL);
36058     return STATUS_SUCCESS;
36059 }
36060
36061 #ifdef _WIN64
36062 static NTSTATUS thunk64_vkDestroyPipelineLayout(void *args)
36063 {
36064     struct vkDestroyPipelineLayout_params *params = args;
36065
36066     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineLayout), params->pAllocator);
36067
36068     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineLayout(wine_device_from_handle(params->device)->device, params->pipelineLayout, NULL);
36069     return STATUS_SUCCESS;
36070 }
36071 #endif /* _WIN64 */
36072
36073 static NTSTATUS thunk32_vkDestroyPipelineLayout(void *args)
36074 {
36075     struct
36076     {
36077         PTR32 device;
36078         VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
36079         PTR32 pAllocator;
36080     } *params = args;
36081
36082     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineLayout), params->pAllocator);
36083
36084     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipelineLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineLayout, NULL);
36085     return STATUS_SUCCESS;
36086 }
36087
36088 #ifdef _WIN64
36089 static NTSTATUS thunk64_vkDestroyPrivateDataSlot(void *args)
36090 {
36091     struct vkDestroyPrivateDataSlot_params *params = args;
36092
36093     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
36094
36095     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlot(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
36096     return STATUS_SUCCESS;
36097 }
36098 #endif /* _WIN64 */
36099
36100 static NTSTATUS thunk32_vkDestroyPrivateDataSlot(void *args)
36101 {
36102     struct
36103     {
36104         PTR32 device;
36105         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
36106         PTR32 pAllocator;
36107     } *params = args;
36108
36109     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
36110
36111     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPrivateDataSlot(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->privateDataSlot, NULL);
36112     return STATUS_SUCCESS;
36113 }
36114
36115 #ifdef _WIN64
36116 static NTSTATUS thunk64_vkDestroyPrivateDataSlotEXT(void *args)
36117 {
36118     struct vkDestroyPrivateDataSlotEXT_params *params = args;
36119
36120     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
36121
36122     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
36123     return STATUS_SUCCESS;
36124 }
36125 #endif /* _WIN64 */
36126
36127 static NTSTATUS thunk32_vkDestroyPrivateDataSlotEXT(void *args)
36128 {
36129     struct
36130     {
36131         PTR32 device;
36132         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
36133         PTR32 pAllocator;
36134     } *params = args;
36135
36136     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
36137
36138     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPrivateDataSlotEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->privateDataSlot, NULL);
36139     return STATUS_SUCCESS;
36140 }
36141
36142 #ifdef _WIN64
36143 static NTSTATUS thunk64_vkDestroyQueryPool(void *args)
36144 {
36145     struct vkDestroyQueryPool_params *params = args;
36146
36147     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->queryPool), params->pAllocator);
36148
36149     wine_device_from_handle(params->device)->funcs.p_vkDestroyQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, NULL);
36150     return STATUS_SUCCESS;
36151 }
36152 #endif /* _WIN64 */
36153
36154 static NTSTATUS thunk32_vkDestroyQueryPool(void *args)
36155 {
36156     struct
36157     {
36158         PTR32 device;
36159         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
36160         PTR32 pAllocator;
36161     } *params = args;
36162
36163     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->queryPool), params->pAllocator);
36164
36165     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyQueryPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->queryPool, NULL);
36166     return STATUS_SUCCESS;
36167 }
36168
36169 #ifdef _WIN64
36170 static NTSTATUS thunk64_vkDestroyRenderPass(void *args)
36171 {
36172     struct vkDestroyRenderPass_params *params = args;
36173
36174     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pAllocator);
36175
36176     wine_device_from_handle(params->device)->funcs.p_vkDestroyRenderPass(wine_device_from_handle(params->device)->device, params->renderPass, NULL);
36177     return STATUS_SUCCESS;
36178 }
36179 #endif /* _WIN64 */
36180
36181 static NTSTATUS thunk32_vkDestroyRenderPass(void *args)
36182 {
36183     struct
36184     {
36185         PTR32 device;
36186         VkRenderPass DECLSPEC_ALIGN(8) renderPass;
36187         PTR32 pAllocator;
36188     } *params = args;
36189
36190     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pAllocator);
36191
36192     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyRenderPass(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->renderPass, NULL);
36193     return STATUS_SUCCESS;
36194 }
36195
36196 #ifdef _WIN64
36197 static NTSTATUS thunk64_vkDestroySampler(void *args)
36198 {
36199     struct vkDestroySampler_params *params = args;
36200
36201     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->sampler), params->pAllocator);
36202
36203     wine_device_from_handle(params->device)->funcs.p_vkDestroySampler(wine_device_from_handle(params->device)->device, params->sampler, NULL);
36204     return STATUS_SUCCESS;
36205 }
36206 #endif /* _WIN64 */
36207
36208 static NTSTATUS thunk32_vkDestroySampler(void *args)
36209 {
36210     struct
36211     {
36212         PTR32 device;
36213         VkSampler DECLSPEC_ALIGN(8) sampler;
36214         PTR32 pAllocator;
36215     } *params = args;
36216
36217     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->sampler), params->pAllocator);
36218
36219     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySampler(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->sampler, NULL);
36220     return STATUS_SUCCESS;
36221 }
36222
36223 #ifdef _WIN64
36224 static NTSTATUS thunk64_vkDestroySamplerYcbcrConversion(void *args)
36225 {
36226     struct vkDestroySamplerYcbcrConversion_params *params = args;
36227
36228     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
36229
36230     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
36231     return STATUS_SUCCESS;
36232 }
36233 #endif /* _WIN64 */
36234
36235 static NTSTATUS thunk32_vkDestroySamplerYcbcrConversion(void *args)
36236 {
36237     struct
36238     {
36239         PTR32 device;
36240         VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) ycbcrConversion;
36241         PTR32 pAllocator;
36242     } *params = args;
36243
36244     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
36245
36246     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySamplerYcbcrConversion(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->ycbcrConversion, NULL);
36247     return STATUS_SUCCESS;
36248 }
36249
36250 #ifdef _WIN64
36251 static NTSTATUS thunk64_vkDestroySamplerYcbcrConversionKHR(void *args)
36252 {
36253     struct vkDestroySamplerYcbcrConversionKHR_params *params = args;
36254
36255     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
36256
36257     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
36258     return STATUS_SUCCESS;
36259 }
36260 #endif /* _WIN64 */
36261
36262 static NTSTATUS thunk32_vkDestroySamplerYcbcrConversionKHR(void *args)
36263 {
36264     struct
36265     {
36266         PTR32 device;
36267         VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) ycbcrConversion;
36268         PTR32 pAllocator;
36269     } *params = args;
36270
36271     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
36272
36273     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySamplerYcbcrConversionKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->ycbcrConversion, NULL);
36274     return STATUS_SUCCESS;
36275 }
36276
36277 #ifdef _WIN64
36278 static NTSTATUS thunk64_vkDestroySemaphore(void *args)
36279 {
36280     struct vkDestroySemaphore_params *params = args;
36281
36282     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pAllocator);
36283
36284     wine_device_from_handle(params->device)->funcs.p_vkDestroySemaphore(wine_device_from_handle(params->device)->device, params->semaphore, NULL);
36285     return STATUS_SUCCESS;
36286 }
36287 #endif /* _WIN64 */
36288
36289 static NTSTATUS thunk32_vkDestroySemaphore(void *args)
36290 {
36291     struct
36292     {
36293         PTR32 device;
36294         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
36295         PTR32 pAllocator;
36296     } *params = args;
36297
36298     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pAllocator);
36299
36300     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySemaphore(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->semaphore, NULL);
36301     return STATUS_SUCCESS;
36302 }
36303
36304 #ifdef _WIN64
36305 static NTSTATUS thunk64_vkDestroyShaderEXT(void *args)
36306 {
36307     struct vkDestroyShaderEXT_params *params = args;
36308
36309     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shader), params->pAllocator);
36310
36311     wine_device_from_handle(params->device)->funcs.p_vkDestroyShaderEXT(wine_device_from_handle(params->device)->device, params->shader, NULL);
36312     return STATUS_SUCCESS;
36313 }
36314 #endif /* _WIN64 */
36315
36316 static NTSTATUS thunk32_vkDestroyShaderEXT(void *args)
36317 {
36318     struct
36319     {
36320         PTR32 device;
36321         VkShaderEXT DECLSPEC_ALIGN(8) shader;
36322         PTR32 pAllocator;
36323     } *params = args;
36324
36325     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->shader), params->pAllocator);
36326
36327     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyShaderEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->shader, NULL);
36328     return STATUS_SUCCESS;
36329 }
36330
36331 #ifdef _WIN64
36332 static NTSTATUS thunk64_vkDestroyShaderModule(void *args)
36333 {
36334     struct vkDestroyShaderModule_params *params = args;
36335
36336     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pAllocator);
36337
36338     wine_device_from_handle(params->device)->funcs.p_vkDestroyShaderModule(wine_device_from_handle(params->device)->device, params->shaderModule, NULL);
36339     return STATUS_SUCCESS;
36340 }
36341 #endif /* _WIN64 */
36342
36343 static NTSTATUS thunk32_vkDestroyShaderModule(void *args)
36344 {
36345     struct
36346     {
36347         PTR32 device;
36348         VkShaderModule DECLSPEC_ALIGN(8) shaderModule;
36349         PTR32 pAllocator;
36350     } *params = args;
36351
36352     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pAllocator);
36353
36354     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyShaderModule(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->shaderModule, NULL);
36355     return STATUS_SUCCESS;
36356 }
36357
36358 #ifdef _WIN64
36359 static NTSTATUS thunk64_vkDestroySurfaceKHR(void *args)
36360 {
36361     struct vkDestroySurfaceKHR_params *params = args;
36362
36363     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->surface), params->pAllocator);
36364
36365     wine_vkDestroySurfaceKHR(params->instance, params->surface, params->pAllocator);
36366     return STATUS_SUCCESS;
36367 }
36368 #endif /* _WIN64 */
36369
36370 static NTSTATUS thunk32_vkDestroySurfaceKHR(void *args)
36371 {
36372     struct
36373     {
36374         PTR32 instance;
36375         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
36376         PTR32 pAllocator;
36377     } *params = args;
36378
36379     TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->surface), params->pAllocator);
36380
36381     wine_vkDestroySurfaceKHR((VkInstance)UlongToPtr(params->instance), params->surface, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
36382     return STATUS_SUCCESS;
36383 }
36384
36385 #ifdef _WIN64
36386 static NTSTATUS thunk64_vkDestroySwapchainKHR(void *args)
36387 {
36388     struct vkDestroySwapchainKHR_params *params = args;
36389
36390     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pAllocator);
36391
36392     wine_device_from_handle(params->device)->funcs.p_vkDestroySwapchainKHR(wine_device_from_handle(params->device)->device, params->swapchain, NULL);
36393     return STATUS_SUCCESS;
36394 }
36395 #endif /* _WIN64 */
36396
36397 static NTSTATUS thunk32_vkDestroySwapchainKHR(void *args)
36398 {
36399     struct
36400     {
36401         PTR32 device;
36402         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
36403         PTR32 pAllocator;
36404     } *params = args;
36405
36406     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pAllocator);
36407
36408     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySwapchainKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->swapchain, NULL);
36409     return STATUS_SUCCESS;
36410 }
36411
36412 #ifdef _WIN64
36413 static NTSTATUS thunk64_vkDestroyValidationCacheEXT(void *args)
36414 {
36415     struct vkDestroyValidationCacheEXT_params *params = args;
36416
36417     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pAllocator);
36418
36419     wine_device_from_handle(params->device)->funcs.p_vkDestroyValidationCacheEXT(wine_device_from_handle(params->device)->device, params->validationCache, NULL);
36420     return STATUS_SUCCESS;
36421 }
36422 #endif /* _WIN64 */
36423
36424 static NTSTATUS thunk32_vkDestroyValidationCacheEXT(void *args)
36425 {
36426     struct
36427     {
36428         PTR32 device;
36429         VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
36430         PTR32 pAllocator;
36431     } *params = args;
36432
36433     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pAllocator);
36434
36435     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyValidationCacheEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->validationCache, NULL);
36436     return STATUS_SUCCESS;
36437 }
36438
36439 #ifdef _WIN64
36440 static NTSTATUS thunk64_vkDeviceWaitIdle(void *args)
36441 {
36442     struct vkDeviceWaitIdle_params *params = args;
36443
36444     TRACE("%p\n", params->device);
36445
36446     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeviceWaitIdle(wine_device_from_handle(params->device)->device);
36447     return STATUS_SUCCESS;
36448 }
36449 #endif /* _WIN64 */
36450
36451 static NTSTATUS thunk32_vkDeviceWaitIdle(void *args)
36452 {
36453     struct
36454     {
36455         PTR32 device;
36456         VkResult result;
36457     } *params = args;
36458
36459     TRACE("%#x\n", params->device);
36460
36461     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDeviceWaitIdle(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
36462     return STATUS_SUCCESS;
36463 }
36464
36465 #ifdef _WIN64
36466 static NTSTATUS thunk64_vkEndCommandBuffer(void *args)
36467 {
36468     struct vkEndCommandBuffer_params *params = args;
36469
36470     TRACE("%p\n", params->commandBuffer);
36471
36472     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
36473     return STATUS_SUCCESS;
36474 }
36475 #endif /* _WIN64 */
36476
36477 static NTSTATUS thunk32_vkEndCommandBuffer(void *args)
36478 {
36479     struct
36480     {
36481         PTR32 commandBuffer;
36482         VkResult result;
36483     } *params = args;
36484
36485     TRACE("%#x\n", params->commandBuffer);
36486
36487     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);
36488     return STATUS_SUCCESS;
36489 }
36490
36491 #ifdef _WIN64
36492 static NTSTATUS thunk64_vkEnumerateDeviceExtensionProperties(void *args)
36493 {
36494     struct vkEnumerateDeviceExtensionProperties_params *params = args;
36495
36496     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
36497
36498     params->result = wine_vkEnumerateDeviceExtensionProperties(params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
36499     return STATUS_SUCCESS;
36500 }
36501 #endif /* _WIN64 */
36502
36503 static NTSTATUS thunk32_vkEnumerateDeviceExtensionProperties(void *args)
36504 {
36505     struct
36506     {
36507         PTR32 physicalDevice;
36508         PTR32 pLayerName;
36509         PTR32 pPropertyCount;
36510         PTR32 pProperties;
36511         VkResult result;
36512     } *params = args;
36513
36514     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
36515
36516     params->result = wine_vkEnumerateDeviceExtensionProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (const char *)UlongToPtr(params->pLayerName), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkExtensionProperties *)UlongToPtr(params->pProperties));
36517     return STATUS_SUCCESS;
36518 }
36519
36520 #ifdef _WIN64
36521 static NTSTATUS thunk64_vkEnumerateDeviceLayerProperties(void *args)
36522 {
36523     struct vkEnumerateDeviceLayerProperties_params *params = args;
36524
36525     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
36526
36527     params->result = wine_vkEnumerateDeviceLayerProperties(params->physicalDevice, params->pPropertyCount, params->pProperties);
36528     return STATUS_SUCCESS;
36529 }
36530 #endif /* _WIN64 */
36531
36532 static NTSTATUS thunk32_vkEnumerateDeviceLayerProperties(void *args)
36533 {
36534     struct
36535     {
36536         PTR32 physicalDevice;
36537         PTR32 pPropertyCount;
36538         PTR32 pProperties;
36539         VkResult result;
36540     } *params = args;
36541
36542     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
36543
36544     params->result = wine_vkEnumerateDeviceLayerProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkLayerProperties *)UlongToPtr(params->pProperties));
36545     return STATUS_SUCCESS;
36546 }
36547
36548 #ifdef _WIN64
36549 static NTSTATUS thunk64_vkEnumerateInstanceExtensionProperties(void *args)
36550 {
36551     struct vkEnumerateInstanceExtensionProperties_params *params = args;
36552
36553     TRACE("%p, %p, %p\n", params->pLayerName, params->pPropertyCount, params->pProperties);
36554
36555     params->result = wine_vkEnumerateInstanceExtensionProperties(params->pLayerName, params->pPropertyCount, params->pProperties);
36556     return STATUS_SUCCESS;
36557 }
36558 #endif /* _WIN64 */
36559
36560 static NTSTATUS thunk32_vkEnumerateInstanceExtensionProperties(void *args)
36561 {
36562     struct
36563     {
36564         PTR32 pLayerName;
36565         PTR32 pPropertyCount;
36566         PTR32 pProperties;
36567         VkResult result;
36568     } *params = args;
36569
36570     TRACE("%#x, %#x, %#x\n", params->pLayerName, params->pPropertyCount, params->pProperties);
36571
36572     params->result = wine_vkEnumerateInstanceExtensionProperties((const char *)UlongToPtr(params->pLayerName), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkExtensionProperties *)UlongToPtr(params->pProperties));
36573     return STATUS_SUCCESS;
36574 }
36575
36576 #ifdef _WIN64
36577 static NTSTATUS thunk64_vkEnumerateInstanceVersion(void *args)
36578 {
36579     struct vkEnumerateInstanceVersion_params *params = args;
36580
36581     TRACE("%p\n", params->pApiVersion);
36582
36583     params->result = wine_vkEnumerateInstanceVersion(params->pApiVersion);
36584     return STATUS_SUCCESS;
36585 }
36586 #endif /* _WIN64 */
36587
36588 static NTSTATUS thunk32_vkEnumerateInstanceVersion(void *args)
36589 {
36590     struct
36591     {
36592         PTR32 pApiVersion;
36593         VkResult result;
36594     } *params = args;
36595
36596     TRACE("%#x\n", params->pApiVersion);
36597
36598     params->result = wine_vkEnumerateInstanceVersion((uint32_t *)UlongToPtr(params->pApiVersion));
36599     return STATUS_SUCCESS;
36600 }
36601
36602 #ifdef _WIN64
36603 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroups(void *args)
36604 {
36605     struct vkEnumeratePhysicalDeviceGroups_params *params = args;
36606
36607     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
36608
36609     params->result = wine_vkEnumeratePhysicalDeviceGroups(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
36610     return STATUS_SUCCESS;
36611 }
36612 #endif /* _WIN64 */
36613
36614 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroups(void *args)
36615 {
36616     struct
36617     {
36618         PTR32 instance;
36619         PTR32 pPhysicalDeviceGroupCount;
36620         PTR32 pPhysicalDeviceGroupProperties;
36621         VkResult result;
36622     } *params = args;
36623     VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties_host;
36624     struct conversion_context local_ctx;
36625     struct conversion_context *ctx = &local_ctx;
36626
36627     TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
36628
36629     init_conversion_context(ctx);
36630     pPhysicalDeviceGroupProperties_host = convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(ctx, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
36631     params->result = wine_vkEnumeratePhysicalDeviceGroups((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount), pPhysicalDeviceGroupProperties_host);
36632     convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(pPhysicalDeviceGroupProperties_host, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
36633     free_conversion_context(ctx);
36634     return STATUS_SUCCESS;
36635 }
36636
36637 #ifdef _WIN64
36638 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
36639 {
36640     struct vkEnumeratePhysicalDeviceGroupsKHR_params *params = args;
36641
36642     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
36643
36644     params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
36645     return STATUS_SUCCESS;
36646 }
36647 #endif /* _WIN64 */
36648
36649 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
36650 {
36651     struct
36652     {
36653         PTR32 instance;
36654         PTR32 pPhysicalDeviceGroupCount;
36655         PTR32 pPhysicalDeviceGroupProperties;
36656         VkResult result;
36657     } *params = args;
36658     VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties_host;
36659     struct conversion_context local_ctx;
36660     struct conversion_context *ctx = &local_ctx;
36661
36662     TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
36663
36664     init_conversion_context(ctx);
36665     pPhysicalDeviceGroupProperties_host = convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(ctx, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
36666     params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount), pPhysicalDeviceGroupProperties_host);
36667     convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(pPhysicalDeviceGroupProperties_host, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
36668     free_conversion_context(ctx);
36669     return STATUS_SUCCESS;
36670 }
36671
36672 #ifdef _WIN64
36673 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(void *args)
36674 {
36675     struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_params *params = args;
36676
36677     TRACE("%p, %u, %p, %p, %p\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
36678
36679     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);
36680     return STATUS_SUCCESS;
36681 }
36682 #endif /* _WIN64 */
36683
36684 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(void *args)
36685 {
36686     struct
36687     {
36688         PTR32 physicalDevice;
36689         uint32_t queueFamilyIndex;
36690         PTR32 pCounterCount;
36691         PTR32 pCounters;
36692         PTR32 pCounterDescriptions;
36693         VkResult result;
36694     } *params = args;
36695     VkPerformanceCounterKHR *pCounters_host;
36696     VkPerformanceCounterDescriptionKHR *pCounterDescriptions_host;
36697     struct conversion_context local_ctx;
36698     struct conversion_context *ctx = &local_ctx;
36699
36700     TRACE("%#x, %u, %#x, %#x, %#x\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
36701
36702     init_conversion_context(ctx);
36703     pCounters_host = convert_VkPerformanceCounterKHR_array_win32_to_host(ctx, (VkPerformanceCounterKHR32 *)UlongToPtr(params->pCounters), *(uint32_t *)UlongToPtr(params->pCounterCount));
36704     pCounterDescriptions_host = convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(ctx, (VkPerformanceCounterDescriptionKHR32 *)UlongToPtr(params->pCounterDescriptions), *(uint32_t *)UlongToPtr(params->pCounterCount));
36705     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);
36706     convert_VkPerformanceCounterKHR_array_host_to_win32(pCounters_host, (VkPerformanceCounterKHR32 *)UlongToPtr(params->pCounters), *(uint32_t *)UlongToPtr(params->pCounterCount));
36707     convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(pCounterDescriptions_host, (VkPerformanceCounterDescriptionKHR32 *)UlongToPtr(params->pCounterDescriptions), *(uint32_t *)UlongToPtr(params->pCounterCount));
36708     free_conversion_context(ctx);
36709     return STATUS_SUCCESS;
36710 }
36711
36712 #ifdef _WIN64
36713 static NTSTATUS thunk64_vkEnumeratePhysicalDevices(void *args)
36714 {
36715     struct vkEnumeratePhysicalDevices_params *params = args;
36716
36717     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
36718
36719     params->result = wine_vkEnumeratePhysicalDevices(params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
36720     return STATUS_SUCCESS;
36721 }
36722 #endif /* _WIN64 */
36723
36724 static NTSTATUS thunk32_vkEnumeratePhysicalDevices(void *args)
36725 {
36726     struct
36727     {
36728         PTR32 instance;
36729         PTR32 pPhysicalDeviceCount;
36730         PTR32 pPhysicalDevices;
36731         VkResult result;
36732     } *params = args;
36733     VkPhysicalDevice *pPhysicalDevices_host;
36734     struct conversion_context local_ctx;
36735     struct conversion_context *ctx = &local_ctx;
36736
36737     TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
36738
36739     init_conversion_context(ctx);
36740     pPhysicalDevices_host = (params->pPhysicalDevices && *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount)) ? conversion_context_alloc(ctx, sizeof(*pPhysicalDevices_host) * *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount)) : NULL;
36741     params->result = wine_vkEnumeratePhysicalDevices((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceCount), pPhysicalDevices_host);
36742     convert_VkPhysicalDevice_array_unwrapped_host_to_win32(pPhysicalDevices_host, (PTR32 *)UlongToPtr(params->pPhysicalDevices), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount));
36743     free_conversion_context(ctx);
36744     return STATUS_SUCCESS;
36745 }
36746
36747 #ifdef _WIN64
36748 static NTSTATUS thunk64_vkFlushMappedMemoryRanges(void *args)
36749 {
36750     struct vkFlushMappedMemoryRanges_params *params = args;
36751     const VkMappedMemoryRange *pMemoryRanges_host;
36752     struct conversion_context local_ctx;
36753     struct conversion_context *ctx = &local_ctx;
36754
36755     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
36756
36757     init_conversion_context(ctx);
36758     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win64_to_host(ctx, params->pMemoryRanges, params->memoryRangeCount);
36759     params->result = wine_device_from_handle(params->device)->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
36760     free_conversion_context(ctx);
36761     return STATUS_SUCCESS;
36762 }
36763 #endif /* _WIN64 */
36764
36765 static NTSTATUS thunk32_vkFlushMappedMemoryRanges(void *args)
36766 {
36767     struct
36768     {
36769         PTR32 device;
36770         uint32_t memoryRangeCount;
36771         PTR32 pMemoryRanges;
36772         VkResult result;
36773     } *params = args;
36774     const VkMappedMemoryRange *pMemoryRanges_host;
36775     struct conversion_context local_ctx;
36776     struct conversion_context *ctx = &local_ctx;
36777
36778     TRACE("%#x, %u, %#x\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
36779
36780     init_conversion_context(ctx);
36781     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(ctx, (const VkMappedMemoryRange32 *)UlongToPtr(params->pMemoryRanges), params->memoryRangeCount);
36782     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);
36783     free_conversion_context(ctx);
36784     return STATUS_SUCCESS;
36785 }
36786
36787 #ifdef _WIN64
36788 static NTSTATUS thunk64_vkFreeCommandBuffers(void *args)
36789 {
36790     struct vkFreeCommandBuffers_params *params = args;
36791
36792     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->commandBufferCount, params->pCommandBuffers);
36793
36794     wine_vkFreeCommandBuffers(params->device, params->commandPool, params->commandBufferCount, params->pCommandBuffers);
36795     return STATUS_SUCCESS;
36796 }
36797 #endif /* _WIN64 */
36798
36799 static NTSTATUS thunk32_vkFreeCommandBuffers(void *args)
36800 {
36801     struct
36802     {
36803         PTR32 device;
36804         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
36805         uint32_t commandBufferCount;
36806         PTR32 pCommandBuffers;
36807     } *params = args;
36808     const VkCommandBuffer *pCommandBuffers_host;
36809     struct conversion_context local_ctx;
36810     struct conversion_context *ctx = &local_ctx;
36811
36812     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->commandBufferCount, params->pCommandBuffers);
36813
36814     init_conversion_context(ctx);
36815     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_unwrapped_host(ctx, (const PTR32 *)UlongToPtr(params->pCommandBuffers), params->commandBufferCount);
36816     wine_vkFreeCommandBuffers((VkDevice)UlongToPtr(params->device), params->commandPool, params->commandBufferCount, pCommandBuffers_host);
36817     free_conversion_context(ctx);
36818     return STATUS_SUCCESS;
36819 }
36820
36821 #ifdef _WIN64
36822 static NTSTATUS thunk64_vkFreeDescriptorSets(void *args)
36823 {
36824     struct vkFreeDescriptorSets_params *params = args;
36825
36826     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);
36827
36828     params->result = wine_device_from_handle(params->device)->funcs.p_vkFreeDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorPool, params->descriptorSetCount, params->pDescriptorSets);
36829     return STATUS_SUCCESS;
36830 }
36831 #endif /* _WIN64 */
36832
36833 static NTSTATUS thunk32_vkFreeDescriptorSets(void *args)
36834 {
36835     struct
36836     {
36837         PTR32 device;
36838         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
36839         uint32_t descriptorSetCount;
36840         PTR32 pDescriptorSets;
36841         VkResult result;
36842     } *params = args;
36843
36844     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);
36845
36846     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));
36847     return STATUS_SUCCESS;
36848 }
36849
36850 #ifdef _WIN64
36851 static NTSTATUS thunk64_vkFreeMemory(void *args)
36852 {
36853     struct vkFreeMemory_params *params = args;
36854
36855     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pAllocator);
36856
36857     wine_vkFreeMemory(params->device, params->memory, params->pAllocator);
36858     return STATUS_SUCCESS;
36859 }
36860 #endif /* _WIN64 */
36861
36862 static NTSTATUS thunk32_vkFreeMemory(void *args)
36863 {
36864     struct
36865     {
36866         PTR32 device;
36867         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
36868         PTR32 pAllocator;
36869     } *params = args;
36870
36871     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->memory), params->pAllocator);
36872
36873     wine_vkFreeMemory((VkDevice)UlongToPtr(params->device), params->memory, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
36874     return STATUS_SUCCESS;
36875 }
36876
36877 #ifdef _WIN64
36878 static NTSTATUS thunk64_vkGetAccelerationStructureBuildSizesKHR(void *args)
36879 {
36880     struct vkGetAccelerationStructureBuildSizesKHR_params *params = args;
36881
36882     TRACE("%p, %#x, %p, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
36883
36884     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureBuildSizesKHR(wine_device_from_handle(params->device)->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
36885     return STATUS_SUCCESS;
36886 }
36887 #endif /* _WIN64 */
36888
36889 static NTSTATUS thunk32_vkGetAccelerationStructureBuildSizesKHR(void *args)
36890 {
36891     struct
36892     {
36893         PTR32 device;
36894         VkAccelerationStructureBuildTypeKHR buildType;
36895         PTR32 pBuildInfo;
36896         PTR32 pMaxPrimitiveCounts;
36897         PTR32 pSizeInfo;
36898     } *params = args;
36899     VkAccelerationStructureBuildGeometryInfoKHR pBuildInfo_host;
36900     VkAccelerationStructureBuildSizesInfoKHR pSizeInfo_host;
36901     struct conversion_context local_ctx;
36902     struct conversion_context *ctx = &local_ctx;
36903
36904     TRACE("%#x, %#x, %#x, %#x, %#x\n", params->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
36905
36906     init_conversion_context(ctx);
36907     convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pBuildInfo), &pBuildInfo_host);
36908     convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host((VkAccelerationStructureBuildSizesInfoKHR32 *)UlongToPtr(params->pSizeInfo), &pSizeInfo_host);
36909     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);
36910     convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(&pSizeInfo_host, (VkAccelerationStructureBuildSizesInfoKHR32 *)UlongToPtr(params->pSizeInfo));
36911     free_conversion_context(ctx);
36912     return STATUS_SUCCESS;
36913 }
36914
36915 #ifdef _WIN64
36916 static NTSTATUS thunk64_vkGetAccelerationStructureDeviceAddressKHR(void *args)
36917 {
36918     struct vkGetAccelerationStructureDeviceAddressKHR_params *params = args;
36919
36920     TRACE("%p, %p\n", params->device, params->pInfo);
36921
36922     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
36923     return STATUS_SUCCESS;
36924 }
36925 #endif /* _WIN64 */
36926
36927 static NTSTATUS thunk32_vkGetAccelerationStructureDeviceAddressKHR(void *args)
36928 {
36929     struct
36930     {
36931         PTR32 device;
36932         PTR32 pInfo;
36933         VkDeviceAddress result;
36934     } *params = args;
36935     VkAccelerationStructureDeviceAddressInfoKHR pInfo_host;
36936
36937     TRACE("%#x, %#x\n", params->device, params->pInfo);
36938
36939     convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host((const VkAccelerationStructureDeviceAddressInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
36940     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
36941     return STATUS_SUCCESS;
36942 }
36943
36944 #ifdef _WIN64
36945 static NTSTATUS thunk64_vkGetAccelerationStructureHandleNV(void *args)
36946 {
36947     struct vkGetAccelerationStructureHandleNV_params *params = args;
36948
36949     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);
36950
36951     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, params->dataSize, params->pData);
36952     return STATUS_SUCCESS;
36953 }
36954 #endif /* _WIN64 */
36955
36956 static NTSTATUS thunk32_vkGetAccelerationStructureHandleNV(void *args)
36957 {
36958     struct
36959     {
36960         PTR32 device;
36961         VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
36962         PTR32 dataSize;
36963         PTR32 pData;
36964         VkResult result;
36965     } *params = args;
36966
36967     TRACE("%#x, 0x%s, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);
36968
36969     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));
36970     return STATUS_SUCCESS;
36971 }
36972
36973 #ifdef _WIN64
36974 static NTSTATUS thunk64_vkGetAccelerationStructureMemoryRequirementsNV(void *args)
36975 {
36976     struct vkGetAccelerationStructureMemoryRequirementsNV_params *params = args;
36977
36978     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36979
36980     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36981     return STATUS_SUCCESS;
36982 }
36983 #endif /* _WIN64 */
36984
36985 static NTSTATUS thunk32_vkGetAccelerationStructureMemoryRequirementsNV(void *args)
36986 {
36987     struct
36988     {
36989         PTR32 device;
36990         PTR32 pInfo;
36991         PTR32 pMemoryRequirements;
36992     } *params = args;
36993     VkAccelerationStructureMemoryRequirementsInfoNV pInfo_host;
36994     VkMemoryRequirements2KHR pMemoryRequirements_host;
36995
36996     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36997
36998     convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host((const VkAccelerationStructureMemoryRequirementsInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
36999     convert_VkMemoryRequirements2KHR_win32_to_host((VkMemoryRequirements2KHR32 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
37000     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
37001     convert_VkMemoryRequirements2KHR_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements2KHR32 *)UlongToPtr(params->pMemoryRequirements));
37002     return STATUS_SUCCESS;
37003 }
37004
37005 #ifdef _WIN64
37006 static NTSTATUS thunk64_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(void *args)
37007 {
37008     struct vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_params *params = args;
37009
37010     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
37011
37012     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
37013     return STATUS_SUCCESS;
37014 }
37015 #endif /* _WIN64 */
37016
37017 static NTSTATUS thunk32_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(void *args)
37018 {
37019     struct
37020     {
37021         PTR32 device;
37022         PTR32 pInfo;
37023         PTR32 pData;
37024         VkResult result;
37025     } *params = args;
37026     VkAccelerationStructureCaptureDescriptorDataInfoEXT pInfo_host;
37027
37028     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
37029
37030     convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_win32_to_host((const VkAccelerationStructureCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
37031     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));
37032     return STATUS_SUCCESS;
37033 }
37034
37035 #ifdef _WIN64
37036 static NTSTATUS thunk64_vkGetBufferDeviceAddress(void *args)
37037 {
37038     struct vkGetBufferDeviceAddress_params *params = args;
37039
37040     TRACE("%p, %p\n", params->device, params->pInfo);
37041
37042     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddress(wine_device_from_handle(params->device)->device, params->pInfo);
37043     return STATUS_SUCCESS;
37044 }
37045 #endif /* _WIN64 */
37046
37047 static NTSTATUS thunk32_vkGetBufferDeviceAddress(void *args)
37048 {
37049     struct
37050     {
37051         PTR32 device;
37052         PTR32 pInfo;
37053         VkDeviceAddress result;
37054     } *params = args;
37055     VkBufferDeviceAddressInfo pInfo_host;
37056
37057     TRACE("%#x, %#x\n", params->device, params->pInfo);
37058
37059     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
37060     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
37061     return STATUS_SUCCESS;
37062 }
37063
37064 #ifdef _WIN64
37065 static NTSTATUS thunk64_vkGetBufferDeviceAddressEXT(void *args)
37066 {
37067     struct vkGetBufferDeviceAddressEXT_params *params = args;
37068
37069     TRACE("%p, %p\n", params->device, params->pInfo);
37070
37071     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressEXT(wine_device_from_handle(params->device)->device, params->pInfo);
37072     return STATUS_SUCCESS;
37073 }
37074 #endif /* _WIN64 */
37075
37076 static NTSTATUS thunk32_vkGetBufferDeviceAddressEXT(void *args)
37077 {
37078     struct
37079     {
37080         PTR32 device;
37081         PTR32 pInfo;
37082         VkDeviceAddress result;
37083     } *params = args;
37084     VkBufferDeviceAddressInfo pInfo_host;
37085
37086     TRACE("%#x, %#x\n", params->device, params->pInfo);
37087
37088     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
37089     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddressEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
37090     return STATUS_SUCCESS;
37091 }
37092
37093 #ifdef _WIN64
37094 static NTSTATUS thunk64_vkGetBufferDeviceAddressKHR(void *args)
37095 {
37096     struct vkGetBufferDeviceAddressKHR_params *params = args;
37097
37098     TRACE("%p, %p\n", params->device, params->pInfo);
37099
37100     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
37101     return STATUS_SUCCESS;
37102 }
37103 #endif /* _WIN64 */
37104
37105 static NTSTATUS thunk32_vkGetBufferDeviceAddressKHR(void *args)
37106 {
37107     struct
37108     {
37109         PTR32 device;
37110         PTR32 pInfo;
37111         VkDeviceAddress result;
37112     } *params = args;
37113     VkBufferDeviceAddressInfo pInfo_host;
37114
37115     TRACE("%#x, %#x\n", params->device, params->pInfo);
37116
37117     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
37118     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
37119     return STATUS_SUCCESS;
37120 }
37121
37122 #ifdef _WIN64
37123 static NTSTATUS thunk64_vkGetBufferMemoryRequirements(void *args)
37124 {
37125     struct vkGetBufferMemoryRequirements_params *params = args;
37126
37127     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pMemoryRequirements);
37128
37129     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->buffer, params->pMemoryRequirements);
37130     return STATUS_SUCCESS;
37131 }
37132 #endif /* _WIN64 */
37133
37134 static NTSTATUS thunk32_vkGetBufferMemoryRequirements(void *args)
37135 {
37136     struct
37137     {
37138         PTR32 device;
37139         VkBuffer DECLSPEC_ALIGN(8) buffer;
37140         PTR32 pMemoryRequirements;
37141     } *params = args;
37142     VkMemoryRequirements pMemoryRequirements_host;
37143
37144     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->buffer), params->pMemoryRequirements);
37145
37146     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buffer, &pMemoryRequirements_host);
37147     convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements32 *)UlongToPtr(params->pMemoryRequirements));
37148     return STATUS_SUCCESS;
37149 }
37150
37151 #ifdef _WIN64
37152 static NTSTATUS thunk64_vkGetBufferMemoryRequirements2(void *args)
37153 {
37154     struct vkGetBufferMemoryRequirements2_params *params = args;
37155
37156     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37157
37158     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
37159     return STATUS_SUCCESS;
37160 }
37161 #endif /* _WIN64 */
37162
37163 static NTSTATUS thunk32_vkGetBufferMemoryRequirements2(void *args)
37164 {
37165     struct
37166     {
37167         PTR32 device;
37168         PTR32 pInfo;
37169         PTR32 pMemoryRequirements;
37170     } *params = args;
37171     VkBufferMemoryRequirementsInfo2 pInfo_host;
37172     VkMemoryRequirements2 pMemoryRequirements_host;
37173     struct conversion_context local_ctx;
37174     struct conversion_context *ctx = &local_ctx;
37175
37176     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
37177
37178     init_conversion_context(ctx);
37179     convert_VkBufferMemoryRequirementsInfo2_win32_to_host((const VkBufferMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
37180     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
37181     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
37182     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
37183     free_conversion_context(ctx);
37184     return STATUS_SUCCESS;
37185 }
37186
37187 #ifdef _WIN64
37188 static NTSTATUS thunk64_vkGetBufferMemoryRequirements2KHR(void *args)
37189 {
37190     struct vkGetBufferMemoryRequirements2KHR_params *params = args;
37191
37192     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37193
37194     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
37195     return STATUS_SUCCESS;
37196 }
37197 #endif /* _WIN64 */
37198
37199 static NTSTATUS thunk32_vkGetBufferMemoryRequirements2KHR(void *args)
37200 {
37201     struct
37202     {
37203         PTR32 device;
37204         PTR32 pInfo;
37205         PTR32 pMemoryRequirements;
37206     } *params = args;
37207     VkBufferMemoryRequirementsInfo2 pInfo_host;
37208     VkMemoryRequirements2 pMemoryRequirements_host;
37209     struct conversion_context local_ctx;
37210     struct conversion_context *ctx = &local_ctx;
37211
37212     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
37213
37214     init_conversion_context(ctx);
37215     convert_VkBufferMemoryRequirementsInfo2_win32_to_host((const VkBufferMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
37216     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
37217     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
37218     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
37219     free_conversion_context(ctx);
37220     return STATUS_SUCCESS;
37221 }
37222
37223 #ifdef _WIN64
37224 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureAddress(void *args)
37225 {
37226     struct vkGetBufferOpaqueCaptureAddress_params *params = args;
37227
37228     TRACE("%p, %p\n", params->device, params->pInfo);
37229
37230     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, params->pInfo);
37231     return STATUS_SUCCESS;
37232 }
37233 #endif /* _WIN64 */
37234
37235 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddress(void *args)
37236 {
37237     struct
37238     {
37239         PTR32 device;
37240         PTR32 pInfo;
37241         uint64_t result;
37242     } *params = args;
37243     VkBufferDeviceAddressInfo pInfo_host;
37244
37245     TRACE("%#x, %#x\n", params->device, params->pInfo);
37246
37247     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
37248     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferOpaqueCaptureAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
37249     return STATUS_SUCCESS;
37250 }
37251
37252 #ifdef _WIN64
37253 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureAddressKHR(void *args)
37254 {
37255     struct vkGetBufferOpaqueCaptureAddressKHR_params *params = args;
37256
37257     TRACE("%p, %p\n", params->device, params->pInfo);
37258
37259     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
37260     return STATUS_SUCCESS;
37261 }
37262 #endif /* _WIN64 */
37263
37264 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddressKHR(void *args)
37265 {
37266     struct
37267     {
37268         PTR32 device;
37269         PTR32 pInfo;
37270         uint64_t result;
37271     } *params = args;
37272     VkBufferDeviceAddressInfo pInfo_host;
37273
37274     TRACE("%#x, %#x\n", params->device, params->pInfo);
37275
37276     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
37277     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
37278     return STATUS_SUCCESS;
37279 }
37280
37281 #ifdef _WIN64
37282 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureDescriptorDataEXT(void *args)
37283 {
37284     struct vkGetBufferOpaqueCaptureDescriptorDataEXT_params *params = args;
37285
37286     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
37287
37288     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
37289     return STATUS_SUCCESS;
37290 }
37291 #endif /* _WIN64 */
37292
37293 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureDescriptorDataEXT(void *args)
37294 {
37295     struct
37296     {
37297         PTR32 device;
37298         PTR32 pInfo;
37299         PTR32 pData;
37300         VkResult result;
37301     } *params = args;
37302     VkBufferCaptureDescriptorDataInfoEXT pInfo_host;
37303
37304     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
37305
37306     convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host((const VkBufferCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
37307     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));
37308     return STATUS_SUCCESS;
37309 }
37310
37311 #ifdef _WIN64
37312 static NTSTATUS thunk64_vkGetCalibratedTimestampsEXT(void *args)
37313 {
37314     struct vkGetCalibratedTimestampsEXT_params *params = args;
37315
37316     TRACE("%p, %u, %p, %p, %p\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
37317
37318     params->result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
37319     return STATUS_SUCCESS;
37320 }
37321 #endif /* _WIN64 */
37322
37323 static NTSTATUS thunk32_vkGetCalibratedTimestampsEXT(void *args)
37324 {
37325     struct
37326     {
37327         PTR32 device;
37328         uint32_t timestampCount;
37329         PTR32 pTimestampInfos;
37330         PTR32 pTimestamps;
37331         PTR32 pMaxDeviation;
37332         VkResult result;
37333     } *params = args;
37334     const VkCalibratedTimestampInfoEXT *pTimestampInfos_host;
37335     struct conversion_context local_ctx;
37336     struct conversion_context *ctx = &local_ctx;
37337
37338     TRACE("%#x, %u, %#x, %#x, %#x\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
37339
37340     init_conversion_context(ctx);
37341     pTimestampInfos_host = convert_VkCalibratedTimestampInfoEXT_array_win32_to_host(ctx, (const VkCalibratedTimestampInfoEXT32 *)UlongToPtr(params->pTimestampInfos), params->timestampCount);
37342     params->result = wine_vkGetCalibratedTimestampsEXT((VkDevice)UlongToPtr(params->device), params->timestampCount, pTimestampInfos_host, (uint64_t *)UlongToPtr(params->pTimestamps), (uint64_t *)UlongToPtr(params->pMaxDeviation));
37343     free_conversion_context(ctx);
37344     return STATUS_SUCCESS;
37345 }
37346
37347 #ifdef _WIN64
37348 static NTSTATUS thunk64_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
37349 {
37350     struct vkGetDeferredOperationMaxConcurrencyKHR_params *params = args;
37351
37352     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
37353
37354     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle(params->device)->device, wine_deferred_operation_from_handle(params->operation)->deferred_operation);
37355     return STATUS_SUCCESS;
37356 }
37357 #endif /* _WIN64 */
37358
37359 static NTSTATUS thunk32_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
37360 {
37361     struct
37362     {
37363         PTR32 device;
37364         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
37365         uint32_t result;
37366     } *params = args;
37367
37368     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
37369
37370     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, wine_deferred_operation_from_handle(params->operation)->deferred_operation);
37371     return STATUS_SUCCESS;
37372 }
37373
37374 #ifdef _WIN64
37375 static NTSTATUS thunk64_vkGetDeferredOperationResultKHR(void *args)
37376 {
37377     struct vkGetDeferredOperationResultKHR_params *params = args;
37378
37379     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
37380
37381     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle(params->device)->device, wine_deferred_operation_from_handle(params->operation)->deferred_operation);
37382     return STATUS_SUCCESS;
37383 }
37384 #endif /* _WIN64 */
37385
37386 static NTSTATUS thunk32_vkGetDeferredOperationResultKHR(void *args)
37387 {
37388     struct
37389     {
37390         PTR32 device;
37391         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
37392         VkResult result;
37393     } *params = args;
37394
37395     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
37396
37397     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, wine_deferred_operation_from_handle(params->operation)->deferred_operation);
37398     return STATUS_SUCCESS;
37399 }
37400
37401 #ifdef _WIN64
37402 static void thunk64_vkGetDescriptorEXT(void *args)
37403 {
37404     struct vkGetDescriptorEXT_params *params = args;
37405
37406     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorEXT(wine_device_from_handle(params->device)->device, params->pDescriptorInfo, params->dataSize, params->pDescriptor);
37407 }
37408 #endif /* _WIN64 */
37409
37410 static void thunk32_vkGetDescriptorEXT(void *args)
37411 {
37412     struct
37413     {
37414         PTR32 device;
37415         PTR32 pDescriptorInfo;
37416         PTR32 dataSize;
37417         PTR32 pDescriptor;
37418     } *params = args;
37419     VkDescriptorGetInfoEXT pDescriptorInfo_host;
37420     struct conversion_context local_ctx;
37421     struct conversion_context *ctx = &local_ctx;
37422
37423     init_conversion_context(ctx);
37424     convert_VkDescriptorGetInfoEXT_win32_to_host(ctx, (const VkDescriptorGetInfoEXT32 *)UlongToPtr(params->pDescriptorInfo), &pDescriptorInfo_host);
37425     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));
37426     free_conversion_context(ctx);
37427 }
37428
37429 #ifdef _WIN64
37430 static NTSTATUS thunk64_vkGetDescriptorSetHostMappingVALVE(void *args)
37431 {
37432     struct vkGetDescriptorSetHostMappingVALVE_params *params = args;
37433
37434     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), params->ppData);
37435
37436     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetHostMappingVALVE(wine_device_from_handle(params->device)->device, params->descriptorSet, params->ppData);
37437     return STATUS_SUCCESS;
37438 }
37439 #endif /* _WIN64 */
37440
37441 static NTSTATUS thunk32_vkGetDescriptorSetHostMappingVALVE(void *args)
37442 {
37443     struct
37444     {
37445         PTR32 device;
37446         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
37447         PTR32 ppData;
37448     } *params = args;
37449
37450     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSet), params->ppData);
37451
37452     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));
37453     return STATUS_SUCCESS;
37454 }
37455
37456 #ifdef _WIN64
37457 static NTSTATUS thunk64_vkGetDescriptorSetLayoutBindingOffsetEXT(void *args)
37458 {
37459     struct vkGetDescriptorSetLayoutBindingOffsetEXT_params *params = args;
37460
37461     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->layout), params->binding, params->pOffset);
37462
37463     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutBindingOffsetEXT(wine_device_from_handle(params->device)->device, params->layout, params->binding, params->pOffset);
37464     return STATUS_SUCCESS;
37465 }
37466 #endif /* _WIN64 */
37467
37468 static NTSTATUS thunk32_vkGetDescriptorSetLayoutBindingOffsetEXT(void *args)
37469 {
37470     struct
37471     {
37472         PTR32 device;
37473         VkDescriptorSetLayout DECLSPEC_ALIGN(8) layout;
37474         uint32_t binding;
37475         PTR32 pOffset;
37476     } *params = args;
37477
37478     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->layout), params->binding, params->pOffset);
37479
37480     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));
37481     return STATUS_SUCCESS;
37482 }
37483
37484 #ifdef _WIN64
37485 static NTSTATUS thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args)
37486 {
37487     struct vkGetDescriptorSetLayoutHostMappingInfoVALVE_params *params = args;
37488
37489     TRACE("%p, %p, %p\n", params->device, params->pBindingReference, params->pHostMapping);
37490
37491     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutHostMappingInfoVALVE(wine_device_from_handle(params->device)->device, params->pBindingReference, params->pHostMapping);
37492     return STATUS_SUCCESS;
37493 }
37494 #endif /* _WIN64 */
37495
37496 static NTSTATUS thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args)
37497 {
37498     struct
37499     {
37500         PTR32 device;
37501         PTR32 pBindingReference;
37502         PTR32 pHostMapping;
37503     } *params = args;
37504     VkDescriptorSetBindingReferenceVALVE pBindingReference_host;
37505     VkDescriptorSetLayoutHostMappingInfoVALVE pHostMapping_host;
37506
37507     TRACE("%#x, %#x, %#x\n", params->device, params->pBindingReference, params->pHostMapping);
37508
37509     convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host((const VkDescriptorSetBindingReferenceVALVE32 *)UlongToPtr(params->pBindingReference), &pBindingReference_host);
37510     convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host((VkDescriptorSetLayoutHostMappingInfoVALVE32 *)UlongToPtr(params->pHostMapping), &pHostMapping_host);
37511     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutHostMappingInfoVALVE(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pBindingReference_host, &pHostMapping_host);
37512     convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(&pHostMapping_host, (VkDescriptorSetLayoutHostMappingInfoVALVE32 *)UlongToPtr(params->pHostMapping));
37513     return STATUS_SUCCESS;
37514 }
37515
37516 #ifdef _WIN64
37517 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSizeEXT(void *args)
37518 {
37519     struct vkGetDescriptorSetLayoutSizeEXT_params *params = args;
37520
37521     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->layout), params->pLayoutSizeInBytes);
37522
37523     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSizeEXT(wine_device_from_handle(params->device)->device, params->layout, params->pLayoutSizeInBytes);
37524     return STATUS_SUCCESS;
37525 }
37526 #endif /* _WIN64 */
37527
37528 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSizeEXT(void *args)
37529 {
37530     struct
37531     {
37532         PTR32 device;
37533         VkDescriptorSetLayout DECLSPEC_ALIGN(8) layout;
37534         PTR32 pLayoutSizeInBytes;
37535     } *params = args;
37536
37537     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->layout), params->pLayoutSizeInBytes);
37538
37539     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));
37540     return STATUS_SUCCESS;
37541 }
37542
37543 #ifdef _WIN64
37544 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSupport(void *args)
37545 {
37546     struct vkGetDescriptorSetLayoutSupport_params *params = args;
37547
37548     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
37549
37550     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupport(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pSupport);
37551     return STATUS_SUCCESS;
37552 }
37553 #endif /* _WIN64 */
37554
37555 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSupport(void *args)
37556 {
37557     struct
37558     {
37559         PTR32 device;
37560         PTR32 pCreateInfo;
37561         PTR32 pSupport;
37562     } *params = args;
37563     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
37564     VkDescriptorSetLayoutSupport pSupport_host;
37565     struct conversion_context local_ctx;
37566     struct conversion_context *ctx = &local_ctx;
37567
37568     TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pSupport);
37569
37570     init_conversion_context(ctx);
37571     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
37572     convert_VkDescriptorSetLayoutSupport_win32_to_host(ctx, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport), &pSupport_host);
37573     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutSupport(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pSupport_host);
37574     convert_VkDescriptorSetLayoutSupport_host_to_win32(&pSupport_host, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport));
37575     free_conversion_context(ctx);
37576     return STATUS_SUCCESS;
37577 }
37578
37579 #ifdef _WIN64
37580 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSupportKHR(void *args)
37581 {
37582     struct vkGetDescriptorSetLayoutSupportKHR_params *params = args;
37583
37584     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
37585
37586     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupportKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pSupport);
37587     return STATUS_SUCCESS;
37588 }
37589 #endif /* _WIN64 */
37590
37591 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSupportKHR(void *args)
37592 {
37593     struct
37594     {
37595         PTR32 device;
37596         PTR32 pCreateInfo;
37597         PTR32 pSupport;
37598     } *params = args;
37599     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
37600     VkDescriptorSetLayoutSupport pSupport_host;
37601     struct conversion_context local_ctx;
37602     struct conversion_context *ctx = &local_ctx;
37603
37604     TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pSupport);
37605
37606     init_conversion_context(ctx);
37607     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
37608     convert_VkDescriptorSetLayoutSupport_win32_to_host(ctx, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport), &pSupport_host);
37609     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutSupportKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pSupport_host);
37610     convert_VkDescriptorSetLayoutSupport_host_to_win32(&pSupport_host, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport));
37611     free_conversion_context(ctx);
37612     return STATUS_SUCCESS;
37613 }
37614
37615 #ifdef _WIN64
37616 static NTSTATUS thunk64_vkGetDeviceAccelerationStructureCompatibilityKHR(void *args)
37617 {
37618     struct vkGetDeviceAccelerationStructureCompatibilityKHR_params *params = args;
37619
37620     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
37621
37622     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceAccelerationStructureCompatibilityKHR(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
37623     return STATUS_SUCCESS;
37624 }
37625 #endif /* _WIN64 */
37626
37627 static NTSTATUS thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR(void *args)
37628 {
37629     struct
37630     {
37631         PTR32 device;
37632         PTR32 pVersionInfo;
37633         PTR32 pCompatibility;
37634     } *params = args;
37635     VkAccelerationStructureVersionInfoKHR pVersionInfo_host;
37636
37637     TRACE("%#x, %#x, %#x\n", params->device, params->pVersionInfo, params->pCompatibility);
37638
37639     convert_VkAccelerationStructureVersionInfoKHR_win32_to_host((const VkAccelerationStructureVersionInfoKHR32 *)UlongToPtr(params->pVersionInfo), &pVersionInfo_host);
37640     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));
37641     return STATUS_SUCCESS;
37642 }
37643
37644 #ifdef _WIN64
37645 static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirements(void *args)
37646 {
37647     struct vkGetDeviceBufferMemoryRequirements_params *params = args;
37648
37649     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37650
37651     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
37652     return STATUS_SUCCESS;
37653 }
37654 #endif /* _WIN64 */
37655
37656 static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirements(void *args)
37657 {
37658     struct
37659     {
37660         PTR32 device;
37661         PTR32 pInfo;
37662         PTR32 pMemoryRequirements;
37663     } *params = args;
37664     VkDeviceBufferMemoryRequirements pInfo_host;
37665     VkMemoryRequirements2 pMemoryRequirements_host;
37666     struct conversion_context local_ctx;
37667     struct conversion_context *ctx = &local_ctx;
37668
37669     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
37670
37671     init_conversion_context(ctx);
37672     convert_VkDeviceBufferMemoryRequirements_win32_to_host(ctx, (const VkDeviceBufferMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
37673     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
37674     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceBufferMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
37675     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
37676     free_conversion_context(ctx);
37677     return STATUS_SUCCESS;
37678 }
37679
37680 #ifdef _WIN64
37681 static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirementsKHR(void *args)
37682 {
37683     struct vkGetDeviceBufferMemoryRequirementsKHR_params *params = args;
37684
37685     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37686
37687     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
37688     return STATUS_SUCCESS;
37689 }
37690 #endif /* _WIN64 */
37691
37692 static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirementsKHR(void *args)
37693 {
37694     struct
37695     {
37696         PTR32 device;
37697         PTR32 pInfo;
37698         PTR32 pMemoryRequirements;
37699     } *params = args;
37700     VkDeviceBufferMemoryRequirements pInfo_host;
37701     VkMemoryRequirements2 pMemoryRequirements_host;
37702     struct conversion_context local_ctx;
37703     struct conversion_context *ctx = &local_ctx;
37704
37705     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
37706
37707     init_conversion_context(ctx);
37708     convert_VkDeviceBufferMemoryRequirements_win32_to_host(ctx, (const VkDeviceBufferMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
37709     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
37710     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceBufferMemoryRequirementsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
37711     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
37712     free_conversion_context(ctx);
37713     return STATUS_SUCCESS;
37714 }
37715
37716 #ifdef _WIN64
37717 static NTSTATUS thunk64_vkGetDeviceFaultInfoEXT(void *args)
37718 {
37719     struct vkGetDeviceFaultInfoEXT_params *params = args;
37720
37721     TRACE("%p, %p, %p\n", params->device, params->pFaultCounts, params->pFaultInfo);
37722
37723     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceFaultInfoEXT(wine_device_from_handle(params->device)->device, params->pFaultCounts, params->pFaultInfo);
37724     return STATUS_SUCCESS;
37725 }
37726 #endif /* _WIN64 */
37727
37728 static NTSTATUS thunk32_vkGetDeviceFaultInfoEXT(void *args)
37729 {
37730     struct
37731     {
37732         PTR32 device;
37733         PTR32 pFaultCounts;
37734         PTR32 pFaultInfo;
37735         VkResult result;
37736     } *params = args;
37737     VkDeviceFaultCountsEXT pFaultCounts_host;
37738     VkDeviceFaultInfoEXT *pFaultInfo_host = NULL;
37739     struct conversion_context local_ctx;
37740     struct conversion_context *ctx = &local_ctx;
37741
37742     TRACE("%#x, %#x, %#x\n", params->device, params->pFaultCounts, params->pFaultInfo);
37743
37744     init_conversion_context(ctx);
37745     convert_VkDeviceFaultCountsEXT_win32_to_host((VkDeviceFaultCountsEXT32 *)UlongToPtr(params->pFaultCounts), &pFaultCounts_host);
37746     if (params->pFaultInfo)
37747     {
37748         pFaultInfo_host = conversion_context_alloc(ctx, sizeof(*pFaultInfo_host));
37749         convert_VkDeviceFaultInfoEXT_win32_to_host(ctx, (VkDeviceFaultInfoEXT32 *)UlongToPtr(params->pFaultInfo), pFaultInfo_host);
37750     }
37751     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);
37752     convert_VkDeviceFaultCountsEXT_host_to_win32(&pFaultCounts_host, (VkDeviceFaultCountsEXT32 *)UlongToPtr(params->pFaultCounts));
37753     convert_VkDeviceFaultInfoEXT_host_to_win32(pFaultInfo_host, (VkDeviceFaultInfoEXT32 *)UlongToPtr(params->pFaultInfo));
37754     free_conversion_context(ctx);
37755     return STATUS_SUCCESS;
37756 }
37757
37758 #ifdef _WIN64
37759 static NTSTATUS thunk64_vkGetDeviceGroupPeerMemoryFeatures(void *args)
37760 {
37761     struct vkGetDeviceGroupPeerMemoryFeatures_params *params = args;
37762
37763     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
37764
37765     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
37766     return STATUS_SUCCESS;
37767 }
37768 #endif /* _WIN64 */
37769
37770 static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeatures(void *args)
37771 {
37772     struct
37773     {
37774         PTR32 device;
37775         uint32_t heapIndex;
37776         uint32_t localDeviceIndex;
37777         uint32_t remoteDeviceIndex;
37778         PTR32 pPeerMemoryFeatures;
37779     } *params = args;
37780
37781     TRACE("%#x, %u, %u, %u, %#x\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
37782
37783     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));
37784     return STATUS_SUCCESS;
37785 }
37786
37787 #ifdef _WIN64
37788 static NTSTATUS thunk64_vkGetDeviceGroupPeerMemoryFeaturesKHR(void *args)
37789 {
37790     struct vkGetDeviceGroupPeerMemoryFeaturesKHR_params *params = args;
37791
37792     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
37793
37794     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
37795     return STATUS_SUCCESS;
37796 }
37797 #endif /* _WIN64 */
37798
37799 static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR(void *args)
37800 {
37801     struct
37802     {
37803         PTR32 device;
37804         uint32_t heapIndex;
37805         uint32_t localDeviceIndex;
37806         uint32_t remoteDeviceIndex;
37807         PTR32 pPeerMemoryFeatures;
37808     } *params = args;
37809
37810     TRACE("%#x, %u, %u, %u, %#x\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
37811
37812     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));
37813     return STATUS_SUCCESS;
37814 }
37815
37816 #ifdef _WIN64
37817 static NTSTATUS thunk64_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
37818 {
37819     struct vkGetDeviceGroupPresentCapabilitiesKHR_params *params = args;
37820
37821     TRACE("%p, %p\n", params->device, params->pDeviceGroupPresentCapabilities);
37822
37823     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle(params->device)->device, params->pDeviceGroupPresentCapabilities);
37824     return STATUS_SUCCESS;
37825 }
37826 #endif /* _WIN64 */
37827
37828 static NTSTATUS thunk32_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
37829 {
37830     struct
37831     {
37832         PTR32 device;
37833         PTR32 pDeviceGroupPresentCapabilities;
37834         VkResult result;
37835     } *params = args;
37836     VkDeviceGroupPresentCapabilitiesKHR pDeviceGroupPresentCapabilities_host;
37837
37838     TRACE("%#x, %#x\n", params->device, params->pDeviceGroupPresentCapabilities);
37839
37840     convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host((VkDeviceGroupPresentCapabilitiesKHR32 *)UlongToPtr(params->pDeviceGroupPresentCapabilities), &pDeviceGroupPresentCapabilities_host);
37841     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pDeviceGroupPresentCapabilities_host);
37842     convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(&pDeviceGroupPresentCapabilities_host, (VkDeviceGroupPresentCapabilitiesKHR32 *)UlongToPtr(params->pDeviceGroupPresentCapabilities));
37843     return STATUS_SUCCESS;
37844 }
37845
37846 #ifdef _WIN64
37847 static NTSTATUS thunk64_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
37848 {
37849     struct vkGetDeviceGroupSurfacePresentModesKHR_params *params = args;
37850
37851     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);
37852
37853     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);
37854     return STATUS_SUCCESS;
37855 }
37856 #endif /* _WIN64 */
37857
37858 static NTSTATUS thunk32_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
37859 {
37860     struct
37861     {
37862         PTR32 device;
37863         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
37864         PTR32 pModes;
37865         VkResult result;
37866     } *params = args;
37867
37868     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);
37869
37870     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));
37871     return STATUS_SUCCESS;
37872 }
37873
37874 #ifdef _WIN64
37875 static NTSTATUS thunk64_vkGetDeviceImageMemoryRequirements(void *args)
37876 {
37877     struct vkGetDeviceImageMemoryRequirements_params *params = args;
37878
37879     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37880
37881     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
37882     return STATUS_SUCCESS;
37883 }
37884 #endif /* _WIN64 */
37885
37886 static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirements(void *args)
37887 {
37888     struct
37889     {
37890         PTR32 device;
37891         PTR32 pInfo;
37892         PTR32 pMemoryRequirements;
37893     } *params = args;
37894     VkDeviceImageMemoryRequirements pInfo_host;
37895     VkMemoryRequirements2 pMemoryRequirements_host;
37896     struct conversion_context local_ctx;
37897     struct conversion_context *ctx = &local_ctx;
37898
37899     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
37900
37901     init_conversion_context(ctx);
37902     convert_VkDeviceImageMemoryRequirements_win32_to_host(ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
37903     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
37904     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
37905     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
37906     free_conversion_context(ctx);
37907     return STATUS_SUCCESS;
37908 }
37909
37910 #ifdef _WIN64
37911 static NTSTATUS thunk64_vkGetDeviceImageMemoryRequirementsKHR(void *args)
37912 {
37913     struct vkGetDeviceImageMemoryRequirementsKHR_params *params = args;
37914
37915     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37916
37917     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
37918     return STATUS_SUCCESS;
37919 }
37920 #endif /* _WIN64 */
37921
37922 static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirementsKHR(void *args)
37923 {
37924     struct
37925     {
37926         PTR32 device;
37927         PTR32 pInfo;
37928         PTR32 pMemoryRequirements;
37929     } *params = args;
37930     VkDeviceImageMemoryRequirements pInfo_host;
37931     VkMemoryRequirements2 pMemoryRequirements_host;
37932     struct conversion_context local_ctx;
37933     struct conversion_context *ctx = &local_ctx;
37934
37935     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
37936
37937     init_conversion_context(ctx);
37938     convert_VkDeviceImageMemoryRequirements_win32_to_host(ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
37939     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
37940     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageMemoryRequirementsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
37941     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
37942     free_conversion_context(ctx);
37943     return STATUS_SUCCESS;
37944 }
37945
37946 #ifdef _WIN64
37947 static NTSTATUS thunk64_vkGetDeviceImageSparseMemoryRequirements(void *args)
37948 {
37949     struct vkGetDeviceImageSparseMemoryRequirements_params *params = args;
37950
37951     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37952
37953     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37954     return STATUS_SUCCESS;
37955 }
37956 #endif /* _WIN64 */
37957
37958 static NTSTATUS thunk32_vkGetDeviceImageSparseMemoryRequirements(void *args)
37959 {
37960     struct
37961     {
37962         PTR32 device;
37963         PTR32 pInfo;
37964         PTR32 pSparseMemoryRequirementCount;
37965         PTR32 pSparseMemoryRequirements;
37966     } *params = args;
37967     VkDeviceImageMemoryRequirements pInfo_host;
37968     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
37969     struct conversion_context local_ctx;
37970     struct conversion_context *ctx = &local_ctx;
37971
37972     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37973
37974     init_conversion_context(ctx);
37975     convert_VkDeviceImageMemoryRequirements_win32_to_host(ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
37976     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
37977     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);
37978     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
37979     free_conversion_context(ctx);
37980     return STATUS_SUCCESS;
37981 }
37982
37983 #ifdef _WIN64
37984 static NTSTATUS thunk64_vkGetDeviceImageSparseMemoryRequirementsKHR(void *args)
37985 {
37986     struct vkGetDeviceImageSparseMemoryRequirementsKHR_params *params = args;
37987
37988     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37989
37990     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37991     return STATUS_SUCCESS;
37992 }
37993 #endif /* _WIN64 */
37994
37995 static NTSTATUS thunk32_vkGetDeviceImageSparseMemoryRequirementsKHR(void *args)
37996 {
37997     struct
37998     {
37999         PTR32 device;
38000         PTR32 pInfo;
38001         PTR32 pSparseMemoryRequirementCount;
38002         PTR32 pSparseMemoryRequirements;
38003     } *params = args;
38004     VkDeviceImageMemoryRequirements pInfo_host;
38005     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
38006     struct conversion_context local_ctx;
38007     struct conversion_context *ctx = &local_ctx;
38008
38009     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
38010
38011     init_conversion_context(ctx);
38012     convert_VkDeviceImageMemoryRequirements_win32_to_host(ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
38013     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
38014     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);
38015     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
38016     free_conversion_context(ctx);
38017     return STATUS_SUCCESS;
38018 }
38019
38020 #ifdef _WIN64
38021 static NTSTATUS thunk64_vkGetDeviceImageSubresourceLayoutKHR(void *args)
38022 {
38023     struct vkGetDeviceImageSubresourceLayoutKHR_params *params = args;
38024
38025     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pLayout);
38026
38027     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSubresourceLayoutKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pLayout);
38028     return STATUS_SUCCESS;
38029 }
38030 #endif /* _WIN64 */
38031
38032 static NTSTATUS thunk32_vkGetDeviceImageSubresourceLayoutKHR(void *args)
38033 {
38034     struct
38035     {
38036         PTR32 device;
38037         PTR32 pInfo;
38038         PTR32 pLayout;
38039     } *params = args;
38040     VkDeviceImageSubresourceInfoKHR pInfo_host;
38041     VkSubresourceLayout2KHR pLayout_host;
38042     struct conversion_context local_ctx;
38043     struct conversion_context *ctx = &local_ctx;
38044
38045     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pLayout);
38046
38047     init_conversion_context(ctx);
38048     convert_VkDeviceImageSubresourceInfoKHR_win32_to_host(ctx, (const VkDeviceImageSubresourceInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
38049     convert_VkSubresourceLayout2KHR_win32_to_host(ctx, (VkSubresourceLayout2KHR32 *)UlongToPtr(params->pLayout), &pLayout_host);
38050     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageSubresourceLayoutKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pLayout_host);
38051     convert_VkSubresourceLayout2KHR_host_to_win32(&pLayout_host, (VkSubresourceLayout2KHR32 *)UlongToPtr(params->pLayout));
38052     free_conversion_context(ctx);
38053     return STATUS_SUCCESS;
38054 }
38055
38056 #ifdef _WIN64
38057 static NTSTATUS thunk64_vkGetDeviceMemoryCommitment(void *args)
38058 {
38059     struct vkGetDeviceMemoryCommitment_params *params = args;
38060
38061     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pCommittedMemoryInBytes);
38062
38063     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);
38064     return STATUS_SUCCESS;
38065 }
38066 #endif /* _WIN64 */
38067
38068 static NTSTATUS thunk32_vkGetDeviceMemoryCommitment(void *args)
38069 {
38070     struct
38071     {
38072         PTR32 device;
38073         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
38074         PTR32 pCommittedMemoryInBytes;
38075     } *params = args;
38076
38077     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->memory), params->pCommittedMemoryInBytes);
38078
38079     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));
38080     return STATUS_SUCCESS;
38081 }
38082
38083 #ifdef _WIN64
38084 static NTSTATUS thunk64_vkGetDeviceMemoryOpaqueCaptureAddress(void *args)
38085 {
38086     struct vkGetDeviceMemoryOpaqueCaptureAddress_params *params = args;
38087     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
38088
38089     TRACE("%p, %p\n", params->device, params->pInfo);
38090
38091     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host(params->pInfo, &pInfo_host);
38092     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, &pInfo_host);
38093     return STATUS_SUCCESS;
38094 }
38095 #endif /* _WIN64 */
38096
38097 static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddress(void *args)
38098 {
38099     struct
38100     {
38101         PTR32 device;
38102         PTR32 pInfo;
38103         uint64_t result;
38104     } *params = args;
38105     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
38106
38107     TRACE("%#x, %#x\n", params->device, params->pInfo);
38108
38109     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host((const VkDeviceMemoryOpaqueCaptureAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
38110     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
38111     return STATUS_SUCCESS;
38112 }
38113
38114 #ifdef _WIN64
38115 static NTSTATUS thunk64_vkGetDeviceMemoryOpaqueCaptureAddressKHR(void *args)
38116 {
38117     struct vkGetDeviceMemoryOpaqueCaptureAddressKHR_params *params = args;
38118     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
38119
38120     TRACE("%p, %p\n", params->device, params->pInfo);
38121
38122     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host(params->pInfo, &pInfo_host);
38123     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
38124     return STATUS_SUCCESS;
38125 }
38126 #endif /* _WIN64 */
38127
38128 static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR(void *args)
38129 {
38130     struct
38131     {
38132         PTR32 device;
38133         PTR32 pInfo;
38134         uint64_t result;
38135     } *params = args;
38136     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
38137
38138     TRACE("%#x, %#x\n", params->device, params->pInfo);
38139
38140     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host((const VkDeviceMemoryOpaqueCaptureAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
38141     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
38142     return STATUS_SUCCESS;
38143 }
38144
38145 #ifdef _WIN64
38146 static NTSTATUS thunk64_vkGetDeviceMicromapCompatibilityEXT(void *args)
38147 {
38148     struct vkGetDeviceMicromapCompatibilityEXT_params *params = args;
38149
38150     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
38151
38152     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMicromapCompatibilityEXT(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
38153     return STATUS_SUCCESS;
38154 }
38155 #endif /* _WIN64 */
38156
38157 static NTSTATUS thunk32_vkGetDeviceMicromapCompatibilityEXT(void *args)
38158 {
38159     struct
38160     {
38161         PTR32 device;
38162         PTR32 pVersionInfo;
38163         PTR32 pCompatibility;
38164     } *params = args;
38165     VkMicromapVersionInfoEXT pVersionInfo_host;
38166
38167     TRACE("%#x, %#x, %#x\n", params->device, params->pVersionInfo, params->pCompatibility);
38168
38169     convert_VkMicromapVersionInfoEXT_win32_to_host((const VkMicromapVersionInfoEXT32 *)UlongToPtr(params->pVersionInfo), &pVersionInfo_host);
38170     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));
38171     return STATUS_SUCCESS;
38172 }
38173
38174 #ifdef _WIN64
38175 static NTSTATUS thunk64_vkGetDeviceQueue(void *args)
38176 {
38177     struct vkGetDeviceQueue_params *params = args;
38178
38179     TRACE("%p, %u, %u, %p\n", params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
38180
38181     wine_vkGetDeviceQueue(params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
38182     return STATUS_SUCCESS;
38183 }
38184 #endif /* _WIN64 */
38185
38186 static NTSTATUS thunk32_vkGetDeviceQueue(void *args)
38187 {
38188     struct
38189     {
38190         PTR32 device;
38191         uint32_t queueFamilyIndex;
38192         uint32_t queueIndex;
38193         PTR32 pQueue;
38194     } *params = args;
38195     VkQueue pQueue_host;
38196
38197     TRACE("%#x, %u, %u, %#x\n", params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
38198
38199     pQueue_host = UlongToPtr(*(PTR32 *)UlongToPtr(params->pQueue));
38200     wine_vkGetDeviceQueue((VkDevice)UlongToPtr(params->device), params->queueFamilyIndex, params->queueIndex, &pQueue_host);
38201     *(PTR32 *)UlongToPtr(params->pQueue) = PtrToUlong(pQueue_host);
38202     return STATUS_SUCCESS;
38203 }
38204
38205 #ifdef _WIN64
38206 static NTSTATUS thunk64_vkGetDeviceQueue2(void *args)
38207 {
38208     struct vkGetDeviceQueue2_params *params = args;
38209
38210     TRACE("%p, %p, %p\n", params->device, params->pQueueInfo, params->pQueue);
38211
38212     wine_vkGetDeviceQueue2(params->device, params->pQueueInfo, params->pQueue);
38213     return STATUS_SUCCESS;
38214 }
38215 #endif /* _WIN64 */
38216
38217 static NTSTATUS thunk32_vkGetDeviceQueue2(void *args)
38218 {
38219     struct
38220     {
38221         PTR32 device;
38222         PTR32 pQueueInfo;
38223         PTR32 pQueue;
38224     } *params = args;
38225     VkDeviceQueueInfo2 pQueueInfo_host;
38226     VkQueue pQueue_host;
38227
38228     TRACE("%#x, %#x, %#x\n", params->device, params->pQueueInfo, params->pQueue);
38229
38230     convert_VkDeviceQueueInfo2_win32_to_host((const VkDeviceQueueInfo232 *)UlongToPtr(params->pQueueInfo), &pQueueInfo_host);
38231     pQueue_host = UlongToPtr(*(PTR32 *)UlongToPtr(params->pQueue));
38232     wine_vkGetDeviceQueue2((VkDevice)UlongToPtr(params->device), &pQueueInfo_host, &pQueue_host);
38233     *(PTR32 *)UlongToPtr(params->pQueue) = PtrToUlong(pQueue_host);
38234     return STATUS_SUCCESS;
38235 }
38236
38237 #ifdef _WIN64
38238 static NTSTATUS thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *args)
38239 {
38240     struct vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_params *params = args;
38241
38242     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);
38243
38244     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle(params->device)->device, params->renderpass, params->pMaxWorkgroupSize);
38245     return STATUS_SUCCESS;
38246 }
38247 #endif /* _WIN64 */
38248
38249 static NTSTATUS thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *args)
38250 {
38251     struct
38252     {
38253         PTR32 device;
38254         VkRenderPass DECLSPEC_ALIGN(8) renderpass;
38255         PTR32 pMaxWorkgroupSize;
38256         VkResult result;
38257     } *params = args;
38258
38259     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);
38260
38261     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));
38262     return STATUS_SUCCESS;
38263 }
38264
38265 #ifdef _WIN64
38266 static NTSTATUS thunk64_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
38267 {
38268     struct vkGetDynamicRenderingTilePropertiesQCOM_params *params = args;
38269
38270     TRACE("%p, %p, %p\n", params->device, params->pRenderingInfo, params->pProperties);
38271
38272     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->pRenderingInfo, params->pProperties);
38273     return STATUS_SUCCESS;
38274 }
38275 #endif /* _WIN64 */
38276
38277 static NTSTATUS thunk32_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
38278 {
38279     struct
38280     {
38281         PTR32 device;
38282         PTR32 pRenderingInfo;
38283         PTR32 pProperties;
38284         VkResult result;
38285     } *params = args;
38286     VkRenderingInfo pRenderingInfo_host;
38287     VkTilePropertiesQCOM pProperties_host;
38288     struct conversion_context local_ctx;
38289     struct conversion_context *ctx = &local_ctx;
38290
38291     TRACE("%#x, %#x, %#x\n", params->device, params->pRenderingInfo, params->pProperties);
38292
38293     init_conversion_context(ctx);
38294     convert_VkRenderingInfo_win32_to_host(ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
38295     convert_VkTilePropertiesQCOM_win32_to_host((VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), &pProperties_host);
38296     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);
38297     convert_VkTilePropertiesQCOM_host_to_win32(&pProperties_host, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties));
38298     free_conversion_context(ctx);
38299     return STATUS_SUCCESS;
38300 }
38301
38302 #ifdef _WIN64
38303 static NTSTATUS thunk64_vkGetEventStatus(void *args)
38304 {
38305     struct vkGetEventStatus_params *params = args;
38306
38307     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
38308
38309     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetEventStatus(wine_device_from_handle(params->device)->device, params->event);
38310     return STATUS_SUCCESS;
38311 }
38312 #endif /* _WIN64 */
38313
38314 static NTSTATUS thunk32_vkGetEventStatus(void *args)
38315 {
38316     struct
38317     {
38318         PTR32 device;
38319         VkEvent DECLSPEC_ALIGN(8) event;
38320         VkResult result;
38321     } *params = args;
38322
38323     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
38324
38325     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetEventStatus(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
38326     return STATUS_SUCCESS;
38327 }
38328
38329 #ifdef _WIN64
38330 static NTSTATUS thunk64_vkGetFenceStatus(void *args)
38331 {
38332     struct vkGetFenceStatus_params *params = args;
38333
38334     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));
38335
38336     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFenceStatus(wine_device_from_handle(params->device)->device, params->fence);
38337     return STATUS_SUCCESS;
38338 }
38339 #endif /* _WIN64 */
38340
38341 static NTSTATUS thunk32_vkGetFenceStatus(void *args)
38342 {
38343     struct
38344     {
38345         PTR32 device;
38346         VkFence DECLSPEC_ALIGN(8) fence;
38347         VkResult result;
38348     } *params = args;
38349
38350     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));
38351
38352     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetFenceStatus(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->fence);
38353     return STATUS_SUCCESS;
38354 }
38355
38356 #ifdef _WIN64
38357 static NTSTATUS thunk64_vkGetFramebufferTilePropertiesQCOM(void *args)
38358 {
38359     struct vkGetFramebufferTilePropertiesQCOM_params *params = args;
38360
38361     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);
38362
38363     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->framebuffer, params->pPropertiesCount, params->pProperties);
38364     return STATUS_SUCCESS;
38365 }
38366 #endif /* _WIN64 */
38367
38368 static NTSTATUS thunk32_vkGetFramebufferTilePropertiesQCOM(void *args)
38369 {
38370     struct
38371     {
38372         PTR32 device;
38373         VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
38374         PTR32 pPropertiesCount;
38375         PTR32 pProperties;
38376         VkResult result;
38377     } *params = args;
38378     VkTilePropertiesQCOM *pProperties_host;
38379     struct conversion_context local_ctx;
38380     struct conversion_context *ctx = &local_ctx;
38381
38382     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);
38383
38384     init_conversion_context(ctx);
38385     pProperties_host = convert_VkTilePropertiesQCOM_array_win32_to_host(ctx, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertiesCount));
38386     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);
38387     convert_VkTilePropertiesQCOM_array_host_to_win32(pProperties_host, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertiesCount));
38388     free_conversion_context(ctx);
38389     return STATUS_SUCCESS;
38390 }
38391
38392 #ifdef _WIN64
38393 static NTSTATUS thunk64_vkGetGeneratedCommandsMemoryRequirementsNV(void *args)
38394 {
38395     struct vkGetGeneratedCommandsMemoryRequirementsNV_params *params = args;
38396
38397     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
38398
38399     wine_device_from_handle(params->device)->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
38400     return STATUS_SUCCESS;
38401 }
38402 #endif /* _WIN64 */
38403
38404 static NTSTATUS thunk32_vkGetGeneratedCommandsMemoryRequirementsNV(void *args)
38405 {
38406     struct
38407     {
38408         PTR32 device;
38409         PTR32 pInfo;
38410         PTR32 pMemoryRequirements;
38411     } *params = args;
38412     VkGeneratedCommandsMemoryRequirementsInfoNV pInfo_host;
38413     VkMemoryRequirements2 pMemoryRequirements_host;
38414     struct conversion_context local_ctx;
38415     struct conversion_context *ctx = &local_ctx;
38416
38417     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
38418
38419     init_conversion_context(ctx);
38420     convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host((const VkGeneratedCommandsMemoryRequirementsInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
38421     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
38422     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
38423     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
38424     free_conversion_context(ctx);
38425     return STATUS_SUCCESS;
38426 }
38427
38428 #ifdef _WIN64
38429 static NTSTATUS thunk64_vkGetImageMemoryRequirements(void *args)
38430 {
38431     struct vkGetImageMemoryRequirements_params *params = args;
38432
38433     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pMemoryRequirements);
38434
38435     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pMemoryRequirements);
38436     return STATUS_SUCCESS;
38437 }
38438 #endif /* _WIN64 */
38439
38440 static NTSTATUS thunk32_vkGetImageMemoryRequirements(void *args)
38441 {
38442     struct
38443     {
38444         PTR32 device;
38445         VkImage DECLSPEC_ALIGN(8) image;
38446         PTR32 pMemoryRequirements;
38447     } *params = args;
38448     VkMemoryRequirements pMemoryRequirements_host;
38449
38450     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pMemoryRequirements);
38451
38452     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, &pMemoryRequirements_host);
38453     convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements32 *)UlongToPtr(params->pMemoryRequirements));
38454     return STATUS_SUCCESS;
38455 }
38456
38457 #ifdef _WIN64
38458 static NTSTATUS thunk64_vkGetImageMemoryRequirements2(void *args)
38459 {
38460     struct vkGetImageMemoryRequirements2_params *params = args;
38461
38462     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
38463
38464     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
38465     return STATUS_SUCCESS;
38466 }
38467 #endif /* _WIN64 */
38468
38469 static NTSTATUS thunk32_vkGetImageMemoryRequirements2(void *args)
38470 {
38471     struct
38472     {
38473         PTR32 device;
38474         PTR32 pInfo;
38475         PTR32 pMemoryRequirements;
38476     } *params = args;
38477     VkImageMemoryRequirementsInfo2 pInfo_host;
38478     VkMemoryRequirements2 pMemoryRequirements_host;
38479     struct conversion_context local_ctx;
38480     struct conversion_context *ctx = &local_ctx;
38481
38482     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
38483
38484     init_conversion_context(ctx);
38485     convert_VkImageMemoryRequirementsInfo2_win32_to_host(ctx, (const VkImageMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
38486     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
38487     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
38488     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
38489     free_conversion_context(ctx);
38490     return STATUS_SUCCESS;
38491 }
38492
38493 #ifdef _WIN64
38494 static NTSTATUS thunk64_vkGetImageMemoryRequirements2KHR(void *args)
38495 {
38496     struct vkGetImageMemoryRequirements2KHR_params *params = args;
38497
38498     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
38499
38500     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
38501     return STATUS_SUCCESS;
38502 }
38503 #endif /* _WIN64 */
38504
38505 static NTSTATUS thunk32_vkGetImageMemoryRequirements2KHR(void *args)
38506 {
38507     struct
38508     {
38509         PTR32 device;
38510         PTR32 pInfo;
38511         PTR32 pMemoryRequirements;
38512     } *params = args;
38513     VkImageMemoryRequirementsInfo2 pInfo_host;
38514     VkMemoryRequirements2 pMemoryRequirements_host;
38515     struct conversion_context local_ctx;
38516     struct conversion_context *ctx = &local_ctx;
38517
38518     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
38519
38520     init_conversion_context(ctx);
38521     convert_VkImageMemoryRequirementsInfo2_win32_to_host(ctx, (const VkImageMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
38522     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
38523     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
38524     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
38525     free_conversion_context(ctx);
38526     return STATUS_SUCCESS;
38527 }
38528
38529 #ifdef _WIN64
38530 static NTSTATUS thunk64_vkGetImageOpaqueCaptureDescriptorDataEXT(void *args)
38531 {
38532     struct vkGetImageOpaqueCaptureDescriptorDataEXT_params *params = args;
38533
38534     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
38535
38536     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
38537     return STATUS_SUCCESS;
38538 }
38539 #endif /* _WIN64 */
38540
38541 static NTSTATUS thunk32_vkGetImageOpaqueCaptureDescriptorDataEXT(void *args)
38542 {
38543     struct
38544     {
38545         PTR32 device;
38546         PTR32 pInfo;
38547         PTR32 pData;
38548         VkResult result;
38549     } *params = args;
38550     VkImageCaptureDescriptorDataInfoEXT pInfo_host;
38551
38552     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
38553
38554     convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host((const VkImageCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
38555     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));
38556     return STATUS_SUCCESS;
38557 }
38558
38559 #ifdef _WIN64
38560 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements(void *args)
38561 {
38562     struct vkGetImageSparseMemoryRequirements_params *params = args;
38563
38564     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
38565
38566     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
38567     return STATUS_SUCCESS;
38568 }
38569 #endif /* _WIN64 */
38570
38571 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements(void *args)
38572 {
38573     struct
38574     {
38575         PTR32 device;
38576         VkImage DECLSPEC_ALIGN(8) image;
38577         PTR32 pSparseMemoryRequirementCount;
38578         PTR32 pSparseMemoryRequirements;
38579     } *params = args;
38580     VkSparseImageMemoryRequirements *pSparseMemoryRequirements_host;
38581     struct conversion_context local_ctx;
38582     struct conversion_context *ctx = &local_ctx;
38583
38584     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
38585
38586     init_conversion_context(ctx);
38587     pSparseMemoryRequirements_host = (params->pSparseMemoryRequirements && *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount)) ? conversion_context_alloc(ctx, sizeof(*pSparseMemoryRequirements_host) * *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount)) : NULL;
38588     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);
38589     convert_VkSparseImageMemoryRequirements_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements32 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
38590     free_conversion_context(ctx);
38591     return STATUS_SUCCESS;
38592 }
38593
38594 #ifdef _WIN64
38595 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements2(void *args)
38596 {
38597     struct vkGetImageSparseMemoryRequirements2_params *params = args;
38598
38599     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
38600
38601     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
38602     return STATUS_SUCCESS;
38603 }
38604 #endif /* _WIN64 */
38605
38606 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements2(void *args)
38607 {
38608     struct
38609     {
38610         PTR32 device;
38611         PTR32 pInfo;
38612         PTR32 pSparseMemoryRequirementCount;
38613         PTR32 pSparseMemoryRequirements;
38614     } *params = args;
38615     VkImageSparseMemoryRequirementsInfo2 pInfo_host;
38616     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
38617     struct conversion_context local_ctx;
38618     struct conversion_context *ctx = &local_ctx;
38619
38620     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
38621
38622     init_conversion_context(ctx);
38623     convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host((const VkImageSparseMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
38624     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
38625     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);
38626     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
38627     free_conversion_context(ctx);
38628     return STATUS_SUCCESS;
38629 }
38630
38631 #ifdef _WIN64
38632 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements2KHR(void *args)
38633 {
38634     struct vkGetImageSparseMemoryRequirements2KHR_params *params = args;
38635
38636     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
38637
38638     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
38639     return STATUS_SUCCESS;
38640 }
38641 #endif /* _WIN64 */
38642
38643 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements2KHR(void *args)
38644 {
38645     struct
38646     {
38647         PTR32 device;
38648         PTR32 pInfo;
38649         PTR32 pSparseMemoryRequirementCount;
38650         PTR32 pSparseMemoryRequirements;
38651     } *params = args;
38652     VkImageSparseMemoryRequirementsInfo2 pInfo_host;
38653     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
38654     struct conversion_context local_ctx;
38655     struct conversion_context *ctx = &local_ctx;
38656
38657     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
38658
38659     init_conversion_context(ctx);
38660     convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host((const VkImageSparseMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
38661     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
38662     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);
38663     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
38664     free_conversion_context(ctx);
38665     return STATUS_SUCCESS;
38666 }
38667
38668 #ifdef _WIN64
38669 static NTSTATUS thunk64_vkGetImageSubresourceLayout(void *args)
38670 {
38671     struct vkGetImageSubresourceLayout_params *params = args;
38672
38673     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
38674
38675     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, params->pLayout);
38676     return STATUS_SUCCESS;
38677 }
38678 #endif /* _WIN64 */
38679
38680 static NTSTATUS thunk32_vkGetImageSubresourceLayout(void *args)
38681 {
38682     struct
38683     {
38684         PTR32 device;
38685         VkImage DECLSPEC_ALIGN(8) image;
38686         PTR32 pSubresource;
38687         PTR32 pLayout;
38688     } *params = args;
38689     VkSubresourceLayout pLayout_host;
38690
38691     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
38692
38693     convert_VkSubresourceLayout_win32_to_host((VkSubresourceLayout32 *)UlongToPtr(params->pLayout), &pLayout_host);
38694     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);
38695     convert_VkSubresourceLayout_host_to_win32(&pLayout_host, (VkSubresourceLayout32 *)UlongToPtr(params->pLayout));
38696     return STATUS_SUCCESS;
38697 }
38698
38699 #ifdef _WIN64
38700 static NTSTATUS thunk64_vkGetImageSubresourceLayout2EXT(void *args)
38701 {
38702     struct vkGetImageSubresourceLayout2EXT_params *params = args;
38703
38704     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
38705
38706     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout2EXT(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, params->pLayout);
38707     return STATUS_SUCCESS;
38708 }
38709 #endif /* _WIN64 */
38710
38711 static NTSTATUS thunk32_vkGetImageSubresourceLayout2EXT(void *args)
38712 {
38713     struct
38714     {
38715         PTR32 device;
38716         VkImage DECLSPEC_ALIGN(8) image;
38717         PTR32 pSubresource;
38718         PTR32 pLayout;
38719     } *params = args;
38720     VkImageSubresource2KHR pSubresource_host;
38721     VkSubresourceLayout2KHR pLayout_host;
38722     struct conversion_context local_ctx;
38723     struct conversion_context *ctx = &local_ctx;
38724
38725     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
38726
38727     init_conversion_context(ctx);
38728     convert_VkImageSubresource2KHR_win32_to_host((const VkImageSubresource2KHR32 *)UlongToPtr(params->pSubresource), &pSubresource_host);
38729     convert_VkSubresourceLayout2KHR_win32_to_host(ctx, (VkSubresourceLayout2KHR32 *)UlongToPtr(params->pLayout), &pLayout_host);
38730     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);
38731     convert_VkSubresourceLayout2KHR_host_to_win32(&pLayout_host, (VkSubresourceLayout2KHR32 *)UlongToPtr(params->pLayout));
38732     free_conversion_context(ctx);
38733     return STATUS_SUCCESS;
38734 }
38735
38736 #ifdef _WIN64
38737 static NTSTATUS thunk64_vkGetImageSubresourceLayout2KHR(void *args)
38738 {
38739     struct vkGetImageSubresourceLayout2KHR_params *params = args;
38740
38741     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
38742
38743     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout2KHR(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, params->pLayout);
38744     return STATUS_SUCCESS;
38745 }
38746 #endif /* _WIN64 */
38747
38748 static NTSTATUS thunk32_vkGetImageSubresourceLayout2KHR(void *args)
38749 {
38750     struct
38751     {
38752         PTR32 device;
38753         VkImage DECLSPEC_ALIGN(8) image;
38754         PTR32 pSubresource;
38755         PTR32 pLayout;
38756     } *params = args;
38757     VkImageSubresource2KHR pSubresource_host;
38758     VkSubresourceLayout2KHR pLayout_host;
38759     struct conversion_context local_ctx;
38760     struct conversion_context *ctx = &local_ctx;
38761
38762     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
38763
38764     init_conversion_context(ctx);
38765     convert_VkImageSubresource2KHR_win32_to_host((const VkImageSubresource2KHR32 *)UlongToPtr(params->pSubresource), &pSubresource_host);
38766     convert_VkSubresourceLayout2KHR_win32_to_host(ctx, (VkSubresourceLayout2KHR32 *)UlongToPtr(params->pLayout), &pLayout_host);
38767     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageSubresourceLayout2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, &pSubresource_host, &pLayout_host);
38768     convert_VkSubresourceLayout2KHR_host_to_win32(&pLayout_host, (VkSubresourceLayout2KHR32 *)UlongToPtr(params->pLayout));
38769     free_conversion_context(ctx);
38770     return STATUS_SUCCESS;
38771 }
38772
38773 #ifdef _WIN64
38774 static NTSTATUS thunk64_vkGetImageViewAddressNVX(void *args)
38775 {
38776     struct vkGetImageViewAddressNVX_params *params = args;
38777
38778     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);
38779
38780     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle(params->device)->device, params->imageView, params->pProperties);
38781     return STATUS_SUCCESS;
38782 }
38783 #endif /* _WIN64 */
38784
38785 static NTSTATUS thunk32_vkGetImageViewAddressNVX(void *args)
38786 {
38787     struct
38788     {
38789         PTR32 device;
38790         VkImageView DECLSPEC_ALIGN(8) imageView;
38791         PTR32 pProperties;
38792         VkResult result;
38793     } *params = args;
38794     VkImageViewAddressPropertiesNVX pProperties_host;
38795
38796     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);
38797
38798     convert_VkImageViewAddressPropertiesNVX_win32_to_host((VkImageViewAddressPropertiesNVX32 *)UlongToPtr(params->pProperties), &pProperties_host);
38799     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);
38800     convert_VkImageViewAddressPropertiesNVX_host_to_win32(&pProperties_host, (VkImageViewAddressPropertiesNVX32 *)UlongToPtr(params->pProperties));
38801     return STATUS_SUCCESS;
38802 }
38803
38804 #ifdef _WIN64
38805 static NTSTATUS thunk64_vkGetImageViewHandleNVX(void *args)
38806 {
38807     struct vkGetImageViewHandleNVX_params *params = args;
38808
38809     TRACE("%p, %p\n", params->device, params->pInfo);
38810
38811     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle(params->device)->device, params->pInfo);
38812     return STATUS_SUCCESS;
38813 }
38814 #endif /* _WIN64 */
38815
38816 static NTSTATUS thunk32_vkGetImageViewHandleNVX(void *args)
38817 {
38818     struct
38819     {
38820         PTR32 device;
38821         PTR32 pInfo;
38822         uint32_t result;
38823     } *params = args;
38824     VkImageViewHandleInfoNVX pInfo_host;
38825
38826     TRACE("%#x, %#x\n", params->device, params->pInfo);
38827
38828     convert_VkImageViewHandleInfoNVX_win32_to_host((const VkImageViewHandleInfoNVX32 *)UlongToPtr(params->pInfo), &pInfo_host);
38829     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
38830     return STATUS_SUCCESS;
38831 }
38832
38833 #ifdef _WIN64
38834 static NTSTATUS thunk64_vkGetImageViewOpaqueCaptureDescriptorDataEXT(void *args)
38835 {
38836     struct vkGetImageViewOpaqueCaptureDescriptorDataEXT_params *params = args;
38837
38838     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
38839
38840     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
38841     return STATUS_SUCCESS;
38842 }
38843 #endif /* _WIN64 */
38844
38845 static NTSTATUS thunk32_vkGetImageViewOpaqueCaptureDescriptorDataEXT(void *args)
38846 {
38847     struct
38848     {
38849         PTR32 device;
38850         PTR32 pInfo;
38851         PTR32 pData;
38852         VkResult result;
38853     } *params = args;
38854     VkImageViewCaptureDescriptorDataInfoEXT pInfo_host;
38855
38856     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
38857
38858     convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host((const VkImageViewCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
38859     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));
38860     return STATUS_SUCCESS;
38861 }
38862
38863 #ifdef _WIN64
38864 static NTSTATUS thunk64_vkGetMemoryHostPointerPropertiesEXT(void *args)
38865 {
38866     struct vkGetMemoryHostPointerPropertiesEXT_params *params = args;
38867
38868     TRACE("%p, %#x, %p, %p\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
38869
38870     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle(params->device)->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
38871     return STATUS_SUCCESS;
38872 }
38873 #endif /* _WIN64 */
38874
38875 static NTSTATUS thunk32_vkGetMemoryHostPointerPropertiesEXT(void *args)
38876 {
38877     struct
38878     {
38879         PTR32 device;
38880         VkExternalMemoryHandleTypeFlagBits handleType;
38881         PTR32 pHostPointer;
38882         PTR32 pMemoryHostPointerProperties;
38883         VkResult result;
38884     } *params = args;
38885     VkMemoryHostPointerPropertiesEXT pMemoryHostPointerProperties_host;
38886
38887     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
38888
38889     convert_VkMemoryHostPointerPropertiesEXT_win32_to_host((VkMemoryHostPointerPropertiesEXT32 *)UlongToPtr(params->pMemoryHostPointerProperties), &pMemoryHostPointerProperties_host);
38890     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);
38891     convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(&pMemoryHostPointerProperties_host, (VkMemoryHostPointerPropertiesEXT32 *)UlongToPtr(params->pMemoryHostPointerProperties));
38892     return STATUS_SUCCESS;
38893 }
38894
38895 #ifdef _WIN64
38896 static NTSTATUS thunk64_vkGetMicromapBuildSizesEXT(void *args)
38897 {
38898     struct vkGetMicromapBuildSizesEXT_params *params = args;
38899
38900     TRACE("%p, %#x, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
38901
38902     wine_device_from_handle(params->device)->funcs.p_vkGetMicromapBuildSizesEXT(wine_device_from_handle(params->device)->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
38903     return STATUS_SUCCESS;
38904 }
38905 #endif /* _WIN64 */
38906
38907 static NTSTATUS thunk32_vkGetMicromapBuildSizesEXT(void *args)
38908 {
38909     struct
38910     {
38911         PTR32 device;
38912         VkAccelerationStructureBuildTypeKHR buildType;
38913         PTR32 pBuildInfo;
38914         PTR32 pSizeInfo;
38915     } *params = args;
38916     VkMicromapBuildInfoEXT pBuildInfo_host;
38917     VkMicromapBuildSizesInfoEXT pSizeInfo_host;
38918     struct conversion_context local_ctx;
38919     struct conversion_context *ctx = &local_ctx;
38920
38921     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
38922
38923     init_conversion_context(ctx);
38924     convert_VkMicromapBuildInfoEXT_win32_to_host(ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pBuildInfo), &pBuildInfo_host);
38925     convert_VkMicromapBuildSizesInfoEXT_win32_to_host((VkMicromapBuildSizesInfoEXT32 *)UlongToPtr(params->pSizeInfo), &pSizeInfo_host);
38926     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);
38927     convert_VkMicromapBuildSizesInfoEXT_host_to_win32(&pSizeInfo_host, (VkMicromapBuildSizesInfoEXT32 *)UlongToPtr(params->pSizeInfo));
38928     free_conversion_context(ctx);
38929     return STATUS_SUCCESS;
38930 }
38931
38932 #ifdef _WIN64
38933 static NTSTATUS thunk64_vkGetPerformanceParameterINTEL(void *args)
38934 {
38935     struct vkGetPerformanceParameterINTEL_params *params = args;
38936
38937     TRACE("%p, %#x, %p\n", params->device, params->parameter, params->pValue);
38938
38939     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle(params->device)->device, params->parameter, params->pValue);
38940     return STATUS_SUCCESS;
38941 }
38942 #endif /* _WIN64 */
38943
38944 static NTSTATUS thunk32_vkGetPerformanceParameterINTEL(void *args)
38945 {
38946     struct
38947     {
38948         PTR32 device;
38949         VkPerformanceParameterTypeINTEL parameter;
38950         PTR32 pValue;
38951         VkResult result;
38952     } *params = args;
38953     VkPerformanceValueINTEL pValue_host;
38954
38955     TRACE("%#x, %#x, %#x\n", params->device, params->parameter, params->pValue);
38956
38957     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);
38958     convert_VkPerformanceValueINTEL_host_to_win32(&pValue_host, (VkPerformanceValueINTEL32 *)UlongToPtr(params->pValue));
38959     return STATUS_SUCCESS;
38960 }
38961
38962 #ifdef _WIN64
38963 static NTSTATUS thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
38964 {
38965     struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params *params = args;
38966
38967     TRACE("%p, %p, %p\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
38968
38969     params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
38970     return STATUS_SUCCESS;
38971 }
38972 #endif /* _WIN64 */
38973
38974 static NTSTATUS thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
38975 {
38976     struct
38977     {
38978         PTR32 physicalDevice;
38979         PTR32 pTimeDomainCount;
38980         PTR32 pTimeDomains;
38981         VkResult result;
38982     } *params = args;
38983
38984     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
38985
38986     params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (uint32_t *)UlongToPtr(params->pTimeDomainCount), (VkTimeDomainEXT *)UlongToPtr(params->pTimeDomains));
38987     return STATUS_SUCCESS;
38988 }
38989
38990 #ifdef _WIN64
38991 static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(void *args)
38992 {
38993     struct vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR_params *params = args;
38994
38995     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
38996
38997     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPropertyCount, params->pProperties);
38998     return STATUS_SUCCESS;
38999 }
39000 #endif /* _WIN64 */
39001
39002 static NTSTATUS thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(void *args)
39003 {
39004     struct
39005     {
39006         PTR32 physicalDevice;
39007         PTR32 pPropertyCount;
39008         PTR32 pProperties;
39009         VkResult result;
39010     } *params = args;
39011     VkCooperativeMatrixPropertiesKHR *pProperties_host;
39012     struct conversion_context local_ctx;
39013     struct conversion_context *ctx = &local_ctx;
39014
39015     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
39016
39017     init_conversion_context(ctx);
39018     pProperties_host = convert_VkCooperativeMatrixPropertiesKHR_array_win32_to_host(ctx, (VkCooperativeMatrixPropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
39019     params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pPropertyCount), pProperties_host);
39020     convert_VkCooperativeMatrixPropertiesKHR_array_host_to_win32(pProperties_host, (VkCooperativeMatrixPropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
39021     free_conversion_context(ctx);
39022     return STATUS_SUCCESS;
39023 }
39024
39025 #ifdef _WIN64
39026 static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
39027 {
39028     struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params *params = args;
39029
39030     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
39031
39032     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);
39033     return STATUS_SUCCESS;
39034 }
39035 #endif /* _WIN64 */
39036
39037 static NTSTATUS thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
39038 {
39039     struct
39040     {
39041         PTR32 physicalDevice;
39042         PTR32 pPropertyCount;
39043         PTR32 pProperties;
39044         VkResult result;
39045     } *params = args;
39046     VkCooperativeMatrixPropertiesNV *pProperties_host;
39047     struct conversion_context local_ctx;
39048     struct conversion_context *ctx = &local_ctx;
39049
39050     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
39051
39052     init_conversion_context(ctx);
39053     pProperties_host = convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(ctx, (VkCooperativeMatrixPropertiesNV32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
39054     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);
39055     convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(pProperties_host, (VkCooperativeMatrixPropertiesNV32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
39056     free_conversion_context(ctx);
39057     return STATUS_SUCCESS;
39058 }
39059
39060 #ifdef _WIN64
39061 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalBufferProperties(void *args)
39062 {
39063     struct vkGetPhysicalDeviceExternalBufferProperties_params *params = args;
39064
39065     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
39066
39067     wine_vkGetPhysicalDeviceExternalBufferProperties(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
39068     return STATUS_SUCCESS;
39069 }
39070 #endif /* _WIN64 */
39071
39072 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferProperties(void *args)
39073 {
39074     struct
39075     {
39076         PTR32 physicalDevice;
39077         PTR32 pExternalBufferInfo;
39078         PTR32 pExternalBufferProperties;
39079     } *params = args;
39080     VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo_host;
39081     VkExternalBufferProperties pExternalBufferProperties_host;
39082     struct conversion_context local_ctx;
39083     struct conversion_context *ctx = &local_ctx;
39084
39085     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
39086
39087     init_conversion_context(ctx);
39088     convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(ctx, (const VkPhysicalDeviceExternalBufferInfo32 *)UlongToPtr(params->pExternalBufferInfo), &pExternalBufferInfo_host);
39089     convert_VkExternalBufferProperties_win32_to_host((VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties), &pExternalBufferProperties_host);
39090     wine_vkGetPhysicalDeviceExternalBufferProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalBufferInfo_host, &pExternalBufferProperties_host);
39091     convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, (VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties));
39092     free_conversion_context(ctx);
39093     return STATUS_SUCCESS;
39094 }
39095
39096 #ifdef _WIN64
39097 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args)
39098 {
39099     struct vkGetPhysicalDeviceExternalBufferPropertiesKHR_params *params = args;
39100
39101     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
39102
39103     wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
39104     return STATUS_SUCCESS;
39105 }
39106 #endif /* _WIN64 */
39107
39108 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args)
39109 {
39110     struct
39111     {
39112         PTR32 physicalDevice;
39113         PTR32 pExternalBufferInfo;
39114         PTR32 pExternalBufferProperties;
39115     } *params = args;
39116     VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo_host;
39117     VkExternalBufferProperties pExternalBufferProperties_host;
39118     struct conversion_context local_ctx;
39119     struct conversion_context *ctx = &local_ctx;
39120
39121     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
39122
39123     init_conversion_context(ctx);
39124     convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(ctx, (const VkPhysicalDeviceExternalBufferInfo32 *)UlongToPtr(params->pExternalBufferInfo), &pExternalBufferInfo_host);
39125     convert_VkExternalBufferProperties_win32_to_host((VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties), &pExternalBufferProperties_host);
39126     wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalBufferInfo_host, &pExternalBufferProperties_host);
39127     convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, (VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties));
39128     free_conversion_context(ctx);
39129     return STATUS_SUCCESS;
39130 }
39131
39132 #ifdef _WIN64
39133 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalFenceProperties(void *args)
39134 {
39135     struct vkGetPhysicalDeviceExternalFenceProperties_params *params = args;
39136
39137     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
39138
39139     wine_vkGetPhysicalDeviceExternalFenceProperties(params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
39140     return STATUS_SUCCESS;
39141 }
39142 #endif /* _WIN64 */
39143
39144 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalFenceProperties(void *args)
39145 {
39146     struct
39147     {
39148         PTR32 physicalDevice;
39149         PTR32 pExternalFenceInfo;
39150         PTR32 pExternalFenceProperties;
39151     } *params = args;
39152     VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo_host;
39153     VkExternalFenceProperties pExternalFenceProperties_host;
39154
39155     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
39156
39157     convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host((const VkPhysicalDeviceExternalFenceInfo32 *)UlongToPtr(params->pExternalFenceInfo), &pExternalFenceInfo_host);
39158     convert_VkExternalFenceProperties_win32_to_host((VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties), &pExternalFenceProperties_host);
39159     wine_vkGetPhysicalDeviceExternalFenceProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalFenceInfo_host, &pExternalFenceProperties_host);
39160     convert_VkExternalFenceProperties_host_to_win32(&pExternalFenceProperties_host, (VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties));
39161     return STATUS_SUCCESS;
39162 }
39163
39164 #ifdef _WIN64
39165 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args)
39166 {
39167     struct vkGetPhysicalDeviceExternalFencePropertiesKHR_params *params = args;
39168
39169     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
39170
39171     wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
39172     return STATUS_SUCCESS;
39173 }
39174 #endif /* _WIN64 */
39175
39176 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args)
39177 {
39178     struct
39179     {
39180         PTR32 physicalDevice;
39181         PTR32 pExternalFenceInfo;
39182         PTR32 pExternalFenceProperties;
39183     } *params = args;
39184     VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo_host;
39185     VkExternalFenceProperties pExternalFenceProperties_host;
39186
39187     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
39188
39189     convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host((const VkPhysicalDeviceExternalFenceInfo32 *)UlongToPtr(params->pExternalFenceInfo), &pExternalFenceInfo_host);
39190     convert_VkExternalFenceProperties_win32_to_host((VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties), &pExternalFenceProperties_host);
39191     wine_vkGetPhysicalDeviceExternalFencePropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalFenceInfo_host, &pExternalFenceProperties_host);
39192     convert_VkExternalFenceProperties_host_to_win32(&pExternalFenceProperties_host, (VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties));
39193     return STATUS_SUCCESS;
39194 }
39195
39196 #ifdef _WIN64
39197 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalSemaphoreProperties(void *args)
39198 {
39199     struct vkGetPhysicalDeviceExternalSemaphoreProperties_params *params = args;
39200
39201     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
39202
39203     wine_vkGetPhysicalDeviceExternalSemaphoreProperties(params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
39204     return STATUS_SUCCESS;
39205 }
39206 #endif /* _WIN64 */
39207
39208 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphoreProperties(void *args)
39209 {
39210     struct
39211     {
39212         PTR32 physicalDevice;
39213         PTR32 pExternalSemaphoreInfo;
39214         PTR32 pExternalSemaphoreProperties;
39215     } *params = args;
39216     VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo_host;
39217     VkExternalSemaphoreProperties pExternalSemaphoreProperties_host;
39218     struct conversion_context local_ctx;
39219     struct conversion_context *ctx = &local_ctx;
39220
39221     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
39222
39223     init_conversion_context(ctx);
39224     convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(ctx, (const VkPhysicalDeviceExternalSemaphoreInfo32 *)UlongToPtr(params->pExternalSemaphoreInfo), &pExternalSemaphoreInfo_host);
39225     convert_VkExternalSemaphoreProperties_win32_to_host((VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties), &pExternalSemaphoreProperties_host);
39226     wine_vkGetPhysicalDeviceExternalSemaphoreProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalSemaphoreInfo_host, &pExternalSemaphoreProperties_host);
39227     convert_VkExternalSemaphoreProperties_host_to_win32(&pExternalSemaphoreProperties_host, (VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties));
39228     free_conversion_context(ctx);
39229     return STATUS_SUCCESS;
39230 }
39231
39232 #ifdef _WIN64
39233 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *args)
39234 {
39235     struct vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_params *params = args;
39236
39237     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
39238
39239     wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
39240     return STATUS_SUCCESS;
39241 }
39242 #endif /* _WIN64 */
39243
39244 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *args)
39245 {
39246     struct
39247     {
39248         PTR32 physicalDevice;
39249         PTR32 pExternalSemaphoreInfo;
39250         PTR32 pExternalSemaphoreProperties;
39251     } *params = args;
39252     VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo_host;
39253     VkExternalSemaphoreProperties pExternalSemaphoreProperties_host;
39254     struct conversion_context local_ctx;
39255     struct conversion_context *ctx = &local_ctx;
39256
39257     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
39258
39259     init_conversion_context(ctx);
39260     convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(ctx, (const VkPhysicalDeviceExternalSemaphoreInfo32 *)UlongToPtr(params->pExternalSemaphoreInfo), &pExternalSemaphoreInfo_host);
39261     convert_VkExternalSemaphoreProperties_win32_to_host((VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties), &pExternalSemaphoreProperties_host);
39262     wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalSemaphoreInfo_host, &pExternalSemaphoreProperties_host);
39263     convert_VkExternalSemaphoreProperties_host_to_win32(&pExternalSemaphoreProperties_host, (VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties));
39264     free_conversion_context(ctx);
39265     return STATUS_SUCCESS;
39266 }
39267
39268 #ifdef _WIN64
39269 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures(void *args)
39270 {
39271     struct vkGetPhysicalDeviceFeatures_params *params = args;
39272
39273     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
39274
39275     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
39276     return STATUS_SUCCESS;
39277 }
39278 #endif /* _WIN64 */
39279
39280 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures(void *args)
39281 {
39282     struct
39283     {
39284         PTR32 physicalDevice;
39285         PTR32 pFeatures;
39286     } *params = args;
39287
39288     TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);
39289
39290     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));
39291     return STATUS_SUCCESS;
39292 }
39293
39294 #ifdef _WIN64
39295 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures2(void *args)
39296 {
39297     struct vkGetPhysicalDeviceFeatures2_params *params = args;
39298
39299     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
39300
39301     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
39302     return STATUS_SUCCESS;
39303 }
39304 #endif /* _WIN64 */
39305
39306 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures2(void *args)
39307 {
39308     struct
39309     {
39310         PTR32 physicalDevice;
39311         PTR32 pFeatures;
39312     } *params = args;
39313     VkPhysicalDeviceFeatures2 pFeatures_host;
39314     struct conversion_context local_ctx;
39315     struct conversion_context *ctx = &local_ctx;
39316
39317     TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);
39318
39319     init_conversion_context(ctx);
39320     convert_VkPhysicalDeviceFeatures2_win32_to_host(ctx, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures), &pFeatures_host);
39321     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);
39322     convert_VkPhysicalDeviceFeatures2_host_to_win32(&pFeatures_host, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures));
39323     free_conversion_context(ctx);
39324     return STATUS_SUCCESS;
39325 }
39326
39327 #ifdef _WIN64
39328 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures2KHR(void *args)
39329 {
39330     struct vkGetPhysicalDeviceFeatures2KHR_params *params = args;
39331
39332     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
39333
39334     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
39335     return STATUS_SUCCESS;
39336 }
39337 #endif /* _WIN64 */
39338
39339 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures2KHR(void *args)
39340 {
39341     struct
39342     {
39343         PTR32 physicalDevice;
39344         PTR32 pFeatures;
39345     } *params = args;
39346     VkPhysicalDeviceFeatures2 pFeatures_host;
39347     struct conversion_context local_ctx;
39348     struct conversion_context *ctx = &local_ctx;
39349
39350     TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);
39351
39352     init_conversion_context(ctx);
39353     convert_VkPhysicalDeviceFeatures2_win32_to_host(ctx, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures), &pFeatures_host);
39354     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);
39355     convert_VkPhysicalDeviceFeatures2_host_to_win32(&pFeatures_host, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures));
39356     free_conversion_context(ctx);
39357     return STATUS_SUCCESS;
39358 }
39359
39360 #ifdef _WIN64
39361 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties(void *args)
39362 {
39363     struct vkGetPhysicalDeviceFormatProperties_params *params = args;
39364
39365     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
39366
39367     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
39368     return STATUS_SUCCESS;
39369 }
39370 #endif /* _WIN64 */
39371
39372 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties(void *args)
39373 {
39374     struct
39375     {
39376         PTR32 physicalDevice;
39377         VkFormat format;
39378         PTR32 pFormatProperties;
39379     } *params = args;
39380
39381     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);
39382
39383     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));
39384     return STATUS_SUCCESS;
39385 }
39386
39387 #ifdef _WIN64
39388 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties2(void *args)
39389 {
39390     struct vkGetPhysicalDeviceFormatProperties2_params *params = args;
39391
39392     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
39393
39394     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
39395     return STATUS_SUCCESS;
39396 }
39397 #endif /* _WIN64 */
39398
39399 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2(void *args)
39400 {
39401     struct
39402     {
39403         PTR32 physicalDevice;
39404         VkFormat format;
39405         PTR32 pFormatProperties;
39406     } *params = args;
39407     VkFormatProperties2 pFormatProperties_host;
39408     struct conversion_context local_ctx;
39409     struct conversion_context *ctx = &local_ctx;
39410
39411     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);
39412
39413     init_conversion_context(ctx);
39414     convert_VkFormatProperties2_win32_to_host(ctx, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties), &pFormatProperties_host);
39415     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);
39416     convert_VkFormatProperties2_host_to_win32(&pFormatProperties_host, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties));
39417     free_conversion_context(ctx);
39418     return STATUS_SUCCESS;
39419 }
39420
39421 #ifdef _WIN64
39422 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties2KHR(void *args)
39423 {
39424     struct vkGetPhysicalDeviceFormatProperties2KHR_params *params = args;
39425
39426     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
39427
39428     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
39429     return STATUS_SUCCESS;
39430 }
39431 #endif /* _WIN64 */
39432
39433 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2KHR(void *args)
39434 {
39435     struct
39436     {
39437         PTR32 physicalDevice;
39438         VkFormat format;
39439         PTR32 pFormatProperties;
39440     } *params = args;
39441     VkFormatProperties2 pFormatProperties_host;
39442     struct conversion_context local_ctx;
39443     struct conversion_context *ctx = &local_ctx;
39444
39445     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);
39446
39447     init_conversion_context(ctx);
39448     convert_VkFormatProperties2_win32_to_host(ctx, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties), &pFormatProperties_host);
39449     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);
39450     convert_VkFormatProperties2_host_to_win32(&pFormatProperties_host, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties));
39451     free_conversion_context(ctx);
39452     return STATUS_SUCCESS;
39453 }
39454
39455 #ifdef _WIN64
39456 static NTSTATUS thunk64_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
39457 {
39458     struct vkGetPhysicalDeviceFragmentShadingRatesKHR_params *params = args;
39459
39460     TRACE("%p, %p, %p\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
39461
39462     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);
39463     return STATUS_SUCCESS;
39464 }
39465 #endif /* _WIN64 */
39466
39467 static NTSTATUS thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
39468 {
39469     struct
39470     {
39471         PTR32 physicalDevice;
39472         PTR32 pFragmentShadingRateCount;
39473         PTR32 pFragmentShadingRates;
39474         VkResult result;
39475     } *params = args;
39476     VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates_host;
39477     struct conversion_context local_ctx;
39478     struct conversion_context *ctx = &local_ctx;
39479
39480     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
39481
39482     init_conversion_context(ctx);
39483     pFragmentShadingRates_host = convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(ctx, (VkPhysicalDeviceFragmentShadingRateKHR32 *)UlongToPtr(params->pFragmentShadingRates), *(uint32_t *)UlongToPtr(params->pFragmentShadingRateCount));
39484     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);
39485     convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(pFragmentShadingRates_host, (VkPhysicalDeviceFragmentShadingRateKHR32 *)UlongToPtr(params->pFragmentShadingRates), *(uint32_t *)UlongToPtr(params->pFragmentShadingRateCount));
39486     free_conversion_context(ctx);
39487     return STATUS_SUCCESS;
39488 }
39489
39490 #ifdef _WIN64
39491 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties(void *args)
39492 {
39493     struct vkGetPhysicalDeviceImageFormatProperties_params *params = args;
39494
39495     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
39496
39497     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);
39498     return STATUS_SUCCESS;
39499 }
39500 #endif /* _WIN64 */
39501
39502 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties(void *args)
39503 {
39504     struct
39505     {
39506         PTR32 physicalDevice;
39507         VkFormat format;
39508         VkImageType type;
39509         VkImageTiling tiling;
39510         VkImageUsageFlags usage;
39511         VkImageCreateFlags flags;
39512         PTR32 pImageFormatProperties;
39513         VkResult result;
39514     } *params = args;
39515     VkImageFormatProperties pImageFormatProperties_host;
39516
39517     TRACE("%#x, %#x, %#x, %#x, %#x, %#x, %#x\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
39518
39519     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);
39520     convert_VkImageFormatProperties_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties32 *)UlongToPtr(params->pImageFormatProperties));
39521     return STATUS_SUCCESS;
39522 }
39523
39524 #ifdef _WIN64
39525 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2(void *args)
39526 {
39527     struct vkGetPhysicalDeviceImageFormatProperties2_params *params = args;
39528
39529     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
39530
39531     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
39532     return STATUS_SUCCESS;
39533 }
39534 #endif /* _WIN64 */
39535
39536 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2(void *args)
39537 {
39538     struct
39539     {
39540         PTR32 physicalDevice;
39541         PTR32 pImageFormatInfo;
39542         PTR32 pImageFormatProperties;
39543         VkResult result;
39544     } *params = args;
39545     VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo_host;
39546     VkImageFormatProperties2 pImageFormatProperties_host;
39547     struct conversion_context local_ctx;
39548     struct conversion_context *ctx = &local_ctx;
39549
39550     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
39551
39552     init_conversion_context(ctx);
39553     convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(ctx, (const VkPhysicalDeviceImageFormatInfo232 *)UlongToPtr(params->pImageFormatInfo), &pImageFormatInfo_host);
39554     convert_VkImageFormatProperties2_win32_to_host(ctx, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties), &pImageFormatProperties_host);
39555     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pImageFormatInfo_host, &pImageFormatProperties_host);
39556     convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties));
39557     free_conversion_context(ctx);
39558     return STATUS_SUCCESS;
39559 }
39560
39561 #ifdef _WIN64
39562 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
39563 {
39564     struct vkGetPhysicalDeviceImageFormatProperties2KHR_params *params = args;
39565
39566     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
39567
39568     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
39569     return STATUS_SUCCESS;
39570 }
39571 #endif /* _WIN64 */
39572
39573 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
39574 {
39575     struct
39576     {
39577         PTR32 physicalDevice;
39578         PTR32 pImageFormatInfo;
39579         PTR32 pImageFormatProperties;
39580         VkResult result;
39581     } *params = args;
39582     VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo_host;
39583     VkImageFormatProperties2 pImageFormatProperties_host;
39584     struct conversion_context local_ctx;
39585     struct conversion_context *ctx = &local_ctx;
39586
39587     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
39588
39589     init_conversion_context(ctx);
39590     convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(ctx, (const VkPhysicalDeviceImageFormatInfo232 *)UlongToPtr(params->pImageFormatInfo), &pImageFormatInfo_host);
39591     convert_VkImageFormatProperties2_win32_to_host(ctx, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties), &pImageFormatProperties_host);
39592     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pImageFormatInfo_host, &pImageFormatProperties_host);
39593     convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties));
39594     free_conversion_context(ctx);
39595     return STATUS_SUCCESS;
39596 }
39597
39598 #ifdef _WIN64
39599 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties(void *args)
39600 {
39601     struct vkGetPhysicalDeviceMemoryProperties_params *params = args;
39602
39603     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
39604
39605     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
39606     return STATUS_SUCCESS;
39607 }
39608 #endif /* _WIN64 */
39609
39610 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties(void *args)
39611 {
39612     struct
39613     {
39614         PTR32 physicalDevice;
39615         PTR32 pMemoryProperties;
39616     } *params = args;
39617     VkPhysicalDeviceMemoryProperties pMemoryProperties_host;
39618
39619     TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);
39620
39621     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);
39622     convert_VkPhysicalDeviceMemoryProperties_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties32 *)UlongToPtr(params->pMemoryProperties));
39623     return STATUS_SUCCESS;
39624 }
39625
39626 #ifdef _WIN64
39627 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties2(void *args)
39628 {
39629     struct vkGetPhysicalDeviceMemoryProperties2_params *params = args;
39630
39631     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
39632
39633     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
39634     return STATUS_SUCCESS;
39635 }
39636 #endif /* _WIN64 */
39637
39638 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties2(void *args)
39639 {
39640     struct
39641     {
39642         PTR32 physicalDevice;
39643         PTR32 pMemoryProperties;
39644     } *params = args;
39645     VkPhysicalDeviceMemoryProperties2 pMemoryProperties_host;
39646     struct conversion_context local_ctx;
39647     struct conversion_context *ctx = &local_ctx;
39648
39649     TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);
39650
39651     init_conversion_context(ctx);
39652     convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(ctx, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties), &pMemoryProperties_host);
39653     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);
39654     convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties));
39655     free_conversion_context(ctx);
39656     return STATUS_SUCCESS;
39657 }
39658
39659 #ifdef _WIN64
39660 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties2KHR(void *args)
39661 {
39662     struct vkGetPhysicalDeviceMemoryProperties2KHR_params *params = args;
39663
39664     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
39665
39666     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
39667     return STATUS_SUCCESS;
39668 }
39669 #endif /* _WIN64 */
39670
39671 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties2KHR(void *args)
39672 {
39673     struct
39674     {
39675         PTR32 physicalDevice;
39676         PTR32 pMemoryProperties;
39677     } *params = args;
39678     VkPhysicalDeviceMemoryProperties2 pMemoryProperties_host;
39679     struct conversion_context local_ctx;
39680     struct conversion_context *ctx = &local_ctx;
39681
39682     TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);
39683
39684     init_conversion_context(ctx);
39685     convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(ctx, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties), &pMemoryProperties_host);
39686     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);
39687     convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties));
39688     free_conversion_context(ctx);
39689     return STATUS_SUCCESS;
39690 }
39691
39692 #ifdef _WIN64
39693 static NTSTATUS thunk64_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)
39694 {
39695     struct vkGetPhysicalDeviceMultisamplePropertiesEXT_params *params = args;
39696
39697     TRACE("%p, %#x, %p\n", params->physicalDevice, params->samples, params->pMultisampleProperties);
39698
39699     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->samples, params->pMultisampleProperties);
39700     return STATUS_SUCCESS;
39701 }
39702 #endif /* _WIN64 */
39703
39704 static NTSTATUS thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)
39705 {
39706     struct
39707     {
39708         PTR32 physicalDevice;
39709         VkSampleCountFlagBits samples;
39710         PTR32 pMultisampleProperties;
39711     } *params = args;
39712     VkMultisamplePropertiesEXT pMultisampleProperties_host;
39713
39714     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->samples, params->pMultisampleProperties);
39715
39716     convert_VkMultisamplePropertiesEXT_win32_to_host((VkMultisamplePropertiesEXT32 *)UlongToPtr(params->pMultisampleProperties), &pMultisampleProperties_host);
39717     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);
39718     convert_VkMultisamplePropertiesEXT_host_to_win32(&pMultisampleProperties_host, (VkMultisamplePropertiesEXT32 *)UlongToPtr(params->pMultisampleProperties));
39719     return STATUS_SUCCESS;
39720 }
39721
39722 #ifdef _WIN64
39723 static NTSTATUS thunk64_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
39724 {
39725     struct vkGetPhysicalDeviceOpticalFlowImageFormatsNV_params *params = args;
39726
39727     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
39728
39729     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);
39730     return STATUS_SUCCESS;
39731 }
39732 #endif /* _WIN64 */
39733
39734 static NTSTATUS thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
39735 {
39736     struct
39737     {
39738         PTR32 physicalDevice;
39739         PTR32 pOpticalFlowImageFormatInfo;
39740         PTR32 pFormatCount;
39741         PTR32 pImageFormatProperties;
39742         VkResult result;
39743     } *params = args;
39744     VkOpticalFlowImageFormatInfoNV pOpticalFlowImageFormatInfo_host;
39745     VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties_host;
39746     struct conversion_context local_ctx;
39747     struct conversion_context *ctx = &local_ctx;
39748
39749     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
39750
39751     init_conversion_context(ctx);
39752     convert_VkOpticalFlowImageFormatInfoNV_win32_to_host((const VkOpticalFlowImageFormatInfoNV32 *)UlongToPtr(params->pOpticalFlowImageFormatInfo), &pOpticalFlowImageFormatInfo_host);
39753     pImageFormatProperties_host = convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(ctx, (VkOpticalFlowImageFormatPropertiesNV32 *)UlongToPtr(params->pImageFormatProperties), *(uint32_t *)UlongToPtr(params->pFormatCount));
39754     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);
39755     convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(pImageFormatProperties_host, (VkOpticalFlowImageFormatPropertiesNV32 *)UlongToPtr(params->pImageFormatProperties), *(uint32_t *)UlongToPtr(params->pFormatCount));
39756     free_conversion_context(ctx);
39757     return STATUS_SUCCESS;
39758 }
39759
39760 #ifdef _WIN64
39761 static NTSTATUS thunk64_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
39762 {
39763     struct vkGetPhysicalDevicePresentRectanglesKHR_params *params = args;
39764
39765     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);
39766
39767     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);
39768     return STATUS_SUCCESS;
39769 }
39770 #endif /* _WIN64 */
39771
39772 static NTSTATUS thunk32_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
39773 {
39774     struct
39775     {
39776         PTR32 physicalDevice;
39777         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
39778         PTR32 pRectCount;
39779         PTR32 pRects;
39780         VkResult result;
39781     } *params = args;
39782
39783     TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);
39784
39785     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));
39786     return STATUS_SUCCESS;
39787 }
39788
39789 #ifdef _WIN64
39790 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties(void *args)
39791 {
39792     struct vkGetPhysicalDeviceProperties_params *params = args;
39793
39794     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
39795
39796     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
39797     return STATUS_SUCCESS;
39798 }
39799 #endif /* _WIN64 */
39800
39801 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties(void *args)
39802 {
39803     struct
39804     {
39805         PTR32 physicalDevice;
39806         PTR32 pProperties;
39807     } *params = args;
39808     VkPhysicalDeviceProperties pProperties_host;
39809
39810     TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);
39811
39812     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);
39813     convert_VkPhysicalDeviceProperties_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties32 *)UlongToPtr(params->pProperties));
39814     return STATUS_SUCCESS;
39815 }
39816
39817 #ifdef _WIN64
39818 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties2(void *args)
39819 {
39820     struct vkGetPhysicalDeviceProperties2_params *params = args;
39821
39822     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
39823
39824     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
39825     return STATUS_SUCCESS;
39826 }
39827 #endif /* _WIN64 */
39828
39829 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2(void *args)
39830 {
39831     struct
39832     {
39833         PTR32 physicalDevice;
39834         PTR32 pProperties;
39835     } *params = args;
39836     VkPhysicalDeviceProperties2 pProperties_host;
39837     struct conversion_context local_ctx;
39838     struct conversion_context *ctx = &local_ctx;
39839
39840     TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);
39841
39842     init_conversion_context(ctx);
39843     convert_VkPhysicalDeviceProperties2_win32_to_host(ctx, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties), &pProperties_host);
39844     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);
39845     convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties));
39846     free_conversion_context(ctx);
39847     return STATUS_SUCCESS;
39848 }
39849
39850 #ifdef _WIN64
39851 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties2KHR(void *args)
39852 {
39853     struct vkGetPhysicalDeviceProperties2KHR_params *params = args;
39854
39855     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
39856
39857     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
39858     return STATUS_SUCCESS;
39859 }
39860 #endif /* _WIN64 */
39861
39862 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2KHR(void *args)
39863 {
39864     struct
39865     {
39866         PTR32 physicalDevice;
39867         PTR32 pProperties;
39868     } *params = args;
39869     VkPhysicalDeviceProperties2 pProperties_host;
39870     struct conversion_context local_ctx;
39871     struct conversion_context *ctx = &local_ctx;
39872
39873     TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);
39874
39875     init_conversion_context(ctx);
39876     convert_VkPhysicalDeviceProperties2_win32_to_host(ctx, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties), &pProperties_host);
39877     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);
39878     convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties));
39879     free_conversion_context(ctx);
39880     return STATUS_SUCCESS;
39881 }
39882
39883 #ifdef _WIN64
39884 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(void *args)
39885 {
39886     struct vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_params *params = args;
39887
39888     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPerformanceQueryCreateInfo, params->pNumPasses);
39889
39890     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPerformanceQueryCreateInfo, params->pNumPasses);
39891     return STATUS_SUCCESS;
39892 }
39893 #endif /* _WIN64 */
39894
39895 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(void *args)
39896 {
39897     struct
39898     {
39899         PTR32 physicalDevice;
39900         PTR32 pPerformanceQueryCreateInfo;
39901         PTR32 pNumPasses;
39902     } *params = args;
39903     VkQueryPoolPerformanceCreateInfoKHR pPerformanceQueryCreateInfo_host;
39904
39905     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPerformanceQueryCreateInfo, params->pNumPasses);
39906
39907     convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host((const VkQueryPoolPerformanceCreateInfoKHR32 *)UlongToPtr(params->pPerformanceQueryCreateInfo), &pPerformanceQueryCreateInfo_host);
39908     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));
39909     return STATUS_SUCCESS;
39910 }
39911
39912 #ifdef _WIN64
39913 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties(void *args)
39914 {
39915     struct vkGetPhysicalDeviceQueueFamilyProperties_params *params = args;
39916
39917     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
39918
39919     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
39920     return STATUS_SUCCESS;
39921 }
39922 #endif /* _WIN64 */
39923
39924 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties(void *args)
39925 {
39926     struct
39927     {
39928         PTR32 physicalDevice;
39929         PTR32 pQueueFamilyPropertyCount;
39930         PTR32 pQueueFamilyProperties;
39931     } *params = args;
39932
39933     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
39934
39935     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));
39936     return STATUS_SUCCESS;
39937 }
39938
39939 #ifdef _WIN64
39940 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties2(void *args)
39941 {
39942     struct vkGetPhysicalDeviceQueueFamilyProperties2_params *params = args;
39943
39944     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
39945
39946     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
39947     return STATUS_SUCCESS;
39948 }
39949 #endif /* _WIN64 */
39950
39951 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties2(void *args)
39952 {
39953     struct
39954     {
39955         PTR32 physicalDevice;
39956         PTR32 pQueueFamilyPropertyCount;
39957         PTR32 pQueueFamilyProperties;
39958     } *params = args;
39959     VkQueueFamilyProperties2 *pQueueFamilyProperties_host;
39960     struct conversion_context local_ctx;
39961     struct conversion_context *ctx = &local_ctx;
39962
39963     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
39964
39965     init_conversion_context(ctx);
39966     pQueueFamilyProperties_host = convert_VkQueueFamilyProperties2_array_win32_to_host(ctx, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
39967     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);
39968     convert_VkQueueFamilyProperties2_array_host_to_win32(pQueueFamilyProperties_host, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
39969     free_conversion_context(ctx);
39970     return STATUS_SUCCESS;
39971 }
39972
39973 #ifdef _WIN64
39974 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties2KHR(void *args)
39975 {
39976     struct vkGetPhysicalDeviceQueueFamilyProperties2KHR_params *params = args;
39977
39978     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
39979
39980     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
39981     return STATUS_SUCCESS;
39982 }
39983 #endif /* _WIN64 */
39984
39985 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties2KHR(void *args)
39986 {
39987     struct
39988     {
39989         PTR32 physicalDevice;
39990         PTR32 pQueueFamilyPropertyCount;
39991         PTR32 pQueueFamilyProperties;
39992     } *params = args;
39993     VkQueueFamilyProperties2 *pQueueFamilyProperties_host;
39994     struct conversion_context local_ctx;
39995     struct conversion_context *ctx = &local_ctx;
39996
39997     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
39998
39999     init_conversion_context(ctx);
40000     pQueueFamilyProperties_host = convert_VkQueueFamilyProperties2_array_win32_to_host(ctx, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
40001     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);
40002     convert_VkQueueFamilyProperties2_array_host_to_win32(pQueueFamilyProperties_host, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
40003     free_conversion_context(ctx);
40004     return STATUS_SUCCESS;
40005 }
40006
40007 #ifdef _WIN64
40008 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties(void *args)
40009 {
40010     struct vkGetPhysicalDeviceSparseImageFormatProperties_params *params = args;
40011
40012     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);
40013
40014     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);
40015     return STATUS_SUCCESS;
40016 }
40017 #endif /* _WIN64 */
40018
40019 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties(void *args)
40020 {
40021     struct
40022     {
40023         PTR32 physicalDevice;
40024         VkFormat format;
40025         VkImageType type;
40026         VkSampleCountFlagBits samples;
40027         VkImageUsageFlags usage;
40028         VkImageTiling tiling;
40029         PTR32 pPropertyCount;
40030         PTR32 pProperties;
40031     } *params = args;
40032
40033     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);
40034
40035     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));
40036     return STATUS_SUCCESS;
40037 }
40038
40039 #ifdef _WIN64
40040 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2(void *args)
40041 {
40042     struct vkGetPhysicalDeviceSparseImageFormatProperties2_params *params = args;
40043
40044     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
40045
40046     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);
40047     return STATUS_SUCCESS;
40048 }
40049 #endif /* _WIN64 */
40050
40051 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2(void *args)
40052 {
40053     struct
40054     {
40055         PTR32 physicalDevice;
40056         PTR32 pFormatInfo;
40057         PTR32 pPropertyCount;
40058         PTR32 pProperties;
40059     } *params = args;
40060     VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo_host;
40061     VkSparseImageFormatProperties2 *pProperties_host;
40062     struct conversion_context local_ctx;
40063     struct conversion_context *ctx = &local_ctx;
40064
40065     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
40066
40067     init_conversion_context(ctx);
40068     convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host((const VkPhysicalDeviceSparseImageFormatInfo232 *)UlongToPtr(params->pFormatInfo), &pFormatInfo_host);
40069     pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(ctx, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
40070     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);
40071     convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
40072     free_conversion_context(ctx);
40073     return STATUS_SUCCESS;
40074 }
40075
40076 #ifdef _WIN64
40077 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void *args)
40078 {
40079     struct vkGetPhysicalDeviceSparseImageFormatProperties2KHR_params *params = args;
40080
40081     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
40082
40083     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);
40084     return STATUS_SUCCESS;
40085 }
40086 #endif /* _WIN64 */
40087
40088 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void *args)
40089 {
40090     struct
40091     {
40092         PTR32 physicalDevice;
40093         PTR32 pFormatInfo;
40094         PTR32 pPropertyCount;
40095         PTR32 pProperties;
40096     } *params = args;
40097     VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo_host;
40098     VkSparseImageFormatProperties2 *pProperties_host;
40099     struct conversion_context local_ctx;
40100     struct conversion_context *ctx = &local_ctx;
40101
40102     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
40103
40104     init_conversion_context(ctx);
40105     convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host((const VkPhysicalDeviceSparseImageFormatInfo232 *)UlongToPtr(params->pFormatInfo), &pFormatInfo_host);
40106     pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(ctx, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
40107     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);
40108     convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
40109     free_conversion_context(ctx);
40110     return STATUS_SUCCESS;
40111 }
40112
40113 #ifdef _WIN64
40114 static NTSTATUS thunk64_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(void *args)
40115 {
40116     struct vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_params *params = args;
40117
40118     TRACE("%p, %p, %p\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);
40119
40120     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);
40121     return STATUS_SUCCESS;
40122 }
40123 #endif /* _WIN64 */
40124
40125 static NTSTATUS thunk32_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(void *args)
40126 {
40127     struct
40128     {
40129         PTR32 physicalDevice;
40130         PTR32 pCombinationCount;
40131         PTR32 pCombinations;
40132         VkResult result;
40133     } *params = args;
40134     VkFramebufferMixedSamplesCombinationNV *pCombinations_host;
40135     struct conversion_context local_ctx;
40136     struct conversion_context *ctx = &local_ctx;
40137
40138     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);
40139
40140     init_conversion_context(ctx);
40141     pCombinations_host = convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(ctx, (VkFramebufferMixedSamplesCombinationNV32 *)UlongToPtr(params->pCombinations), *(uint32_t *)UlongToPtr(params->pCombinationCount));
40142     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);
40143     convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(pCombinations_host, (VkFramebufferMixedSamplesCombinationNV32 *)UlongToPtr(params->pCombinations), *(uint32_t *)UlongToPtr(params->pCombinationCount));
40144     free_conversion_context(ctx);
40145     return STATUS_SUCCESS;
40146 }
40147
40148 #ifdef _WIN64
40149 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
40150 {
40151     struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params *params = args;
40152
40153     TRACE("%p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
40154
40155     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
40156     return STATUS_SUCCESS;
40157 }
40158 #endif /* _WIN64 */
40159
40160 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
40161 {
40162     struct
40163     {
40164         PTR32 physicalDevice;
40165         PTR32 pSurfaceInfo;
40166         PTR32 pSurfaceCapabilities;
40167         VkResult result;
40168     } *params = args;
40169     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
40170     VkSurfaceCapabilities2KHR pSurfaceCapabilities_host;
40171     struct conversion_context local_ctx;
40172     struct conversion_context *ctx = &local_ctx;
40173
40174     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
40175
40176     init_conversion_context(ctx);
40177     convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(ctx, (const VkPhysicalDeviceSurfaceInfo2KHR32 *)UlongToPtr(params->pSurfaceInfo), &pSurfaceInfo_host);
40178     convert_VkSurfaceCapabilities2KHR_win32_to_host(ctx, (VkSurfaceCapabilities2KHR32 *)UlongToPtr(params->pSurfaceCapabilities), &pSurfaceCapabilities_host);
40179     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pSurfaceInfo_host, &pSurfaceCapabilities_host);
40180     convert_VkSurfaceCapabilities2KHR_host_to_win32(&pSurfaceCapabilities_host, (VkSurfaceCapabilities2KHR32 *)UlongToPtr(params->pSurfaceCapabilities));
40181     free_conversion_context(ctx);
40182     return STATUS_SUCCESS;
40183 }
40184
40185 #ifdef _WIN64
40186 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
40187 {
40188     struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params *params = args;
40189
40190     TRACE("%p, 0x%s, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);
40191
40192     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(params->physicalDevice, params->surface, params->pSurfaceCapabilities);
40193     return STATUS_SUCCESS;
40194 }
40195 #endif /* _WIN64 */
40196
40197 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
40198 {
40199     struct
40200     {
40201         PTR32 physicalDevice;
40202         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
40203         PTR32 pSurfaceCapabilities;
40204         VkResult result;
40205     } *params = args;
40206
40207     TRACE("%#x, 0x%s, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);
40208
40209     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), params->surface, (VkSurfaceCapabilitiesKHR *)UlongToPtr(params->pSurfaceCapabilities));
40210     return STATUS_SUCCESS;
40211 }
40212
40213 #ifdef _WIN64
40214 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
40215 {
40216     struct vkGetPhysicalDeviceSurfaceFormats2KHR_params *params = args;
40217     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
40218
40219     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);
40220
40221     convert_VkPhysicalDeviceSurfaceInfo2KHR_win64_to_host(params->pSurfaceInfo, &pSurfaceInfo_host);
40222     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);
40223     return STATUS_SUCCESS;
40224 }
40225 #endif /* _WIN64 */
40226
40227 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
40228 {
40229     struct
40230     {
40231         PTR32 physicalDevice;
40232         PTR32 pSurfaceInfo;
40233         PTR32 pSurfaceFormatCount;
40234         PTR32 pSurfaceFormats;
40235         VkResult result;
40236     } *params = args;
40237     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
40238     VkSurfaceFormat2KHR *pSurfaceFormats_host;
40239     struct conversion_context local_ctx;
40240     struct conversion_context *ctx = &local_ctx;
40241
40242     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);
40243
40244     init_conversion_context(ctx);
40245     convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host(ctx, (const VkPhysicalDeviceSurfaceInfo2KHR32 *)UlongToPtr(params->pSurfaceInfo), &pSurfaceInfo_host);
40246     pSurfaceFormats_host = convert_VkSurfaceFormat2KHR_array_win32_to_host(ctx, (VkSurfaceFormat2KHR32 *)UlongToPtr(params->pSurfaceFormats), *(uint32_t *)UlongToPtr(params->pSurfaceFormatCount));
40247     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);
40248     convert_VkSurfaceFormat2KHR_array_host_to_win32(pSurfaceFormats_host, (VkSurfaceFormat2KHR32 *)UlongToPtr(params->pSurfaceFormats), *(uint32_t *)UlongToPtr(params->pSurfaceFormatCount));
40249     free_conversion_context(ctx);
40250     return STATUS_SUCCESS;
40251 }
40252
40253 #ifdef _WIN64
40254 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
40255 {
40256     struct vkGetPhysicalDeviceSurfaceFormatsKHR_params *params = args;
40257
40258     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);
40259
40260     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);
40261     return STATUS_SUCCESS;
40262 }
40263 #endif /* _WIN64 */
40264
40265 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
40266 {
40267     struct
40268     {
40269         PTR32 physicalDevice;
40270         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
40271         PTR32 pSurfaceFormatCount;
40272         PTR32 pSurfaceFormats;
40273         VkResult result;
40274     } *params = args;
40275
40276     TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);
40277
40278     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));
40279     return STATUS_SUCCESS;
40280 }
40281
40282 #ifdef _WIN64
40283 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
40284 {
40285     struct vkGetPhysicalDeviceSurfacePresentModesKHR_params *params = args;
40286
40287     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);
40288
40289     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);
40290     return STATUS_SUCCESS;
40291 }
40292 #endif /* _WIN64 */
40293
40294 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
40295 {
40296     struct
40297     {
40298         PTR32 physicalDevice;
40299         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
40300         PTR32 pPresentModeCount;
40301         PTR32 pPresentModes;
40302         VkResult result;
40303     } *params = args;
40304
40305     TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);
40306
40307     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));
40308     return STATUS_SUCCESS;
40309 }
40310
40311 #ifdef _WIN64
40312 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
40313 {
40314     struct vkGetPhysicalDeviceSurfaceSupportKHR_params *params = args;
40315
40316     TRACE("%p, %u, 0x%s, %p\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);
40317
40318     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);
40319     return STATUS_SUCCESS;
40320 }
40321 #endif /* _WIN64 */
40322
40323 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
40324 {
40325     struct
40326     {
40327         PTR32 physicalDevice;
40328         uint32_t queueFamilyIndex;
40329         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
40330         PTR32 pSupported;
40331         VkResult result;
40332     } *params = args;
40333
40334     TRACE("%#x, %u, 0x%s, %#x\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);
40335
40336     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));
40337     return STATUS_SUCCESS;
40338 }
40339
40340 #ifdef _WIN64
40341 static NTSTATUS thunk64_vkGetPhysicalDeviceToolProperties(void *args)
40342 {
40343     struct vkGetPhysicalDeviceToolProperties_params *params = args;
40344
40345     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
40346
40347     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);
40348     return STATUS_SUCCESS;
40349 }
40350 #endif /* _WIN64 */
40351
40352 static NTSTATUS thunk32_vkGetPhysicalDeviceToolProperties(void *args)
40353 {
40354     struct
40355     {
40356         PTR32 physicalDevice;
40357         PTR32 pToolCount;
40358         PTR32 pToolProperties;
40359         VkResult result;
40360     } *params = args;
40361     VkPhysicalDeviceToolProperties *pToolProperties_host;
40362     struct conversion_context local_ctx;
40363     struct conversion_context *ctx = &local_ctx;
40364
40365     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
40366
40367     init_conversion_context(ctx);
40368     pToolProperties_host = convert_VkPhysicalDeviceToolProperties_array_win32_to_host(ctx, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
40369     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);
40370     convert_VkPhysicalDeviceToolProperties_array_host_to_win32(pToolProperties_host, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
40371     free_conversion_context(ctx);
40372     return STATUS_SUCCESS;
40373 }
40374
40375 #ifdef _WIN64
40376 static NTSTATUS thunk64_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
40377 {
40378     struct vkGetPhysicalDeviceToolPropertiesEXT_params *params = args;
40379
40380     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
40381
40382     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);
40383     return STATUS_SUCCESS;
40384 }
40385 #endif /* _WIN64 */
40386
40387 static NTSTATUS thunk32_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
40388 {
40389     struct
40390     {
40391         PTR32 physicalDevice;
40392         PTR32 pToolCount;
40393         PTR32 pToolProperties;
40394         VkResult result;
40395     } *params = args;
40396     VkPhysicalDeviceToolProperties *pToolProperties_host;
40397     struct conversion_context local_ctx;
40398     struct conversion_context *ctx = &local_ctx;
40399
40400     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
40401
40402     init_conversion_context(ctx);
40403     pToolProperties_host = convert_VkPhysicalDeviceToolProperties_array_win32_to_host(ctx, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
40404     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);
40405     convert_VkPhysicalDeviceToolProperties_array_host_to_win32(pToolProperties_host, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
40406     free_conversion_context(ctx);
40407     return STATUS_SUCCESS;
40408 }
40409
40410 #ifdef _WIN64
40411 static NTSTATUS thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *args)
40412 {
40413     struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params *params = args;
40414
40415     TRACE("%p, %u\n", params->physicalDevice, params->queueFamilyIndex);
40416
40417     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex);
40418     return STATUS_SUCCESS;
40419 }
40420 #endif /* _WIN64 */
40421
40422 static NTSTATUS thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *args)
40423 {
40424     struct
40425     {
40426         PTR32 physicalDevice;
40427         uint32_t queueFamilyIndex;
40428         VkBool32 result;
40429     } *params = args;
40430
40431     TRACE("%#x, %u\n", params->physicalDevice, params->queueFamilyIndex);
40432
40433     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);
40434     return STATUS_SUCCESS;
40435 }
40436
40437 #ifdef _WIN64
40438 static NTSTATUS thunk64_vkGetPipelineCacheData(void *args)
40439 {
40440     struct vkGetPipelineCacheData_params *params = args;
40441
40442     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);
40443
40444     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineCacheData(wine_device_from_handle(params->device)->device, params->pipelineCache, params->pDataSize, params->pData);
40445     return STATUS_SUCCESS;
40446 }
40447 #endif /* _WIN64 */
40448
40449 static NTSTATUS thunk32_vkGetPipelineCacheData(void *args)
40450 {
40451     struct
40452     {
40453         PTR32 device;
40454         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
40455         PTR32 pDataSize;
40456         PTR32 pData;
40457         VkResult result;
40458     } *params = args;
40459     size_t pDataSize_host;
40460
40461     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);
40462
40463     pDataSize_host = *(PTR32 *)UlongToPtr(params->pDataSize);
40464     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));
40465     *(PTR32 *)UlongToPtr(params->pDataSize) = pDataSize_host;
40466     return STATUS_SUCCESS;
40467 }
40468
40469 #ifdef _WIN64
40470 static NTSTATUS thunk64_vkGetPipelineExecutableInternalRepresentationsKHR(void *args)
40471 {
40472     struct vkGetPipelineExecutableInternalRepresentationsKHR_params *params = args;
40473
40474     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
40475
40476     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
40477     return STATUS_SUCCESS;
40478 }
40479 #endif /* _WIN64 */
40480
40481 static NTSTATUS thunk32_vkGetPipelineExecutableInternalRepresentationsKHR(void *args)
40482 {
40483     struct
40484     {
40485         PTR32 device;
40486         PTR32 pExecutableInfo;
40487         PTR32 pInternalRepresentationCount;
40488         PTR32 pInternalRepresentations;
40489         VkResult result;
40490     } *params = args;
40491     VkPipelineExecutableInfoKHR pExecutableInfo_host;
40492     VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations_host;
40493     struct conversion_context local_ctx;
40494     struct conversion_context *ctx = &local_ctx;
40495
40496     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
40497
40498     init_conversion_context(ctx);
40499     convert_VkPipelineExecutableInfoKHR_win32_to_host((const VkPipelineExecutableInfoKHR32 *)UlongToPtr(params->pExecutableInfo), &pExecutableInfo_host);
40500     pInternalRepresentations_host = convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(ctx, (VkPipelineExecutableInternalRepresentationKHR32 *)UlongToPtr(params->pInternalRepresentations), *(uint32_t *)UlongToPtr(params->pInternalRepresentationCount));
40501     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);
40502     convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(pInternalRepresentations_host, (VkPipelineExecutableInternalRepresentationKHR32 *)UlongToPtr(params->pInternalRepresentations), *(uint32_t *)UlongToPtr(params->pInternalRepresentationCount));
40503     free_conversion_context(ctx);
40504     return STATUS_SUCCESS;
40505 }
40506
40507 #ifdef _WIN64
40508 static NTSTATUS thunk64_vkGetPipelineExecutablePropertiesKHR(void *args)
40509 {
40510     struct vkGetPipelineExecutablePropertiesKHR_params *params = args;
40511
40512     TRACE("%p, %p, %p, %p\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
40513
40514     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
40515     return STATUS_SUCCESS;
40516 }
40517 #endif /* _WIN64 */
40518
40519 static NTSTATUS thunk32_vkGetPipelineExecutablePropertiesKHR(void *args)
40520 {
40521     struct
40522     {
40523         PTR32 device;
40524         PTR32 pPipelineInfo;
40525         PTR32 pExecutableCount;
40526         PTR32 pProperties;
40527         VkResult result;
40528     } *params = args;
40529     VkPipelineInfoKHR pPipelineInfo_host;
40530     VkPipelineExecutablePropertiesKHR *pProperties_host;
40531     struct conversion_context local_ctx;
40532     struct conversion_context *ctx = &local_ctx;
40533
40534     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
40535
40536     init_conversion_context(ctx);
40537     convert_VkPipelineInfoKHR_win32_to_host((const VkPipelineInfoKHR32 *)UlongToPtr(params->pPipelineInfo), &pPipelineInfo_host);
40538     pProperties_host = convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(ctx, (VkPipelineExecutablePropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pExecutableCount));
40539     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);
40540     convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(pProperties_host, (VkPipelineExecutablePropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pExecutableCount));
40541     free_conversion_context(ctx);
40542     return STATUS_SUCCESS;
40543 }
40544
40545 #ifdef _WIN64
40546 static NTSTATUS thunk64_vkGetPipelineExecutableStatisticsKHR(void *args)
40547 {
40548     struct vkGetPipelineExecutableStatisticsKHR_params *params = args;
40549
40550     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
40551
40552     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
40553     return STATUS_SUCCESS;
40554 }
40555 #endif /* _WIN64 */
40556
40557 static NTSTATUS thunk32_vkGetPipelineExecutableStatisticsKHR(void *args)
40558 {
40559     struct
40560     {
40561         PTR32 device;
40562         PTR32 pExecutableInfo;
40563         PTR32 pStatisticCount;
40564         PTR32 pStatistics;
40565         VkResult result;
40566     } *params = args;
40567     VkPipelineExecutableInfoKHR pExecutableInfo_host;
40568     VkPipelineExecutableStatisticKHR *pStatistics_host;
40569     struct conversion_context local_ctx;
40570     struct conversion_context *ctx = &local_ctx;
40571
40572     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
40573
40574     init_conversion_context(ctx);
40575     convert_VkPipelineExecutableInfoKHR_win32_to_host((const VkPipelineExecutableInfoKHR32 *)UlongToPtr(params->pExecutableInfo), &pExecutableInfo_host);
40576     pStatistics_host = convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(ctx, (VkPipelineExecutableStatisticKHR32 *)UlongToPtr(params->pStatistics), *(uint32_t *)UlongToPtr(params->pStatisticCount));
40577     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);
40578     convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(pStatistics_host, (VkPipelineExecutableStatisticKHR32 *)UlongToPtr(params->pStatistics), *(uint32_t *)UlongToPtr(params->pStatisticCount));
40579     free_conversion_context(ctx);
40580     return STATUS_SUCCESS;
40581 }
40582
40583 #ifdef _WIN64
40584 static NTSTATUS thunk64_vkGetPipelineIndirectDeviceAddressNV(void *args)
40585 {
40586     struct vkGetPipelineIndirectDeviceAddressNV_params *params = args;
40587
40588     TRACE("%p, %p\n", params->device, params->pInfo);
40589
40590     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineIndirectDeviceAddressNV(wine_device_from_handle(params->device)->device, params->pInfo);
40591     return STATUS_SUCCESS;
40592 }
40593 #endif /* _WIN64 */
40594
40595 static NTSTATUS thunk32_vkGetPipelineIndirectDeviceAddressNV(void *args)
40596 {
40597     struct
40598     {
40599         PTR32 device;
40600         PTR32 pInfo;
40601         VkDeviceAddress result;
40602     } *params = args;
40603     VkPipelineIndirectDeviceAddressInfoNV pInfo_host;
40604
40605     TRACE("%#x, %#x\n", params->device, params->pInfo);
40606
40607     convert_VkPipelineIndirectDeviceAddressInfoNV_win32_to_host((const VkPipelineIndirectDeviceAddressInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
40608     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPipelineIndirectDeviceAddressNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
40609     return STATUS_SUCCESS;
40610 }
40611
40612 #ifdef _WIN64
40613 static NTSTATUS thunk64_vkGetPipelineIndirectMemoryRequirementsNV(void *args)
40614 {
40615     struct vkGetPipelineIndirectMemoryRequirementsNV_params *params = args;
40616     VkComputePipelineCreateInfo pCreateInfo_host;
40617     struct conversion_context local_ctx;
40618     struct conversion_context *ctx = &local_ctx;
40619
40620     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pMemoryRequirements);
40621
40622     init_conversion_context(ctx);
40623     convert_VkComputePipelineCreateInfo_win64_to_host(ctx, params->pCreateInfo, &pCreateInfo_host);
40624     wine_device_from_handle(params->device)->funcs.p_vkGetPipelineIndirectMemoryRequirementsNV(wine_device_from_handle(params->device)->device, &pCreateInfo_host, params->pMemoryRequirements);
40625     free_conversion_context(ctx);
40626     return STATUS_SUCCESS;
40627 }
40628 #endif /* _WIN64 */
40629
40630 static NTSTATUS thunk32_vkGetPipelineIndirectMemoryRequirementsNV(void *args)
40631 {
40632     struct
40633     {
40634         PTR32 device;
40635         PTR32 pCreateInfo;
40636         PTR32 pMemoryRequirements;
40637     } *params = args;
40638     VkComputePipelineCreateInfo pCreateInfo_host;
40639     VkMemoryRequirements2 pMemoryRequirements_host;
40640     struct conversion_context local_ctx;
40641     struct conversion_context *ctx = &local_ctx;
40642
40643     TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pMemoryRequirements);
40644
40645     init_conversion_context(ctx);
40646     convert_VkComputePipelineCreateInfo_win32_to_host(ctx, (const VkComputePipelineCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
40647     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
40648     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPipelineIndirectMemoryRequirementsNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pMemoryRequirements_host);
40649     convert_VkComputePipelineCreateInfo_host_to_win32(&pCreateInfo_host, (const VkComputePipelineCreateInfo32 *)UlongToPtr(params->pCreateInfo));
40650     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
40651     free_conversion_context(ctx);
40652     return STATUS_SUCCESS;
40653 }
40654
40655 #ifdef _WIN64
40656 static NTSTATUS thunk64_vkGetPipelinePropertiesEXT(void *args)
40657 {
40658     struct vkGetPipelinePropertiesEXT_params *params = args;
40659
40660     TRACE("%p, %p, %p\n", params->device, params->pPipelineInfo, params->pPipelineProperties);
40661
40662     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pPipelineProperties);
40663     return STATUS_SUCCESS;
40664 }
40665 #endif /* _WIN64 */
40666
40667 static NTSTATUS thunk32_vkGetPipelinePropertiesEXT(void *args)
40668 {
40669     struct
40670     {
40671         PTR32 device;
40672         PTR32 pPipelineInfo;
40673         PTR32 pPipelineProperties;
40674         VkResult result;
40675     } *params = args;
40676     VkPipelineInfoEXT pPipelineInfo_host;
40677
40678     TRACE("%#x, %#x, %#x\n", params->device, params->pPipelineInfo, params->pPipelineProperties);
40679
40680     convert_VkPipelineInfoEXT_win32_to_host((const VkPipelineInfoEXT32 *)UlongToPtr(params->pPipelineInfo), &pPipelineInfo_host);
40681     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));
40682     return STATUS_SUCCESS;
40683 }
40684
40685 #ifdef _WIN64
40686 static NTSTATUS thunk64_vkGetPrivateData(void *args)
40687 {
40688     struct vkGetPrivateData_params *params = args;
40689
40690     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);
40691
40692     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);
40693     return STATUS_SUCCESS;
40694 }
40695 #endif /* _WIN64 */
40696
40697 static NTSTATUS thunk32_vkGetPrivateData(void *args)
40698 {
40699     struct
40700     {
40701         PTR32 device;
40702         VkObjectType objectType;
40703         uint64_t DECLSPEC_ALIGN(8) objectHandle;
40704         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
40705         PTR32 pData;
40706     } *params = args;
40707
40708     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);
40709
40710     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));
40711     return STATUS_SUCCESS;
40712 }
40713
40714 #ifdef _WIN64
40715 static NTSTATUS thunk64_vkGetPrivateDataEXT(void *args)
40716 {
40717     struct vkGetPrivateDataEXT_params *params = args;
40718
40719     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);
40720
40721     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);
40722     return STATUS_SUCCESS;
40723 }
40724 #endif /* _WIN64 */
40725
40726 static NTSTATUS thunk32_vkGetPrivateDataEXT(void *args)
40727 {
40728     struct
40729     {
40730         PTR32 device;
40731         VkObjectType objectType;
40732         uint64_t DECLSPEC_ALIGN(8) objectHandle;
40733         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
40734         PTR32 pData;
40735     } *params = args;
40736
40737     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);
40738
40739     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));
40740     return STATUS_SUCCESS;
40741 }
40742
40743 #ifdef _WIN64
40744 static NTSTATUS thunk64_vkGetQueryPoolResults(void *args)
40745 {
40746     struct vkGetQueryPoolResults_params *params = args;
40747
40748     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);
40749
40750     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);
40751     return STATUS_SUCCESS;
40752 }
40753 #endif /* _WIN64 */
40754
40755 static NTSTATUS thunk32_vkGetQueryPoolResults(void *args)
40756 {
40757     struct
40758     {
40759         PTR32 device;
40760         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
40761         uint32_t firstQuery;
40762         uint32_t queryCount;
40763         PTR32 dataSize;
40764         PTR32 pData;
40765         VkDeviceSize DECLSPEC_ALIGN(8) stride;
40766         VkQueryResultFlags flags;
40767         VkResult result;
40768     } *params = args;
40769
40770     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);
40771
40772     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);
40773     return STATUS_SUCCESS;
40774 }
40775
40776 #ifdef _WIN64
40777 static NTSTATUS thunk64_vkGetQueueCheckpointData2NV(void *args)
40778 {
40779     struct vkGetQueueCheckpointData2NV_params *params = args;
40780
40781     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
40782
40783     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointData2NV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, params->pCheckpointData);
40784     return STATUS_SUCCESS;
40785 }
40786 #endif /* _WIN64 */
40787
40788 static NTSTATUS thunk32_vkGetQueueCheckpointData2NV(void *args)
40789 {
40790     struct
40791     {
40792         PTR32 queue;
40793         PTR32 pCheckpointDataCount;
40794         PTR32 pCheckpointData;
40795     } *params = args;
40796     VkCheckpointData2NV *pCheckpointData_host;
40797     struct conversion_context local_ctx;
40798     struct conversion_context *ctx = &local_ctx;
40799
40800     TRACE("%#x, %#x, %#x\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
40801
40802     init_conversion_context(ctx);
40803     pCheckpointData_host = convert_VkCheckpointData2NV_array_win32_to_host(ctx, (VkCheckpointData2NV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
40804     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);
40805     convert_VkCheckpointData2NV_array_host_to_win32(pCheckpointData_host, (VkCheckpointData2NV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
40806     free_conversion_context(ctx);
40807     return STATUS_SUCCESS;
40808 }
40809
40810 #ifdef _WIN64
40811 static NTSTATUS thunk64_vkGetQueueCheckpointDataNV(void *args)
40812 {
40813     struct vkGetQueueCheckpointDataNV_params *params = args;
40814
40815     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
40816
40817     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointDataNV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, params->pCheckpointData);
40818     return STATUS_SUCCESS;
40819 }
40820 #endif /* _WIN64 */
40821
40822 static NTSTATUS thunk32_vkGetQueueCheckpointDataNV(void *args)
40823 {
40824     struct
40825     {
40826         PTR32 queue;
40827         PTR32 pCheckpointDataCount;
40828         PTR32 pCheckpointData;
40829     } *params = args;
40830     VkCheckpointDataNV *pCheckpointData_host;
40831     struct conversion_context local_ctx;
40832     struct conversion_context *ctx = &local_ctx;
40833
40834     TRACE("%#x, %#x, %#x\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
40835
40836     init_conversion_context(ctx);
40837     pCheckpointData_host = convert_VkCheckpointDataNV_array_win32_to_host(ctx, (VkCheckpointDataNV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
40838     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);
40839     convert_VkCheckpointDataNV_array_host_to_win32(pCheckpointData_host, (VkCheckpointDataNV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
40840     free_conversion_context(ctx);
40841     return STATUS_SUCCESS;
40842 }
40843
40844 #ifdef _WIN64
40845 static NTSTATUS thunk64_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *args)
40846 {
40847     struct vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_params *params = args;
40848
40849     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);
40850
40851     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);
40852     return STATUS_SUCCESS;
40853 }
40854 #endif /* _WIN64 */
40855
40856 static NTSTATUS thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *args)
40857 {
40858     struct
40859     {
40860         PTR32 device;
40861         VkPipeline DECLSPEC_ALIGN(8) pipeline;
40862         uint32_t firstGroup;
40863         uint32_t groupCount;
40864         PTR32 dataSize;
40865         PTR32 pData;
40866         VkResult result;
40867     } *params = args;
40868
40869     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);
40870
40871     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));
40872     return STATUS_SUCCESS;
40873 }
40874
40875 #ifdef _WIN64
40876 static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesKHR(void *args)
40877 {
40878     struct vkGetRayTracingShaderGroupHandlesKHR_params *params = args;
40879
40880     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);
40881
40882     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);
40883     return STATUS_SUCCESS;
40884 }
40885 #endif /* _WIN64 */
40886
40887 static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesKHR(void *args)
40888 {
40889     struct
40890     {
40891         PTR32 device;
40892         VkPipeline DECLSPEC_ALIGN(8) pipeline;
40893         uint32_t firstGroup;
40894         uint32_t groupCount;
40895         PTR32 dataSize;
40896         PTR32 pData;
40897         VkResult result;
40898     } *params = args;
40899
40900     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);
40901
40902     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));
40903     return STATUS_SUCCESS;
40904 }
40905
40906 #ifdef _WIN64
40907 static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesNV(void *args)
40908 {
40909     struct vkGetRayTracingShaderGroupHandlesNV_params *params = args;
40910
40911     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);
40912
40913     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);
40914     return STATUS_SUCCESS;
40915 }
40916 #endif /* _WIN64 */
40917
40918 static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesNV(void *args)
40919 {
40920     struct
40921     {
40922         PTR32 device;
40923         VkPipeline DECLSPEC_ALIGN(8) pipeline;
40924         uint32_t firstGroup;
40925         uint32_t groupCount;
40926         PTR32 dataSize;
40927         PTR32 pData;
40928         VkResult result;
40929     } *params = args;
40930
40931     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);
40932
40933     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));
40934     return STATUS_SUCCESS;
40935 }
40936
40937 #ifdef _WIN64
40938 static NTSTATUS thunk64_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
40939 {
40940     struct vkGetRayTracingShaderGroupStackSizeKHR_params *params = args;
40941
40942     TRACE("%p, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);
40943
40944     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->group, params->groupShader);
40945     return STATUS_SUCCESS;
40946 }
40947 #endif /* _WIN64 */
40948
40949 static NTSTATUS thunk32_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
40950 {
40951     struct
40952     {
40953         PTR32 device;
40954         VkPipeline DECLSPEC_ALIGN(8) pipeline;
40955         uint32_t group;
40956         VkShaderGroupShaderKHR groupShader;
40957         VkDeviceSize result;
40958     } *params = args;
40959
40960     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);
40961
40962     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);
40963     return STATUS_SUCCESS;
40964 }
40965
40966 #ifdef _WIN64
40967 static NTSTATUS thunk64_vkGetRenderAreaGranularity(void *args)
40968 {
40969     struct vkGetRenderAreaGranularity_params *params = args;
40970
40971     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pGranularity);
40972
40973     wine_device_from_handle(params->device)->funcs.p_vkGetRenderAreaGranularity(wine_device_from_handle(params->device)->device, params->renderPass, params->pGranularity);
40974     return STATUS_SUCCESS;
40975 }
40976 #endif /* _WIN64 */
40977
40978 static NTSTATUS thunk32_vkGetRenderAreaGranularity(void *args)
40979 {
40980     struct
40981     {
40982         PTR32 device;
40983         VkRenderPass DECLSPEC_ALIGN(8) renderPass;
40984         PTR32 pGranularity;
40985     } *params = args;
40986
40987     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pGranularity);
40988
40989     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));
40990     return STATUS_SUCCESS;
40991 }
40992
40993 #ifdef _WIN64
40994 static NTSTATUS thunk64_vkGetRenderingAreaGranularityKHR(void *args)
40995 {
40996     struct vkGetRenderingAreaGranularityKHR_params *params = args;
40997
40998     TRACE("%p, %p, %p\n", params->device, params->pRenderingAreaInfo, params->pGranularity);
40999
41000     wine_device_from_handle(params->device)->funcs.p_vkGetRenderingAreaGranularityKHR(wine_device_from_handle(params->device)->device, params->pRenderingAreaInfo, params->pGranularity);
41001     return STATUS_SUCCESS;
41002 }
41003 #endif /* _WIN64 */
41004
41005 static NTSTATUS thunk32_vkGetRenderingAreaGranularityKHR(void *args)
41006 {
41007     struct
41008     {
41009         PTR32 device;
41010         PTR32 pRenderingAreaInfo;
41011         PTR32 pGranularity;
41012     } *params = args;
41013     VkRenderingAreaInfoKHR pRenderingAreaInfo_host;
41014
41015     TRACE("%#x, %#x, %#x\n", params->device, params->pRenderingAreaInfo, params->pGranularity);
41016
41017     convert_VkRenderingAreaInfoKHR_win32_to_host((const VkRenderingAreaInfoKHR32 *)UlongToPtr(params->pRenderingAreaInfo), &pRenderingAreaInfo_host);
41018     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetRenderingAreaGranularityKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pRenderingAreaInfo_host, (VkExtent2D *)UlongToPtr(params->pGranularity));
41019     return STATUS_SUCCESS;
41020 }
41021
41022 #ifdef _WIN64
41023 static NTSTATUS thunk64_vkGetSamplerOpaqueCaptureDescriptorDataEXT(void *args)
41024 {
41025     struct vkGetSamplerOpaqueCaptureDescriptorDataEXT_params *params = args;
41026
41027     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
41028
41029     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSamplerOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
41030     return STATUS_SUCCESS;
41031 }
41032 #endif /* _WIN64 */
41033
41034 static NTSTATUS thunk32_vkGetSamplerOpaqueCaptureDescriptorDataEXT(void *args)
41035 {
41036     struct
41037     {
41038         PTR32 device;
41039         PTR32 pInfo;
41040         PTR32 pData;
41041         VkResult result;
41042     } *params = args;
41043     VkSamplerCaptureDescriptorDataInfoEXT pInfo_host;
41044
41045     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
41046
41047     convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host((const VkSamplerCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
41048     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));
41049     return STATUS_SUCCESS;
41050 }
41051
41052 #ifdef _WIN64
41053 static NTSTATUS thunk64_vkGetSemaphoreCounterValue(void *args)
41054 {
41055     struct vkGetSemaphoreCounterValue_params *params = args;
41056
41057     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
41058
41059     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
41060     return STATUS_SUCCESS;
41061 }
41062 #endif /* _WIN64 */
41063
41064 static NTSTATUS thunk32_vkGetSemaphoreCounterValue(void *args)
41065 {
41066     struct
41067     {
41068         PTR32 device;
41069         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
41070         PTR32 pValue;
41071         VkResult result;
41072     } *params = args;
41073
41074     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
41075
41076     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));
41077     return STATUS_SUCCESS;
41078 }
41079
41080 #ifdef _WIN64
41081 static NTSTATUS thunk64_vkGetSemaphoreCounterValueKHR(void *args)
41082 {
41083     struct vkGetSemaphoreCounterValueKHR_params *params = args;
41084
41085     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
41086
41087     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
41088     return STATUS_SUCCESS;
41089 }
41090 #endif /* _WIN64 */
41091
41092 static NTSTATUS thunk32_vkGetSemaphoreCounterValueKHR(void *args)
41093 {
41094     struct
41095     {
41096         PTR32 device;
41097         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
41098         PTR32 pValue;
41099         VkResult result;
41100     } *params = args;
41101
41102     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
41103
41104     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));
41105     return STATUS_SUCCESS;
41106 }
41107
41108 #ifdef _WIN64
41109 static NTSTATUS thunk64_vkGetShaderBinaryDataEXT(void *args)
41110 {
41111     struct vkGetShaderBinaryDataEXT_params *params = args;
41112
41113     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->shader), params->pDataSize, params->pData);
41114
41115     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetShaderBinaryDataEXT(wine_device_from_handle(params->device)->device, params->shader, params->pDataSize, params->pData);
41116     return STATUS_SUCCESS;
41117 }
41118 #endif /* _WIN64 */
41119
41120 static NTSTATUS thunk32_vkGetShaderBinaryDataEXT(void *args)
41121 {
41122     struct
41123     {
41124         PTR32 device;
41125         VkShaderEXT DECLSPEC_ALIGN(8) shader;
41126         PTR32 pDataSize;
41127         PTR32 pData;
41128         VkResult result;
41129     } *params = args;
41130     size_t pDataSize_host;
41131
41132     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->shader), params->pDataSize, params->pData);
41133
41134     pDataSize_host = *(PTR32 *)UlongToPtr(params->pDataSize);
41135     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));
41136     *(PTR32 *)UlongToPtr(params->pDataSize) = pDataSize_host;
41137     return STATUS_SUCCESS;
41138 }
41139
41140 #ifdef _WIN64
41141 static NTSTATUS thunk64_vkGetShaderInfoAMD(void *args)
41142 {
41143     struct vkGetShaderInfoAMD_params *params = args;
41144
41145     TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
41146
41147     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);
41148     return STATUS_SUCCESS;
41149 }
41150 #endif /* _WIN64 */
41151
41152 static NTSTATUS thunk32_vkGetShaderInfoAMD(void *args)
41153 {
41154     struct
41155     {
41156         PTR32 device;
41157         VkPipeline DECLSPEC_ALIGN(8) pipeline;
41158         VkShaderStageFlagBits shaderStage;
41159         VkShaderInfoTypeAMD infoType;
41160         PTR32 pInfoSize;
41161         PTR32 pInfo;
41162         VkResult result;
41163     } *params = args;
41164     size_t pInfoSize_host;
41165
41166     TRACE("%#x, 0x%s, %#x, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
41167
41168     pInfoSize_host = *(PTR32 *)UlongToPtr(params->pInfoSize);
41169     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));
41170     *(PTR32 *)UlongToPtr(params->pInfoSize) = pInfoSize_host;
41171     return STATUS_SUCCESS;
41172 }
41173
41174 #ifdef _WIN64
41175 static NTSTATUS thunk64_vkGetShaderModuleCreateInfoIdentifierEXT(void *args)
41176 {
41177     struct vkGetShaderModuleCreateInfoIdentifierEXT_params *params = args;
41178
41179     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pIdentifier);
41180
41181     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleCreateInfoIdentifierEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pIdentifier);
41182     return STATUS_SUCCESS;
41183 }
41184 #endif /* _WIN64 */
41185
41186 static NTSTATUS thunk32_vkGetShaderModuleCreateInfoIdentifierEXT(void *args)
41187 {
41188     struct
41189     {
41190         PTR32 device;
41191         PTR32 pCreateInfo;
41192         PTR32 pIdentifier;
41193     } *params = args;
41194     VkShaderModuleCreateInfo pCreateInfo_host;
41195     VkShaderModuleIdentifierEXT pIdentifier_host;
41196     struct conversion_context local_ctx;
41197     struct conversion_context *ctx = &local_ctx;
41198
41199     TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pIdentifier);
41200
41201     init_conversion_context(ctx);
41202     convert_VkShaderModuleCreateInfo_win32_to_host(ctx, (const VkShaderModuleCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
41203     convert_VkShaderModuleIdentifierEXT_win32_to_host((VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier), &pIdentifier_host);
41204     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetShaderModuleCreateInfoIdentifierEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pIdentifier_host);
41205     convert_VkShaderModuleIdentifierEXT_host_to_win32(&pIdentifier_host, (VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier));
41206     free_conversion_context(ctx);
41207     return STATUS_SUCCESS;
41208 }
41209
41210 #ifdef _WIN64
41211 static NTSTATUS thunk64_vkGetShaderModuleIdentifierEXT(void *args)
41212 {
41213     struct vkGetShaderModuleIdentifierEXT_params *params = args;
41214
41215     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pIdentifier);
41216
41217     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleIdentifierEXT(wine_device_from_handle(params->device)->device, params->shaderModule, params->pIdentifier);
41218     return STATUS_SUCCESS;
41219 }
41220 #endif /* _WIN64 */
41221
41222 static NTSTATUS thunk32_vkGetShaderModuleIdentifierEXT(void *args)
41223 {
41224     struct
41225     {
41226         PTR32 device;
41227         VkShaderModule DECLSPEC_ALIGN(8) shaderModule;
41228         PTR32 pIdentifier;
41229     } *params = args;
41230     VkShaderModuleIdentifierEXT pIdentifier_host;
41231
41232     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pIdentifier);
41233
41234     convert_VkShaderModuleIdentifierEXT_win32_to_host((VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier), &pIdentifier_host);
41235     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetShaderModuleIdentifierEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->shaderModule, &pIdentifier_host);
41236     convert_VkShaderModuleIdentifierEXT_host_to_win32(&pIdentifier_host, (VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier));
41237     return STATUS_SUCCESS;
41238 }
41239
41240 #ifdef _WIN64
41241 static NTSTATUS thunk64_vkGetSwapchainImagesKHR(void *args)
41242 {
41243     struct vkGetSwapchainImagesKHR_params *params = args;
41244
41245     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);
41246
41247     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->pSwapchainImageCount, params->pSwapchainImages);
41248     return STATUS_SUCCESS;
41249 }
41250 #endif /* _WIN64 */
41251
41252 static NTSTATUS thunk32_vkGetSwapchainImagesKHR(void *args)
41253 {
41254     struct
41255     {
41256         PTR32 device;
41257         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
41258         PTR32 pSwapchainImageCount;
41259         PTR32 pSwapchainImages;
41260         VkResult result;
41261     } *params = args;
41262
41263     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);
41264
41265     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));
41266     return STATUS_SUCCESS;
41267 }
41268
41269 #ifdef _WIN64
41270 static NTSTATUS thunk64_vkGetValidationCacheDataEXT(void *args)
41271 {
41272     struct vkGetValidationCacheDataEXT_params *params = args;
41273
41274     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);
41275
41276     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle(params->device)->device, params->validationCache, params->pDataSize, params->pData);
41277     return STATUS_SUCCESS;
41278 }
41279 #endif /* _WIN64 */
41280
41281 static NTSTATUS thunk32_vkGetValidationCacheDataEXT(void *args)
41282 {
41283     struct
41284     {
41285         PTR32 device;
41286         VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
41287         PTR32 pDataSize;
41288         PTR32 pData;
41289         VkResult result;
41290     } *params = args;
41291     size_t pDataSize_host;
41292
41293     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);
41294
41295     pDataSize_host = *(PTR32 *)UlongToPtr(params->pDataSize);
41296     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));
41297     *(PTR32 *)UlongToPtr(params->pDataSize) = pDataSize_host;
41298     return STATUS_SUCCESS;
41299 }
41300
41301 #ifdef _WIN64
41302 static NTSTATUS thunk64_vkInitializePerformanceApiINTEL(void *args)
41303 {
41304     struct vkInitializePerformanceApiINTEL_params *params = args;
41305
41306     TRACE("%p, %p\n", params->device, params->pInitializeInfo);
41307
41308     params->result = wine_device_from_handle(params->device)->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device, params->pInitializeInfo);
41309     return STATUS_SUCCESS;
41310 }
41311 #endif /* _WIN64 */
41312
41313 static NTSTATUS thunk32_vkInitializePerformanceApiINTEL(void *args)
41314 {
41315     struct
41316     {
41317         PTR32 device;
41318         PTR32 pInitializeInfo;
41319         VkResult result;
41320     } *params = args;
41321     VkInitializePerformanceApiInfoINTEL pInitializeInfo_host;
41322
41323     TRACE("%#x, %#x\n", params->device, params->pInitializeInfo);
41324
41325     convert_VkInitializePerformanceApiInfoINTEL_win32_to_host((const VkInitializePerformanceApiInfoINTEL32 *)UlongToPtr(params->pInitializeInfo), &pInitializeInfo_host);
41326     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInitializeInfo_host);
41327     return STATUS_SUCCESS;
41328 }
41329
41330 #ifdef _WIN64
41331 static NTSTATUS thunk64_vkInvalidateMappedMemoryRanges(void *args)
41332 {
41333     struct vkInvalidateMappedMemoryRanges_params *params = args;
41334     const VkMappedMemoryRange *pMemoryRanges_host;
41335     struct conversion_context local_ctx;
41336     struct conversion_context *ctx = &local_ctx;
41337
41338     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
41339
41340     init_conversion_context(ctx);
41341     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win64_to_host(ctx, params->pMemoryRanges, params->memoryRangeCount);
41342     params->result = wine_device_from_handle(params->device)->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
41343     free_conversion_context(ctx);
41344     return STATUS_SUCCESS;
41345 }
41346 #endif /* _WIN64 */
41347
41348 static NTSTATUS thunk32_vkInvalidateMappedMemoryRanges(void *args)
41349 {
41350     struct
41351     {
41352         PTR32 device;
41353         uint32_t memoryRangeCount;
41354         PTR32 pMemoryRanges;
41355         VkResult result;
41356     } *params = args;
41357     const VkMappedMemoryRange *pMemoryRanges_host;
41358     struct conversion_context local_ctx;
41359     struct conversion_context *ctx = &local_ctx;
41360
41361     TRACE("%#x, %u, %#x\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
41362
41363     init_conversion_context(ctx);
41364     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(ctx, (const VkMappedMemoryRange32 *)UlongToPtr(params->pMemoryRanges), params->memoryRangeCount);
41365     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);
41366     free_conversion_context(ctx);
41367     return STATUS_SUCCESS;
41368 }
41369
41370 #ifdef _WIN64
41371 static NTSTATUS thunk64_vkMapMemory(void *args)
41372 {
41373     struct vkMapMemory_params *params = args;
41374
41375     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);
41376
41377     params->result = wine_vkMapMemory(params->device, params->memory, params->offset, params->size, params->flags, params->ppData);
41378     return STATUS_SUCCESS;
41379 }
41380 #endif /* _WIN64 */
41381
41382 static NTSTATUS thunk32_vkMapMemory(void *args)
41383 {
41384     struct
41385     {
41386         PTR32 device;
41387         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
41388         VkDeviceSize DECLSPEC_ALIGN(8) offset;
41389         VkDeviceSize DECLSPEC_ALIGN(8) size;
41390         VkMemoryMapFlags flags;
41391         PTR32 ppData;
41392         VkResult result;
41393     } *params = args;
41394
41395     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);
41396
41397     params->result = wine_vkMapMemory((VkDevice)UlongToPtr(params->device), params->memory, params->offset, params->size, params->flags, (void **)UlongToPtr(params->ppData));
41398     return STATUS_SUCCESS;
41399 }
41400
41401 #ifdef _WIN64
41402 static NTSTATUS thunk64_vkMapMemory2KHR(void *args)
41403 {
41404     struct vkMapMemory2KHR_params *params = args;
41405
41406     TRACE("%p, %p, %p\n", params->device, params->pMemoryMapInfo, params->ppData);
41407
41408     params->result = wine_vkMapMemory2KHR(params->device, params->pMemoryMapInfo, params->ppData);
41409     return STATUS_SUCCESS;
41410 }
41411 #endif /* _WIN64 */
41412
41413 static NTSTATUS thunk32_vkMapMemory2KHR(void *args)
41414 {
41415     struct
41416     {
41417         PTR32 device;
41418         PTR32 pMemoryMapInfo;
41419         PTR32 ppData;
41420         VkResult result;
41421     } *params = args;
41422     VkMemoryMapInfoKHR pMemoryMapInfo_host;
41423
41424     TRACE("%#x, %#x, %#x\n", params->device, params->pMemoryMapInfo, params->ppData);
41425
41426     convert_VkMemoryMapInfoKHR_win32_to_unwrapped_host((const VkMemoryMapInfoKHR32 *)UlongToPtr(params->pMemoryMapInfo), &pMemoryMapInfo_host);
41427     params->result = wine_vkMapMemory2KHR((VkDevice)UlongToPtr(params->device), &pMemoryMapInfo_host, (void **)UlongToPtr(params->ppData));
41428     return STATUS_SUCCESS;
41429 }
41430
41431 #ifdef _WIN64
41432 static NTSTATUS thunk64_vkMergePipelineCaches(void *args)
41433 {
41434     struct vkMergePipelineCaches_params *params = args;
41435
41436     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
41437
41438     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergePipelineCaches(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
41439     return STATUS_SUCCESS;
41440 }
41441 #endif /* _WIN64 */
41442
41443 static NTSTATUS thunk32_vkMergePipelineCaches(void *args)
41444 {
41445     struct
41446     {
41447         PTR32 device;
41448         VkPipelineCache DECLSPEC_ALIGN(8) dstCache;
41449         uint32_t srcCacheCount;
41450         PTR32 pSrcCaches;
41451         VkResult result;
41452     } *params = args;
41453
41454     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
41455
41456     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));
41457     return STATUS_SUCCESS;
41458 }
41459
41460 #ifdef _WIN64
41461 static NTSTATUS thunk64_vkMergeValidationCachesEXT(void *args)
41462 {
41463     struct vkMergeValidationCachesEXT_params *params = args;
41464
41465     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
41466
41467     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
41468     return STATUS_SUCCESS;
41469 }
41470 #endif /* _WIN64 */
41471
41472 static NTSTATUS thunk32_vkMergeValidationCachesEXT(void *args)
41473 {
41474     struct
41475     {
41476         PTR32 device;
41477         VkValidationCacheEXT DECLSPEC_ALIGN(8) dstCache;
41478         uint32_t srcCacheCount;
41479         PTR32 pSrcCaches;
41480         VkResult result;
41481     } *params = args;
41482
41483     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
41484
41485     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));
41486     return STATUS_SUCCESS;
41487 }
41488
41489 #ifdef _WIN64
41490 static NTSTATUS thunk64_vkQueueBeginDebugUtilsLabelEXT(void *args)
41491 {
41492     struct vkQueueBeginDebugUtilsLabelEXT_params *params = args;
41493
41494     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
41495
41496     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, params->pLabelInfo);
41497     return STATUS_SUCCESS;
41498 }
41499 #endif /* _WIN64 */
41500
41501 static NTSTATUS thunk32_vkQueueBeginDebugUtilsLabelEXT(void *args)
41502 {
41503     struct
41504     {
41505         PTR32 queue;
41506         PTR32 pLabelInfo;
41507     } *params = args;
41508     VkDebugUtilsLabelEXT pLabelInfo_host;
41509
41510     TRACE("%#x, %#x\n", params->queue, params->pLabelInfo);
41511
41512     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
41513     wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, &pLabelInfo_host);
41514     return STATUS_SUCCESS;
41515 }
41516
41517 #ifdef _WIN64
41518 static NTSTATUS thunk64_vkQueueBindSparse(void *args)
41519 {
41520     struct vkQueueBindSparse_params *params = args;
41521     const VkBindSparseInfo *pBindInfo_host;
41522     struct conversion_context local_ctx;
41523     struct conversion_context *ctx = &local_ctx;
41524
41525     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));
41526
41527     init_conversion_context(ctx);
41528     pBindInfo_host = convert_VkBindSparseInfo_array_win64_to_host(ctx, params->pBindInfo, params->bindInfoCount);
41529     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);
41530     free_conversion_context(ctx);
41531     return STATUS_SUCCESS;
41532 }
41533 #endif /* _WIN64 */
41534
41535 static NTSTATUS thunk32_vkQueueBindSparse(void *args)
41536 {
41537     struct
41538     {
41539         PTR32 queue;
41540         uint32_t bindInfoCount;
41541         PTR32 pBindInfo;
41542         VkFence DECLSPEC_ALIGN(8) fence;
41543         VkResult result;
41544     } *params = args;
41545     const VkBindSparseInfo *pBindInfo_host;
41546     struct conversion_context local_ctx;
41547     struct conversion_context *ctx = &local_ctx;
41548
41549     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));
41550
41551     init_conversion_context(ctx);
41552     pBindInfo_host = convert_VkBindSparseInfo_array_win32_to_host(ctx, (const VkBindSparseInfo32 *)UlongToPtr(params->pBindInfo), params->bindInfoCount);
41553     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);
41554     free_conversion_context(ctx);
41555     return STATUS_SUCCESS;
41556 }
41557
41558 #ifdef _WIN64
41559 static NTSTATUS thunk64_vkQueueEndDebugUtilsLabelEXT(void *args)
41560 {
41561     struct vkQueueEndDebugUtilsLabelEXT_params *params = args;
41562
41563     TRACE("%p\n", params->queue);
41564
41565     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue);
41566     return STATUS_SUCCESS;
41567 }
41568 #endif /* _WIN64 */
41569
41570 static NTSTATUS thunk32_vkQueueEndDebugUtilsLabelEXT(void *args)
41571 {
41572     struct
41573     {
41574         PTR32 queue;
41575     } *params = args;
41576
41577     TRACE("%#x\n", params->queue);
41578
41579     wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue);
41580     return STATUS_SUCCESS;
41581 }
41582
41583 #ifdef _WIN64
41584 static NTSTATUS thunk64_vkQueueInsertDebugUtilsLabelEXT(void *args)
41585 {
41586     struct vkQueueInsertDebugUtilsLabelEXT_params *params = args;
41587
41588     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
41589
41590     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, params->pLabelInfo);
41591     return STATUS_SUCCESS;
41592 }
41593 #endif /* _WIN64 */
41594
41595 static NTSTATUS thunk32_vkQueueInsertDebugUtilsLabelEXT(void *args)
41596 {
41597     struct
41598     {
41599         PTR32 queue;
41600         PTR32 pLabelInfo;
41601     } *params = args;
41602     VkDebugUtilsLabelEXT pLabelInfo_host;
41603
41604     TRACE("%#x, %#x\n", params->queue, params->pLabelInfo);
41605
41606     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
41607     wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, &pLabelInfo_host);
41608     return STATUS_SUCCESS;
41609 }
41610
41611 #ifdef _WIN64
41612 static NTSTATUS thunk64_vkQueuePresentKHR(void *args)
41613 {
41614     struct vkQueuePresentKHR_params *params = args;
41615
41616     TRACE("%p, %p\n", params->queue, params->pPresentInfo);
41617
41618     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle(params->queue)->queue, params->pPresentInfo);
41619     return STATUS_SUCCESS;
41620 }
41621 #endif /* _WIN64 */
41622
41623 static NTSTATUS thunk32_vkQueuePresentKHR(void *args)
41624 {
41625     struct
41626     {
41627         PTR32 queue;
41628         PTR32 pPresentInfo;
41629         VkResult result;
41630     } *params = args;
41631     VkPresentInfoKHR pPresentInfo_host;
41632     struct conversion_context local_ctx;
41633     struct conversion_context *ctx = &local_ctx;
41634
41635     TRACE("%#x, %#x\n", params->queue, params->pPresentInfo);
41636
41637     init_conversion_context(ctx);
41638     convert_VkPresentInfoKHR_win32_to_host(ctx, (const VkPresentInfoKHR32 *)UlongToPtr(params->pPresentInfo), &pPresentInfo_host);
41639     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);
41640     free_conversion_context(ctx);
41641     return STATUS_SUCCESS;
41642 }
41643
41644 #ifdef _WIN64
41645 static NTSTATUS thunk64_vkQueueSetPerformanceConfigurationINTEL(void *args)
41646 {
41647     struct vkQueueSetPerformanceConfigurationINTEL_params *params = args;
41648
41649     TRACE("%p, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));
41650
41651     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle(params->queue)->queue, params->configuration);
41652     return STATUS_SUCCESS;
41653 }
41654 #endif /* _WIN64 */
41655
41656 static NTSTATUS thunk32_vkQueueSetPerformanceConfigurationINTEL(void *args)
41657 {
41658     struct
41659     {
41660         PTR32 queue;
41661         VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
41662         VkResult result;
41663     } *params = args;
41664
41665     TRACE("%#x, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));
41666
41667     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);
41668     return STATUS_SUCCESS;
41669 }
41670
41671 #ifdef _WIN64
41672 static NTSTATUS thunk64_vkQueueSubmit(void *args)
41673 {
41674     struct vkQueueSubmit_params *params = args;
41675     const VkSubmitInfo *pSubmits_host;
41676     struct conversion_context local_ctx;
41677     struct conversion_context *ctx = &local_ctx;
41678
41679     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
41680
41681     init_conversion_context(ctx);
41682     pSubmits_host = convert_VkSubmitInfo_array_win64_to_host(ctx, params->pSubmits, params->submitCount);
41683     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);
41684     free_conversion_context(ctx);
41685     return STATUS_SUCCESS;
41686 }
41687 #endif /* _WIN64 */
41688
41689 static NTSTATUS thunk32_vkQueueSubmit(void *args)
41690 {
41691     struct
41692     {
41693         PTR32 queue;
41694         uint32_t submitCount;
41695         PTR32 pSubmits;
41696         VkFence DECLSPEC_ALIGN(8) fence;
41697         VkResult result;
41698     } *params = args;
41699     const VkSubmitInfo *pSubmits_host;
41700     struct conversion_context local_ctx;
41701     struct conversion_context *ctx = &local_ctx;
41702
41703     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
41704
41705     init_conversion_context(ctx);
41706     pSubmits_host = convert_VkSubmitInfo_array_win32_to_host(ctx, (const VkSubmitInfo32 *)UlongToPtr(params->pSubmits), params->submitCount);
41707     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);
41708     free_conversion_context(ctx);
41709     return STATUS_SUCCESS;
41710 }
41711
41712 #ifdef _WIN64
41713 static NTSTATUS thunk64_vkQueueSubmit2(void *args)
41714 {
41715     struct vkQueueSubmit2_params *params = args;
41716     const VkSubmitInfo2 *pSubmits_host;
41717     struct conversion_context local_ctx;
41718     struct conversion_context *ctx = &local_ctx;
41719
41720     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
41721
41722     init_conversion_context(ctx);
41723     pSubmits_host = convert_VkSubmitInfo2_array_win64_to_host(ctx, params->pSubmits, params->submitCount);
41724     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);
41725     free_conversion_context(ctx);
41726     return STATUS_SUCCESS;
41727 }
41728 #endif /* _WIN64 */
41729
41730 static NTSTATUS thunk32_vkQueueSubmit2(void *args)
41731 {
41732     struct
41733     {
41734         PTR32 queue;
41735         uint32_t submitCount;
41736         PTR32 pSubmits;
41737         VkFence DECLSPEC_ALIGN(8) fence;
41738         VkResult result;
41739     } *params = args;
41740     const VkSubmitInfo2 *pSubmits_host;
41741     struct conversion_context local_ctx;
41742     struct conversion_context *ctx = &local_ctx;
41743
41744     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
41745
41746     init_conversion_context(ctx);
41747     pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(ctx, (const VkSubmitInfo232 *)UlongToPtr(params->pSubmits), params->submitCount);
41748     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);
41749     free_conversion_context(ctx);
41750     return STATUS_SUCCESS;
41751 }
41752
41753 #ifdef _WIN64
41754 static NTSTATUS thunk64_vkQueueSubmit2KHR(void *args)
41755 {
41756     struct vkQueueSubmit2KHR_params *params = args;
41757     const VkSubmitInfo2 *pSubmits_host;
41758     struct conversion_context local_ctx;
41759     struct conversion_context *ctx = &local_ctx;
41760
41761     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
41762
41763     init_conversion_context(ctx);
41764     pSubmits_host = convert_VkSubmitInfo2_array_win64_to_host(ctx, params->pSubmits, params->submitCount);
41765     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);
41766     free_conversion_context(ctx);
41767     return STATUS_SUCCESS;
41768 }
41769 #endif /* _WIN64 */
41770
41771 static NTSTATUS thunk32_vkQueueSubmit2KHR(void *args)
41772 {
41773     struct
41774     {
41775         PTR32 queue;
41776         uint32_t submitCount;
41777         PTR32 pSubmits;
41778         VkFence DECLSPEC_ALIGN(8) fence;
41779         VkResult result;
41780     } *params = args;
41781     const VkSubmitInfo2 *pSubmits_host;
41782     struct conversion_context local_ctx;
41783     struct conversion_context *ctx = &local_ctx;
41784
41785     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
41786
41787     init_conversion_context(ctx);
41788     pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(ctx, (const VkSubmitInfo232 *)UlongToPtr(params->pSubmits), params->submitCount);
41789     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);
41790     free_conversion_context(ctx);
41791     return STATUS_SUCCESS;
41792 }
41793
41794 #ifdef _WIN64
41795 static NTSTATUS thunk64_vkQueueWaitIdle(void *args)
41796 {
41797     struct vkQueueWaitIdle_params *params = args;
41798
41799     TRACE("%p\n", params->queue);
41800
41801     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle(params->queue)->queue);
41802     return STATUS_SUCCESS;
41803 }
41804 #endif /* _WIN64 */
41805
41806 static NTSTATUS thunk32_vkQueueWaitIdle(void *args)
41807 {
41808     struct
41809     {
41810         PTR32 queue;
41811         VkResult result;
41812     } *params = args;
41813
41814     TRACE("%#x\n", params->queue);
41815
41816     params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue);
41817     return STATUS_SUCCESS;
41818 }
41819
41820 #ifdef _WIN64
41821 static NTSTATUS thunk64_vkReleasePerformanceConfigurationINTEL(void *args)
41822 {
41823     struct vkReleasePerformanceConfigurationINTEL_params *params = args;
41824
41825     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));
41826
41827     params->result = wine_device_from_handle(params->device)->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->configuration);
41828     return STATUS_SUCCESS;
41829 }
41830 #endif /* _WIN64 */
41831
41832 static NTSTATUS thunk32_vkReleasePerformanceConfigurationINTEL(void *args)
41833 {
41834     struct
41835     {
41836         PTR32 device;
41837         VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
41838         VkResult result;
41839     } *params = args;
41840
41841     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));
41842
41843     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->configuration);
41844     return STATUS_SUCCESS;
41845 }
41846
41847 #ifdef _WIN64
41848 static NTSTATUS thunk64_vkReleaseProfilingLockKHR(void *args)
41849 {
41850     struct vkReleaseProfilingLockKHR_params *params = args;
41851
41852     TRACE("%p\n", params->device);
41853
41854     wine_device_from_handle(params->device)->funcs.p_vkReleaseProfilingLockKHR(wine_device_from_handle(params->device)->device);
41855     return STATUS_SUCCESS;
41856 }
41857 #endif /* _WIN64 */
41858
41859 static NTSTATUS thunk32_vkReleaseProfilingLockKHR(void *args)
41860 {
41861     struct
41862     {
41863         PTR32 device;
41864     } *params = args;
41865
41866     TRACE("%#x\n", params->device);
41867
41868     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkReleaseProfilingLockKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
41869     return STATUS_SUCCESS;
41870 }
41871
41872 #ifdef _WIN64
41873 static NTSTATUS thunk64_vkReleaseSwapchainImagesEXT(void *args)
41874 {
41875     struct vkReleaseSwapchainImagesEXT_params *params = args;
41876
41877     TRACE("%p, %p\n", params->device, params->pReleaseInfo);
41878
41879     params->result = wine_device_from_handle(params->device)->funcs.p_vkReleaseSwapchainImagesEXT(wine_device_from_handle(params->device)->device, params->pReleaseInfo);
41880     return STATUS_SUCCESS;
41881 }
41882 #endif /* _WIN64 */
41883
41884 static NTSTATUS thunk32_vkReleaseSwapchainImagesEXT(void *args)
41885 {
41886     struct
41887     {
41888         PTR32 device;
41889         PTR32 pReleaseInfo;
41890         VkResult result;
41891     } *params = args;
41892     VkReleaseSwapchainImagesInfoEXT pReleaseInfo_host;
41893
41894     TRACE("%#x, %#x\n", params->device, params->pReleaseInfo);
41895
41896     convert_VkReleaseSwapchainImagesInfoEXT_win32_to_host((const VkReleaseSwapchainImagesInfoEXT32 *)UlongToPtr(params->pReleaseInfo), &pReleaseInfo_host);
41897     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkReleaseSwapchainImagesEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pReleaseInfo_host);
41898     return STATUS_SUCCESS;
41899 }
41900
41901 #ifdef _WIN64
41902 static NTSTATUS thunk64_vkResetCommandBuffer(void *args)
41903 {
41904     struct vkResetCommandBuffer_params *params = args;
41905
41906     TRACE("%p, %#x\n", params->commandBuffer, params->flags);
41907
41908     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->flags);
41909     return STATUS_SUCCESS;
41910 }
41911 #endif /* _WIN64 */
41912
41913 static NTSTATUS thunk32_vkResetCommandBuffer(void *args)
41914 {
41915     struct
41916     {
41917         PTR32 commandBuffer;
41918         VkCommandBufferResetFlags flags;
41919         VkResult result;
41920     } *params = args;
41921
41922     TRACE("%#x, %#x\n", params->commandBuffer, params->flags);
41923
41924     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);
41925     return STATUS_SUCCESS;
41926 }
41927
41928 #ifdef _WIN64
41929 static NTSTATUS thunk64_vkResetCommandPool(void *args)
41930 {
41931     struct vkResetCommandPool_params *params = args;
41932
41933     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
41934
41935     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);
41936     return STATUS_SUCCESS;
41937 }
41938 #endif /* _WIN64 */
41939
41940 static NTSTATUS thunk32_vkResetCommandPool(void *args)
41941 {
41942     struct
41943     {
41944         PTR32 device;
41945         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
41946         VkCommandPoolResetFlags flags;
41947         VkResult result;
41948     } *params = args;
41949
41950     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
41951
41952     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);
41953     return STATUS_SUCCESS;
41954 }
41955
41956 #ifdef _WIN64
41957 static NTSTATUS thunk64_vkResetDescriptorPool(void *args)
41958 {
41959     struct vkResetDescriptorPool_params *params = args;
41960
41961     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);
41962
41963     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, params->flags);
41964     return STATUS_SUCCESS;
41965 }
41966 #endif /* _WIN64 */
41967
41968 static NTSTATUS thunk32_vkResetDescriptorPool(void *args)
41969 {
41970     struct
41971     {
41972         PTR32 device;
41973         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
41974         VkDescriptorPoolResetFlags flags;
41975         VkResult result;
41976     } *params = args;
41977
41978     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);
41979
41980     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);
41981     return STATUS_SUCCESS;
41982 }
41983
41984 #ifdef _WIN64
41985 static NTSTATUS thunk64_vkResetEvent(void *args)
41986 {
41987     struct vkResetEvent_params *params = args;
41988
41989     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
41990
41991     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetEvent(wine_device_from_handle(params->device)->device, params->event);
41992     return STATUS_SUCCESS;
41993 }
41994 #endif /* _WIN64 */
41995
41996 static NTSTATUS thunk32_vkResetEvent(void *args)
41997 {
41998     struct
41999     {
42000         PTR32 device;
42001         VkEvent DECLSPEC_ALIGN(8) event;
42002         VkResult result;
42003     } *params = args;
42004
42005     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
42006
42007     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
42008     return STATUS_SUCCESS;
42009 }
42010
42011 #ifdef _WIN64
42012 static NTSTATUS thunk64_vkResetFences(void *args)
42013 {
42014     struct vkResetFences_params *params = args;
42015
42016     TRACE("%p, %u, %p\n", params->device, params->fenceCount, params->pFences);
42017
42018     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences);
42019     return STATUS_SUCCESS;
42020 }
42021 #endif /* _WIN64 */
42022
42023 static NTSTATUS thunk32_vkResetFences(void *args)
42024 {
42025     struct
42026     {
42027         PTR32 device;
42028         uint32_t fenceCount;
42029         PTR32 pFences;
42030         VkResult result;
42031     } *params = args;
42032
42033     TRACE("%#x, %u, %#x\n", params->device, params->fenceCount, params->pFences);
42034
42035     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));
42036     return STATUS_SUCCESS;
42037 }
42038
42039 #ifdef _WIN64
42040 static NTSTATUS thunk64_vkResetQueryPool(void *args)
42041 {
42042     struct vkResetQueryPool_params *params = args;
42043
42044     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
42045
42046     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
42047     return STATUS_SUCCESS;
42048 }
42049 #endif /* _WIN64 */
42050
42051 static NTSTATUS thunk32_vkResetQueryPool(void *args)
42052 {
42053     struct
42054     {
42055         PTR32 device;
42056         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
42057         uint32_t firstQuery;
42058         uint32_t queryCount;
42059     } *params = args;
42060
42061     TRACE("%#x, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
42062
42063     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);
42064     return STATUS_SUCCESS;
42065 }
42066
42067 #ifdef _WIN64
42068 static NTSTATUS thunk64_vkResetQueryPoolEXT(void *args)
42069 {
42070     struct vkResetQueryPoolEXT_params *params = args;
42071
42072     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
42073
42074     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPoolEXT(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
42075     return STATUS_SUCCESS;
42076 }
42077 #endif /* _WIN64 */
42078
42079 static NTSTATUS thunk32_vkResetQueryPoolEXT(void *args)
42080 {
42081     struct
42082     {
42083         PTR32 device;
42084         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
42085         uint32_t firstQuery;
42086         uint32_t queryCount;
42087     } *params = args;
42088
42089     TRACE("%#x, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
42090
42091     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);
42092     return STATUS_SUCCESS;
42093 }
42094
42095 #ifdef _WIN64
42096 static NTSTATUS thunk64_vkSetDebugUtilsObjectNameEXT(void *args)
42097 {
42098     struct vkSetDebugUtilsObjectNameEXT_params *params = args;
42099     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;
42100
42101     TRACE("%p, %p\n", params->device, params->pNameInfo);
42102
42103     convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(params->pNameInfo, &pNameInfo_host);
42104     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
42105     return STATUS_SUCCESS;
42106 }
42107 #endif /* _WIN64 */
42108
42109 static NTSTATUS thunk32_vkSetDebugUtilsObjectNameEXT(void *args)
42110 {
42111     struct
42112     {
42113         PTR32 device;
42114         PTR32 pNameInfo;
42115         VkResult result;
42116     } *params = args;
42117     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;
42118
42119     TRACE("%#x, %#x\n", params->device, params->pNameInfo);
42120
42121     convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host((const VkDebugUtilsObjectNameInfoEXT32 *)UlongToPtr(params->pNameInfo), &pNameInfo_host);
42122     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pNameInfo_host);
42123     return STATUS_SUCCESS;
42124 }
42125
42126 #ifdef _WIN64
42127 static NTSTATUS thunk64_vkSetDebugUtilsObjectTagEXT(void *args)
42128 {
42129     struct vkSetDebugUtilsObjectTagEXT_params *params = args;
42130     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;
42131
42132     TRACE("%p, %p\n", params->device, params->pTagInfo);
42133
42134     convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(params->pTagInfo, &pTagInfo_host);
42135     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
42136     return STATUS_SUCCESS;
42137 }
42138 #endif /* _WIN64 */
42139
42140 static NTSTATUS thunk32_vkSetDebugUtilsObjectTagEXT(void *args)
42141 {
42142     struct
42143     {
42144         PTR32 device;
42145         PTR32 pTagInfo;
42146         VkResult result;
42147     } *params = args;
42148     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;
42149
42150     TRACE("%#x, %#x\n", params->device, params->pTagInfo);
42151
42152     convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host((const VkDebugUtilsObjectTagInfoEXT32 *)UlongToPtr(params->pTagInfo), &pTagInfo_host);
42153     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pTagInfo_host);
42154     return STATUS_SUCCESS;
42155 }
42156
42157 #ifdef _WIN64
42158 static NTSTATUS thunk64_vkSetDeviceMemoryPriorityEXT(void *args)
42159 {
42160     struct vkSetDeviceMemoryPriorityEXT_params *params = args;
42161
42162     TRACE("%p, 0x%s, %f\n", params->device, wine_dbgstr_longlong(params->memory), params->priority);
42163
42164     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);
42165     return STATUS_SUCCESS;
42166 }
42167 #endif /* _WIN64 */
42168
42169 static NTSTATUS thunk32_vkSetDeviceMemoryPriorityEXT(void *args)
42170 {
42171     struct
42172     {
42173         PTR32 device;
42174         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
42175         float priority;
42176     } *params = args;
42177
42178     TRACE("%#x, 0x%s, %f\n", params->device, wine_dbgstr_longlong(params->memory), params->priority);
42179
42180     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);
42181     return STATUS_SUCCESS;
42182 }
42183
42184 #ifdef _WIN64
42185 static NTSTATUS thunk64_vkSetEvent(void *args)
42186 {
42187     struct vkSetEvent_params *params = args;
42188
42189     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
42190
42191     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetEvent(wine_device_from_handle(params->device)->device, params->event);
42192     return STATUS_SUCCESS;
42193 }
42194 #endif /* _WIN64 */
42195
42196 static NTSTATUS thunk32_vkSetEvent(void *args)
42197 {
42198     struct
42199     {
42200         PTR32 device;
42201         VkEvent DECLSPEC_ALIGN(8) event;
42202         VkResult result;
42203     } *params = args;
42204
42205     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
42206
42207     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
42208     return STATUS_SUCCESS;
42209 }
42210
42211 #ifdef _WIN64
42212 static NTSTATUS thunk64_vkSetHdrMetadataEXT(void *args)
42213 {
42214     struct vkSetHdrMetadataEXT_params *params = args;
42215
42216     TRACE("%p, %u, %p, %p\n", params->device, params->swapchainCount, params->pSwapchains, params->pMetadata);
42217
42218     wine_device_from_handle(params->device)->funcs.p_vkSetHdrMetadataEXT(wine_device_from_handle(params->device)->device, params->swapchainCount, params->pSwapchains, params->pMetadata);
42219     return STATUS_SUCCESS;
42220 }
42221 #endif /* _WIN64 */
42222
42223 static NTSTATUS thunk32_vkSetHdrMetadataEXT(void *args)
42224 {
42225     struct
42226     {
42227         PTR32 device;
42228         uint32_t swapchainCount;
42229         PTR32 pSwapchains;
42230         PTR32 pMetadata;
42231     } *params = args;
42232     const VkHdrMetadataEXT *pMetadata_host;
42233     struct conversion_context local_ctx;
42234     struct conversion_context *ctx = &local_ctx;
42235
42236     TRACE("%#x, %u, %#x, %#x\n", params->device, params->swapchainCount, params->pSwapchains, params->pMetadata);
42237
42238     init_conversion_context(ctx);
42239     pMetadata_host = convert_VkHdrMetadataEXT_array_win32_to_host(ctx, (const VkHdrMetadataEXT32 *)UlongToPtr(params->pMetadata), params->swapchainCount);
42240     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);
42241     free_conversion_context(ctx);
42242     return STATUS_SUCCESS;
42243 }
42244
42245 #ifdef _WIN64
42246 static NTSTATUS thunk64_vkSetPrivateData(void *args)
42247 {
42248     struct vkSetPrivateData_params *params = args;
42249
42250     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));
42251
42252     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);
42253     return STATUS_SUCCESS;
42254 }
42255 #endif /* _WIN64 */
42256
42257 static NTSTATUS thunk32_vkSetPrivateData(void *args)
42258 {
42259     struct
42260     {
42261         PTR32 device;
42262         VkObjectType objectType;
42263         uint64_t DECLSPEC_ALIGN(8) objectHandle;
42264         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
42265         uint64_t DECLSPEC_ALIGN(8) data;
42266         VkResult result;
42267     } *params = args;
42268
42269     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));
42270
42271     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);
42272     return STATUS_SUCCESS;
42273 }
42274
42275 #ifdef _WIN64
42276 static NTSTATUS thunk64_vkSetPrivateDataEXT(void *args)
42277 {
42278     struct vkSetPrivateDataEXT_params *params = args;
42279
42280     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));
42281
42282     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);
42283     return STATUS_SUCCESS;
42284 }
42285 #endif /* _WIN64 */
42286
42287 static NTSTATUS thunk32_vkSetPrivateDataEXT(void *args)
42288 {
42289     struct
42290     {
42291         PTR32 device;
42292         VkObjectType objectType;
42293         uint64_t DECLSPEC_ALIGN(8) objectHandle;
42294         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
42295         uint64_t DECLSPEC_ALIGN(8) data;
42296         VkResult result;
42297     } *params = args;
42298
42299     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));
42300
42301     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);
42302     return STATUS_SUCCESS;
42303 }
42304
42305 #ifdef _WIN64
42306 static NTSTATUS thunk64_vkSignalSemaphore(void *args)
42307 {
42308     struct vkSignalSemaphore_params *params = args;
42309
42310     TRACE("%p, %p\n", params->device, params->pSignalInfo);
42311
42312     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphore(wine_device_from_handle(params->device)->device, params->pSignalInfo);
42313     return STATUS_SUCCESS;
42314 }
42315 #endif /* _WIN64 */
42316
42317 static NTSTATUS thunk32_vkSignalSemaphore(void *args)
42318 {
42319     struct
42320     {
42321         PTR32 device;
42322         PTR32 pSignalInfo;
42323         VkResult result;
42324     } *params = args;
42325     VkSemaphoreSignalInfo pSignalInfo_host;
42326
42327     TRACE("%#x, %#x\n", params->device, params->pSignalInfo);
42328
42329     convert_VkSemaphoreSignalInfo_win32_to_host((const VkSemaphoreSignalInfo32 *)UlongToPtr(params->pSignalInfo), &pSignalInfo_host);
42330     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSignalSemaphore(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pSignalInfo_host);
42331     return STATUS_SUCCESS;
42332 }
42333
42334 #ifdef _WIN64
42335 static NTSTATUS thunk64_vkSignalSemaphoreKHR(void *args)
42336 {
42337     struct vkSignalSemaphoreKHR_params *params = args;
42338
42339     TRACE("%p, %p\n", params->device, params->pSignalInfo);
42340
42341     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle(params->device)->device, params->pSignalInfo);
42342     return STATUS_SUCCESS;
42343 }
42344 #endif /* _WIN64 */
42345
42346 static NTSTATUS thunk32_vkSignalSemaphoreKHR(void *args)
42347 {
42348     struct
42349     {
42350         PTR32 device;
42351         PTR32 pSignalInfo;
42352         VkResult result;
42353     } *params = args;
42354     VkSemaphoreSignalInfo pSignalInfo_host;
42355
42356     TRACE("%#x, %#x\n", params->device, params->pSignalInfo);
42357
42358     convert_VkSemaphoreSignalInfo_win32_to_host((const VkSemaphoreSignalInfo32 *)UlongToPtr(params->pSignalInfo), &pSignalInfo_host);
42359     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pSignalInfo_host);
42360     return STATUS_SUCCESS;
42361 }
42362
42363 #ifdef _WIN64
42364 static NTSTATUS thunk64_vkSubmitDebugUtilsMessageEXT(void *args)
42365 {
42366     struct vkSubmitDebugUtilsMessageEXT_params *params = args;
42367     VkDebugUtilsMessengerCallbackDataEXT pCallbackData_host;
42368     struct conversion_context local_ctx;
42369     struct conversion_context *ctx = &local_ctx;
42370
42371     TRACE("%p, %#x, %#x, %p\n", params->instance, params->messageSeverity, params->messageTypes, params->pCallbackData);
42372
42373     init_conversion_context(ctx);
42374     convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(ctx, params->pCallbackData, &pCallbackData_host);
42375     wine_instance_from_handle(params->instance)->funcs.p_vkSubmitDebugUtilsMessageEXT(wine_instance_from_handle(params->instance)->instance, params->messageSeverity, params->messageTypes, &pCallbackData_host);
42376     free_conversion_context(ctx);
42377     return STATUS_SUCCESS;
42378 }
42379 #endif /* _WIN64 */
42380
42381 static NTSTATUS thunk32_vkSubmitDebugUtilsMessageEXT(void *args)
42382 {
42383     struct
42384     {
42385         PTR32 instance;
42386         VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity;
42387         VkDebugUtilsMessageTypeFlagsEXT messageTypes;
42388         PTR32 pCallbackData;
42389     } *params = args;
42390     VkDebugUtilsMessengerCallbackDataEXT pCallbackData_host;
42391     struct conversion_context local_ctx;
42392     struct conversion_context *ctx = &local_ctx;
42393
42394     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->messageSeverity, params->messageTypes, params->pCallbackData);
42395
42396     init_conversion_context(ctx);
42397     convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(ctx, (const VkDebugUtilsMessengerCallbackDataEXT32 *)UlongToPtr(params->pCallbackData), &pCallbackData_host);
42398     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);
42399     free_conversion_context(ctx);
42400     return STATUS_SUCCESS;
42401 }
42402
42403 #ifdef _WIN64
42404 static NTSTATUS thunk64_vkTransitionImageLayoutEXT(void *args)
42405 {
42406     struct vkTransitionImageLayoutEXT_params *params = args;
42407
42408     TRACE("%p, %u, %p\n", params->device, params->transitionCount, params->pTransitions);
42409
42410     params->result = wine_device_from_handle(params->device)->funcs.p_vkTransitionImageLayoutEXT(wine_device_from_handle(params->device)->device, params->transitionCount, params->pTransitions);
42411     return STATUS_SUCCESS;
42412 }
42413 #endif /* _WIN64 */
42414
42415 static NTSTATUS thunk32_vkTransitionImageLayoutEXT(void *args)
42416 {
42417     struct
42418     {
42419         PTR32 device;
42420         uint32_t transitionCount;
42421         PTR32 pTransitions;
42422         VkResult result;
42423     } *params = args;
42424     const VkHostImageLayoutTransitionInfoEXT *pTransitions_host;
42425     struct conversion_context local_ctx;
42426     struct conversion_context *ctx = &local_ctx;
42427
42428     TRACE("%#x, %u, %#x\n", params->device, params->transitionCount, params->pTransitions);
42429
42430     init_conversion_context(ctx);
42431     pTransitions_host = convert_VkHostImageLayoutTransitionInfoEXT_array_win32_to_host(ctx, (const VkHostImageLayoutTransitionInfoEXT32 *)UlongToPtr(params->pTransitions), params->transitionCount);
42432     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkTransitionImageLayoutEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->transitionCount, pTransitions_host);
42433     free_conversion_context(ctx);
42434     return STATUS_SUCCESS;
42435 }
42436
42437 #ifdef _WIN64
42438 static NTSTATUS thunk64_vkTrimCommandPool(void *args)
42439 {
42440     struct vkTrimCommandPool_params *params = args;
42441
42442     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
42443
42444     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);
42445     return STATUS_SUCCESS;
42446 }
42447 #endif /* _WIN64 */
42448
42449 static NTSTATUS thunk32_vkTrimCommandPool(void *args)
42450 {
42451     struct
42452     {
42453         PTR32 device;
42454         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
42455         VkCommandPoolTrimFlags flags;
42456     } *params = args;
42457
42458     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
42459
42460     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);
42461     return STATUS_SUCCESS;
42462 }
42463
42464 #ifdef _WIN64
42465 static NTSTATUS thunk64_vkTrimCommandPoolKHR(void *args)
42466 {
42467     struct vkTrimCommandPoolKHR_params *params = args;
42468
42469     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
42470
42471     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);
42472     return STATUS_SUCCESS;
42473 }
42474 #endif /* _WIN64 */
42475
42476 static NTSTATUS thunk32_vkTrimCommandPoolKHR(void *args)
42477 {
42478     struct
42479     {
42480         PTR32 device;
42481         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
42482         VkCommandPoolTrimFlags flags;
42483     } *params = args;
42484
42485     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
42486
42487     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);
42488     return STATUS_SUCCESS;
42489 }
42490
42491 #ifdef _WIN64
42492 static NTSTATUS thunk64_vkUninitializePerformanceApiINTEL(void *args)
42493 {
42494     struct vkUninitializePerformanceApiINTEL_params *params = args;
42495
42496     TRACE("%p\n", params->device);
42497
42498     wine_device_from_handle(params->device)->funcs.p_vkUninitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device);
42499     return STATUS_SUCCESS;
42500 }
42501 #endif /* _WIN64 */
42502
42503 static NTSTATUS thunk32_vkUninitializePerformanceApiINTEL(void *args)
42504 {
42505     struct
42506     {
42507         PTR32 device;
42508     } *params = args;
42509
42510     TRACE("%#x\n", params->device);
42511
42512     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUninitializePerformanceApiINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
42513     return STATUS_SUCCESS;
42514 }
42515
42516 #ifdef _WIN64
42517 static NTSTATUS thunk64_vkUnmapMemory(void *args)
42518 {
42519     struct vkUnmapMemory_params *params = args;
42520
42521     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->memory));
42522
42523     wine_vkUnmapMemory(params->device, params->memory);
42524     return STATUS_SUCCESS;
42525 }
42526 #endif /* _WIN64 */
42527
42528 static NTSTATUS thunk32_vkUnmapMemory(void *args)
42529 {
42530     struct
42531     {
42532         PTR32 device;
42533         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
42534     } *params = args;
42535
42536     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->memory));
42537
42538     wine_vkUnmapMemory((VkDevice)UlongToPtr(params->device), params->memory);
42539     return STATUS_SUCCESS;
42540 }
42541
42542 #ifdef _WIN64
42543 static NTSTATUS thunk64_vkUnmapMemory2KHR(void *args)
42544 {
42545     struct vkUnmapMemory2KHR_params *params = args;
42546
42547     TRACE("%p, %p\n", params->device, params->pMemoryUnmapInfo);
42548
42549     params->result = wine_vkUnmapMemory2KHR(params->device, params->pMemoryUnmapInfo);
42550     return STATUS_SUCCESS;
42551 }
42552 #endif /* _WIN64 */
42553
42554 static NTSTATUS thunk32_vkUnmapMemory2KHR(void *args)
42555 {
42556     struct
42557     {
42558         PTR32 device;
42559         PTR32 pMemoryUnmapInfo;
42560         VkResult result;
42561     } *params = args;
42562     VkMemoryUnmapInfoKHR pMemoryUnmapInfo_host;
42563
42564     TRACE("%#x, %#x\n", params->device, params->pMemoryUnmapInfo);
42565
42566     convert_VkMemoryUnmapInfoKHR_win32_to_unwrapped_host((const VkMemoryUnmapInfoKHR32 *)UlongToPtr(params->pMemoryUnmapInfo), &pMemoryUnmapInfo_host);
42567     params->result = wine_vkUnmapMemory2KHR((VkDevice)UlongToPtr(params->device), &pMemoryUnmapInfo_host);
42568     return STATUS_SUCCESS;
42569 }
42570
42571 #ifdef _WIN64
42572 static void thunk64_vkUpdateDescriptorSetWithTemplate(void *args)
42573 {
42574     struct vkUpdateDescriptorSetWithTemplate_params *params = args;
42575
42576     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
42577 }
42578 #endif /* _WIN64 */
42579
42580 static void thunk32_vkUpdateDescriptorSetWithTemplate(void *args)
42581 {
42582     struct
42583     {
42584         PTR32 device;
42585         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
42586         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
42587         PTR32 pData;
42588     } *params = args;
42589
42590     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));
42591 }
42592
42593 #ifdef _WIN64
42594 static NTSTATUS thunk64_vkUpdateDescriptorSetWithTemplateKHR(void *args)
42595 {
42596     struct vkUpdateDescriptorSetWithTemplateKHR_params *params = args;
42597
42598     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
42599
42600     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
42601     return STATUS_SUCCESS;
42602 }
42603 #endif /* _WIN64 */
42604
42605 static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplateKHR(void *args)
42606 {
42607     struct
42608     {
42609         PTR32 device;
42610         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
42611         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
42612         PTR32 pData;
42613     } *params = args;
42614
42615     TRACE("%#x, 0x%s, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
42616
42617     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));
42618     return STATUS_SUCCESS;
42619 }
42620
42621 #ifdef _WIN64
42622 static void thunk64_vkUpdateDescriptorSets(void *args)
42623 {
42624     struct vkUpdateDescriptorSets_params *params = args;
42625
42626     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
42627 }
42628 #endif /* _WIN64 */
42629
42630 static void thunk32_vkUpdateDescriptorSets(void *args)
42631 {
42632     struct
42633     {
42634         PTR32 device;
42635         uint32_t descriptorWriteCount;
42636         PTR32 pDescriptorWrites;
42637         uint32_t descriptorCopyCount;
42638         PTR32 pDescriptorCopies;
42639     } *params = args;
42640     const VkWriteDescriptorSet *pDescriptorWrites_host;
42641     const VkCopyDescriptorSet *pDescriptorCopies_host;
42642     struct conversion_context local_ctx;
42643     struct conversion_context *ctx = &local_ctx;
42644
42645     init_conversion_context(ctx);
42646     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(ctx, (const VkWriteDescriptorSet32 *)UlongToPtr(params->pDescriptorWrites), params->descriptorWriteCount);
42647     pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win32_to_host(ctx, (const VkCopyDescriptorSet32 *)UlongToPtr(params->pDescriptorCopies), params->descriptorCopyCount);
42648     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);
42649     free_conversion_context(ctx);
42650 }
42651
42652 #ifdef _WIN64
42653 static NTSTATUS thunk64_vkWaitForFences(void *args)
42654 {
42655     struct vkWaitForFences_params *params = args;
42656
42657     TRACE("%p, %u, %p, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));
42658
42659     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);
42660     return STATUS_SUCCESS;
42661 }
42662 #endif /* _WIN64 */
42663
42664 static NTSTATUS thunk32_vkWaitForFences(void *args)
42665 {
42666     struct
42667     {
42668         PTR32 device;
42669         uint32_t fenceCount;
42670         PTR32 pFences;
42671         VkBool32 waitAll;
42672         uint64_t DECLSPEC_ALIGN(8) timeout;
42673         VkResult result;
42674     } *params = args;
42675
42676     TRACE("%#x, %u, %#x, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));
42677
42678     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);
42679     return STATUS_SUCCESS;
42680 }
42681
42682 #ifdef _WIN64
42683 static NTSTATUS thunk64_vkWaitForPresentKHR(void *args)
42684 {
42685     struct vkWaitForPresentKHR_params *params = args;
42686
42687     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));
42688
42689     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForPresentKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->presentId, params->timeout);
42690     return STATUS_SUCCESS;
42691 }
42692 #endif /* _WIN64 */
42693
42694 static NTSTATUS thunk32_vkWaitForPresentKHR(void *args)
42695 {
42696     struct
42697     {
42698         PTR32 device;
42699         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
42700         uint64_t DECLSPEC_ALIGN(8) presentId;
42701         uint64_t DECLSPEC_ALIGN(8) timeout;
42702         VkResult result;
42703     } *params = args;
42704
42705     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));
42706
42707     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);
42708     return STATUS_SUCCESS;
42709 }
42710
42711 #ifdef _WIN64
42712 static NTSTATUS thunk64_vkWaitSemaphores(void *args)
42713 {
42714     struct vkWaitSemaphores_params *params = args;
42715
42716     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
42717
42718     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphores(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
42719     return STATUS_SUCCESS;
42720 }
42721 #endif /* _WIN64 */
42722
42723 static NTSTATUS thunk32_vkWaitSemaphores(void *args)
42724 {
42725     struct
42726     {
42727         PTR32 device;
42728         PTR32 pWaitInfo;
42729         uint64_t DECLSPEC_ALIGN(8) timeout;
42730         VkResult result;
42731     } *params = args;
42732     VkSemaphoreWaitInfo pWaitInfo_host;
42733
42734     TRACE("%#x, %#x, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
42735
42736     convert_VkSemaphoreWaitInfo_win32_to_host((const VkSemaphoreWaitInfo32 *)UlongToPtr(params->pWaitInfo), &pWaitInfo_host);
42737     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);
42738     return STATUS_SUCCESS;
42739 }
42740
42741 #ifdef _WIN64
42742 static NTSTATUS thunk64_vkWaitSemaphoresKHR(void *args)
42743 {
42744     struct vkWaitSemaphoresKHR_params *params = args;
42745
42746     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
42747
42748     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
42749     return STATUS_SUCCESS;
42750 }
42751 #endif /* _WIN64 */
42752
42753 static NTSTATUS thunk32_vkWaitSemaphoresKHR(void *args)
42754 {
42755     struct
42756     {
42757         PTR32 device;
42758         PTR32 pWaitInfo;
42759         uint64_t DECLSPEC_ALIGN(8) timeout;
42760         VkResult result;
42761     } *params = args;
42762     VkSemaphoreWaitInfo pWaitInfo_host;
42763
42764     TRACE("%#x, %#x, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
42765
42766     convert_VkSemaphoreWaitInfo_win32_to_host((const VkSemaphoreWaitInfo32 *)UlongToPtr(params->pWaitInfo), &pWaitInfo_host);
42767     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);
42768     return STATUS_SUCCESS;
42769 }
42770
42771 #ifdef _WIN64
42772 static NTSTATUS thunk64_vkWriteAccelerationStructuresPropertiesKHR(void *args)
42773 {
42774     struct vkWriteAccelerationStructuresPropertiesKHR_params *params = args;
42775
42776     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));
42777
42778     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);
42779     return STATUS_SUCCESS;
42780 }
42781 #endif /* _WIN64 */
42782
42783 static NTSTATUS thunk32_vkWriteAccelerationStructuresPropertiesKHR(void *args)
42784 {
42785     struct
42786     {
42787         PTR32 device;
42788         uint32_t accelerationStructureCount;
42789         PTR32 pAccelerationStructures;
42790         VkQueryType queryType;
42791         PTR32 dataSize;
42792         PTR32 pData;
42793         PTR32 stride;
42794         VkResult result;
42795     } *params = args;
42796
42797     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));
42798
42799     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);
42800     return STATUS_SUCCESS;
42801 }
42802
42803 #ifdef _WIN64
42804 static NTSTATUS thunk64_vkWriteMicromapsPropertiesEXT(void *args)
42805 {
42806     struct vkWriteMicromapsPropertiesEXT_params *params = args;
42807
42808     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));
42809
42810     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);
42811     return STATUS_SUCCESS;
42812 }
42813 #endif /* _WIN64 */
42814
42815 static NTSTATUS thunk32_vkWriteMicromapsPropertiesEXT(void *args)
42816 {
42817     struct
42818     {
42819         PTR32 device;
42820         uint32_t micromapCount;
42821         PTR32 pMicromaps;
42822         VkQueryType queryType;
42823         PTR32 dataSize;
42824         PTR32 pData;
42825         PTR32 stride;
42826         VkResult result;
42827     } *params = args;
42828
42829     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));
42830
42831     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);
42832     return STATUS_SUCCESS;
42833 }
42834
42835 static const char * const vk_device_extensions[] =
42836 {
42837     "VK_AMD_buffer_marker",
42838     "VK_AMD_device_coherent_memory",
42839     "VK_AMD_draw_indirect_count",
42840     "VK_AMD_gcn_shader",
42841     "VK_AMD_gpu_shader_half_float",
42842     "VK_AMD_gpu_shader_int16",
42843     "VK_AMD_memory_overallocation_behavior",
42844     "VK_AMD_mixed_attachment_samples",
42845     "VK_AMD_negative_viewport_height",
42846     "VK_AMD_pipeline_compiler_control",
42847     "VK_AMD_rasterization_order",
42848     "VK_AMD_shader_ballot",
42849     "VK_AMD_shader_core_properties",
42850     "VK_AMD_shader_core_properties2",
42851     "VK_AMD_shader_early_and_late_fragment_tests",
42852     "VK_AMD_shader_explicit_vertex_parameter",
42853     "VK_AMD_shader_fragment_mask",
42854     "VK_AMD_shader_image_load_store_lod",
42855     "VK_AMD_shader_info",
42856     "VK_AMD_shader_trinary_minmax",
42857     "VK_AMD_texture_gather_bias_lod",
42858     "VK_ARM_rasterization_order_attachment_access",
42859     "VK_ARM_shader_core_builtins",
42860     "VK_ARM_shader_core_properties",
42861     "VK_EXT_4444_formats",
42862     "VK_EXT_astc_decode_mode",
42863     "VK_EXT_attachment_feedback_loop_dynamic_state",
42864     "VK_EXT_attachment_feedback_loop_layout",
42865     "VK_EXT_blend_operation_advanced",
42866     "VK_EXT_border_color_swizzle",
42867     "VK_EXT_buffer_device_address",
42868     "VK_EXT_calibrated_timestamps",
42869     "VK_EXT_color_write_enable",
42870     "VK_EXT_conditional_rendering",
42871     "VK_EXT_conservative_rasterization",
42872     "VK_EXT_custom_border_color",
42873     "VK_EXT_debug_marker",
42874     "VK_EXT_depth_bias_control",
42875     "VK_EXT_depth_clamp_zero_one",
42876     "VK_EXT_depth_clip_control",
42877     "VK_EXT_depth_clip_enable",
42878     "VK_EXT_depth_range_unrestricted",
42879     "VK_EXT_descriptor_buffer",
42880     "VK_EXT_descriptor_indexing",
42881     "VK_EXT_device_address_binding_report",
42882     "VK_EXT_device_fault",
42883     "VK_EXT_discard_rectangles",
42884     "VK_EXT_dynamic_rendering_unused_attachments",
42885     "VK_EXT_extended_dynamic_state",
42886     "VK_EXT_extended_dynamic_state2",
42887     "VK_EXT_extended_dynamic_state3",
42888     "VK_EXT_external_memory_acquire_unmodified",
42889     "VK_EXT_external_memory_host",
42890     "VK_EXT_filter_cubic",
42891     "VK_EXT_fragment_density_map",
42892     "VK_EXT_fragment_density_map2",
42893     "VK_EXT_fragment_shader_interlock",
42894     "VK_EXT_global_priority",
42895     "VK_EXT_global_priority_query",
42896     "VK_EXT_graphics_pipeline_library",
42897     "VK_EXT_hdr_metadata",
42898     "VK_EXT_host_image_copy",
42899     "VK_EXT_host_query_reset",
42900     "VK_EXT_image_2d_view_of_3d",
42901     "VK_EXT_image_compression_control",
42902     "VK_EXT_image_compression_control_swapchain",
42903     "VK_EXT_image_robustness",
42904     "VK_EXT_image_sliced_view_of_3d",
42905     "VK_EXT_image_view_min_lod",
42906     "VK_EXT_index_type_uint8",
42907     "VK_EXT_inline_uniform_block",
42908     "VK_EXT_legacy_dithering",
42909     "VK_EXT_line_rasterization",
42910     "VK_EXT_load_store_op_none",
42911     "VK_EXT_memory_budget",
42912     "VK_EXT_memory_priority",
42913     "VK_EXT_mesh_shader",
42914     "VK_EXT_multi_draw",
42915     "VK_EXT_multisampled_render_to_single_sampled",
42916     "VK_EXT_mutable_descriptor_type",
42917     "VK_EXT_non_seamless_cube_map",
42918     "VK_EXT_opacity_micromap",
42919     "VK_EXT_pageable_device_local_memory",
42920     "VK_EXT_pci_bus_info",
42921     "VK_EXT_pipeline_creation_cache_control",
42922     "VK_EXT_pipeline_creation_feedback",
42923     "VK_EXT_pipeline_library_group_handles",
42924     "VK_EXT_pipeline_properties",
42925     "VK_EXT_pipeline_protected_access",
42926     "VK_EXT_pipeline_robustness",
42927     "VK_EXT_post_depth_coverage",
42928     "VK_EXT_primitive_topology_list_restart",
42929     "VK_EXT_primitives_generated_query",
42930     "VK_EXT_private_data",
42931     "VK_EXT_provoking_vertex",
42932     "VK_EXT_queue_family_foreign",
42933     "VK_EXT_rasterization_order_attachment_access",
42934     "VK_EXT_rgba10x6_formats",
42935     "VK_EXT_robustness2",
42936     "VK_EXT_sample_locations",
42937     "VK_EXT_sampler_filter_minmax",
42938     "VK_EXT_scalar_block_layout",
42939     "VK_EXT_separate_stencil_usage",
42940     "VK_EXT_shader_atomic_float",
42941     "VK_EXT_shader_atomic_float2",
42942     "VK_EXT_shader_demote_to_helper_invocation",
42943     "VK_EXT_shader_image_atomic_int64",
42944     "VK_EXT_shader_module_identifier",
42945     "VK_EXT_shader_object",
42946     "VK_EXT_shader_stencil_export",
42947     "VK_EXT_shader_subgroup_ballot",
42948     "VK_EXT_shader_subgroup_vote",
42949     "VK_EXT_shader_tile_image",
42950     "VK_EXT_shader_viewport_index_layer",
42951     "VK_EXT_subgroup_size_control",
42952     "VK_EXT_subpass_merge_feedback",
42953     "VK_EXT_swapchain_maintenance1",
42954     "VK_EXT_texel_buffer_alignment",
42955     "VK_EXT_texture_compression_astc_hdr",
42956     "VK_EXT_tooling_info",
42957     "VK_EXT_transform_feedback",
42958     "VK_EXT_validation_cache",
42959     "VK_EXT_vertex_attribute_divisor",
42960     "VK_EXT_vertex_input_dynamic_state",
42961     "VK_EXT_ycbcr_2plane_444_formats",
42962     "VK_EXT_ycbcr_image_arrays",
42963     "VK_GOOGLE_decorate_string",
42964     "VK_GOOGLE_hlsl_functionality1",
42965     "VK_GOOGLE_user_type",
42966     "VK_HUAWEI_cluster_culling_shader",
42967     "VK_HUAWEI_invocation_mask",
42968     "VK_HUAWEI_subpass_shading",
42969     "VK_IMG_filter_cubic",
42970     "VK_IMG_format_pvrtc",
42971     "VK_INTEL_performance_query",
42972     "VK_INTEL_shader_integer_functions2",
42973     "VK_KHR_16bit_storage",
42974     "VK_KHR_8bit_storage",
42975     "VK_KHR_acceleration_structure",
42976     "VK_KHR_bind_memory2",
42977     "VK_KHR_buffer_device_address",
42978     "VK_KHR_cooperative_matrix",
42979     "VK_KHR_copy_commands2",
42980     "VK_KHR_create_renderpass2",
42981     "VK_KHR_dedicated_allocation",
42982     "VK_KHR_deferred_host_operations",
42983     "VK_KHR_depth_stencil_resolve",
42984     "VK_KHR_descriptor_update_template",
42985     "VK_KHR_device_group",
42986     "VK_KHR_draw_indirect_count",
42987     "VK_KHR_driver_properties",
42988     "VK_KHR_dynamic_rendering",
42989     "VK_KHR_external_fence",
42990     "VK_KHR_external_memory",
42991     "VK_KHR_external_semaphore",
42992     "VK_KHR_format_feature_flags2",
42993     "VK_KHR_fragment_shader_barycentric",
42994     "VK_KHR_fragment_shading_rate",
42995     "VK_KHR_get_memory_requirements2",
42996     "VK_KHR_global_priority",
42997     "VK_KHR_image_format_list",
42998     "VK_KHR_imageless_framebuffer",
42999     "VK_KHR_incremental_present",
43000     "VK_KHR_maintenance1",
43001     "VK_KHR_maintenance2",
43002     "VK_KHR_maintenance3",
43003     "VK_KHR_maintenance4",
43004     "VK_KHR_maintenance5",
43005     "VK_KHR_map_memory2",
43006     "VK_KHR_multiview",
43007     "VK_KHR_performance_query",
43008     "VK_KHR_pipeline_executable_properties",
43009     "VK_KHR_pipeline_library",
43010     "VK_KHR_present_id",
43011     "VK_KHR_present_wait",
43012     "VK_KHR_push_descriptor",
43013     "VK_KHR_ray_query",
43014     "VK_KHR_ray_tracing_maintenance1",
43015     "VK_KHR_ray_tracing_pipeline",
43016     "VK_KHR_ray_tracing_position_fetch",
43017     "VK_KHR_relaxed_block_layout",
43018     "VK_KHR_sampler_mirror_clamp_to_edge",
43019     "VK_KHR_sampler_ycbcr_conversion",
43020     "VK_KHR_separate_depth_stencil_layouts",
43021     "VK_KHR_shader_atomic_int64",
43022     "VK_KHR_shader_clock",
43023     "VK_KHR_shader_draw_parameters",
43024     "VK_KHR_shader_float16_int8",
43025     "VK_KHR_shader_float_controls",
43026     "VK_KHR_shader_integer_dot_product",
43027     "VK_KHR_shader_non_semantic_info",
43028     "VK_KHR_shader_subgroup_extended_types",
43029     "VK_KHR_shader_subgroup_uniform_control_flow",
43030     "VK_KHR_shader_terminate_invocation",
43031     "VK_KHR_spirv_1_4",
43032     "VK_KHR_storage_buffer_storage_class",
43033     "VK_KHR_swapchain",
43034     "VK_KHR_swapchain_mutable_format",
43035     "VK_KHR_synchronization2",
43036     "VK_KHR_timeline_semaphore",
43037     "VK_KHR_uniform_buffer_standard_layout",
43038     "VK_KHR_variable_pointers",
43039     "VK_KHR_vulkan_memory_model",
43040     "VK_KHR_workgroup_memory_explicit_layout",
43041     "VK_KHR_zero_initialize_workgroup_memory",
43042     "VK_NVX_binary_import",
43043     "VK_NVX_image_view_handle",
43044     "VK_NV_clip_space_w_scaling",
43045     "VK_NV_compute_shader_derivatives",
43046     "VK_NV_cooperative_matrix",
43047     "VK_NV_copy_memory_indirect",
43048     "VK_NV_corner_sampled_image",
43049     "VK_NV_coverage_reduction_mode",
43050     "VK_NV_dedicated_allocation",
43051     "VK_NV_dedicated_allocation_image_aliasing",
43052     "VK_NV_device_diagnostic_checkpoints",
43053     "VK_NV_device_diagnostics_config",
43054     "VK_NV_device_generated_commands",
43055     "VK_NV_device_generated_commands_compute",
43056     "VK_NV_fill_rectangle",
43057     "VK_NV_fragment_coverage_to_color",
43058     "VK_NV_fragment_shader_barycentric",
43059     "VK_NV_fragment_shading_rate_enums",
43060     "VK_NV_framebuffer_mixed_samples",
43061     "VK_NV_geometry_shader_passthrough",
43062     "VK_NV_glsl_shader",
43063     "VK_NV_inherited_viewport_scissor",
43064     "VK_NV_linear_color_attachment",
43065     "VK_NV_low_latency",
43066     "VK_NV_memory_decompression",
43067     "VK_NV_mesh_shader",
43068     "VK_NV_optical_flow",
43069     "VK_NV_present_barrier",
43070     "VK_NV_ray_tracing",
43071     "VK_NV_ray_tracing_invocation_reorder",
43072     "VK_NV_ray_tracing_motion_blur",
43073     "VK_NV_representative_fragment_test",
43074     "VK_NV_sample_mask_override_coverage",
43075     "VK_NV_scissor_exclusive",
43076     "VK_NV_shader_image_footprint",
43077     "VK_NV_shader_sm_builtins",
43078     "VK_NV_shader_subgroup_partitioned",
43079     "VK_NV_shading_rate_image",
43080     "VK_NV_viewport_array2",
43081     "VK_NV_viewport_swizzle",
43082     "VK_QCOM_fragment_density_map_offset",
43083     "VK_QCOM_image_processing",
43084     "VK_QCOM_multiview_per_view_render_areas",
43085     "VK_QCOM_multiview_per_view_viewports",
43086     "VK_QCOM_render_pass_shader_resolve",
43087     "VK_QCOM_render_pass_store_ops",
43088     "VK_QCOM_render_pass_transform",
43089     "VK_QCOM_rotated_copy_commands",
43090     "VK_QCOM_tile_properties",
43091     "VK_VALVE_descriptor_set_host_mapping",
43092     "VK_VALVE_mutable_descriptor_type",
43093 };
43094
43095 static const char * const vk_instance_extensions[] =
43096 {
43097     "VK_EXT_debug_report",
43098     "VK_EXT_debug_utils",
43099     "VK_EXT_surface_maintenance1",
43100     "VK_EXT_swapchain_colorspace",
43101     "VK_EXT_validation_features",
43102     "VK_EXT_validation_flags",
43103     "VK_KHR_device_group_creation",
43104     "VK_KHR_external_fence_capabilities",
43105     "VK_KHR_external_memory_capabilities",
43106     "VK_KHR_external_semaphore_capabilities",
43107     "VK_KHR_get_physical_device_properties2",
43108     "VK_KHR_get_surface_capabilities2",
43109     "VK_KHR_portability_enumeration",
43110     "VK_KHR_surface",
43111     "VK_KHR_win32_surface",
43112 };
43113
43114 BOOL wine_vk_device_extension_supported(const char *name)
43115 {
43116     unsigned int i;
43117     for (i = 0; i < ARRAY_SIZE(vk_device_extensions); i++)
43118     {
43119         if (strcmp(vk_device_extensions[i], name) == 0)
43120             return TRUE;
43121     }
43122     return FALSE;
43123 }
43124
43125 BOOL wine_vk_instance_extension_supported(const char *name)
43126 {
43127     unsigned int i;
43128     for (i = 0; i < ARRAY_SIZE(vk_instance_extensions); i++)
43129     {
43130         if (strcmp(vk_instance_extensions[i], name) == 0)
43131             return TRUE;
43132     }
43133     return FALSE;
43134 }
43135
43136 BOOL wine_vk_is_type_wrapped(VkObjectType type)
43137 {
43138     return FALSE ||
43139         type == VK_OBJECT_TYPE_COMMAND_BUFFER ||
43140         type == VK_OBJECT_TYPE_COMMAND_POOL ||
43141         type == VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT ||
43142         type == VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT ||
43143         type == VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR ||
43144         type == VK_OBJECT_TYPE_DEVICE ||
43145         type == VK_OBJECT_TYPE_DEVICE_MEMORY ||
43146         type == VK_OBJECT_TYPE_INSTANCE ||
43147         type == VK_OBJECT_TYPE_PHYSICAL_DEVICE ||
43148         type == VK_OBJECT_TYPE_QUEUE ||
43149         type == VK_OBJECT_TYPE_SURFACE_KHR;
43150 }
43151
43152 #ifdef _WIN64
43153
43154 const unixlib_entry_t __wine_unix_call_funcs[] =
43155 {
43156     init_vulkan,
43157     vk_is_available_instance_function,
43158     vk_is_available_device_function,
43159     thunk64_vkAcquireNextImage2KHR,
43160     thunk64_vkAcquireNextImageKHR,
43161     thunk64_vkAcquirePerformanceConfigurationINTEL,
43162     thunk64_vkAcquireProfilingLockKHR,
43163     thunk64_vkAllocateCommandBuffers,
43164     thunk64_vkAllocateDescriptorSets,
43165     thunk64_vkAllocateMemory,
43166     thunk64_vkBeginCommandBuffer,
43167     thunk64_vkBindAccelerationStructureMemoryNV,
43168     thunk64_vkBindBufferMemory,
43169     thunk64_vkBindBufferMemory2,
43170     thunk64_vkBindBufferMemory2KHR,
43171     thunk64_vkBindImageMemory,
43172     thunk64_vkBindImageMemory2,
43173     thunk64_vkBindImageMemory2KHR,
43174     thunk64_vkBindOpticalFlowSessionImageNV,
43175     thunk64_vkBuildAccelerationStructuresKHR,
43176     thunk64_vkBuildMicromapsEXT,
43177     (void *)thunk64_vkCmdBeginConditionalRenderingEXT,
43178     (void *)thunk64_vkCmdBeginDebugUtilsLabelEXT,
43179     (void *)thunk64_vkCmdBeginQuery,
43180     (void *)thunk64_vkCmdBeginQueryIndexedEXT,
43181     (void *)thunk64_vkCmdBeginRenderPass,
43182     (void *)thunk64_vkCmdBeginRenderPass2,
43183     (void *)thunk64_vkCmdBeginRenderPass2KHR,
43184     (void *)thunk64_vkCmdBeginRendering,
43185     (void *)thunk64_vkCmdBeginRenderingKHR,
43186     (void *)thunk64_vkCmdBeginTransformFeedbackEXT,
43187     (void *)thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
43188     (void *)thunk64_vkCmdBindDescriptorBuffersEXT,
43189     (void *)thunk64_vkCmdBindDescriptorSets,
43190     (void *)thunk64_vkCmdBindIndexBuffer,
43191     (void *)thunk64_vkCmdBindIndexBuffer2KHR,
43192     (void *)thunk64_vkCmdBindInvocationMaskHUAWEI,
43193     (void *)thunk64_vkCmdBindPipeline,
43194     (void *)thunk64_vkCmdBindPipelineShaderGroupNV,
43195     (void *)thunk64_vkCmdBindShadersEXT,
43196     (void *)thunk64_vkCmdBindShadingRateImageNV,
43197     (void *)thunk64_vkCmdBindTransformFeedbackBuffersEXT,
43198     (void *)thunk64_vkCmdBindVertexBuffers,
43199     (void *)thunk64_vkCmdBindVertexBuffers2,
43200     (void *)thunk64_vkCmdBindVertexBuffers2EXT,
43201     (void *)thunk64_vkCmdBlitImage,
43202     (void *)thunk64_vkCmdBlitImage2,
43203     (void *)thunk64_vkCmdBlitImage2KHR,
43204     (void *)thunk64_vkCmdBuildAccelerationStructureNV,
43205     (void *)thunk64_vkCmdBuildAccelerationStructuresIndirectKHR,
43206     (void *)thunk64_vkCmdBuildAccelerationStructuresKHR,
43207     (void *)thunk64_vkCmdBuildMicromapsEXT,
43208     (void *)thunk64_vkCmdClearAttachments,
43209     (void *)thunk64_vkCmdClearColorImage,
43210     (void *)thunk64_vkCmdClearDepthStencilImage,
43211     (void *)thunk64_vkCmdCopyAccelerationStructureKHR,
43212     (void *)thunk64_vkCmdCopyAccelerationStructureNV,
43213     (void *)thunk64_vkCmdCopyAccelerationStructureToMemoryKHR,
43214     (void *)thunk64_vkCmdCopyBuffer,
43215     (void *)thunk64_vkCmdCopyBuffer2,
43216     (void *)thunk64_vkCmdCopyBuffer2KHR,
43217     (void *)thunk64_vkCmdCopyBufferToImage,
43218     (void *)thunk64_vkCmdCopyBufferToImage2,
43219     (void *)thunk64_vkCmdCopyBufferToImage2KHR,
43220     (void *)thunk64_vkCmdCopyImage,
43221     (void *)thunk64_vkCmdCopyImage2,
43222     (void *)thunk64_vkCmdCopyImage2KHR,
43223     (void *)thunk64_vkCmdCopyImageToBuffer,
43224     (void *)thunk64_vkCmdCopyImageToBuffer2,
43225     (void *)thunk64_vkCmdCopyImageToBuffer2KHR,
43226     (void *)thunk64_vkCmdCopyMemoryIndirectNV,
43227     (void *)thunk64_vkCmdCopyMemoryToAccelerationStructureKHR,
43228     (void *)thunk64_vkCmdCopyMemoryToImageIndirectNV,
43229     (void *)thunk64_vkCmdCopyMemoryToMicromapEXT,
43230     (void *)thunk64_vkCmdCopyMicromapEXT,
43231     (void *)thunk64_vkCmdCopyMicromapToMemoryEXT,
43232     (void *)thunk64_vkCmdCopyQueryPoolResults,
43233     (void *)thunk64_vkCmdCuLaunchKernelNVX,
43234     (void *)thunk64_vkCmdDebugMarkerBeginEXT,
43235     (void *)thunk64_vkCmdDebugMarkerEndEXT,
43236     (void *)thunk64_vkCmdDebugMarkerInsertEXT,
43237     (void *)thunk64_vkCmdDecompressMemoryIndirectCountNV,
43238     (void *)thunk64_vkCmdDecompressMemoryNV,
43239     (void *)thunk64_vkCmdDispatch,
43240     (void *)thunk64_vkCmdDispatchBase,
43241     (void *)thunk64_vkCmdDispatchBaseKHR,
43242     (void *)thunk64_vkCmdDispatchIndirect,
43243     (void *)thunk64_vkCmdDraw,
43244     (void *)thunk64_vkCmdDrawClusterHUAWEI,
43245     (void *)thunk64_vkCmdDrawClusterIndirectHUAWEI,
43246     (void *)thunk64_vkCmdDrawIndexed,
43247     (void *)thunk64_vkCmdDrawIndexedIndirect,
43248     (void *)thunk64_vkCmdDrawIndexedIndirectCount,
43249     (void *)thunk64_vkCmdDrawIndexedIndirectCountAMD,
43250     (void *)thunk64_vkCmdDrawIndexedIndirectCountKHR,
43251     (void *)thunk64_vkCmdDrawIndirect,
43252     (void *)thunk64_vkCmdDrawIndirectByteCountEXT,
43253     (void *)thunk64_vkCmdDrawIndirectCount,
43254     (void *)thunk64_vkCmdDrawIndirectCountAMD,
43255     (void *)thunk64_vkCmdDrawIndirectCountKHR,
43256     (void *)thunk64_vkCmdDrawMeshTasksEXT,
43257     (void *)thunk64_vkCmdDrawMeshTasksIndirectCountEXT,
43258     (void *)thunk64_vkCmdDrawMeshTasksIndirectCountNV,
43259     (void *)thunk64_vkCmdDrawMeshTasksIndirectEXT,
43260     (void *)thunk64_vkCmdDrawMeshTasksIndirectNV,
43261     (void *)thunk64_vkCmdDrawMeshTasksNV,
43262     (void *)thunk64_vkCmdDrawMultiEXT,
43263     (void *)thunk64_vkCmdDrawMultiIndexedEXT,
43264     (void *)thunk64_vkCmdEndConditionalRenderingEXT,
43265     (void *)thunk64_vkCmdEndDebugUtilsLabelEXT,
43266     (void *)thunk64_vkCmdEndQuery,
43267     (void *)thunk64_vkCmdEndQueryIndexedEXT,
43268     (void *)thunk64_vkCmdEndRenderPass,
43269     (void *)thunk64_vkCmdEndRenderPass2,
43270     (void *)thunk64_vkCmdEndRenderPass2KHR,
43271     (void *)thunk64_vkCmdEndRendering,
43272     (void *)thunk64_vkCmdEndRenderingKHR,
43273     (void *)thunk64_vkCmdEndTransformFeedbackEXT,
43274     (void *)thunk64_vkCmdExecuteCommands,
43275     (void *)thunk64_vkCmdExecuteGeneratedCommandsNV,
43276     (void *)thunk64_vkCmdFillBuffer,
43277     (void *)thunk64_vkCmdInsertDebugUtilsLabelEXT,
43278     (void *)thunk64_vkCmdNextSubpass,
43279     (void *)thunk64_vkCmdNextSubpass2,
43280     (void *)thunk64_vkCmdNextSubpass2KHR,
43281     (void *)thunk64_vkCmdOpticalFlowExecuteNV,
43282     (void *)thunk64_vkCmdPipelineBarrier,
43283     (void *)thunk64_vkCmdPipelineBarrier2,
43284     (void *)thunk64_vkCmdPipelineBarrier2KHR,
43285     (void *)thunk64_vkCmdPreprocessGeneratedCommandsNV,
43286     (void *)thunk64_vkCmdPushConstants,
43287     (void *)thunk64_vkCmdPushDescriptorSetKHR,
43288     (void *)thunk64_vkCmdPushDescriptorSetWithTemplateKHR,
43289     (void *)thunk64_vkCmdResetEvent,
43290     (void *)thunk64_vkCmdResetEvent2,
43291     (void *)thunk64_vkCmdResetEvent2KHR,
43292     (void *)thunk64_vkCmdResetQueryPool,
43293     (void *)thunk64_vkCmdResolveImage,
43294     (void *)thunk64_vkCmdResolveImage2,
43295     (void *)thunk64_vkCmdResolveImage2KHR,
43296     (void *)thunk64_vkCmdSetAlphaToCoverageEnableEXT,
43297     (void *)thunk64_vkCmdSetAlphaToOneEnableEXT,
43298     (void *)thunk64_vkCmdSetAttachmentFeedbackLoopEnableEXT,
43299     (void *)thunk64_vkCmdSetBlendConstants,
43300     (void *)thunk64_vkCmdSetCheckpointNV,
43301     (void *)thunk64_vkCmdSetCoarseSampleOrderNV,
43302     (void *)thunk64_vkCmdSetColorBlendAdvancedEXT,
43303     (void *)thunk64_vkCmdSetColorBlendEnableEXT,
43304     (void *)thunk64_vkCmdSetColorBlendEquationEXT,
43305     (void *)thunk64_vkCmdSetColorWriteEnableEXT,
43306     (void *)thunk64_vkCmdSetColorWriteMaskEXT,
43307     (void *)thunk64_vkCmdSetConservativeRasterizationModeEXT,
43308     (void *)thunk64_vkCmdSetCoverageModulationModeNV,
43309     (void *)thunk64_vkCmdSetCoverageModulationTableEnableNV,
43310     (void *)thunk64_vkCmdSetCoverageModulationTableNV,
43311     (void *)thunk64_vkCmdSetCoverageReductionModeNV,
43312     (void *)thunk64_vkCmdSetCoverageToColorEnableNV,
43313     (void *)thunk64_vkCmdSetCoverageToColorLocationNV,
43314     (void *)thunk64_vkCmdSetCullMode,
43315     (void *)thunk64_vkCmdSetCullModeEXT,
43316     (void *)thunk64_vkCmdSetDepthBias,
43317     (void *)thunk64_vkCmdSetDepthBias2EXT,
43318     (void *)thunk64_vkCmdSetDepthBiasEnable,
43319     (void *)thunk64_vkCmdSetDepthBiasEnableEXT,
43320     (void *)thunk64_vkCmdSetDepthBounds,
43321     (void *)thunk64_vkCmdSetDepthBoundsTestEnable,
43322     (void *)thunk64_vkCmdSetDepthBoundsTestEnableEXT,
43323     (void *)thunk64_vkCmdSetDepthClampEnableEXT,
43324     (void *)thunk64_vkCmdSetDepthClipEnableEXT,
43325     (void *)thunk64_vkCmdSetDepthClipNegativeOneToOneEXT,
43326     (void *)thunk64_vkCmdSetDepthCompareOp,
43327     (void *)thunk64_vkCmdSetDepthCompareOpEXT,
43328     (void *)thunk64_vkCmdSetDepthTestEnable,
43329     (void *)thunk64_vkCmdSetDepthTestEnableEXT,
43330     (void *)thunk64_vkCmdSetDepthWriteEnable,
43331     (void *)thunk64_vkCmdSetDepthWriteEnableEXT,
43332     (void *)thunk64_vkCmdSetDescriptorBufferOffsetsEXT,
43333     (void *)thunk64_vkCmdSetDeviceMask,
43334     (void *)thunk64_vkCmdSetDeviceMaskKHR,
43335     (void *)thunk64_vkCmdSetDiscardRectangleEXT,
43336     (void *)thunk64_vkCmdSetDiscardRectangleEnableEXT,
43337     (void *)thunk64_vkCmdSetDiscardRectangleModeEXT,
43338     (void *)thunk64_vkCmdSetEvent,
43339     (void *)thunk64_vkCmdSetEvent2,
43340     (void *)thunk64_vkCmdSetEvent2KHR,
43341     (void *)thunk64_vkCmdSetExclusiveScissorEnableNV,
43342     (void *)thunk64_vkCmdSetExclusiveScissorNV,
43343     (void *)thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
43344     (void *)thunk64_vkCmdSetFragmentShadingRateEnumNV,
43345     (void *)thunk64_vkCmdSetFragmentShadingRateKHR,
43346     (void *)thunk64_vkCmdSetFrontFace,
43347     (void *)thunk64_vkCmdSetFrontFaceEXT,
43348     (void *)thunk64_vkCmdSetLineRasterizationModeEXT,
43349     (void *)thunk64_vkCmdSetLineStippleEXT,
43350     (void *)thunk64_vkCmdSetLineStippleEnableEXT,
43351     (void *)thunk64_vkCmdSetLineWidth,
43352     (void *)thunk64_vkCmdSetLogicOpEXT,
43353     (void *)thunk64_vkCmdSetLogicOpEnableEXT,
43354     (void *)thunk64_vkCmdSetPatchControlPointsEXT,
43355     thunk64_vkCmdSetPerformanceMarkerINTEL,
43356     thunk64_vkCmdSetPerformanceOverrideINTEL,
43357     thunk64_vkCmdSetPerformanceStreamMarkerINTEL,
43358     (void *)thunk64_vkCmdSetPolygonModeEXT,
43359     (void *)thunk64_vkCmdSetPrimitiveRestartEnable,
43360     (void *)thunk64_vkCmdSetPrimitiveRestartEnableEXT,
43361     (void *)thunk64_vkCmdSetPrimitiveTopology,
43362     (void *)thunk64_vkCmdSetPrimitiveTopologyEXT,
43363     (void *)thunk64_vkCmdSetProvokingVertexModeEXT,
43364     (void *)thunk64_vkCmdSetRasterizationSamplesEXT,
43365     (void *)thunk64_vkCmdSetRasterizationStreamEXT,
43366     (void *)thunk64_vkCmdSetRasterizerDiscardEnable,
43367     (void *)thunk64_vkCmdSetRasterizerDiscardEnableEXT,
43368     (void *)thunk64_vkCmdSetRayTracingPipelineStackSizeKHR,
43369     (void *)thunk64_vkCmdSetRepresentativeFragmentTestEnableNV,
43370     (void *)thunk64_vkCmdSetSampleLocationsEXT,
43371     (void *)thunk64_vkCmdSetSampleLocationsEnableEXT,
43372     (void *)thunk64_vkCmdSetSampleMaskEXT,
43373     (void *)thunk64_vkCmdSetScissor,
43374     (void *)thunk64_vkCmdSetScissorWithCount,
43375     (void *)thunk64_vkCmdSetScissorWithCountEXT,
43376     (void *)thunk64_vkCmdSetShadingRateImageEnableNV,
43377     (void *)thunk64_vkCmdSetStencilCompareMask,
43378     (void *)thunk64_vkCmdSetStencilOp,
43379     (void *)thunk64_vkCmdSetStencilOpEXT,
43380     (void *)thunk64_vkCmdSetStencilReference,
43381     (void *)thunk64_vkCmdSetStencilTestEnable,
43382     (void *)thunk64_vkCmdSetStencilTestEnableEXT,
43383     (void *)thunk64_vkCmdSetStencilWriteMask,
43384     (void *)thunk64_vkCmdSetTessellationDomainOriginEXT,
43385     (void *)thunk64_vkCmdSetVertexInputEXT,
43386     (void *)thunk64_vkCmdSetViewport,
43387     (void *)thunk64_vkCmdSetViewportShadingRatePaletteNV,
43388     (void *)thunk64_vkCmdSetViewportSwizzleNV,
43389     (void *)thunk64_vkCmdSetViewportWScalingEnableNV,
43390     (void *)thunk64_vkCmdSetViewportWScalingNV,
43391     (void *)thunk64_vkCmdSetViewportWithCount,
43392     (void *)thunk64_vkCmdSetViewportWithCountEXT,
43393     (void *)thunk64_vkCmdSubpassShadingHUAWEI,
43394     (void *)thunk64_vkCmdTraceRaysIndirect2KHR,
43395     (void *)thunk64_vkCmdTraceRaysIndirectKHR,
43396     (void *)thunk64_vkCmdTraceRaysKHR,
43397     (void *)thunk64_vkCmdTraceRaysNV,
43398     (void *)thunk64_vkCmdUpdateBuffer,
43399     (void *)thunk64_vkCmdUpdatePipelineIndirectBufferNV,
43400     (void *)thunk64_vkCmdWaitEvents,
43401     (void *)thunk64_vkCmdWaitEvents2,
43402     (void *)thunk64_vkCmdWaitEvents2KHR,
43403     (void *)thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR,
43404     (void *)thunk64_vkCmdWriteAccelerationStructuresPropertiesNV,
43405     (void *)thunk64_vkCmdWriteBufferMarker2AMD,
43406     (void *)thunk64_vkCmdWriteBufferMarkerAMD,
43407     (void *)thunk64_vkCmdWriteMicromapsPropertiesEXT,
43408     (void *)thunk64_vkCmdWriteTimestamp,
43409     (void *)thunk64_vkCmdWriteTimestamp2,
43410     (void *)thunk64_vkCmdWriteTimestamp2KHR,
43411     thunk64_vkCompileDeferredNV,
43412     thunk64_vkCopyAccelerationStructureKHR,
43413     thunk64_vkCopyAccelerationStructureToMemoryKHR,
43414     thunk64_vkCopyImageToImageEXT,
43415     thunk64_vkCopyImageToMemoryEXT,
43416     thunk64_vkCopyMemoryToAccelerationStructureKHR,
43417     thunk64_vkCopyMemoryToImageEXT,
43418     thunk64_vkCopyMemoryToMicromapEXT,
43419     thunk64_vkCopyMicromapEXT,
43420     thunk64_vkCopyMicromapToMemoryEXT,
43421     thunk64_vkCreateAccelerationStructureKHR,
43422     thunk64_vkCreateAccelerationStructureNV,
43423     thunk64_vkCreateBuffer,
43424     thunk64_vkCreateBufferView,
43425     thunk64_vkCreateCommandPool,
43426     thunk64_vkCreateComputePipelines,
43427     thunk64_vkCreateCuFunctionNVX,
43428     thunk64_vkCreateCuModuleNVX,
43429     thunk64_vkCreateDebugReportCallbackEXT,
43430     thunk64_vkCreateDebugUtilsMessengerEXT,
43431     thunk64_vkCreateDeferredOperationKHR,
43432     thunk64_vkCreateDescriptorPool,
43433     thunk64_vkCreateDescriptorSetLayout,
43434     thunk64_vkCreateDescriptorUpdateTemplate,
43435     thunk64_vkCreateDescriptorUpdateTemplateKHR,
43436     thunk64_vkCreateDevice,
43437     thunk64_vkCreateEvent,
43438     thunk64_vkCreateFence,
43439     thunk64_vkCreateFramebuffer,
43440     thunk64_vkCreateGraphicsPipelines,
43441     thunk64_vkCreateImage,
43442     thunk64_vkCreateImageView,
43443     thunk64_vkCreateIndirectCommandsLayoutNV,
43444     thunk64_vkCreateInstance,
43445     thunk64_vkCreateMicromapEXT,
43446     thunk64_vkCreateOpticalFlowSessionNV,
43447     thunk64_vkCreatePipelineCache,
43448     thunk64_vkCreatePipelineLayout,
43449     thunk64_vkCreatePrivateDataSlot,
43450     thunk64_vkCreatePrivateDataSlotEXT,
43451     thunk64_vkCreateQueryPool,
43452     thunk64_vkCreateRayTracingPipelinesKHR,
43453     thunk64_vkCreateRayTracingPipelinesNV,
43454     thunk64_vkCreateRenderPass,
43455     thunk64_vkCreateRenderPass2,
43456     thunk64_vkCreateRenderPass2KHR,
43457     thunk64_vkCreateSampler,
43458     thunk64_vkCreateSamplerYcbcrConversion,
43459     thunk64_vkCreateSamplerYcbcrConversionKHR,
43460     thunk64_vkCreateSemaphore,
43461     thunk64_vkCreateShaderModule,
43462     thunk64_vkCreateShadersEXT,
43463     thunk64_vkCreateSwapchainKHR,
43464     thunk64_vkCreateValidationCacheEXT,
43465     thunk64_vkCreateWin32SurfaceKHR,
43466     thunk64_vkDebugMarkerSetObjectNameEXT,
43467     thunk64_vkDebugMarkerSetObjectTagEXT,
43468     thunk64_vkDebugReportMessageEXT,
43469     thunk64_vkDeferredOperationJoinKHR,
43470     thunk64_vkDestroyAccelerationStructureKHR,
43471     thunk64_vkDestroyAccelerationStructureNV,
43472     thunk64_vkDestroyBuffer,
43473     thunk64_vkDestroyBufferView,
43474     thunk64_vkDestroyCommandPool,
43475     thunk64_vkDestroyCuFunctionNVX,
43476     thunk64_vkDestroyCuModuleNVX,
43477     thunk64_vkDestroyDebugReportCallbackEXT,
43478     thunk64_vkDestroyDebugUtilsMessengerEXT,
43479     thunk64_vkDestroyDeferredOperationKHR,
43480     thunk64_vkDestroyDescriptorPool,
43481     thunk64_vkDestroyDescriptorSetLayout,
43482     thunk64_vkDestroyDescriptorUpdateTemplate,
43483     thunk64_vkDestroyDescriptorUpdateTemplateKHR,
43484     thunk64_vkDestroyDevice,
43485     thunk64_vkDestroyEvent,
43486     thunk64_vkDestroyFence,
43487     thunk64_vkDestroyFramebuffer,
43488     thunk64_vkDestroyImage,
43489     thunk64_vkDestroyImageView,
43490     thunk64_vkDestroyIndirectCommandsLayoutNV,
43491     thunk64_vkDestroyInstance,
43492     thunk64_vkDestroyMicromapEXT,
43493     thunk64_vkDestroyOpticalFlowSessionNV,
43494     thunk64_vkDestroyPipeline,
43495     thunk64_vkDestroyPipelineCache,
43496     thunk64_vkDestroyPipelineLayout,
43497     thunk64_vkDestroyPrivateDataSlot,
43498     thunk64_vkDestroyPrivateDataSlotEXT,
43499     thunk64_vkDestroyQueryPool,
43500     thunk64_vkDestroyRenderPass,
43501     thunk64_vkDestroySampler,
43502     thunk64_vkDestroySamplerYcbcrConversion,
43503     thunk64_vkDestroySamplerYcbcrConversionKHR,
43504     thunk64_vkDestroySemaphore,
43505     thunk64_vkDestroyShaderEXT,
43506     thunk64_vkDestroyShaderModule,
43507     thunk64_vkDestroySurfaceKHR,
43508     thunk64_vkDestroySwapchainKHR,
43509     thunk64_vkDestroyValidationCacheEXT,
43510     thunk64_vkDeviceWaitIdle,
43511     thunk64_vkEndCommandBuffer,
43512     thunk64_vkEnumerateDeviceExtensionProperties,
43513     thunk64_vkEnumerateDeviceLayerProperties,
43514     thunk64_vkEnumerateInstanceExtensionProperties,
43515     thunk64_vkEnumerateInstanceVersion,
43516     thunk64_vkEnumeratePhysicalDeviceGroups,
43517     thunk64_vkEnumeratePhysicalDeviceGroupsKHR,
43518     thunk64_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
43519     thunk64_vkEnumeratePhysicalDevices,
43520     thunk64_vkFlushMappedMemoryRanges,
43521     thunk64_vkFreeCommandBuffers,
43522     thunk64_vkFreeDescriptorSets,
43523     thunk64_vkFreeMemory,
43524     thunk64_vkGetAccelerationStructureBuildSizesKHR,
43525     thunk64_vkGetAccelerationStructureDeviceAddressKHR,
43526     thunk64_vkGetAccelerationStructureHandleNV,
43527     thunk64_vkGetAccelerationStructureMemoryRequirementsNV,
43528     thunk64_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
43529     thunk64_vkGetBufferDeviceAddress,
43530     thunk64_vkGetBufferDeviceAddressEXT,
43531     thunk64_vkGetBufferDeviceAddressKHR,
43532     thunk64_vkGetBufferMemoryRequirements,
43533     thunk64_vkGetBufferMemoryRequirements2,
43534     thunk64_vkGetBufferMemoryRequirements2KHR,
43535     thunk64_vkGetBufferOpaqueCaptureAddress,
43536     thunk64_vkGetBufferOpaqueCaptureAddressKHR,
43537     thunk64_vkGetBufferOpaqueCaptureDescriptorDataEXT,
43538     thunk64_vkGetCalibratedTimestampsEXT,
43539     thunk64_vkGetDeferredOperationMaxConcurrencyKHR,
43540     thunk64_vkGetDeferredOperationResultKHR,
43541     (void *)thunk64_vkGetDescriptorEXT,
43542     thunk64_vkGetDescriptorSetHostMappingVALVE,
43543     thunk64_vkGetDescriptorSetLayoutBindingOffsetEXT,
43544     thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
43545     thunk64_vkGetDescriptorSetLayoutSizeEXT,
43546     thunk64_vkGetDescriptorSetLayoutSupport,
43547     thunk64_vkGetDescriptorSetLayoutSupportKHR,
43548     thunk64_vkGetDeviceAccelerationStructureCompatibilityKHR,
43549     thunk64_vkGetDeviceBufferMemoryRequirements,
43550     thunk64_vkGetDeviceBufferMemoryRequirementsKHR,
43551     thunk64_vkGetDeviceFaultInfoEXT,
43552     thunk64_vkGetDeviceGroupPeerMemoryFeatures,
43553     thunk64_vkGetDeviceGroupPeerMemoryFeaturesKHR,
43554     thunk64_vkGetDeviceGroupPresentCapabilitiesKHR,
43555     thunk64_vkGetDeviceGroupSurfacePresentModesKHR,
43556     thunk64_vkGetDeviceImageMemoryRequirements,
43557     thunk64_vkGetDeviceImageMemoryRequirementsKHR,
43558     thunk64_vkGetDeviceImageSparseMemoryRequirements,
43559     thunk64_vkGetDeviceImageSparseMemoryRequirementsKHR,
43560     thunk64_vkGetDeviceImageSubresourceLayoutKHR,
43561     thunk64_vkGetDeviceMemoryCommitment,
43562     thunk64_vkGetDeviceMemoryOpaqueCaptureAddress,
43563     thunk64_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
43564     thunk64_vkGetDeviceMicromapCompatibilityEXT,
43565     thunk64_vkGetDeviceQueue,
43566     thunk64_vkGetDeviceQueue2,
43567     thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
43568     thunk64_vkGetDynamicRenderingTilePropertiesQCOM,
43569     thunk64_vkGetEventStatus,
43570     thunk64_vkGetFenceStatus,
43571     thunk64_vkGetFramebufferTilePropertiesQCOM,
43572     thunk64_vkGetGeneratedCommandsMemoryRequirementsNV,
43573     thunk64_vkGetImageMemoryRequirements,
43574     thunk64_vkGetImageMemoryRequirements2,
43575     thunk64_vkGetImageMemoryRequirements2KHR,
43576     thunk64_vkGetImageOpaqueCaptureDescriptorDataEXT,
43577     thunk64_vkGetImageSparseMemoryRequirements,
43578     thunk64_vkGetImageSparseMemoryRequirements2,
43579     thunk64_vkGetImageSparseMemoryRequirements2KHR,
43580     thunk64_vkGetImageSubresourceLayout,
43581     thunk64_vkGetImageSubresourceLayout2EXT,
43582     thunk64_vkGetImageSubresourceLayout2KHR,
43583     thunk64_vkGetImageViewAddressNVX,
43584     thunk64_vkGetImageViewHandleNVX,
43585     thunk64_vkGetImageViewOpaqueCaptureDescriptorDataEXT,
43586     thunk64_vkGetMemoryHostPointerPropertiesEXT,
43587     thunk64_vkGetMicromapBuildSizesEXT,
43588     thunk64_vkGetPerformanceParameterINTEL,
43589     thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
43590     thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR,
43591     thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
43592     thunk64_vkGetPhysicalDeviceExternalBufferProperties,
43593     thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
43594     thunk64_vkGetPhysicalDeviceExternalFenceProperties,
43595     thunk64_vkGetPhysicalDeviceExternalFencePropertiesKHR,
43596     thunk64_vkGetPhysicalDeviceExternalSemaphoreProperties,
43597     thunk64_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
43598     thunk64_vkGetPhysicalDeviceFeatures,
43599     thunk64_vkGetPhysicalDeviceFeatures2,
43600     thunk64_vkGetPhysicalDeviceFeatures2KHR,
43601     thunk64_vkGetPhysicalDeviceFormatProperties,
43602     thunk64_vkGetPhysicalDeviceFormatProperties2,
43603     thunk64_vkGetPhysicalDeviceFormatProperties2KHR,
43604     thunk64_vkGetPhysicalDeviceFragmentShadingRatesKHR,
43605     thunk64_vkGetPhysicalDeviceImageFormatProperties,
43606     thunk64_vkGetPhysicalDeviceImageFormatProperties2,
43607     thunk64_vkGetPhysicalDeviceImageFormatProperties2KHR,
43608     thunk64_vkGetPhysicalDeviceMemoryProperties,
43609     thunk64_vkGetPhysicalDeviceMemoryProperties2,
43610     thunk64_vkGetPhysicalDeviceMemoryProperties2KHR,
43611     thunk64_vkGetPhysicalDeviceMultisamplePropertiesEXT,
43612     thunk64_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
43613     thunk64_vkGetPhysicalDevicePresentRectanglesKHR,
43614     thunk64_vkGetPhysicalDeviceProperties,
43615     thunk64_vkGetPhysicalDeviceProperties2,
43616     thunk64_vkGetPhysicalDeviceProperties2KHR,
43617     thunk64_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
43618     thunk64_vkGetPhysicalDeviceQueueFamilyProperties,
43619     thunk64_vkGetPhysicalDeviceQueueFamilyProperties2,
43620     thunk64_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
43621     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties,
43622     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2,
43623     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
43624     thunk64_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
43625     thunk64_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
43626     thunk64_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
43627     thunk64_vkGetPhysicalDeviceSurfaceFormats2KHR,
43628     thunk64_vkGetPhysicalDeviceSurfaceFormatsKHR,
43629     thunk64_vkGetPhysicalDeviceSurfacePresentModesKHR,
43630     thunk64_vkGetPhysicalDeviceSurfaceSupportKHR,
43631     thunk64_vkGetPhysicalDeviceToolProperties,
43632     thunk64_vkGetPhysicalDeviceToolPropertiesEXT,
43633     thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR,
43634     thunk64_vkGetPipelineCacheData,
43635     thunk64_vkGetPipelineExecutableInternalRepresentationsKHR,
43636     thunk64_vkGetPipelineExecutablePropertiesKHR,
43637     thunk64_vkGetPipelineExecutableStatisticsKHR,
43638     thunk64_vkGetPipelineIndirectDeviceAddressNV,
43639     thunk64_vkGetPipelineIndirectMemoryRequirementsNV,
43640     thunk64_vkGetPipelinePropertiesEXT,
43641     thunk64_vkGetPrivateData,
43642     thunk64_vkGetPrivateDataEXT,
43643     thunk64_vkGetQueryPoolResults,
43644     thunk64_vkGetQueueCheckpointData2NV,
43645     thunk64_vkGetQueueCheckpointDataNV,
43646     thunk64_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
43647     thunk64_vkGetRayTracingShaderGroupHandlesKHR,
43648     thunk64_vkGetRayTracingShaderGroupHandlesNV,
43649     thunk64_vkGetRayTracingShaderGroupStackSizeKHR,
43650     thunk64_vkGetRenderAreaGranularity,
43651     thunk64_vkGetRenderingAreaGranularityKHR,
43652     thunk64_vkGetSamplerOpaqueCaptureDescriptorDataEXT,
43653     thunk64_vkGetSemaphoreCounterValue,
43654     thunk64_vkGetSemaphoreCounterValueKHR,
43655     thunk64_vkGetShaderBinaryDataEXT,
43656     thunk64_vkGetShaderInfoAMD,
43657     thunk64_vkGetShaderModuleCreateInfoIdentifierEXT,
43658     thunk64_vkGetShaderModuleIdentifierEXT,
43659     thunk64_vkGetSwapchainImagesKHR,
43660     thunk64_vkGetValidationCacheDataEXT,
43661     thunk64_vkInitializePerformanceApiINTEL,
43662     thunk64_vkInvalidateMappedMemoryRanges,
43663     thunk64_vkMapMemory,
43664     thunk64_vkMapMemory2KHR,
43665     thunk64_vkMergePipelineCaches,
43666     thunk64_vkMergeValidationCachesEXT,
43667     thunk64_vkQueueBeginDebugUtilsLabelEXT,
43668     thunk64_vkQueueBindSparse,
43669     thunk64_vkQueueEndDebugUtilsLabelEXT,
43670     thunk64_vkQueueInsertDebugUtilsLabelEXT,
43671     thunk64_vkQueuePresentKHR,
43672     thunk64_vkQueueSetPerformanceConfigurationINTEL,
43673     thunk64_vkQueueSubmit,
43674     thunk64_vkQueueSubmit2,
43675     thunk64_vkQueueSubmit2KHR,
43676     thunk64_vkQueueWaitIdle,
43677     thunk64_vkReleasePerformanceConfigurationINTEL,
43678     thunk64_vkReleaseProfilingLockKHR,
43679     thunk64_vkReleaseSwapchainImagesEXT,
43680     thunk64_vkResetCommandBuffer,
43681     thunk64_vkResetCommandPool,
43682     thunk64_vkResetDescriptorPool,
43683     thunk64_vkResetEvent,
43684     thunk64_vkResetFences,
43685     thunk64_vkResetQueryPool,
43686     thunk64_vkResetQueryPoolEXT,
43687     thunk64_vkSetDebugUtilsObjectNameEXT,
43688     thunk64_vkSetDebugUtilsObjectTagEXT,
43689     thunk64_vkSetDeviceMemoryPriorityEXT,
43690     thunk64_vkSetEvent,
43691     thunk64_vkSetHdrMetadataEXT,
43692     thunk64_vkSetPrivateData,
43693     thunk64_vkSetPrivateDataEXT,
43694     thunk64_vkSignalSemaphore,
43695     thunk64_vkSignalSemaphoreKHR,
43696     thunk64_vkSubmitDebugUtilsMessageEXT,
43697     thunk64_vkTransitionImageLayoutEXT,
43698     thunk64_vkTrimCommandPool,
43699     thunk64_vkTrimCommandPoolKHR,
43700     thunk64_vkUninitializePerformanceApiINTEL,
43701     thunk64_vkUnmapMemory,
43702     thunk64_vkUnmapMemory2KHR,
43703     (void *)thunk64_vkUpdateDescriptorSetWithTemplate,
43704     thunk64_vkUpdateDescriptorSetWithTemplateKHR,
43705     (void *)thunk64_vkUpdateDescriptorSets,
43706     thunk64_vkWaitForFences,
43707     thunk64_vkWaitForPresentKHR,
43708     thunk64_vkWaitSemaphores,
43709     thunk64_vkWaitSemaphoresKHR,
43710     thunk64_vkWriteAccelerationStructuresPropertiesKHR,
43711     thunk64_vkWriteMicromapsPropertiesEXT,
43712 };
43713 C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);
43714
43715 #endif /* _WIN64 */
43716
43717 #ifdef _WIN64
43718 const unixlib_entry_t __wine_unix_call_wow64_funcs[] =
43719 #else
43720 const unixlib_entry_t __wine_unix_call_funcs[] =
43721 #endif
43722 {
43723     init_vulkan,
43724     vk_is_available_instance_function32,
43725     vk_is_available_device_function32,
43726     thunk32_vkAcquireNextImage2KHR,
43727     thunk32_vkAcquireNextImageKHR,
43728     thunk32_vkAcquirePerformanceConfigurationINTEL,
43729     thunk32_vkAcquireProfilingLockKHR,
43730     thunk32_vkAllocateCommandBuffers,
43731     thunk32_vkAllocateDescriptorSets,
43732     thunk32_vkAllocateMemory,
43733     thunk32_vkBeginCommandBuffer,
43734     thunk32_vkBindAccelerationStructureMemoryNV,
43735     thunk32_vkBindBufferMemory,
43736     thunk32_vkBindBufferMemory2,
43737     thunk32_vkBindBufferMemory2KHR,
43738     thunk32_vkBindImageMemory,
43739     thunk32_vkBindImageMemory2,
43740     thunk32_vkBindImageMemory2KHR,
43741     thunk32_vkBindOpticalFlowSessionImageNV,
43742     thunk32_vkBuildAccelerationStructuresKHR,
43743     thunk32_vkBuildMicromapsEXT,
43744     (void *)thunk32_vkCmdBeginConditionalRenderingEXT,
43745     (void *)thunk32_vkCmdBeginDebugUtilsLabelEXT,
43746     (void *)thunk32_vkCmdBeginQuery,
43747     (void *)thunk32_vkCmdBeginQueryIndexedEXT,
43748     (void *)thunk32_vkCmdBeginRenderPass,
43749     (void *)thunk32_vkCmdBeginRenderPass2,
43750     (void *)thunk32_vkCmdBeginRenderPass2KHR,
43751     (void *)thunk32_vkCmdBeginRendering,
43752     (void *)thunk32_vkCmdBeginRenderingKHR,
43753     (void *)thunk32_vkCmdBeginTransformFeedbackEXT,
43754     (void *)thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
43755     (void *)thunk32_vkCmdBindDescriptorBuffersEXT,
43756     (void *)thunk32_vkCmdBindDescriptorSets,
43757     (void *)thunk32_vkCmdBindIndexBuffer,
43758     (void *)thunk32_vkCmdBindIndexBuffer2KHR,
43759     (void *)thunk32_vkCmdBindInvocationMaskHUAWEI,
43760     (void *)thunk32_vkCmdBindPipeline,
43761     (void *)thunk32_vkCmdBindPipelineShaderGroupNV,
43762     (void *)thunk32_vkCmdBindShadersEXT,
43763     (void *)thunk32_vkCmdBindShadingRateImageNV,
43764     (void *)thunk32_vkCmdBindTransformFeedbackBuffersEXT,
43765     (void *)thunk32_vkCmdBindVertexBuffers,
43766     (void *)thunk32_vkCmdBindVertexBuffers2,
43767     (void *)thunk32_vkCmdBindVertexBuffers2EXT,
43768     (void *)thunk32_vkCmdBlitImage,
43769     (void *)thunk32_vkCmdBlitImage2,
43770     (void *)thunk32_vkCmdBlitImage2KHR,
43771     (void *)thunk32_vkCmdBuildAccelerationStructureNV,
43772     (void *)thunk32_vkCmdBuildAccelerationStructuresIndirectKHR,
43773     (void *)thunk32_vkCmdBuildAccelerationStructuresKHR,
43774     (void *)thunk32_vkCmdBuildMicromapsEXT,
43775     (void *)thunk32_vkCmdClearAttachments,
43776     (void *)thunk32_vkCmdClearColorImage,
43777     (void *)thunk32_vkCmdClearDepthStencilImage,
43778     (void *)thunk32_vkCmdCopyAccelerationStructureKHR,
43779     (void *)thunk32_vkCmdCopyAccelerationStructureNV,
43780     (void *)thunk32_vkCmdCopyAccelerationStructureToMemoryKHR,
43781     (void *)thunk32_vkCmdCopyBuffer,
43782     (void *)thunk32_vkCmdCopyBuffer2,
43783     (void *)thunk32_vkCmdCopyBuffer2KHR,
43784     (void *)thunk32_vkCmdCopyBufferToImage,
43785     (void *)thunk32_vkCmdCopyBufferToImage2,
43786     (void *)thunk32_vkCmdCopyBufferToImage2KHR,
43787     (void *)thunk32_vkCmdCopyImage,
43788     (void *)thunk32_vkCmdCopyImage2,
43789     (void *)thunk32_vkCmdCopyImage2KHR,
43790     (void *)thunk32_vkCmdCopyImageToBuffer,
43791     (void *)thunk32_vkCmdCopyImageToBuffer2,
43792     (void *)thunk32_vkCmdCopyImageToBuffer2KHR,
43793     (void *)thunk32_vkCmdCopyMemoryIndirectNV,
43794     (void *)thunk32_vkCmdCopyMemoryToAccelerationStructureKHR,
43795     (void *)thunk32_vkCmdCopyMemoryToImageIndirectNV,
43796     (void *)thunk32_vkCmdCopyMemoryToMicromapEXT,
43797     (void *)thunk32_vkCmdCopyMicromapEXT,
43798     (void *)thunk32_vkCmdCopyMicromapToMemoryEXT,
43799     (void *)thunk32_vkCmdCopyQueryPoolResults,
43800     (void *)thunk32_vkCmdCuLaunchKernelNVX,
43801     (void *)thunk32_vkCmdDebugMarkerBeginEXT,
43802     (void *)thunk32_vkCmdDebugMarkerEndEXT,
43803     (void *)thunk32_vkCmdDebugMarkerInsertEXT,
43804     (void *)thunk32_vkCmdDecompressMemoryIndirectCountNV,
43805     (void *)thunk32_vkCmdDecompressMemoryNV,
43806     (void *)thunk32_vkCmdDispatch,
43807     (void *)thunk32_vkCmdDispatchBase,
43808     (void *)thunk32_vkCmdDispatchBaseKHR,
43809     (void *)thunk32_vkCmdDispatchIndirect,
43810     (void *)thunk32_vkCmdDraw,
43811     (void *)thunk32_vkCmdDrawClusterHUAWEI,
43812     (void *)thunk32_vkCmdDrawClusterIndirectHUAWEI,
43813     (void *)thunk32_vkCmdDrawIndexed,
43814     (void *)thunk32_vkCmdDrawIndexedIndirect,
43815     (void *)thunk32_vkCmdDrawIndexedIndirectCount,
43816     (void *)thunk32_vkCmdDrawIndexedIndirectCountAMD,
43817     (void *)thunk32_vkCmdDrawIndexedIndirectCountKHR,
43818     (void *)thunk32_vkCmdDrawIndirect,
43819     (void *)thunk32_vkCmdDrawIndirectByteCountEXT,
43820     (void *)thunk32_vkCmdDrawIndirectCount,
43821     (void *)thunk32_vkCmdDrawIndirectCountAMD,
43822     (void *)thunk32_vkCmdDrawIndirectCountKHR,
43823     (void *)thunk32_vkCmdDrawMeshTasksEXT,
43824     (void *)thunk32_vkCmdDrawMeshTasksIndirectCountEXT,
43825     (void *)thunk32_vkCmdDrawMeshTasksIndirectCountNV,
43826     (void *)thunk32_vkCmdDrawMeshTasksIndirectEXT,
43827     (void *)thunk32_vkCmdDrawMeshTasksIndirectNV,
43828     (void *)thunk32_vkCmdDrawMeshTasksNV,
43829     (void *)thunk32_vkCmdDrawMultiEXT,
43830     (void *)thunk32_vkCmdDrawMultiIndexedEXT,
43831     (void *)thunk32_vkCmdEndConditionalRenderingEXT,
43832     (void *)thunk32_vkCmdEndDebugUtilsLabelEXT,
43833     (void *)thunk32_vkCmdEndQuery,
43834     (void *)thunk32_vkCmdEndQueryIndexedEXT,
43835     (void *)thunk32_vkCmdEndRenderPass,
43836     (void *)thunk32_vkCmdEndRenderPass2,
43837     (void *)thunk32_vkCmdEndRenderPass2KHR,
43838     (void *)thunk32_vkCmdEndRendering,
43839     (void *)thunk32_vkCmdEndRenderingKHR,
43840     (void *)thunk32_vkCmdEndTransformFeedbackEXT,
43841     (void *)thunk32_vkCmdExecuteCommands,
43842     (void *)thunk32_vkCmdExecuteGeneratedCommandsNV,
43843     (void *)thunk32_vkCmdFillBuffer,
43844     (void *)thunk32_vkCmdInsertDebugUtilsLabelEXT,
43845     (void *)thunk32_vkCmdNextSubpass,
43846     (void *)thunk32_vkCmdNextSubpass2,
43847     (void *)thunk32_vkCmdNextSubpass2KHR,
43848     (void *)thunk32_vkCmdOpticalFlowExecuteNV,
43849     (void *)thunk32_vkCmdPipelineBarrier,
43850     (void *)thunk32_vkCmdPipelineBarrier2,
43851     (void *)thunk32_vkCmdPipelineBarrier2KHR,
43852     (void *)thunk32_vkCmdPreprocessGeneratedCommandsNV,
43853     (void *)thunk32_vkCmdPushConstants,
43854     (void *)thunk32_vkCmdPushDescriptorSetKHR,
43855     (void *)thunk32_vkCmdPushDescriptorSetWithTemplateKHR,
43856     (void *)thunk32_vkCmdResetEvent,
43857     (void *)thunk32_vkCmdResetEvent2,
43858     (void *)thunk32_vkCmdResetEvent2KHR,
43859     (void *)thunk32_vkCmdResetQueryPool,
43860     (void *)thunk32_vkCmdResolveImage,
43861     (void *)thunk32_vkCmdResolveImage2,
43862     (void *)thunk32_vkCmdResolveImage2KHR,
43863     (void *)thunk32_vkCmdSetAlphaToCoverageEnableEXT,
43864     (void *)thunk32_vkCmdSetAlphaToOneEnableEXT,
43865     (void *)thunk32_vkCmdSetAttachmentFeedbackLoopEnableEXT,
43866     (void *)thunk32_vkCmdSetBlendConstants,
43867     (void *)thunk32_vkCmdSetCheckpointNV,
43868     (void *)thunk32_vkCmdSetCoarseSampleOrderNV,
43869     (void *)thunk32_vkCmdSetColorBlendAdvancedEXT,
43870     (void *)thunk32_vkCmdSetColorBlendEnableEXT,
43871     (void *)thunk32_vkCmdSetColorBlendEquationEXT,
43872     (void *)thunk32_vkCmdSetColorWriteEnableEXT,
43873     (void *)thunk32_vkCmdSetColorWriteMaskEXT,
43874     (void *)thunk32_vkCmdSetConservativeRasterizationModeEXT,
43875     (void *)thunk32_vkCmdSetCoverageModulationModeNV,
43876     (void *)thunk32_vkCmdSetCoverageModulationTableEnableNV,
43877     (void *)thunk32_vkCmdSetCoverageModulationTableNV,
43878     (void *)thunk32_vkCmdSetCoverageReductionModeNV,
43879     (void *)thunk32_vkCmdSetCoverageToColorEnableNV,
43880     (void *)thunk32_vkCmdSetCoverageToColorLocationNV,
43881     (void *)thunk32_vkCmdSetCullMode,
43882     (void *)thunk32_vkCmdSetCullModeEXT,
43883     (void *)thunk32_vkCmdSetDepthBias,
43884     (void *)thunk32_vkCmdSetDepthBias2EXT,
43885     (void *)thunk32_vkCmdSetDepthBiasEnable,
43886     (void *)thunk32_vkCmdSetDepthBiasEnableEXT,
43887     (void *)thunk32_vkCmdSetDepthBounds,
43888     (void *)thunk32_vkCmdSetDepthBoundsTestEnable,
43889     (void *)thunk32_vkCmdSetDepthBoundsTestEnableEXT,
43890     (void *)thunk32_vkCmdSetDepthClampEnableEXT,
43891     (void *)thunk32_vkCmdSetDepthClipEnableEXT,
43892     (void *)thunk32_vkCmdSetDepthClipNegativeOneToOneEXT,
43893     (void *)thunk32_vkCmdSetDepthCompareOp,
43894     (void *)thunk32_vkCmdSetDepthCompareOpEXT,
43895     (void *)thunk32_vkCmdSetDepthTestEnable,
43896     (void *)thunk32_vkCmdSetDepthTestEnableEXT,
43897     (void *)thunk32_vkCmdSetDepthWriteEnable,
43898     (void *)thunk32_vkCmdSetDepthWriteEnableEXT,
43899     (void *)thunk32_vkCmdSetDescriptorBufferOffsetsEXT,
43900     (void *)thunk32_vkCmdSetDeviceMask,
43901     (void *)thunk32_vkCmdSetDeviceMaskKHR,
43902     (void *)thunk32_vkCmdSetDiscardRectangleEXT,
43903     (void *)thunk32_vkCmdSetDiscardRectangleEnableEXT,
43904     (void *)thunk32_vkCmdSetDiscardRectangleModeEXT,
43905     (void *)thunk32_vkCmdSetEvent,
43906     (void *)thunk32_vkCmdSetEvent2,
43907     (void *)thunk32_vkCmdSetEvent2KHR,
43908     (void *)thunk32_vkCmdSetExclusiveScissorEnableNV,
43909     (void *)thunk32_vkCmdSetExclusiveScissorNV,
43910     (void *)thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
43911     (void *)thunk32_vkCmdSetFragmentShadingRateEnumNV,
43912     (void *)thunk32_vkCmdSetFragmentShadingRateKHR,
43913     (void *)thunk32_vkCmdSetFrontFace,
43914     (void *)thunk32_vkCmdSetFrontFaceEXT,
43915     (void *)thunk32_vkCmdSetLineRasterizationModeEXT,
43916     (void *)thunk32_vkCmdSetLineStippleEXT,
43917     (void *)thunk32_vkCmdSetLineStippleEnableEXT,
43918     (void *)thunk32_vkCmdSetLineWidth,
43919     (void *)thunk32_vkCmdSetLogicOpEXT,
43920     (void *)thunk32_vkCmdSetLogicOpEnableEXT,
43921     (void *)thunk32_vkCmdSetPatchControlPointsEXT,
43922     thunk32_vkCmdSetPerformanceMarkerINTEL,
43923     thunk32_vkCmdSetPerformanceOverrideINTEL,
43924     thunk32_vkCmdSetPerformanceStreamMarkerINTEL,
43925     (void *)thunk32_vkCmdSetPolygonModeEXT,
43926     (void *)thunk32_vkCmdSetPrimitiveRestartEnable,
43927     (void *)thunk32_vkCmdSetPrimitiveRestartEnableEXT,
43928     (void *)thunk32_vkCmdSetPrimitiveTopology,
43929     (void *)thunk32_vkCmdSetPrimitiveTopologyEXT,
43930     (void *)thunk32_vkCmdSetProvokingVertexModeEXT,
43931     (void *)thunk32_vkCmdSetRasterizationSamplesEXT,
43932     (void *)thunk32_vkCmdSetRasterizationStreamEXT,
43933     (void *)thunk32_vkCmdSetRasterizerDiscardEnable,
43934     (void *)thunk32_vkCmdSetRasterizerDiscardEnableEXT,
43935     (void *)thunk32_vkCmdSetRayTracingPipelineStackSizeKHR,
43936     (void *)thunk32_vkCmdSetRepresentativeFragmentTestEnableNV,
43937     (void *)thunk32_vkCmdSetSampleLocationsEXT,
43938     (void *)thunk32_vkCmdSetSampleLocationsEnableEXT,
43939     (void *)thunk32_vkCmdSetSampleMaskEXT,
43940     (void *)thunk32_vkCmdSetScissor,
43941     (void *)thunk32_vkCmdSetScissorWithCount,
43942     (void *)thunk32_vkCmdSetScissorWithCountEXT,
43943     (void *)thunk32_vkCmdSetShadingRateImageEnableNV,
43944     (void *)thunk32_vkCmdSetStencilCompareMask,
43945     (void *)thunk32_vkCmdSetStencilOp,
43946     (void *)thunk32_vkCmdSetStencilOpEXT,
43947     (void *)thunk32_vkCmdSetStencilReference,
43948     (void *)thunk32_vkCmdSetStencilTestEnable,
43949     (void *)thunk32_vkCmdSetStencilTestEnableEXT,
43950     (void *)thunk32_vkCmdSetStencilWriteMask,
43951     (void *)thunk32_vkCmdSetTessellationDomainOriginEXT,
43952     (void *)thunk32_vkCmdSetVertexInputEXT,
43953     (void *)thunk32_vkCmdSetViewport,
43954     (void *)thunk32_vkCmdSetViewportShadingRatePaletteNV,
43955     (void *)thunk32_vkCmdSetViewportSwizzleNV,
43956     (void *)thunk32_vkCmdSetViewportWScalingEnableNV,
43957     (void *)thunk32_vkCmdSetViewportWScalingNV,
43958     (void *)thunk32_vkCmdSetViewportWithCount,
43959     (void *)thunk32_vkCmdSetViewportWithCountEXT,
43960     (void *)thunk32_vkCmdSubpassShadingHUAWEI,
43961     (void *)thunk32_vkCmdTraceRaysIndirect2KHR,
43962     (void *)thunk32_vkCmdTraceRaysIndirectKHR,
43963     (void *)thunk32_vkCmdTraceRaysKHR,
43964     (void *)thunk32_vkCmdTraceRaysNV,
43965     (void *)thunk32_vkCmdUpdateBuffer,
43966     (void *)thunk32_vkCmdUpdatePipelineIndirectBufferNV,
43967     (void *)thunk32_vkCmdWaitEvents,
43968     (void *)thunk32_vkCmdWaitEvents2,
43969     (void *)thunk32_vkCmdWaitEvents2KHR,
43970     (void *)thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR,
43971     (void *)thunk32_vkCmdWriteAccelerationStructuresPropertiesNV,
43972     (void *)thunk32_vkCmdWriteBufferMarker2AMD,
43973     (void *)thunk32_vkCmdWriteBufferMarkerAMD,
43974     (void *)thunk32_vkCmdWriteMicromapsPropertiesEXT,
43975     (void *)thunk32_vkCmdWriteTimestamp,
43976     (void *)thunk32_vkCmdWriteTimestamp2,
43977     (void *)thunk32_vkCmdWriteTimestamp2KHR,
43978     thunk32_vkCompileDeferredNV,
43979     thunk32_vkCopyAccelerationStructureKHR,
43980     thunk32_vkCopyAccelerationStructureToMemoryKHR,
43981     thunk32_vkCopyImageToImageEXT,
43982     thunk32_vkCopyImageToMemoryEXT,
43983     thunk32_vkCopyMemoryToAccelerationStructureKHR,
43984     thunk32_vkCopyMemoryToImageEXT,
43985     thunk32_vkCopyMemoryToMicromapEXT,
43986     thunk32_vkCopyMicromapEXT,
43987     thunk32_vkCopyMicromapToMemoryEXT,
43988     thunk32_vkCreateAccelerationStructureKHR,
43989     thunk32_vkCreateAccelerationStructureNV,
43990     thunk32_vkCreateBuffer,
43991     thunk32_vkCreateBufferView,
43992     thunk32_vkCreateCommandPool,
43993     thunk32_vkCreateComputePipelines,
43994     thunk32_vkCreateCuFunctionNVX,
43995     thunk32_vkCreateCuModuleNVX,
43996     thunk32_vkCreateDebugReportCallbackEXT,
43997     thunk32_vkCreateDebugUtilsMessengerEXT,
43998     thunk32_vkCreateDeferredOperationKHR,
43999     thunk32_vkCreateDescriptorPool,
44000     thunk32_vkCreateDescriptorSetLayout,
44001     thunk32_vkCreateDescriptorUpdateTemplate,
44002     thunk32_vkCreateDescriptorUpdateTemplateKHR,
44003     thunk32_vkCreateDevice,
44004     thunk32_vkCreateEvent,
44005     thunk32_vkCreateFence,
44006     thunk32_vkCreateFramebuffer,
44007     thunk32_vkCreateGraphicsPipelines,
44008     thunk32_vkCreateImage,
44009     thunk32_vkCreateImageView,
44010     thunk32_vkCreateIndirectCommandsLayoutNV,
44011     thunk32_vkCreateInstance,
44012     thunk32_vkCreateMicromapEXT,
44013     thunk32_vkCreateOpticalFlowSessionNV,
44014     thunk32_vkCreatePipelineCache,
44015     thunk32_vkCreatePipelineLayout,
44016     thunk32_vkCreatePrivateDataSlot,
44017     thunk32_vkCreatePrivateDataSlotEXT,
44018     thunk32_vkCreateQueryPool,
44019     thunk32_vkCreateRayTracingPipelinesKHR,
44020     thunk32_vkCreateRayTracingPipelinesNV,
44021     thunk32_vkCreateRenderPass,
44022     thunk32_vkCreateRenderPass2,
44023     thunk32_vkCreateRenderPass2KHR,
44024     thunk32_vkCreateSampler,
44025     thunk32_vkCreateSamplerYcbcrConversion,
44026     thunk32_vkCreateSamplerYcbcrConversionKHR,
44027     thunk32_vkCreateSemaphore,
44028     thunk32_vkCreateShaderModule,
44029     thunk32_vkCreateShadersEXT,
44030     thunk32_vkCreateSwapchainKHR,
44031     thunk32_vkCreateValidationCacheEXT,
44032     thunk32_vkCreateWin32SurfaceKHR,
44033     thunk32_vkDebugMarkerSetObjectNameEXT,
44034     thunk32_vkDebugMarkerSetObjectTagEXT,
44035     thunk32_vkDebugReportMessageEXT,
44036     thunk32_vkDeferredOperationJoinKHR,
44037     thunk32_vkDestroyAccelerationStructureKHR,
44038     thunk32_vkDestroyAccelerationStructureNV,
44039     thunk32_vkDestroyBuffer,
44040     thunk32_vkDestroyBufferView,
44041     thunk32_vkDestroyCommandPool,
44042     thunk32_vkDestroyCuFunctionNVX,
44043     thunk32_vkDestroyCuModuleNVX,
44044     thunk32_vkDestroyDebugReportCallbackEXT,
44045     thunk32_vkDestroyDebugUtilsMessengerEXT,
44046     thunk32_vkDestroyDeferredOperationKHR,
44047     thunk32_vkDestroyDescriptorPool,
44048     thunk32_vkDestroyDescriptorSetLayout,
44049     thunk32_vkDestroyDescriptorUpdateTemplate,
44050     thunk32_vkDestroyDescriptorUpdateTemplateKHR,
44051     thunk32_vkDestroyDevice,
44052     thunk32_vkDestroyEvent,
44053     thunk32_vkDestroyFence,
44054     thunk32_vkDestroyFramebuffer,
44055     thunk32_vkDestroyImage,
44056     thunk32_vkDestroyImageView,
44057     thunk32_vkDestroyIndirectCommandsLayoutNV,
44058     thunk32_vkDestroyInstance,
44059     thunk32_vkDestroyMicromapEXT,
44060     thunk32_vkDestroyOpticalFlowSessionNV,
44061     thunk32_vkDestroyPipeline,
44062     thunk32_vkDestroyPipelineCache,
44063     thunk32_vkDestroyPipelineLayout,
44064     thunk32_vkDestroyPrivateDataSlot,
44065     thunk32_vkDestroyPrivateDataSlotEXT,
44066     thunk32_vkDestroyQueryPool,
44067     thunk32_vkDestroyRenderPass,
44068     thunk32_vkDestroySampler,
44069     thunk32_vkDestroySamplerYcbcrConversion,
44070     thunk32_vkDestroySamplerYcbcrConversionKHR,
44071     thunk32_vkDestroySemaphore,
44072     thunk32_vkDestroyShaderEXT,
44073     thunk32_vkDestroyShaderModule,
44074     thunk32_vkDestroySurfaceKHR,
44075     thunk32_vkDestroySwapchainKHR,
44076     thunk32_vkDestroyValidationCacheEXT,
44077     thunk32_vkDeviceWaitIdle,
44078     thunk32_vkEndCommandBuffer,
44079     thunk32_vkEnumerateDeviceExtensionProperties,
44080     thunk32_vkEnumerateDeviceLayerProperties,
44081     thunk32_vkEnumerateInstanceExtensionProperties,
44082     thunk32_vkEnumerateInstanceVersion,
44083     thunk32_vkEnumeratePhysicalDeviceGroups,
44084     thunk32_vkEnumeratePhysicalDeviceGroupsKHR,
44085     thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
44086     thunk32_vkEnumeratePhysicalDevices,
44087     thunk32_vkFlushMappedMemoryRanges,
44088     thunk32_vkFreeCommandBuffers,
44089     thunk32_vkFreeDescriptorSets,
44090     thunk32_vkFreeMemory,
44091     thunk32_vkGetAccelerationStructureBuildSizesKHR,
44092     thunk32_vkGetAccelerationStructureDeviceAddressKHR,
44093     thunk32_vkGetAccelerationStructureHandleNV,
44094     thunk32_vkGetAccelerationStructureMemoryRequirementsNV,
44095     thunk32_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
44096     thunk32_vkGetBufferDeviceAddress,
44097     thunk32_vkGetBufferDeviceAddressEXT,
44098     thunk32_vkGetBufferDeviceAddressKHR,
44099     thunk32_vkGetBufferMemoryRequirements,
44100     thunk32_vkGetBufferMemoryRequirements2,
44101     thunk32_vkGetBufferMemoryRequirements2KHR,
44102     thunk32_vkGetBufferOpaqueCaptureAddress,
44103     thunk32_vkGetBufferOpaqueCaptureAddressKHR,
44104     thunk32_vkGetBufferOpaqueCaptureDescriptorDataEXT,
44105     thunk32_vkGetCalibratedTimestampsEXT,
44106     thunk32_vkGetDeferredOperationMaxConcurrencyKHR,
44107     thunk32_vkGetDeferredOperationResultKHR,
44108     (void *)thunk32_vkGetDescriptorEXT,
44109     thunk32_vkGetDescriptorSetHostMappingVALVE,
44110     thunk32_vkGetDescriptorSetLayoutBindingOffsetEXT,
44111     thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
44112     thunk32_vkGetDescriptorSetLayoutSizeEXT,
44113     thunk32_vkGetDescriptorSetLayoutSupport,
44114     thunk32_vkGetDescriptorSetLayoutSupportKHR,
44115     thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR,
44116     thunk32_vkGetDeviceBufferMemoryRequirements,
44117     thunk32_vkGetDeviceBufferMemoryRequirementsKHR,
44118     thunk32_vkGetDeviceFaultInfoEXT,
44119     thunk32_vkGetDeviceGroupPeerMemoryFeatures,
44120     thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR,
44121     thunk32_vkGetDeviceGroupPresentCapabilitiesKHR,
44122     thunk32_vkGetDeviceGroupSurfacePresentModesKHR,
44123     thunk32_vkGetDeviceImageMemoryRequirements,
44124     thunk32_vkGetDeviceImageMemoryRequirementsKHR,
44125     thunk32_vkGetDeviceImageSparseMemoryRequirements,
44126     thunk32_vkGetDeviceImageSparseMemoryRequirementsKHR,
44127     thunk32_vkGetDeviceImageSubresourceLayoutKHR,
44128     thunk32_vkGetDeviceMemoryCommitment,
44129     thunk32_vkGetDeviceMemoryOpaqueCaptureAddress,
44130     thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
44131     thunk32_vkGetDeviceMicromapCompatibilityEXT,
44132     thunk32_vkGetDeviceQueue,
44133     thunk32_vkGetDeviceQueue2,
44134     thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
44135     thunk32_vkGetDynamicRenderingTilePropertiesQCOM,
44136     thunk32_vkGetEventStatus,
44137     thunk32_vkGetFenceStatus,
44138     thunk32_vkGetFramebufferTilePropertiesQCOM,
44139     thunk32_vkGetGeneratedCommandsMemoryRequirementsNV,
44140     thunk32_vkGetImageMemoryRequirements,
44141     thunk32_vkGetImageMemoryRequirements2,
44142     thunk32_vkGetImageMemoryRequirements2KHR,
44143     thunk32_vkGetImageOpaqueCaptureDescriptorDataEXT,
44144     thunk32_vkGetImageSparseMemoryRequirements,
44145     thunk32_vkGetImageSparseMemoryRequirements2,
44146     thunk32_vkGetImageSparseMemoryRequirements2KHR,
44147     thunk32_vkGetImageSubresourceLayout,
44148     thunk32_vkGetImageSubresourceLayout2EXT,
44149     thunk32_vkGetImageSubresourceLayout2KHR,
44150     thunk32_vkGetImageViewAddressNVX,
44151     thunk32_vkGetImageViewHandleNVX,
44152     thunk32_vkGetImageViewOpaqueCaptureDescriptorDataEXT,
44153     thunk32_vkGetMemoryHostPointerPropertiesEXT,
44154     thunk32_vkGetMicromapBuildSizesEXT,
44155     thunk32_vkGetPerformanceParameterINTEL,
44156     thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
44157     thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR,
44158     thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
44159     thunk32_vkGetPhysicalDeviceExternalBufferProperties,
44160     thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
44161     thunk32_vkGetPhysicalDeviceExternalFenceProperties,
44162     thunk32_vkGetPhysicalDeviceExternalFencePropertiesKHR,
44163     thunk32_vkGetPhysicalDeviceExternalSemaphoreProperties,
44164     thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
44165     thunk32_vkGetPhysicalDeviceFeatures,
44166     thunk32_vkGetPhysicalDeviceFeatures2,
44167     thunk32_vkGetPhysicalDeviceFeatures2KHR,
44168     thunk32_vkGetPhysicalDeviceFormatProperties,
44169     thunk32_vkGetPhysicalDeviceFormatProperties2,
44170     thunk32_vkGetPhysicalDeviceFormatProperties2KHR,
44171     thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR,
44172     thunk32_vkGetPhysicalDeviceImageFormatProperties,
44173     thunk32_vkGetPhysicalDeviceImageFormatProperties2,
44174     thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR,
44175     thunk32_vkGetPhysicalDeviceMemoryProperties,
44176     thunk32_vkGetPhysicalDeviceMemoryProperties2,
44177     thunk32_vkGetPhysicalDeviceMemoryProperties2KHR,
44178     thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT,
44179     thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
44180     thunk32_vkGetPhysicalDevicePresentRectanglesKHR,
44181     thunk32_vkGetPhysicalDeviceProperties,
44182     thunk32_vkGetPhysicalDeviceProperties2,
44183     thunk32_vkGetPhysicalDeviceProperties2KHR,
44184     thunk32_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
44185     thunk32_vkGetPhysicalDeviceQueueFamilyProperties,
44186     thunk32_vkGetPhysicalDeviceQueueFamilyProperties2,
44187     thunk32_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
44188     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties,
44189     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2,
44190     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
44191     thunk32_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
44192     thunk32_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
44193     thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
44194     thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR,
44195     thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR,
44196     thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR,
44197     thunk32_vkGetPhysicalDeviceSurfaceSupportKHR,
44198     thunk32_vkGetPhysicalDeviceToolProperties,
44199     thunk32_vkGetPhysicalDeviceToolPropertiesEXT,
44200     thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR,
44201     thunk32_vkGetPipelineCacheData,
44202     thunk32_vkGetPipelineExecutableInternalRepresentationsKHR,
44203     thunk32_vkGetPipelineExecutablePropertiesKHR,
44204     thunk32_vkGetPipelineExecutableStatisticsKHR,
44205     thunk32_vkGetPipelineIndirectDeviceAddressNV,
44206     thunk32_vkGetPipelineIndirectMemoryRequirementsNV,
44207     thunk32_vkGetPipelinePropertiesEXT,
44208     thunk32_vkGetPrivateData,
44209     thunk32_vkGetPrivateDataEXT,
44210     thunk32_vkGetQueryPoolResults,
44211     thunk32_vkGetQueueCheckpointData2NV,
44212     thunk32_vkGetQueueCheckpointDataNV,
44213     thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
44214     thunk32_vkGetRayTracingShaderGroupHandlesKHR,
44215     thunk32_vkGetRayTracingShaderGroupHandlesNV,
44216     thunk32_vkGetRayTracingShaderGroupStackSizeKHR,
44217     thunk32_vkGetRenderAreaGranularity,
44218     thunk32_vkGetRenderingAreaGranularityKHR,
44219     thunk32_vkGetSamplerOpaqueCaptureDescriptorDataEXT,
44220     thunk32_vkGetSemaphoreCounterValue,
44221     thunk32_vkGetSemaphoreCounterValueKHR,
44222     thunk32_vkGetShaderBinaryDataEXT,
44223     thunk32_vkGetShaderInfoAMD,
44224     thunk32_vkGetShaderModuleCreateInfoIdentifierEXT,
44225     thunk32_vkGetShaderModuleIdentifierEXT,
44226     thunk32_vkGetSwapchainImagesKHR,
44227     thunk32_vkGetValidationCacheDataEXT,
44228     thunk32_vkInitializePerformanceApiINTEL,
44229     thunk32_vkInvalidateMappedMemoryRanges,
44230     thunk32_vkMapMemory,
44231     thunk32_vkMapMemory2KHR,
44232     thunk32_vkMergePipelineCaches,
44233     thunk32_vkMergeValidationCachesEXT,
44234     thunk32_vkQueueBeginDebugUtilsLabelEXT,
44235     thunk32_vkQueueBindSparse,
44236     thunk32_vkQueueEndDebugUtilsLabelEXT,
44237     thunk32_vkQueueInsertDebugUtilsLabelEXT,
44238     thunk32_vkQueuePresentKHR,
44239     thunk32_vkQueueSetPerformanceConfigurationINTEL,
44240     thunk32_vkQueueSubmit,
44241     thunk32_vkQueueSubmit2,
44242     thunk32_vkQueueSubmit2KHR,
44243     thunk32_vkQueueWaitIdle,
44244     thunk32_vkReleasePerformanceConfigurationINTEL,
44245     thunk32_vkReleaseProfilingLockKHR,
44246     thunk32_vkReleaseSwapchainImagesEXT,
44247     thunk32_vkResetCommandBuffer,
44248     thunk32_vkResetCommandPool,
44249     thunk32_vkResetDescriptorPool,
44250     thunk32_vkResetEvent,
44251     thunk32_vkResetFences,
44252     thunk32_vkResetQueryPool,
44253     thunk32_vkResetQueryPoolEXT,
44254     thunk32_vkSetDebugUtilsObjectNameEXT,
44255     thunk32_vkSetDebugUtilsObjectTagEXT,
44256     thunk32_vkSetDeviceMemoryPriorityEXT,
44257     thunk32_vkSetEvent,
44258     thunk32_vkSetHdrMetadataEXT,
44259     thunk32_vkSetPrivateData,
44260     thunk32_vkSetPrivateDataEXT,
44261     thunk32_vkSignalSemaphore,
44262     thunk32_vkSignalSemaphoreKHR,
44263     thunk32_vkSubmitDebugUtilsMessageEXT,
44264     thunk32_vkTransitionImageLayoutEXT,
44265     thunk32_vkTrimCommandPool,
44266     thunk32_vkTrimCommandPoolKHR,
44267     thunk32_vkUninitializePerformanceApiINTEL,
44268     thunk32_vkUnmapMemory,
44269     thunk32_vkUnmapMemory2KHR,
44270     (void *)thunk32_vkUpdateDescriptorSetWithTemplate,
44271     thunk32_vkUpdateDescriptorSetWithTemplateKHR,
44272     (void *)thunk32_vkUpdateDescriptorSets,
44273     thunk32_vkWaitForFences,
44274     thunk32_vkWaitForPresentKHR,
44275     thunk32_vkWaitSemaphores,
44276     thunk32_vkWaitSemaphoresKHR,
44277     thunk32_vkWriteAccelerationStructuresPropertiesKHR,
44278     thunk32_vkWriteMicromapsPropertiesEXT,
44279 };
44280 C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);