dlls/winevulkan/vulkan_thunks.c

   1 /* Automatically generated from Vulkan vk.xml; DO NOT EDIT!
   2  *
   3  * This file is generated from Vulkan vk.xml file covered
   4  * by the following copyright and permission notice:
   5  *
   6  * Copyright 2015-2023 The Khronos Group Inc.
   7  *
   8  * SPDX-License-Identifier: Apache-2.0 OR MIT
   9  *
  10  */
  11
  12 #if 0
  13 #pragma makedep unix
  14 #endif
  15
  16 #include "config.h"
  17
  18 #include <stdlib.h>
  19
  20 #include "vulkan_private.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
  23
  24 typedef struct VkAcquireNextImageInfoKHR32
  25 {
  26     VkStructureType sType;
  27     PTR32 pNext;
  28     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
  29     uint64_t DECLSPEC_ALIGN(8) timeout;
  30     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
  31     VkFence DECLSPEC_ALIGN(8) fence;
  32     uint32_t deviceMask;
  33 } VkAcquireNextImageInfoKHR32;
  34
  35 typedef struct VkPerformanceConfigurationAcquireInfoINTEL32
  36 {
  37     VkStructureType sType;
  38     PTR32 pNext;
  39     VkPerformanceConfigurationTypeINTEL type;
  40 } VkPerformanceConfigurationAcquireInfoINTEL32;
  41
  42 typedef struct VkAcquireProfilingLockInfoKHR32
  43 {
  44     VkStructureType sType;
  45     PTR32 pNext;
  46     VkAcquireProfilingLockFlagsKHR flags;
  47     uint64_t DECLSPEC_ALIGN(8) timeout;
  48 } VkAcquireProfilingLockInfoKHR32;
  49
  50 typedef struct VkCommandBufferAllocateInfo32
  51 {
  52     VkStructureType sType;
  53     PTR32 pNext;
  54     VkCommandPool DECLSPEC_ALIGN(8) commandPool;
  55     VkCommandBufferLevel level;
  56     uint32_t commandBufferCount;
  57 } VkCommandBufferAllocateInfo32;
  58
  59 typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo32
  60 {
  61     VkStructureType sType;
  62     PTR32 pNext;
  63     uint32_t descriptorSetCount;
  64     PTR32 pDescriptorCounts;
  65 } VkDescriptorSetVariableDescriptorCountAllocateInfo32;
  66 typedef VkDescriptorSetVariableDescriptorCountAllocateInfo32 VkDescriptorSetVariableDescriptorCountAllocateInfoEXT32;
  67
  68 typedef struct VkDescriptorSetAllocateInfo32
  69 {
  70     VkStructureType sType;
  71     PTR32 pNext;
  72     VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
  73     uint32_t descriptorSetCount;
  74     PTR32 pSetLayouts;
  75 } VkDescriptorSetAllocateInfo32;
  76
  77 typedef struct VkDedicatedAllocationMemoryAllocateInfoNV32
  78 {
  79     VkStructureType sType;
  80     PTR32 pNext;
  81     VkImage DECLSPEC_ALIGN(8) image;
  82     VkBuffer DECLSPEC_ALIGN(8) buffer;
  83 } VkDedicatedAllocationMemoryAllocateInfoNV32;
  84
  85 typedef struct VkExportMemoryAllocateInfo32
  86 {
  87     VkStructureType sType;
  88     PTR32 pNext;
  89     VkExternalMemoryHandleTypeFlags handleTypes;
  90 } VkExportMemoryAllocateInfo32;
  91 typedef VkExportMemoryAllocateInfo32 VkExportMemoryAllocateInfoKHR32;
  92
  93 typedef struct VkImportMemoryWin32HandleInfoKHR32
  94 {
  95     VkStructureType sType;
  96     PTR32 pNext;
  97     VkExternalMemoryHandleTypeFlagBits handleType;
  98     HANDLE handle;
  99     LPCWSTR name;
 100 } VkImportMemoryWin32HandleInfoKHR32;
 101
 102 typedef struct VkExportMemoryWin32HandleInfoKHR32
 103 {
 104     VkStructureType sType;
 105     PTR32 pNext;
 106     PTR32 pAttributes;
 107     DWORD dwAccess;
 108     LPCWSTR name;
 109 } VkExportMemoryWin32HandleInfoKHR32;
 110
 111 typedef struct VkMemoryAllocateFlagsInfo32
 112 {
 113     VkStructureType sType;
 114     PTR32 pNext;
 115     VkMemoryAllocateFlags flags;
 116     uint32_t deviceMask;
 117 } VkMemoryAllocateFlagsInfo32;
 118 typedef VkMemoryAllocateFlagsInfo32 VkMemoryAllocateFlagsInfoKHR32;
 119
 120 typedef struct VkMemoryDedicatedAllocateInfo32
 121 {
 122     VkStructureType sType;
 123     PTR32 pNext;
 124     VkImage DECLSPEC_ALIGN(8) image;
 125     VkBuffer DECLSPEC_ALIGN(8) buffer;
 126 } VkMemoryDedicatedAllocateInfo32;
 127 typedef VkMemoryDedicatedAllocateInfo32 VkMemoryDedicatedAllocateInfoKHR32;
 128
 129 typedef struct VkImportMemoryHostPointerInfoEXT32
 130 {
 131     VkStructureType sType;
 132     PTR32 pNext;
 133     VkExternalMemoryHandleTypeFlagBits handleType;
 134     PTR32 pHostPointer;
 135 } VkImportMemoryHostPointerInfoEXT32;
 136
 137 typedef struct VkMemoryPriorityAllocateInfoEXT32
 138 {
 139     VkStructureType sType;
 140     PTR32 pNext;
 141     float priority;
 142 } VkMemoryPriorityAllocateInfoEXT32;
 143
 144 typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo32
 145 {
 146     VkStructureType sType;
 147     PTR32 pNext;
 148     uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
 149 } VkMemoryOpaqueCaptureAddressAllocateInfo32;
 150 typedef VkMemoryOpaqueCaptureAddressAllocateInfo32 VkMemoryOpaqueCaptureAddressAllocateInfoKHR32;
 151
 152 typedef struct VkMemoryAllocateInfo32
 153 {
 154     VkStructureType sType;
 155     PTR32 pNext;
 156     VkDeviceSize DECLSPEC_ALIGN(8) allocationSize;
 157     uint32_t memoryTypeIndex;
 158 } VkMemoryAllocateInfo32;
 159
 160 typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT32
 161 {
 162     VkStructureType sType;
 163     PTR32 pNext;
 164     VkBool32 conditionalRenderingEnable;
 165 } VkCommandBufferInheritanceConditionalRenderingInfoEXT32;
 166
 167 typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM32
 168 {
 169     VkStructureType sType;
 170     PTR32 pNext;
 171     VkSurfaceTransformFlagBitsKHR transform;
 172     VkRect2D renderArea;
 173 } VkCommandBufferInheritanceRenderPassTransformInfoQCOM32;
 174
 175 typedef struct VkCommandBufferInheritanceViewportScissorInfoNV32
 176 {
 177     VkStructureType sType;
 178     PTR32 pNext;
 179     VkBool32 viewportScissor2D;
 180     uint32_t viewportDepthCount;
 181     PTR32 pViewportDepths;
 182 } VkCommandBufferInheritanceViewportScissorInfoNV32;
 183
 184 typedef struct VkCommandBufferInheritanceRenderingInfo32
 185 {
 186     VkStructureType sType;
 187     PTR32 pNext;
 188     VkRenderingFlags flags;
 189     uint32_t viewMask;
 190     uint32_t colorAttachmentCount;
 191     PTR32 pColorAttachmentFormats;
 192     VkFormat depthAttachmentFormat;
 193     VkFormat stencilAttachmentFormat;
 194     VkSampleCountFlagBits rasterizationSamples;
 195 } VkCommandBufferInheritanceRenderingInfo32;
 196 typedef VkCommandBufferInheritanceRenderingInfo32 VkCommandBufferInheritanceRenderingInfoKHR32;
 197
 198 typedef struct VkAttachmentSampleCountInfoAMD32
 199 {
 200     VkStructureType sType;
 201     PTR32 pNext;
 202     uint32_t colorAttachmentCount;
 203     PTR32 pColorAttachmentSamples;
 204     VkSampleCountFlagBits depthStencilAttachmentSamples;
 205 } VkAttachmentSampleCountInfoAMD32;
 206 typedef VkAttachmentSampleCountInfoAMD32 VkAttachmentSampleCountInfoNV32;
 207
 208 typedef struct VkMultiviewPerViewAttributesInfoNVX32
 209 {
 210     VkStructureType sType;
 211     PTR32 pNext;
 212     VkBool32 perViewAttributes;
 213     VkBool32 perViewAttributesPositionXOnly;
 214 } VkMultiviewPerViewAttributesInfoNVX32;
 215
 216 typedef struct VkCommandBufferInheritanceInfo32
 217 {
 218     VkStructureType sType;
 219     PTR32 pNext;
 220     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
 221     uint32_t subpass;
 222     VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
 223     VkBool32 occlusionQueryEnable;
 224     VkQueryControlFlags queryFlags;
 225     VkQueryPipelineStatisticFlags pipelineStatistics;
 226 } VkCommandBufferInheritanceInfo32;
 227
 228 typedef struct VkDeviceGroupCommandBufferBeginInfo32
 229 {
 230     VkStructureType sType;
 231     PTR32 pNext;
 232     uint32_t deviceMask;
 233 } VkDeviceGroupCommandBufferBeginInfo32;
 234 typedef VkDeviceGroupCommandBufferBeginInfo32 VkDeviceGroupCommandBufferBeginInfoKHR32;
 235
 236 typedef struct VkCommandBufferBeginInfo32
 237 {
 238     VkStructureType sType;
 239     PTR32 pNext;
 240     VkCommandBufferUsageFlags flags;
 241     PTR32 pInheritanceInfo;
 242 } VkCommandBufferBeginInfo32;
 243
 244 typedef struct VkBindAccelerationStructureMemoryInfoNV32
 245 {
 246     VkStructureType sType;
 247     PTR32 pNext;
 248     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
 249     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
 250     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
 251     uint32_t deviceIndexCount;
 252     PTR32 pDeviceIndices;
 253 } VkBindAccelerationStructureMemoryInfoNV32;
 254
 255 typedef struct VkBindBufferMemoryDeviceGroupInfo32
 256 {
 257     VkStructureType sType;
 258     PTR32 pNext;
 259     uint32_t deviceIndexCount;
 260     PTR32 pDeviceIndices;
 261 } VkBindBufferMemoryDeviceGroupInfo32;
 262 typedef VkBindBufferMemoryDeviceGroupInfo32 VkBindBufferMemoryDeviceGroupInfoKHR32;
 263
 264 typedef struct VkBindBufferMemoryInfo32
 265 {
 266     VkStructureType sType;
 267     PTR32 pNext;
 268     VkBuffer DECLSPEC_ALIGN(8) buffer;
 269     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
 270     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
 271 } VkBindBufferMemoryInfo32;
 272 typedef VkBindBufferMemoryInfo32 VkBindBufferMemoryInfoKHR32;
 273
 274 typedef struct VkBindImageMemoryDeviceGroupInfo32
 275 {
 276     VkStructureType sType;
 277     PTR32 pNext;
 278     uint32_t deviceIndexCount;
 279     PTR32 pDeviceIndices;
 280     uint32_t splitInstanceBindRegionCount;
 281     PTR32 pSplitInstanceBindRegions;
 282 } VkBindImageMemoryDeviceGroupInfo32;
 283 typedef VkBindImageMemoryDeviceGroupInfo32 VkBindImageMemoryDeviceGroupInfoKHR32;
 284
 285 typedef struct VkBindImageMemorySwapchainInfoKHR32
 286 {
 287     VkStructureType sType;
 288     PTR32 pNext;
 289     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
 290     uint32_t imageIndex;
 291 } VkBindImageMemorySwapchainInfoKHR32;
 292
 293 typedef struct VkBindImagePlaneMemoryInfo32
 294 {
 295     VkStructureType sType;
 296     PTR32 pNext;
 297     VkImageAspectFlagBits planeAspect;
 298 } VkBindImagePlaneMemoryInfo32;
 299 typedef VkBindImagePlaneMemoryInfo32 VkBindImagePlaneMemoryInfoKHR32;
 300
 301 typedef struct VkBindImageMemoryInfo32
 302 {
 303     VkStructureType sType;
 304     PTR32 pNext;
 305     VkImage DECLSPEC_ALIGN(8) image;
 306     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
 307     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
 308 } VkBindImageMemoryInfo32;
 309 typedef VkBindImageMemoryInfo32 VkBindImageMemoryInfoKHR32;
 310
 311 typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV32
 312 {
 313     VkStructureType sType;
 314     PTR32 pNext;
 315     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData;
 316 } VkAccelerationStructureGeometryMotionTrianglesDataNV32;
 317
 318 typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT32
 319 {
 320     VkStructureType sType;
 321     PTR32 pNext;
 322     VkIndexType indexType;
 323     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexBuffer;
 324     VkDeviceSize DECLSPEC_ALIGN(8) indexStride;
 325     uint32_t baseTriangle;
 326     uint32_t usageCountsCount;
 327     PTR32 pUsageCounts;
 328     PTR32 ppUsageCounts;
 329     VkMicromapEXT DECLSPEC_ALIGN(8) micromap;
 330 } VkAccelerationStructureTrianglesOpacityMicromapEXT32;
 331
 332 typedef struct VkAccelerationStructureGeometryTrianglesDataKHR32
 333 {
 334     VkStructureType sType;
 335     PTR32 pNext;
 336     VkFormat vertexFormat;
 337     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData;
 338     VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
 339     uint32_t maxVertex;
 340     VkIndexType indexType;
 341     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexData;
 342     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) transformData;
 343 } VkAccelerationStructureGeometryTrianglesDataKHR32;
 344
 345 typedef struct VkAccelerationStructureGeometryAabbsDataKHR32
 346 {
 347     VkStructureType sType;
 348     PTR32 pNext;
 349     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
 350     VkDeviceSize DECLSPEC_ALIGN(8) stride;
 351 } VkAccelerationStructureGeometryAabbsDataKHR32;
 352
 353 typedef struct VkAccelerationStructureGeometryInstancesDataKHR32
 354 {
 355     VkStructureType sType;
 356     PTR32 pNext;
 357     VkBool32 arrayOfPointers;
 358     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
 359 } VkAccelerationStructureGeometryInstancesDataKHR32;
 360
 361 typedef union VkAccelerationStructureGeometryDataKHR32
 362 {
 363     VkAccelerationStructureGeometryTrianglesDataKHR32 DECLSPEC_ALIGN(8) triangles;
 364     VkAccelerationStructureGeometryAabbsDataKHR32 DECLSPEC_ALIGN(8) aabbs;
 365     VkAccelerationStructureGeometryInstancesDataKHR32 DECLSPEC_ALIGN(8) instances;
 366 } VkAccelerationStructureGeometryDataKHR32;
 367
 368 typedef struct VkAccelerationStructureGeometryKHR32
 369 {
 370     VkStructureType sType;
 371     PTR32 pNext;
 372     VkGeometryTypeKHR geometryType;
 373     VkAccelerationStructureGeometryDataKHR32 DECLSPEC_ALIGN(8) geometry;
 374     VkGeometryFlagsKHR flags;
 375 } VkAccelerationStructureGeometryKHR32;
 376
 377 typedef struct VkAccelerationStructureBuildGeometryInfoKHR32
 378 {
 379     VkStructureType sType;
 380     PTR32 pNext;
 381     VkAccelerationStructureTypeKHR type;
 382     VkBuildAccelerationStructureFlagsKHR flags;
 383     VkBuildAccelerationStructureModeKHR mode;
 384     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) srcAccelerationStructure;
 385     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dstAccelerationStructure;
 386     uint32_t geometryCount;
 387     PTR32 pGeometries;
 388     PTR32 ppGeometries;
 389     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData;
 390 } VkAccelerationStructureBuildGeometryInfoKHR32;
 391
 392 typedef struct VkMicromapBuildInfoEXT32
 393 {
 394     VkStructureType sType;
 395     PTR32 pNext;
 396     VkMicromapTypeEXT type;
 397     VkBuildMicromapFlagsEXT flags;
 398     VkBuildMicromapModeEXT mode;
 399     VkMicromapEXT DECLSPEC_ALIGN(8) dstMicromap;
 400     uint32_t usageCountsCount;
 401     PTR32 pUsageCounts;
 402     PTR32 ppUsageCounts;
 403     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
 404     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData;
 405     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) triangleArray;
 406     VkDeviceSize DECLSPEC_ALIGN(8) triangleArrayStride;
 407 } VkMicromapBuildInfoEXT32;
 408
 409 typedef struct VkConditionalRenderingBeginInfoEXT32
 410 {
 411     VkStructureType sType;
 412     PTR32 pNext;
 413     VkBuffer DECLSPEC_ALIGN(8) buffer;
 414     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 415     VkConditionalRenderingFlagsEXT flags;
 416 } VkConditionalRenderingBeginInfoEXT32;
 417
 418 typedef struct VkDebugUtilsLabelEXT32
 419 {
 420     VkStructureType sType;
 421     PTR32 pNext;
 422     PTR32 pLabelName;
 423     float color[4];
 424 } VkDebugUtilsLabelEXT32;
 425
 426 typedef struct VkSampleLocationsInfoEXT32
 427 {
 428     VkStructureType sType;
 429     PTR32 pNext;
 430     VkSampleCountFlagBits sampleLocationsPerPixel;
 431     VkExtent2D sampleLocationGridSize;
 432     uint32_t sampleLocationsCount;
 433     PTR32 pSampleLocations;
 434 } VkSampleLocationsInfoEXT32;
 435
 436 typedef struct VkAttachmentSampleLocationsEXT32
 437 {
 438     uint32_t attachmentIndex;
 439     VkSampleLocationsInfoEXT32 sampleLocationsInfo;
 440 } VkAttachmentSampleLocationsEXT32;
 441
 442 typedef struct VkSubpassSampleLocationsEXT32
 443 {
 444     uint32_t subpassIndex;
 445     VkSampleLocationsInfoEXT32 sampleLocationsInfo;
 446 } VkSubpassSampleLocationsEXT32;
 447
 448 typedef struct VkDeviceGroupRenderPassBeginInfo32
 449 {
 450     VkStructureType sType;
 451     PTR32 pNext;
 452     uint32_t deviceMask;
 453     uint32_t deviceRenderAreaCount;
 454     PTR32 pDeviceRenderAreas;
 455 } VkDeviceGroupRenderPassBeginInfo32;
 456 typedef VkDeviceGroupRenderPassBeginInfo32 VkDeviceGroupRenderPassBeginInfoKHR32;
 457
 458 typedef struct VkRenderPassSampleLocationsBeginInfoEXT32
 459 {
 460     VkStructureType sType;
 461     PTR32 pNext;
 462     uint32_t attachmentInitialSampleLocationsCount;
 463     PTR32 pAttachmentInitialSampleLocations;
 464     uint32_t postSubpassSampleLocationsCount;
 465     PTR32 pPostSubpassSampleLocations;
 466 } VkRenderPassSampleLocationsBeginInfoEXT32;
 467
 468 typedef struct VkRenderPassAttachmentBeginInfo32
 469 {
 470     VkStructureType sType;
 471     PTR32 pNext;
 472     uint32_t attachmentCount;
 473     PTR32 pAttachments;
 474 } VkRenderPassAttachmentBeginInfo32;
 475 typedef VkRenderPassAttachmentBeginInfo32 VkRenderPassAttachmentBeginInfoKHR32;
 476
 477 typedef struct VkRenderPassTransformBeginInfoQCOM32
 478 {
 479     VkStructureType sType;
 480     PTR32 pNext;
 481     VkSurfaceTransformFlagBitsKHR transform;
 482 } VkRenderPassTransformBeginInfoQCOM32;
 483
 484 typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32
 485 {
 486     VkStructureType sType;
 487     PTR32 pNext;
 488     uint32_t perViewRenderAreaCount;
 489     PTR32 pPerViewRenderAreas;
 490 } VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32;
 491
 492 typedef struct VkRenderPassBeginInfo32
 493 {
 494     VkStructureType sType;
 495     PTR32 pNext;
 496     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
 497     VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
 498     VkRect2D renderArea;
 499     uint32_t clearValueCount;
 500     PTR32 pClearValues;
 501 } VkRenderPassBeginInfo32;
 502
 503 typedef struct VkSubpassBeginInfo32
 504 {
 505     VkStructureType sType;
 506     PTR32 pNext;
 507     VkSubpassContents contents;
 508 } VkSubpassBeginInfo32;
 509 typedef VkSubpassBeginInfo32 VkSubpassBeginInfoKHR32;
 510
 511 typedef struct VkRenderingAttachmentInfo32
 512 {
 513     VkStructureType sType;
 514     PTR32 pNext;
 515     VkImageView DECLSPEC_ALIGN(8) imageView;
 516     VkImageLayout imageLayout;
 517     VkResolveModeFlagBits resolveMode;
 518     VkImageView DECLSPEC_ALIGN(8) resolveImageView;
 519     VkImageLayout resolveImageLayout;
 520     VkAttachmentLoadOp loadOp;
 521     VkAttachmentStoreOp storeOp;
 522     VkClearValue clearValue;
 523 } VkRenderingAttachmentInfo32;
 524 typedef VkRenderingAttachmentInfo32 VkRenderingAttachmentInfoKHR32;
 525
 526 typedef struct VkMultisampledRenderToSingleSampledInfoEXT32
 527 {
 528     VkStructureType sType;
 529     PTR32 pNext;
 530     VkBool32 multisampledRenderToSingleSampledEnable;
 531     VkSampleCountFlagBits rasterizationSamples;
 532 } VkMultisampledRenderToSingleSampledInfoEXT32;
 533
 534 typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR32
 535 {
 536     VkStructureType sType;
 537     PTR32 pNext;
 538     VkImageView DECLSPEC_ALIGN(8) imageView;
 539     VkImageLayout imageLayout;
 540     VkExtent2D shadingRateAttachmentTexelSize;
 541 } VkRenderingFragmentShadingRateAttachmentInfoKHR32;
 542
 543 typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT32
 544 {
 545     VkStructureType sType;
 546     PTR32 pNext;
 547     VkImageView DECLSPEC_ALIGN(8) imageView;
 548     VkImageLayout imageLayout;
 549 } VkRenderingFragmentDensityMapAttachmentInfoEXT32;
 550
 551 typedef struct VkRenderingInfo32
 552 {
 553     VkStructureType sType;
 554     PTR32 pNext;
 555     VkRenderingFlags flags;
 556     VkRect2D renderArea;
 557     uint32_t layerCount;
 558     uint32_t viewMask;
 559     uint32_t colorAttachmentCount;
 560     PTR32 pColorAttachments;
 561     PTR32 pDepthAttachment;
 562     PTR32 pStencilAttachment;
 563 } VkRenderingInfo32;
 564 typedef VkRenderingInfo32 VkRenderingInfoKHR32;
 565
 566 typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32
 567 {
 568     VkStructureType sType;
 569     PTR32 pNext;
 570     VkBuffer DECLSPEC_ALIGN(8) buffer;
 571 } VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32;
 572
 573 typedef struct VkDescriptorBufferBindingInfoEXT32
 574 {
 575     VkStructureType sType;
 576     PTR32 pNext;
 577     VkDeviceAddress DECLSPEC_ALIGN(8) address;
 578     VkBufferUsageFlags usage;
 579 } VkDescriptorBufferBindingInfoEXT32;
 580
 581 typedef struct VkCopyCommandTransformInfoQCOM32
 582 {
 583     VkStructureType sType;
 584     PTR32 pNext;
 585     VkSurfaceTransformFlagBitsKHR transform;
 586 } VkCopyCommandTransformInfoQCOM32;
 587
 588 typedef struct VkImageBlit232
 589 {
 590     VkStructureType sType;
 591     PTR32 pNext;
 592     VkImageSubresourceLayers srcSubresource;
 593     VkOffset3D srcOffsets[2];
 594     VkImageSubresourceLayers dstSubresource;
 595     VkOffset3D dstOffsets[2];
 596 } VkImageBlit232;
 597 typedef VkImageBlit232 VkImageBlit2KHR32;
 598
 599 typedef struct VkBlitImageInfo232
 600 {
 601     VkStructureType sType;
 602     PTR32 pNext;
 603     VkImage DECLSPEC_ALIGN(8) srcImage;
 604     VkImageLayout srcImageLayout;
 605     VkImage DECLSPEC_ALIGN(8) dstImage;
 606     VkImageLayout dstImageLayout;
 607     uint32_t regionCount;
 608     PTR32 pRegions;
 609     VkFilter filter;
 610 } VkBlitImageInfo232;
 611 typedef VkBlitImageInfo232 VkBlitImageInfo2KHR32;
 612
 613 typedef struct VkGeometryTrianglesNV32
 614 {
 615     VkStructureType sType;
 616     PTR32 pNext;
 617     VkBuffer DECLSPEC_ALIGN(8) vertexData;
 618     VkDeviceSize DECLSPEC_ALIGN(8) vertexOffset;
 619     uint32_t vertexCount;
 620     VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
 621     VkFormat vertexFormat;
 622     VkBuffer DECLSPEC_ALIGN(8) indexData;
 623     VkDeviceSize DECLSPEC_ALIGN(8) indexOffset;
 624     uint32_t indexCount;
 625     VkIndexType indexType;
 626     VkBuffer DECLSPEC_ALIGN(8) transformData;
 627     VkDeviceSize DECLSPEC_ALIGN(8) transformOffset;
 628 } VkGeometryTrianglesNV32;
 629
 630 typedef struct VkGeometryAABBNV32
 631 {
 632     VkStructureType sType;
 633     PTR32 pNext;
 634     VkBuffer DECLSPEC_ALIGN(8) aabbData;
 635     uint32_t numAABBs;
 636     uint32_t stride;
 637     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 638 } VkGeometryAABBNV32;
 639
 640 typedef struct VkGeometryDataNV32
 641 {
 642     VkGeometryTrianglesNV32 DECLSPEC_ALIGN(8) triangles;
 643     VkGeometryAABBNV32 DECLSPEC_ALIGN(8) aabbs;
 644 } VkGeometryDataNV32;
 645
 646 typedef struct VkGeometryNV32
 647 {
 648     VkStructureType sType;
 649     PTR32 pNext;
 650     VkGeometryTypeKHR geometryType;
 651     VkGeometryDataNV32 DECLSPEC_ALIGN(8) geometry;
 652     VkGeometryFlagsKHR flags;
 653 } VkGeometryNV32;
 654
 655 typedef struct VkAccelerationStructureInfoNV32
 656 {
 657     VkStructureType sType;
 658     PTR32 pNext;
 659     VkAccelerationStructureTypeNV type;
 660     VkBuildAccelerationStructureFlagsNV flags;
 661     uint32_t instanceCount;
 662     uint32_t geometryCount;
 663     PTR32 pGeometries;
 664 } VkAccelerationStructureInfoNV32;
 665
 666 typedef struct VkCopyAccelerationStructureInfoKHR32
 667 {
 668     VkStructureType sType;
 669     PTR32 pNext;
 670     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
 671     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
 672     VkCopyAccelerationStructureModeKHR mode;
 673 } VkCopyAccelerationStructureInfoKHR32;
 674
 675 typedef struct VkCopyAccelerationStructureToMemoryInfoKHR32
 676 {
 677     VkStructureType sType;
 678     PTR32 pNext;
 679     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
 680     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
 681     VkCopyAccelerationStructureModeKHR mode;
 682 } VkCopyAccelerationStructureToMemoryInfoKHR32;
 683
 684 typedef struct VkBufferCopy32
 685 {
 686     VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
 687     VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
 688     VkDeviceSize DECLSPEC_ALIGN(8) size;
 689 } VkBufferCopy32;
 690
 691 typedef struct VkBufferCopy232
 692 {
 693     VkStructureType sType;
 694     PTR32 pNext;
 695     VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
 696     VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
 697     VkDeviceSize DECLSPEC_ALIGN(8) size;
 698 } VkBufferCopy232;
 699 typedef VkBufferCopy232 VkBufferCopy2KHR32;
 700
 701 typedef struct VkCopyBufferInfo232
 702 {
 703     VkStructureType sType;
 704     PTR32 pNext;
 705     VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
 706     VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
 707     uint32_t regionCount;
 708     PTR32 pRegions;
 709 } VkCopyBufferInfo232;
 710 typedef VkCopyBufferInfo232 VkCopyBufferInfo2KHR32;
 711
 712 typedef struct VkBufferImageCopy32
 713 {
 714     VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
 715     uint32_t bufferRowLength;
 716     uint32_t bufferImageHeight;
 717     VkImageSubresourceLayers imageSubresource;
 718     VkOffset3D imageOffset;
 719     VkExtent3D imageExtent;
 720 } VkBufferImageCopy32;
 721
 722 typedef struct VkBufferImageCopy232
 723 {
 724     VkStructureType sType;
 725     PTR32 pNext;
 726     VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
 727     uint32_t bufferRowLength;
 728     uint32_t bufferImageHeight;
 729     VkImageSubresourceLayers imageSubresource;
 730     VkOffset3D imageOffset;
 731     VkExtent3D imageExtent;
 732 } VkBufferImageCopy232;
 733 typedef VkBufferImageCopy232 VkBufferImageCopy2KHR32;
 734
 735 typedef struct VkCopyBufferToImageInfo232
 736 {
 737     VkStructureType sType;
 738     PTR32 pNext;
 739     VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
 740     VkImage DECLSPEC_ALIGN(8) dstImage;
 741     VkImageLayout dstImageLayout;
 742     uint32_t regionCount;
 743     PTR32 pRegions;
 744 } VkCopyBufferToImageInfo232;
 745 typedef VkCopyBufferToImageInfo232 VkCopyBufferToImageInfo2KHR32;
 746
 747 typedef struct VkImageCopy232
 748 {
 749     VkStructureType sType;
 750     PTR32 pNext;
 751     VkImageSubresourceLayers srcSubresource;
 752     VkOffset3D srcOffset;
 753     VkImageSubresourceLayers dstSubresource;
 754     VkOffset3D dstOffset;
 755     VkExtent3D extent;
 756 } VkImageCopy232;
 757 typedef VkImageCopy232 VkImageCopy2KHR32;
 758
 759 typedef struct VkCopyImageInfo232
 760 {
 761     VkStructureType sType;
 762     PTR32 pNext;
 763     VkImage DECLSPEC_ALIGN(8) srcImage;
 764     VkImageLayout srcImageLayout;
 765     VkImage DECLSPEC_ALIGN(8) dstImage;
 766     VkImageLayout dstImageLayout;
 767     uint32_t regionCount;
 768     PTR32 pRegions;
 769 } VkCopyImageInfo232;
 770 typedef VkCopyImageInfo232 VkCopyImageInfo2KHR32;
 771
 772 typedef struct VkCopyImageToBufferInfo232
 773 {
 774     VkStructureType sType;
 775     PTR32 pNext;
 776     VkImage DECLSPEC_ALIGN(8) srcImage;
 777     VkImageLayout srcImageLayout;
 778     VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
 779     uint32_t regionCount;
 780     PTR32 pRegions;
 781 } VkCopyImageToBufferInfo232;
 782 typedef VkCopyImageToBufferInfo232 VkCopyImageToBufferInfo2KHR32;
 783
 784 typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32
 785 {
 786     VkStructureType sType;
 787     PTR32 pNext;
 788     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
 789     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
 790     VkCopyAccelerationStructureModeKHR mode;
 791 } VkCopyMemoryToAccelerationStructureInfoKHR32;
 792
 793 typedef struct VkCopyMemoryToMicromapInfoEXT32
 794 {
 795     VkStructureType sType;
 796     PTR32 pNext;
 797     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
 798     VkMicromapEXT DECLSPEC_ALIGN(8) dst;
 799     VkCopyMicromapModeEXT mode;
 800 } VkCopyMemoryToMicromapInfoEXT32;
 801
 802 typedef struct VkCopyMicromapInfoEXT32
 803 {
 804     VkStructureType sType;
 805     PTR32 pNext;
 806     VkMicromapEXT DECLSPEC_ALIGN(8) src;
 807     VkMicromapEXT DECLSPEC_ALIGN(8) dst;
 808     VkCopyMicromapModeEXT mode;
 809 } VkCopyMicromapInfoEXT32;
 810
 811 typedef struct VkCopyMicromapToMemoryInfoEXT32
 812 {
 813     VkStructureType sType;
 814     PTR32 pNext;
 815     VkMicromapEXT DECLSPEC_ALIGN(8) src;
 816     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
 817     VkCopyMicromapModeEXT mode;
 818 } VkCopyMicromapToMemoryInfoEXT32;
 819
 820 typedef struct VkCuLaunchInfoNVX32
 821 {
 822     VkStructureType sType;
 823     PTR32 pNext;
 824     VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
 825     uint32_t gridDimX;
 826     uint32_t gridDimY;
 827     uint32_t gridDimZ;
 828     uint32_t blockDimX;
 829     uint32_t blockDimY;
 830     uint32_t blockDimZ;
 831     uint32_t sharedMemBytes;
 832     PTR32 paramCount;
 833     PTR32 pParams;
 834     PTR32 extraCount;
 835     PTR32 pExtras;
 836 } VkCuLaunchInfoNVX32;
 837
 838 typedef struct VkDebugMarkerMarkerInfoEXT32
 839 {
 840     VkStructureType sType;
 841     PTR32 pNext;
 842     PTR32 pMarkerName;
 843     float color[4];
 844 } VkDebugMarkerMarkerInfoEXT32;
 845
 846 typedef struct VkDecompressMemoryRegionNV32
 847 {
 848     VkDeviceAddress DECLSPEC_ALIGN(8) srcAddress;
 849     VkDeviceAddress DECLSPEC_ALIGN(8) dstAddress;
 850     VkDeviceSize DECLSPEC_ALIGN(8) compressedSize;
 851     VkDeviceSize DECLSPEC_ALIGN(8) decompressedSize;
 852     VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethod;
 853 } VkDecompressMemoryRegionNV32;
 854
 855 typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM32
 856 {
 857     VkStructureType sType;
 858     PTR32 pNext;
 859     uint32_t fragmentDensityOffsetCount;
 860     PTR32 pFragmentDensityOffsets;
 861 } VkSubpassFragmentDensityMapOffsetEndInfoQCOM32;
 862
 863 typedef struct VkSubpassEndInfo32
 864 {
 865     VkStructureType sType;
 866     PTR32 pNext;
 867 } VkSubpassEndInfo32;
 868 typedef VkSubpassEndInfo32 VkSubpassEndInfoKHR32;
 869
 870 typedef struct VkIndirectCommandsStreamNV32
 871 {
 872     VkBuffer DECLSPEC_ALIGN(8) buffer;
 873     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 874 } VkIndirectCommandsStreamNV32;
 875
 876 typedef struct VkGeneratedCommandsInfoNV32
 877 {
 878     VkStructureType sType;
 879     PTR32 pNext;
 880     VkPipelineBindPoint pipelineBindPoint;
 881     VkPipeline DECLSPEC_ALIGN(8) pipeline;
 882     VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
 883     uint32_t streamCount;
 884     PTR32 pStreams;
 885     uint32_t sequencesCount;
 886     VkBuffer DECLSPEC_ALIGN(8) preprocessBuffer;
 887     VkDeviceSize DECLSPEC_ALIGN(8) preprocessOffset;
 888     VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize;
 889     VkBuffer DECLSPEC_ALIGN(8) sequencesCountBuffer;
 890     VkDeviceSize DECLSPEC_ALIGN(8) sequencesCountOffset;
 891     VkBuffer DECLSPEC_ALIGN(8) sequencesIndexBuffer;
 892     VkDeviceSize DECLSPEC_ALIGN(8) sequencesIndexOffset;
 893 } VkGeneratedCommandsInfoNV32;
 894
 895 typedef struct VkOpticalFlowExecuteInfoNV32
 896 {
 897     VkStructureType sType;
 898     PTR32 pNext;
 899     VkOpticalFlowExecuteFlagsNV flags;
 900     uint32_t regionCount;
 901     PTR32 pRegions;
 902 } VkOpticalFlowExecuteInfoNV32;
 903
 904 typedef struct VkMemoryBarrier32
 905 {
 906     VkStructureType sType;
 907     PTR32 pNext;
 908     VkAccessFlags srcAccessMask;
 909     VkAccessFlags dstAccessMask;
 910 } VkMemoryBarrier32;
 911
 912 typedef struct VkExternalMemoryAcquireUnmodifiedEXT32
 913 {
 914     VkStructureType sType;
 915     PTR32 pNext;
 916     VkBool32 acquireUnmodifiedMemory;
 917 } VkExternalMemoryAcquireUnmodifiedEXT32;
 918
 919 typedef struct VkBufferMemoryBarrier32
 920 {
 921     VkStructureType sType;
 922     PTR32 pNext;
 923     VkAccessFlags srcAccessMask;
 924     VkAccessFlags dstAccessMask;
 925     uint32_t srcQueueFamilyIndex;
 926     uint32_t dstQueueFamilyIndex;
 927     VkBuffer DECLSPEC_ALIGN(8) buffer;
 928     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 929     VkDeviceSize DECLSPEC_ALIGN(8) size;
 930 } VkBufferMemoryBarrier32;
 931
 932 typedef struct VkImageMemoryBarrier32
 933 {
 934     VkStructureType sType;
 935     PTR32 pNext;
 936     VkAccessFlags srcAccessMask;
 937     VkAccessFlags dstAccessMask;
 938     VkImageLayout oldLayout;
 939     VkImageLayout newLayout;
 940     uint32_t srcQueueFamilyIndex;
 941     uint32_t dstQueueFamilyIndex;
 942     VkImage DECLSPEC_ALIGN(8) image;
 943     VkImageSubresourceRange subresourceRange;
 944 } VkImageMemoryBarrier32;
 945
 946 typedef struct VkMemoryBarrier232
 947 {
 948     VkStructureType sType;
 949     PTR32 pNext;
 950     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 951     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 952     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 953     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 954 } VkMemoryBarrier232;
 955 typedef VkMemoryBarrier232 VkMemoryBarrier2KHR32;
 956
 957 typedef struct VkBufferMemoryBarrier232
 958 {
 959     VkStructureType sType;
 960     PTR32 pNext;
 961     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 962     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 963     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 964     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 965     uint32_t srcQueueFamilyIndex;
 966     uint32_t dstQueueFamilyIndex;
 967     VkBuffer DECLSPEC_ALIGN(8) buffer;
 968     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 969     VkDeviceSize DECLSPEC_ALIGN(8) size;
 970 } VkBufferMemoryBarrier232;
 971 typedef VkBufferMemoryBarrier232 VkBufferMemoryBarrier2KHR32;
 972
 973 typedef struct VkImageMemoryBarrier232
 974 {
 975     VkStructureType sType;
 976     PTR32 pNext;
 977     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 978     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 979     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 980     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 981     VkImageLayout oldLayout;
 982     VkImageLayout newLayout;
 983     uint32_t srcQueueFamilyIndex;
 984     uint32_t dstQueueFamilyIndex;
 985     VkImage DECLSPEC_ALIGN(8) image;
 986     VkImageSubresourceRange subresourceRange;
 987 } VkImageMemoryBarrier232;
 988 typedef VkImageMemoryBarrier232 VkImageMemoryBarrier2KHR32;
 989
 990 typedef struct VkDependencyInfo32
 991 {
 992     VkStructureType sType;
 993     PTR32 pNext;
 994     VkDependencyFlags dependencyFlags;
 995     uint32_t memoryBarrierCount;
 996     PTR32 pMemoryBarriers;
 997     uint32_t bufferMemoryBarrierCount;
 998     PTR32 pBufferMemoryBarriers;
 999     uint32_t imageMemoryBarrierCount;
1000     PTR32 pImageMemoryBarriers;
1001 } VkDependencyInfo32;
1002 typedef VkDependencyInfo32 VkDependencyInfoKHR32;
1003
1004 typedef struct VkDescriptorImageInfo32
1005 {
1006     VkSampler DECLSPEC_ALIGN(8) sampler;
1007     VkImageView DECLSPEC_ALIGN(8) imageView;
1008     VkImageLayout imageLayout;
1009 } VkDescriptorImageInfo32;
1010
1011 typedef struct VkDescriptorBufferInfo32
1012 {
1013     VkBuffer DECLSPEC_ALIGN(8) buffer;
1014     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1015     VkDeviceSize DECLSPEC_ALIGN(8) range;
1016 } VkDescriptorBufferInfo32;
1017
1018 typedef struct VkWriteDescriptorSetInlineUniformBlock32
1019 {
1020     VkStructureType sType;
1021     PTR32 pNext;
1022     uint32_t dataSize;
1023     PTR32 pData;
1024 } VkWriteDescriptorSetInlineUniformBlock32;
1025 typedef VkWriteDescriptorSetInlineUniformBlock32 VkWriteDescriptorSetInlineUniformBlockEXT32;
1026
1027 typedef struct VkWriteDescriptorSetAccelerationStructureKHR32
1028 {
1029     VkStructureType sType;
1030     PTR32 pNext;
1031     uint32_t accelerationStructureCount;
1032     PTR32 pAccelerationStructures;
1033 } VkWriteDescriptorSetAccelerationStructureKHR32;
1034
1035 typedef struct VkWriteDescriptorSetAccelerationStructureNV32
1036 {
1037     VkStructureType sType;
1038     PTR32 pNext;
1039     uint32_t accelerationStructureCount;
1040     PTR32 pAccelerationStructures;
1041 } VkWriteDescriptorSetAccelerationStructureNV32;
1042
1043 typedef struct VkWriteDescriptorSet32
1044 {
1045     VkStructureType sType;
1046     PTR32 pNext;
1047     VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
1048     uint32_t dstBinding;
1049     uint32_t dstArrayElement;
1050     uint32_t descriptorCount;
1051     VkDescriptorType descriptorType;
1052     PTR32 pImageInfo;
1053     PTR32 pBufferInfo;
1054     PTR32 pTexelBufferView;
1055 } VkWriteDescriptorSet32;
1056
1057 typedef struct VkImageResolve232
1058 {
1059     VkStructureType sType;
1060     PTR32 pNext;
1061     VkImageSubresourceLayers srcSubresource;
1062     VkOffset3D srcOffset;
1063     VkImageSubresourceLayers dstSubresource;
1064     VkOffset3D dstOffset;
1065     VkExtent3D extent;
1066 } VkImageResolve232;
1067 typedef VkImageResolve232 VkImageResolve2KHR32;
1068
1069 typedef struct VkResolveImageInfo232
1070 {
1071     VkStructureType sType;
1072     PTR32 pNext;
1073     VkImage DECLSPEC_ALIGN(8) srcImage;
1074     VkImageLayout srcImageLayout;
1075     VkImage DECLSPEC_ALIGN(8) dstImage;
1076     VkImageLayout dstImageLayout;
1077     uint32_t regionCount;
1078     PTR32 pRegions;
1079 } VkResolveImageInfo232;
1080 typedef VkResolveImageInfo232 VkResolveImageInfo2KHR32;
1081
1082 typedef struct VkCoarseSampleOrderCustomNV32
1083 {
1084     VkShadingRatePaletteEntryNV shadingRate;
1085     uint32_t sampleCount;
1086     uint32_t sampleLocationCount;
1087     PTR32 pSampleLocations;
1088 } VkCoarseSampleOrderCustomNV32;
1089
1090 typedef struct VkDepthBiasRepresentationInfoEXT32
1091 {
1092     VkStructureType sType;
1093     PTR32 pNext;
1094     VkDepthBiasRepresentationEXT depthBiasRepresentation;
1095     VkBool32 depthBiasExact;
1096 } VkDepthBiasRepresentationInfoEXT32;
1097
1098 typedef struct VkDepthBiasInfoEXT32
1099 {
1100     VkStructureType sType;
1101     PTR32 pNext;
1102     float depthBiasConstantFactor;
1103     float depthBiasClamp;
1104     float depthBiasSlopeFactor;
1105 } VkDepthBiasInfoEXT32;
1106
1107 typedef struct VkPerformanceMarkerInfoINTEL32
1108 {
1109     VkStructureType sType;
1110     PTR32 pNext;
1111     uint64_t DECLSPEC_ALIGN(8) marker;
1112 } VkPerformanceMarkerInfoINTEL32;
1113
1114 typedef struct VkPerformanceOverrideInfoINTEL32
1115 {
1116     VkStructureType sType;
1117     PTR32 pNext;
1118     VkPerformanceOverrideTypeINTEL type;
1119     VkBool32 enable;
1120     uint64_t DECLSPEC_ALIGN(8) parameter;
1121 } VkPerformanceOverrideInfoINTEL32;
1122
1123 typedef struct VkPerformanceStreamMarkerInfoINTEL32
1124 {
1125     VkStructureType sType;
1126     PTR32 pNext;
1127     uint32_t marker;
1128 } VkPerformanceStreamMarkerInfoINTEL32;
1129
1130 typedef struct VkVertexInputBindingDescription2EXT32
1131 {
1132     VkStructureType sType;
1133     PTR32 pNext;
1134     uint32_t binding;
1135     uint32_t stride;
1136     VkVertexInputRate inputRate;
1137     uint32_t divisor;
1138 } VkVertexInputBindingDescription2EXT32;
1139
1140 typedef struct VkVertexInputAttributeDescription2EXT32
1141 {
1142     VkStructureType sType;
1143     PTR32 pNext;
1144     uint32_t location;
1145     uint32_t binding;
1146     VkFormat format;
1147     uint32_t offset;
1148 } VkVertexInputAttributeDescription2EXT32;
1149
1150 typedef struct VkShadingRatePaletteNV32
1151 {
1152     uint32_t shadingRatePaletteEntryCount;
1153     PTR32 pShadingRatePaletteEntries;
1154 } VkShadingRatePaletteNV32;
1155
1156 typedef struct VkStridedDeviceAddressRegionKHR32
1157 {
1158     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1159     VkDeviceSize DECLSPEC_ALIGN(8) stride;
1160     VkDeviceSize DECLSPEC_ALIGN(8) size;
1161 } VkStridedDeviceAddressRegionKHR32;
1162
1163 typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT32
1164 {
1165     VkStructureType sType;
1166     PTR32 pNext;
1167     PTR32 opaqueCaptureDescriptorData;
1168 } VkOpaqueCaptureDescriptorDataCreateInfoEXT32;
1169
1170 typedef struct VkAccelerationStructureMotionInfoNV32
1171 {
1172     VkStructureType sType;
1173     PTR32 pNext;
1174     uint32_t maxInstances;
1175     VkAccelerationStructureMotionInfoFlagsNV flags;
1176 } VkAccelerationStructureMotionInfoNV32;
1177
1178 typedef struct VkAccelerationStructureCreateInfoKHR32
1179 {
1180     VkStructureType sType;
1181     PTR32 pNext;
1182     VkAccelerationStructureCreateFlagsKHR createFlags;
1183     VkBuffer DECLSPEC_ALIGN(8) buffer;
1184     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1185     VkDeviceSize DECLSPEC_ALIGN(8) size;
1186     VkAccelerationStructureTypeKHR type;
1187     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1188 } VkAccelerationStructureCreateInfoKHR32;
1189
1190 typedef struct VkAccelerationStructureCreateInfoNV32
1191 {
1192     VkStructureType sType;
1193     PTR32 pNext;
1194     VkDeviceSize DECLSPEC_ALIGN(8) compactedSize;
1195     VkAccelerationStructureInfoNV32 info;
1196 } VkAccelerationStructureCreateInfoNV32;
1197
1198 typedef struct VkDedicatedAllocationBufferCreateInfoNV32
1199 {
1200     VkStructureType sType;
1201     PTR32 pNext;
1202     VkBool32 dedicatedAllocation;
1203 } VkDedicatedAllocationBufferCreateInfoNV32;
1204
1205 typedef struct VkExternalMemoryBufferCreateInfo32
1206 {
1207     VkStructureType sType;
1208     PTR32 pNext;
1209     VkExternalMemoryHandleTypeFlags handleTypes;
1210 } VkExternalMemoryBufferCreateInfo32;
1211 typedef VkExternalMemoryBufferCreateInfo32 VkExternalMemoryBufferCreateInfoKHR32;
1212
1213 typedef struct VkBufferOpaqueCaptureAddressCreateInfo32
1214 {
1215     VkStructureType sType;
1216     PTR32 pNext;
1217     uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
1218 } VkBufferOpaqueCaptureAddressCreateInfo32;
1219 typedef VkBufferOpaqueCaptureAddressCreateInfo32 VkBufferOpaqueCaptureAddressCreateInfoKHR32;
1220
1221 typedef struct VkBufferDeviceAddressCreateInfoEXT32
1222 {
1223     VkStructureType sType;
1224     PTR32 pNext;
1225     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1226 } VkBufferDeviceAddressCreateInfoEXT32;
1227
1228 typedef struct VkBufferCreateInfo32
1229 {
1230     VkStructureType sType;
1231     PTR32 pNext;
1232     VkBufferCreateFlags flags;
1233     VkDeviceSize DECLSPEC_ALIGN(8) size;
1234     VkBufferUsageFlags usage;
1235     VkSharingMode sharingMode;
1236     uint32_t queueFamilyIndexCount;
1237     PTR32 pQueueFamilyIndices;
1238 } VkBufferCreateInfo32;
1239
1240 typedef struct VkBufferViewCreateInfo32
1241 {
1242     VkStructureType sType;
1243     PTR32 pNext;
1244     VkBufferViewCreateFlags flags;
1245     VkBuffer DECLSPEC_ALIGN(8) buffer;
1246     VkFormat format;
1247     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1248     VkDeviceSize DECLSPEC_ALIGN(8) range;
1249 } VkBufferViewCreateInfo32;
1250
1251 typedef struct VkCommandPoolCreateInfo32
1252 {
1253     VkStructureType sType;
1254     PTR32 pNext;
1255     VkCommandPoolCreateFlags flags;
1256     uint32_t queueFamilyIndex;
1257 } VkCommandPoolCreateInfo32;
1258
1259 typedef struct VkPipelineCreationFeedback32
1260 {
1261     VkPipelineCreationFeedbackFlags flags;
1262     uint64_t DECLSPEC_ALIGN(8) duration;
1263 } VkPipelineCreationFeedback32;
1264 typedef VkPipelineCreationFeedback32 VkPipelineCreationFeedbackEXT32;
1265
1266 typedef struct VkSpecializationMapEntry32
1267 {
1268     uint32_t constantID;
1269     uint32_t offset;
1270     PTR32 size;
1271 } VkSpecializationMapEntry32;
1272
1273 typedef struct VkSpecializationInfo32
1274 {
1275     uint32_t mapEntryCount;
1276     PTR32 pMapEntries;
1277     PTR32 dataSize;
1278     PTR32 pData;
1279 } VkSpecializationInfo32;
1280
1281 typedef struct VkShaderModuleCreateInfo32
1282 {
1283     VkStructureType sType;
1284     PTR32 pNext;
1285     VkShaderModuleCreateFlags flags;
1286     PTR32 codeSize;
1287     PTR32 pCode;
1288 } VkShaderModuleCreateInfo32;
1289
1290 typedef struct VkShaderModuleValidationCacheCreateInfoEXT32
1291 {
1292     VkStructureType sType;
1293     PTR32 pNext;
1294     VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
1295 } VkShaderModuleValidationCacheCreateInfoEXT32;
1296
1297 typedef struct VkDebugUtilsObjectNameInfoEXT32
1298 {
1299     VkStructureType sType;
1300     PTR32 pNext;
1301     VkObjectType objectType;
1302     uint64_t DECLSPEC_ALIGN(8) objectHandle;
1303     PTR32 pObjectName;
1304 } VkDebugUtilsObjectNameInfoEXT32;
1305
1306 typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32
1307 {
1308     VkStructureType sType;
1309     PTR32 pNext;
1310     uint32_t requiredSubgroupSize;
1311 } VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32;
1312 typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT32;
1313 typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkShaderRequiredSubgroupSizeCreateInfoEXT32;
1314
1315 typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT32
1316 {
1317     VkStructureType sType;
1318     PTR32 pNext;
1319     uint32_t identifierSize;
1320     PTR32 pIdentifier;
1321 } VkPipelineShaderStageModuleIdentifierCreateInfoEXT32;
1322
1323 typedef struct VkPipelineRobustnessCreateInfoEXT32
1324 {
1325     VkStructureType sType;
1326     PTR32 pNext;
1327     VkPipelineRobustnessBufferBehaviorEXT storageBuffers;
1328     VkPipelineRobustnessBufferBehaviorEXT uniformBuffers;
1329     VkPipelineRobustnessBufferBehaviorEXT vertexInputs;
1330     VkPipelineRobustnessImageBehaviorEXT images;
1331 } VkPipelineRobustnessCreateInfoEXT32;
1332
1333 typedef struct VkPipelineShaderStageCreateInfo32
1334 {
1335     VkStructureType sType;
1336     PTR32 pNext;
1337     VkPipelineShaderStageCreateFlags flags;
1338     VkShaderStageFlagBits stage;
1339     VkShaderModule DECLSPEC_ALIGN(8) module;
1340     PTR32 pName;
1341     PTR32 pSpecializationInfo;
1342 } VkPipelineShaderStageCreateInfo32;
1343
1344 typedef struct VkPipelineCreationFeedbackCreateInfo32
1345 {
1346     VkStructureType sType;
1347     PTR32 pNext;
1348     PTR32 pPipelineCreationFeedback;
1349     uint32_t pipelineStageCreationFeedbackCount;
1350     PTR32 pPipelineStageCreationFeedbacks;
1351 } VkPipelineCreationFeedbackCreateInfo32;
1352 typedef VkPipelineCreationFeedbackCreateInfo32 VkPipelineCreationFeedbackCreateInfoEXT32;
1353
1354 typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI32
1355 {
1356     VkStructureType sType;
1357     PTR32 pNext;
1358     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
1359     uint32_t subpass;
1360 } VkSubpassShadingPipelineCreateInfoHUAWEI32;
1361
1362 typedef struct VkPipelineCompilerControlCreateInfoAMD32
1363 {
1364     VkStructureType sType;
1365     PTR32 pNext;
1366     VkPipelineCompilerControlFlagsAMD compilerControlFlags;
1367 } VkPipelineCompilerControlCreateInfoAMD32;
1368
1369 typedef struct VkComputePipelineCreateInfo32
1370 {
1371     VkStructureType sType;
1372     PTR32 pNext;
1373     VkPipelineCreateFlags flags;
1374     VkPipelineShaderStageCreateInfo32 DECLSPEC_ALIGN(8) stage;
1375     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
1376     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
1377     int32_t basePipelineIndex;
1378 } VkComputePipelineCreateInfo32;
1379
1380 typedef struct VkCuFunctionCreateInfoNVX32
1381 {
1382     VkStructureType sType;
1383     PTR32 pNext;
1384     VkCuModuleNVX DECLSPEC_ALIGN(8) module;
1385     PTR32 pName;
1386 } VkCuFunctionCreateInfoNVX32;
1387
1388 typedef struct VkCuModuleCreateInfoNVX32
1389 {
1390     VkStructureType sType;
1391     PTR32 pNext;
1392     PTR32 dataSize;
1393     PTR32 pData;
1394 } VkCuModuleCreateInfoNVX32;
1395
1396 typedef struct VkDebugReportCallbackCreateInfoEXT32
1397 {
1398     VkStructureType sType;
1399     PTR32 pNext;
1400     VkDebugReportFlagsEXT flags;
1401     PFN_vkDebugReportCallbackEXT pfnCallback;
1402     PTR32 pUserData;
1403 } VkDebugReportCallbackCreateInfoEXT32;
1404
1405 typedef struct VkDebugUtilsMessengerCreateInfoEXT32
1406 {
1407     VkStructureType sType;
1408     PTR32 pNext;
1409     VkDebugUtilsMessengerCreateFlagsEXT flags;
1410     VkDebugUtilsMessageSeverityFlagsEXT messageSeverity;
1411     VkDebugUtilsMessageTypeFlagsEXT messageType;
1412     PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
1413     PTR32 pUserData;
1414 } VkDebugUtilsMessengerCreateInfoEXT32;
1415
1416 typedef struct VkMutableDescriptorTypeListEXT32
1417 {
1418     uint32_t descriptorTypeCount;
1419     PTR32 pDescriptorTypes;
1420 } VkMutableDescriptorTypeListEXT32;
1421 typedef VkMutableDescriptorTypeListEXT32 VkMutableDescriptorTypeListVALVE32;
1422
1423 typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo32
1424 {
1425     VkStructureType sType;
1426     PTR32 pNext;
1427     uint32_t maxInlineUniformBlockBindings;
1428 } VkDescriptorPoolInlineUniformBlockCreateInfo32;
1429 typedef VkDescriptorPoolInlineUniformBlockCreateInfo32 VkDescriptorPoolInlineUniformBlockCreateInfoEXT32;
1430
1431 typedef struct VkMutableDescriptorTypeCreateInfoEXT32
1432 {
1433     VkStructureType sType;
1434     PTR32 pNext;
1435     uint32_t mutableDescriptorTypeListCount;
1436     PTR32 pMutableDescriptorTypeLists;
1437 } VkMutableDescriptorTypeCreateInfoEXT32;
1438 typedef VkMutableDescriptorTypeCreateInfoEXT32 VkMutableDescriptorTypeCreateInfoVALVE32;
1439
1440 typedef struct VkDescriptorPoolCreateInfo32
1441 {
1442     VkStructureType sType;
1443     PTR32 pNext;
1444     VkDescriptorPoolCreateFlags flags;
1445     uint32_t maxSets;
1446     uint32_t poolSizeCount;
1447     PTR32 pPoolSizes;
1448 } VkDescriptorPoolCreateInfo32;
1449
1450 typedef struct VkDescriptorSetLayoutBinding32
1451 {
1452     uint32_t binding;
1453     VkDescriptorType descriptorType;
1454     uint32_t descriptorCount;
1455     VkShaderStageFlags stageFlags;
1456     PTR32 pImmutableSamplers;
1457 } VkDescriptorSetLayoutBinding32;
1458
1459 typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo32
1460 {
1461     VkStructureType sType;
1462     PTR32 pNext;
1463     uint32_t bindingCount;
1464     PTR32 pBindingFlags;
1465 } VkDescriptorSetLayoutBindingFlagsCreateInfo32;
1466 typedef VkDescriptorSetLayoutBindingFlagsCreateInfo32 VkDescriptorSetLayoutBindingFlagsCreateInfoEXT32;
1467
1468 typedef struct VkDescriptorSetLayoutCreateInfo32
1469 {
1470     VkStructureType sType;
1471     PTR32 pNext;
1472     VkDescriptorSetLayoutCreateFlags flags;
1473     uint32_t bindingCount;
1474     PTR32 pBindings;
1475 } VkDescriptorSetLayoutCreateInfo32;
1476
1477 typedef struct VkDescriptorUpdateTemplateEntry32
1478 {
1479     uint32_t dstBinding;
1480     uint32_t dstArrayElement;
1481     uint32_t descriptorCount;
1482     VkDescriptorType descriptorType;
1483     PTR32 offset;
1484     PTR32 stride;
1485 } VkDescriptorUpdateTemplateEntry32;
1486 typedef VkDescriptorUpdateTemplateEntry32 VkDescriptorUpdateTemplateEntryKHR32;
1487
1488 typedef struct VkDescriptorUpdateTemplateCreateInfo32
1489 {
1490     VkStructureType sType;
1491     PTR32 pNext;
1492     VkDescriptorUpdateTemplateCreateFlags flags;
1493     uint32_t descriptorUpdateEntryCount;
1494     PTR32 pDescriptorUpdateEntries;
1495     VkDescriptorUpdateTemplateType templateType;
1496     VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
1497     VkPipelineBindPoint pipelineBindPoint;
1498     VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
1499     uint32_t set;
1500 } VkDescriptorUpdateTemplateCreateInfo32;
1501 typedef VkDescriptorUpdateTemplateCreateInfo32 VkDescriptorUpdateTemplateCreateInfoKHR32;
1502
1503 typedef struct VkDeviceQueueGlobalPriorityCreateInfoKHR32
1504 {
1505     VkStructureType sType;
1506     PTR32 pNext;
1507     VkQueueGlobalPriorityKHR globalPriority;
1508 } VkDeviceQueueGlobalPriorityCreateInfoKHR32;
1509 typedef VkDeviceQueueGlobalPriorityCreateInfoKHR32 VkDeviceQueueGlobalPriorityCreateInfoEXT32;
1510
1511 typedef struct VkDeviceQueueCreateInfo32
1512 {
1513     VkStructureType sType;
1514     PTR32 pNext;
1515     VkDeviceQueueCreateFlags flags;
1516     uint32_t queueFamilyIndex;
1517     uint32_t queueCount;
1518     PTR32 pQueuePriorities;
1519 } VkDeviceQueueCreateInfo32;
1520
1521 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32
1522 {
1523     VkStructureType sType;
1524     PTR32 pNext;
1525     VkBool32 deviceGeneratedCommands;
1526 } VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32;
1527
1528 typedef struct VkDevicePrivateDataCreateInfo32
1529 {
1530     VkStructureType sType;
1531     PTR32 pNext;
1532     uint32_t privateDataSlotRequestCount;
1533 } VkDevicePrivateDataCreateInfo32;
1534 typedef VkDevicePrivateDataCreateInfo32 VkDevicePrivateDataCreateInfoEXT32;
1535
1536 typedef struct VkPhysicalDevicePrivateDataFeatures32
1537 {
1538     VkStructureType sType;
1539     PTR32 pNext;
1540     VkBool32 privateData;
1541 } VkPhysicalDevicePrivateDataFeatures32;
1542 typedef VkPhysicalDevicePrivateDataFeatures32 VkPhysicalDevicePrivateDataFeaturesEXT32;
1543
1544 typedef struct VkPhysicalDeviceFeatures232
1545 {
1546     VkStructureType sType;
1547     PTR32 pNext;
1548     VkPhysicalDeviceFeatures features;
1549 } VkPhysicalDeviceFeatures232;
1550 typedef VkPhysicalDeviceFeatures232 VkPhysicalDeviceFeatures2KHR32;
1551
1552 typedef struct VkPhysicalDeviceVariablePointersFeatures32
1553 {
1554     VkStructureType sType;
1555     PTR32 pNext;
1556     VkBool32 variablePointersStorageBuffer;
1557     VkBool32 variablePointers;
1558 } VkPhysicalDeviceVariablePointersFeatures32;
1559 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointersFeaturesKHR32;
1560 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeaturesKHR32;
1561 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeatures32;
1562
1563 typedef struct VkPhysicalDeviceMultiviewFeatures32
1564 {
1565     VkStructureType sType;
1566     PTR32 pNext;
1567     VkBool32 multiview;
1568     VkBool32 multiviewGeometryShader;
1569     VkBool32 multiviewTessellationShader;
1570 } VkPhysicalDeviceMultiviewFeatures32;
1571 typedef VkPhysicalDeviceMultiviewFeatures32 VkPhysicalDeviceMultiviewFeaturesKHR32;
1572
1573 typedef struct VkDeviceGroupDeviceCreateInfo32
1574 {
1575     VkStructureType sType;
1576     PTR32 pNext;
1577     uint32_t physicalDeviceCount;
1578     PTR32 pPhysicalDevices;
1579 } VkDeviceGroupDeviceCreateInfo32;
1580 typedef VkDeviceGroupDeviceCreateInfo32 VkDeviceGroupDeviceCreateInfoKHR32;
1581
1582 typedef struct VkPhysicalDevicePresentIdFeaturesKHR32
1583 {
1584     VkStructureType sType;
1585     PTR32 pNext;
1586     VkBool32 presentId;
1587 } VkPhysicalDevicePresentIdFeaturesKHR32;
1588
1589 typedef struct VkPhysicalDevicePresentWaitFeaturesKHR32
1590 {
1591     VkStructureType sType;
1592     PTR32 pNext;
1593     VkBool32 presentWait;
1594 } VkPhysicalDevicePresentWaitFeaturesKHR32;
1595
1596 typedef struct VkPhysicalDevice16BitStorageFeatures32
1597 {
1598     VkStructureType sType;
1599     PTR32 pNext;
1600     VkBool32 storageBuffer16BitAccess;
1601     VkBool32 uniformAndStorageBuffer16BitAccess;
1602     VkBool32 storagePushConstant16;
1603     VkBool32 storageInputOutput16;
1604 } VkPhysicalDevice16BitStorageFeatures32;
1605 typedef VkPhysicalDevice16BitStorageFeatures32 VkPhysicalDevice16BitStorageFeaturesKHR32;
1606
1607 typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32
1608 {
1609     VkStructureType sType;
1610     PTR32 pNext;
1611     VkBool32 shaderSubgroupExtendedTypes;
1612 } VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32;
1613 typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR32;
1614
1615 typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures32
1616 {
1617     VkStructureType sType;
1618     PTR32 pNext;
1619     VkBool32 samplerYcbcrConversion;
1620 } VkPhysicalDeviceSamplerYcbcrConversionFeatures32;
1621 typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures32 VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR32;
1622
1623 typedef struct VkPhysicalDeviceProtectedMemoryFeatures32
1624 {
1625     VkStructureType sType;
1626     PTR32 pNext;
1627     VkBool32 protectedMemory;
1628 } VkPhysicalDeviceProtectedMemoryFeatures32;
1629
1630 typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32
1631 {
1632     VkStructureType sType;
1633     PTR32 pNext;
1634     VkBool32 advancedBlendCoherentOperations;
1635 } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32;
1636
1637 typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT32
1638 {
1639     VkStructureType sType;
1640     PTR32 pNext;
1641     VkBool32 multiDraw;
1642 } VkPhysicalDeviceMultiDrawFeaturesEXT32;
1643
1644 typedef struct VkPhysicalDeviceInlineUniformBlockFeatures32
1645 {
1646     VkStructureType sType;
1647     PTR32 pNext;
1648     VkBool32 inlineUniformBlock;
1649     VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
1650 } VkPhysicalDeviceInlineUniformBlockFeatures32;
1651 typedef VkPhysicalDeviceInlineUniformBlockFeatures32 VkPhysicalDeviceInlineUniformBlockFeaturesEXT32;
1652
1653 typedef struct VkPhysicalDeviceMaintenance4Features32
1654 {
1655     VkStructureType sType;
1656     PTR32 pNext;
1657     VkBool32 maintenance4;
1658 } VkPhysicalDeviceMaintenance4Features32;
1659 typedef VkPhysicalDeviceMaintenance4Features32 VkPhysicalDeviceMaintenance4FeaturesKHR32;
1660
1661 typedef struct VkPhysicalDeviceShaderDrawParametersFeatures32
1662 {
1663     VkStructureType sType;
1664     PTR32 pNext;
1665     VkBool32 shaderDrawParameters;
1666 } VkPhysicalDeviceShaderDrawParametersFeatures32;
1667 typedef VkPhysicalDeviceShaderDrawParametersFeatures32 VkPhysicalDeviceShaderDrawParameterFeatures32;
1668
1669 typedef struct VkPhysicalDeviceShaderFloat16Int8Features32
1670 {
1671     VkStructureType sType;
1672     PTR32 pNext;
1673     VkBool32 shaderFloat16;
1674     VkBool32 shaderInt8;
1675 } VkPhysicalDeviceShaderFloat16Int8Features32;
1676 typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceShaderFloat16Int8FeaturesKHR32;
1677 typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceFloat16Int8FeaturesKHR32;
1678
1679 typedef struct VkPhysicalDeviceHostQueryResetFeatures32
1680 {
1681     VkStructureType sType;
1682     PTR32 pNext;
1683     VkBool32 hostQueryReset;
1684 } VkPhysicalDeviceHostQueryResetFeatures32;
1685 typedef VkPhysicalDeviceHostQueryResetFeatures32 VkPhysicalDeviceHostQueryResetFeaturesEXT32;
1686
1687 typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32
1688 {
1689     VkStructureType sType;
1690     PTR32 pNext;
1691     VkBool32 globalPriorityQuery;
1692 } VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32;
1693 typedef VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT32;
1694
1695 typedef struct VkPhysicalDeviceDescriptorIndexingFeatures32
1696 {
1697     VkStructureType sType;
1698     PTR32 pNext;
1699     VkBool32 shaderInputAttachmentArrayDynamicIndexing;
1700     VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
1701     VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
1702     VkBool32 shaderUniformBufferArrayNonUniformIndexing;
1703     VkBool32 shaderSampledImageArrayNonUniformIndexing;
1704     VkBool32 shaderStorageBufferArrayNonUniformIndexing;
1705     VkBool32 shaderStorageImageArrayNonUniformIndexing;
1706     VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
1707     VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
1708     VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
1709     VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
1710     VkBool32 descriptorBindingSampledImageUpdateAfterBind;
1711     VkBool32 descriptorBindingStorageImageUpdateAfterBind;
1712     VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
1713     VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
1714     VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
1715     VkBool32 descriptorBindingUpdateUnusedWhilePending;
1716     VkBool32 descriptorBindingPartiallyBound;
1717     VkBool32 descriptorBindingVariableDescriptorCount;
1718     VkBool32 runtimeDescriptorArray;
1719 } VkPhysicalDeviceDescriptorIndexingFeatures32;
1720 typedef VkPhysicalDeviceDescriptorIndexingFeatures32 VkPhysicalDeviceDescriptorIndexingFeaturesEXT32;
1721
1722 typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures32
1723 {
1724     VkStructureType sType;
1725     PTR32 pNext;
1726     VkBool32 timelineSemaphore;
1727 } VkPhysicalDeviceTimelineSemaphoreFeatures32;
1728 typedef VkPhysicalDeviceTimelineSemaphoreFeatures32 VkPhysicalDeviceTimelineSemaphoreFeaturesKHR32;
1729
1730 typedef struct VkPhysicalDevice8BitStorageFeatures32
1731 {
1732     VkStructureType sType;
1733     PTR32 pNext;
1734     VkBool32 storageBuffer8BitAccess;
1735     VkBool32 uniformAndStorageBuffer8BitAccess;
1736     VkBool32 storagePushConstant8;
1737 } VkPhysicalDevice8BitStorageFeatures32;
1738 typedef VkPhysicalDevice8BitStorageFeatures32 VkPhysicalDevice8BitStorageFeaturesKHR32;
1739
1740 typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT32
1741 {
1742     VkStructureType sType;
1743     PTR32 pNext;
1744     VkBool32 conditionalRendering;
1745     VkBool32 inheritedConditionalRendering;
1746 } VkPhysicalDeviceConditionalRenderingFeaturesEXT32;
1747
1748 typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures32
1749 {
1750     VkStructureType sType;
1751     PTR32 pNext;
1752     VkBool32 vulkanMemoryModel;
1753     VkBool32 vulkanMemoryModelDeviceScope;
1754     VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
1755 } VkPhysicalDeviceVulkanMemoryModelFeatures32;
1756 typedef VkPhysicalDeviceVulkanMemoryModelFeatures32 VkPhysicalDeviceVulkanMemoryModelFeaturesKHR32;
1757
1758 typedef struct VkPhysicalDeviceShaderAtomicInt64Features32
1759 {
1760     VkStructureType sType;
1761     PTR32 pNext;
1762     VkBool32 shaderBufferInt64Atomics;
1763     VkBool32 shaderSharedInt64Atomics;
1764 } VkPhysicalDeviceShaderAtomicInt64Features32;
1765 typedef VkPhysicalDeviceShaderAtomicInt64Features32 VkPhysicalDeviceShaderAtomicInt64FeaturesKHR32;
1766
1767 typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32
1768 {
1769     VkStructureType sType;
1770     PTR32 pNext;
1771     VkBool32 shaderBufferFloat32Atomics;
1772     VkBool32 shaderBufferFloat32AtomicAdd;
1773     VkBool32 shaderBufferFloat64Atomics;
1774     VkBool32 shaderBufferFloat64AtomicAdd;
1775     VkBool32 shaderSharedFloat32Atomics;
1776     VkBool32 shaderSharedFloat32AtomicAdd;
1777     VkBool32 shaderSharedFloat64Atomics;
1778     VkBool32 shaderSharedFloat64AtomicAdd;
1779     VkBool32 shaderImageFloat32Atomics;
1780     VkBool32 shaderImageFloat32AtomicAdd;
1781     VkBool32 sparseImageFloat32Atomics;
1782     VkBool32 sparseImageFloat32AtomicAdd;
1783 } VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32;
1784
1785 typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32
1786 {
1787     VkStructureType sType;
1788     PTR32 pNext;
1789     VkBool32 shaderBufferFloat16Atomics;
1790     VkBool32 shaderBufferFloat16AtomicAdd;
1791     VkBool32 shaderBufferFloat16AtomicMinMax;
1792     VkBool32 shaderBufferFloat32AtomicMinMax;
1793     VkBool32 shaderBufferFloat64AtomicMinMax;
1794     VkBool32 shaderSharedFloat16Atomics;
1795     VkBool32 shaderSharedFloat16AtomicAdd;
1796     VkBool32 shaderSharedFloat16AtomicMinMax;
1797     VkBool32 shaderSharedFloat32AtomicMinMax;
1798     VkBool32 shaderSharedFloat64AtomicMinMax;
1799     VkBool32 shaderImageFloat32AtomicMinMax;
1800     VkBool32 sparseImageFloat32AtomicMinMax;
1801 } VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32;
1802
1803 typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32
1804 {
1805     VkStructureType sType;
1806     PTR32 pNext;
1807     VkBool32 vertexAttributeInstanceRateDivisor;
1808     VkBool32 vertexAttributeInstanceRateZeroDivisor;
1809 } VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32;
1810
1811 typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT32
1812 {
1813     VkStructureType sType;
1814     PTR32 pNext;
1815     VkBool32 decodeModeSharedExponent;
1816 } VkPhysicalDeviceASTCDecodeFeaturesEXT32;
1817
1818 typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT32
1819 {
1820     VkStructureType sType;
1821     PTR32 pNext;
1822     VkBool32 transformFeedback;
1823     VkBool32 geometryStreams;
1824 } VkPhysicalDeviceTransformFeedbackFeaturesEXT32;
1825
1826 typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32
1827 {
1828     VkStructureType sType;
1829     PTR32 pNext;
1830     VkBool32 representativeFragmentTest;
1831 } VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32;
1832
1833 typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV32
1834 {
1835     VkStructureType sType;
1836     PTR32 pNext;
1837     VkBool32 exclusiveScissor;
1838 } VkPhysicalDeviceExclusiveScissorFeaturesNV32;
1839
1840 typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV32
1841 {
1842     VkStructureType sType;
1843     PTR32 pNext;
1844     VkBool32 cornerSampledImage;
1845 } VkPhysicalDeviceCornerSampledImageFeaturesNV32;
1846
1847 typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32
1848 {
1849     VkStructureType sType;
1850     PTR32 pNext;
1851     VkBool32 computeDerivativeGroupQuads;
1852     VkBool32 computeDerivativeGroupLinear;
1853 } VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32;
1854
1855 typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV32
1856 {
1857     VkStructureType sType;
1858     PTR32 pNext;
1859     VkBool32 imageFootprint;
1860 } VkPhysicalDeviceShaderImageFootprintFeaturesNV32;
1861
1862 typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32
1863 {
1864     VkStructureType sType;
1865     PTR32 pNext;
1866     VkBool32 dedicatedAllocationImageAliasing;
1867 } VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32;
1868
1869 typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32
1870 {
1871     VkStructureType sType;
1872     PTR32 pNext;
1873     VkBool32 indirectCopy;
1874 } VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32;
1875
1876 typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV32
1877 {
1878     VkStructureType sType;
1879     PTR32 pNext;
1880     VkBool32 memoryDecompression;
1881 } VkPhysicalDeviceMemoryDecompressionFeaturesNV32;
1882
1883 typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV32
1884 {
1885     VkStructureType sType;
1886     PTR32 pNext;
1887     VkBool32 shadingRateImage;
1888     VkBool32 shadingRateCoarseSampleOrder;
1889 } VkPhysicalDeviceShadingRateImageFeaturesNV32;
1890
1891 typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32
1892 {
1893     VkStructureType sType;
1894     PTR32 pNext;
1895     VkBool32 invocationMask;
1896 } VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32;
1897
1898 typedef struct VkPhysicalDeviceMeshShaderFeaturesNV32
1899 {
1900     VkStructureType sType;
1901     PTR32 pNext;
1902     VkBool32 taskShader;
1903     VkBool32 meshShader;
1904 } VkPhysicalDeviceMeshShaderFeaturesNV32;
1905
1906 typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT32
1907 {
1908     VkStructureType sType;
1909     PTR32 pNext;
1910     VkBool32 taskShader;
1911     VkBool32 meshShader;
1912     VkBool32 multiviewMeshShader;
1913     VkBool32 primitiveFragmentShadingRateMeshShader;
1914     VkBool32 meshShaderQueries;
1915 } VkPhysicalDeviceMeshShaderFeaturesEXT32;
1916
1917 typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR32
1918 {
1919     VkStructureType sType;
1920     PTR32 pNext;
1921     VkBool32 accelerationStructure;
1922     VkBool32 accelerationStructureCaptureReplay;
1923     VkBool32 accelerationStructureIndirectBuild;
1924     VkBool32 accelerationStructureHostCommands;
1925     VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind;
1926 } VkPhysicalDeviceAccelerationStructureFeaturesKHR32;
1927
1928 typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR32
1929 {
1930     VkStructureType sType;
1931     PTR32 pNext;
1932     VkBool32 rayTracingPipeline;
1933     VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay;
1934     VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
1935     VkBool32 rayTracingPipelineTraceRaysIndirect;
1936     VkBool32 rayTraversalPrimitiveCulling;
1937 } VkPhysicalDeviceRayTracingPipelineFeaturesKHR32;
1938
1939 typedef struct VkPhysicalDeviceRayQueryFeaturesKHR32
1940 {
1941     VkStructureType sType;
1942     PTR32 pNext;
1943     VkBool32 rayQuery;
1944 } VkPhysicalDeviceRayQueryFeaturesKHR32;
1945
1946 typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32
1947 {
1948     VkStructureType sType;
1949     PTR32 pNext;
1950     VkBool32 rayTracingMaintenance1;
1951     VkBool32 rayTracingPipelineTraceRaysIndirect2;
1952 } VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32;
1953
1954 typedef struct VkDeviceMemoryOverallocationCreateInfoAMD32
1955 {
1956     VkStructureType sType;
1957     PTR32 pNext;
1958     VkMemoryOverallocationBehaviorAMD overallocationBehavior;
1959 } VkDeviceMemoryOverallocationCreateInfoAMD32;
1960
1961 typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT32
1962 {
1963     VkStructureType sType;
1964     PTR32 pNext;
1965     VkBool32 fragmentDensityMap;
1966     VkBool32 fragmentDensityMapDynamic;
1967     VkBool32 fragmentDensityMapNonSubsampledImages;
1968 } VkPhysicalDeviceFragmentDensityMapFeaturesEXT32;
1969
1970 typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32
1971 {
1972     VkStructureType sType;
1973     PTR32 pNext;
1974     VkBool32 fragmentDensityMapDeferred;
1975 } VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32;
1976
1977 typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32
1978 {
1979     VkStructureType sType;
1980     PTR32 pNext;
1981     VkBool32 fragmentDensityMapOffset;
1982 } VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32;
1983
1984 typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures32
1985 {
1986     VkStructureType sType;
1987     PTR32 pNext;
1988     VkBool32 scalarBlockLayout;
1989 } VkPhysicalDeviceScalarBlockLayoutFeatures32;
1990 typedef VkPhysicalDeviceScalarBlockLayoutFeatures32 VkPhysicalDeviceScalarBlockLayoutFeaturesEXT32;
1991
1992 typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures32
1993 {
1994     VkStructureType sType;
1995     PTR32 pNext;
1996     VkBool32 uniformBufferStandardLayout;
1997 } VkPhysicalDeviceUniformBufferStandardLayoutFeatures32;
1998 typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR32;
1999
2000 typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT32
2001 {
2002     VkStructureType sType;
2003     PTR32 pNext;
2004     VkBool32 depthClipEnable;
2005 } VkPhysicalDeviceDepthClipEnableFeaturesEXT32;
2006
2007 typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT32
2008 {
2009     VkStructureType sType;
2010     PTR32 pNext;
2011     VkBool32 memoryPriority;
2012 } VkPhysicalDeviceMemoryPriorityFeaturesEXT32;
2013
2014 typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32
2015 {
2016     VkStructureType sType;
2017     PTR32 pNext;
2018     VkBool32 pageableDeviceLocalMemory;
2019 } VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32;
2020
2021 typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures32
2022 {
2023     VkStructureType sType;
2024     PTR32 pNext;
2025     VkBool32 bufferDeviceAddress;
2026     VkBool32 bufferDeviceAddressCaptureReplay;
2027     VkBool32 bufferDeviceAddressMultiDevice;
2028 } VkPhysicalDeviceBufferDeviceAddressFeatures32;
2029 typedef VkPhysicalDeviceBufferDeviceAddressFeatures32 VkPhysicalDeviceBufferDeviceAddressFeaturesKHR32;
2030
2031 typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32
2032 {
2033     VkStructureType sType;
2034     PTR32 pNext;
2035     VkBool32 bufferDeviceAddress;
2036     VkBool32 bufferDeviceAddressCaptureReplay;
2037     VkBool32 bufferDeviceAddressMultiDevice;
2038 } VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32;
2039 typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 VkPhysicalDeviceBufferAddressFeaturesEXT32;
2040
2041 typedef struct VkPhysicalDeviceImagelessFramebufferFeatures32
2042 {
2043     VkStructureType sType;
2044     PTR32 pNext;
2045     VkBool32 imagelessFramebuffer;
2046 } VkPhysicalDeviceImagelessFramebufferFeatures32;
2047 typedef VkPhysicalDeviceImagelessFramebufferFeatures32 VkPhysicalDeviceImagelessFramebufferFeaturesKHR32;
2048
2049 typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures32
2050 {
2051     VkStructureType sType;
2052     PTR32 pNext;
2053     VkBool32 textureCompressionASTC_HDR;
2054 } VkPhysicalDeviceTextureCompressionASTCHDRFeatures32;
2055 typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT32;
2056
2057 typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV32
2058 {
2059     VkStructureType sType;
2060     PTR32 pNext;
2061     VkBool32 cooperativeMatrix;
2062     VkBool32 cooperativeMatrixRobustBufferAccess;
2063 } VkPhysicalDeviceCooperativeMatrixFeaturesNV32;
2064
2065 typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32
2066 {
2067     VkStructureType sType;
2068     PTR32 pNext;
2069     VkBool32 ycbcrImageArrays;
2070 } VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32;
2071
2072 typedef struct VkPhysicalDevicePresentBarrierFeaturesNV32
2073 {
2074     VkStructureType sType;
2075     PTR32 pNext;
2076     VkBool32 presentBarrier;
2077 } VkPhysicalDevicePresentBarrierFeaturesNV32;
2078
2079 typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR32
2080 {
2081     VkStructureType sType;
2082     PTR32 pNext;
2083     VkBool32 performanceCounterQueryPools;
2084     VkBool32 performanceCounterMultipleQueryPools;
2085 } VkPhysicalDevicePerformanceQueryFeaturesKHR32;
2086
2087 typedef struct VkPerformanceQueryReservationInfoKHR32
2088 {
2089     VkStructureType sType;
2090     PTR32 pNext;
2091     uint32_t maxPerformanceQueriesPerPool;
2092 } VkPerformanceQueryReservationInfoKHR32;
2093
2094 typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV32
2095 {
2096     VkStructureType sType;
2097     PTR32 pNext;
2098     VkBool32 coverageReductionMode;
2099 } VkPhysicalDeviceCoverageReductionModeFeaturesNV32;
2100
2101 typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32
2102 {
2103     VkStructureType sType;
2104     PTR32 pNext;
2105     VkBool32 shaderIntegerFunctions2;
2106 } VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32;
2107
2108 typedef struct VkPhysicalDeviceShaderClockFeaturesKHR32
2109 {
2110     VkStructureType sType;
2111     PTR32 pNext;
2112     VkBool32 shaderSubgroupClock;
2113     VkBool32 shaderDeviceClock;
2114 } VkPhysicalDeviceShaderClockFeaturesKHR32;
2115
2116 typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT32
2117 {
2118     VkStructureType sType;
2119     PTR32 pNext;
2120     VkBool32 indexTypeUint8;
2121 } VkPhysicalDeviceIndexTypeUint8FeaturesEXT32;
2122
2123 typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32
2124 {
2125     VkStructureType sType;
2126     PTR32 pNext;
2127     VkBool32 shaderSMBuiltins;
2128 } VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32;
2129
2130 typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32
2131 {
2132     VkStructureType sType;
2133     PTR32 pNext;
2134     VkBool32 fragmentShaderSampleInterlock;
2135     VkBool32 fragmentShaderPixelInterlock;
2136     VkBool32 fragmentShaderShadingRateInterlock;
2137 } VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32;
2138
2139 typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32
2140 {
2141     VkStructureType sType;
2142     PTR32 pNext;
2143     VkBool32 separateDepthStencilLayouts;
2144 } VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32;
2145 typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR32;
2146
2147 typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32
2148 {
2149     VkStructureType sType;
2150     PTR32 pNext;
2151     VkBool32 primitiveTopologyListRestart;
2152     VkBool32 primitiveTopologyPatchListRestart;
2153 } VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32;
2154
2155 typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32
2156 {
2157     VkStructureType sType;
2158     PTR32 pNext;
2159     VkBool32 pipelineExecutableInfo;
2160 } VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32;
2161
2162 typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32
2163 {
2164     VkStructureType sType;
2165     PTR32 pNext;
2166     VkBool32 shaderDemoteToHelperInvocation;
2167 } VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32;
2168 typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT32;
2169
2170 typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32
2171 {
2172     VkStructureType sType;
2173     PTR32 pNext;
2174     VkBool32 texelBufferAlignment;
2175 } VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32;
2176
2177 typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures32
2178 {
2179     VkStructureType sType;
2180     PTR32 pNext;
2181     VkBool32 subgroupSizeControl;
2182     VkBool32 computeFullSubgroups;
2183 } VkPhysicalDeviceSubgroupSizeControlFeatures32;
2184 typedef VkPhysicalDeviceSubgroupSizeControlFeatures32 VkPhysicalDeviceSubgroupSizeControlFeaturesEXT32;
2185
2186 typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT32
2187 {
2188     VkStructureType sType;
2189     PTR32 pNext;
2190     VkBool32 rectangularLines;
2191     VkBool32 bresenhamLines;
2192     VkBool32 smoothLines;
2193     VkBool32 stippledRectangularLines;
2194     VkBool32 stippledBresenhamLines;
2195     VkBool32 stippledSmoothLines;
2196 } VkPhysicalDeviceLineRasterizationFeaturesEXT32;
2197
2198 typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures32
2199 {
2200     VkStructureType sType;
2201     PTR32 pNext;
2202     VkBool32 pipelineCreationCacheControl;
2203 } VkPhysicalDevicePipelineCreationCacheControlFeatures32;
2204 typedef VkPhysicalDevicePipelineCreationCacheControlFeatures32 VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT32;
2205
2206 typedef struct VkPhysicalDeviceVulkan11Features32
2207 {
2208     VkStructureType sType;
2209     PTR32 pNext;
2210     VkBool32 storageBuffer16BitAccess;
2211     VkBool32 uniformAndStorageBuffer16BitAccess;
2212     VkBool32 storagePushConstant16;
2213     VkBool32 storageInputOutput16;
2214     VkBool32 multiview;
2215     VkBool32 multiviewGeometryShader;
2216     VkBool32 multiviewTessellationShader;
2217     VkBool32 variablePointersStorageBuffer;
2218     VkBool32 variablePointers;
2219     VkBool32 protectedMemory;
2220     VkBool32 samplerYcbcrConversion;
2221     VkBool32 shaderDrawParameters;
2222 } VkPhysicalDeviceVulkan11Features32;
2223
2224 typedef struct VkPhysicalDeviceVulkan12Features32
2225 {
2226     VkStructureType sType;
2227     PTR32 pNext;
2228     VkBool32 samplerMirrorClampToEdge;
2229     VkBool32 drawIndirectCount;
2230     VkBool32 storageBuffer8BitAccess;
2231     VkBool32 uniformAndStorageBuffer8BitAccess;
2232     VkBool32 storagePushConstant8;
2233     VkBool32 shaderBufferInt64Atomics;
2234     VkBool32 shaderSharedInt64Atomics;
2235     VkBool32 shaderFloat16;
2236     VkBool32 shaderInt8;
2237     VkBool32 descriptorIndexing;
2238     VkBool32 shaderInputAttachmentArrayDynamicIndexing;
2239     VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
2240     VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
2241     VkBool32 shaderUniformBufferArrayNonUniformIndexing;
2242     VkBool32 shaderSampledImageArrayNonUniformIndexing;
2243     VkBool32 shaderStorageBufferArrayNonUniformIndexing;
2244     VkBool32 shaderStorageImageArrayNonUniformIndexing;
2245     VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
2246     VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
2247     VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
2248     VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
2249     VkBool32 descriptorBindingSampledImageUpdateAfterBind;
2250     VkBool32 descriptorBindingStorageImageUpdateAfterBind;
2251     VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
2252     VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
2253     VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
2254     VkBool32 descriptorBindingUpdateUnusedWhilePending;
2255     VkBool32 descriptorBindingPartiallyBound;
2256     VkBool32 descriptorBindingVariableDescriptorCount;
2257     VkBool32 runtimeDescriptorArray;
2258     VkBool32 samplerFilterMinmax;
2259     VkBool32 scalarBlockLayout;
2260     VkBool32 imagelessFramebuffer;
2261     VkBool32 uniformBufferStandardLayout;
2262     VkBool32 shaderSubgroupExtendedTypes;
2263     VkBool32 separateDepthStencilLayouts;
2264     VkBool32 hostQueryReset;
2265     VkBool32 timelineSemaphore;
2266     VkBool32 bufferDeviceAddress;
2267     VkBool32 bufferDeviceAddressCaptureReplay;
2268     VkBool32 bufferDeviceAddressMultiDevice;
2269     VkBool32 vulkanMemoryModel;
2270     VkBool32 vulkanMemoryModelDeviceScope;
2271     VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
2272     VkBool32 shaderOutputViewportIndex;
2273     VkBool32 shaderOutputLayer;
2274     VkBool32 subgroupBroadcastDynamicId;
2275 } VkPhysicalDeviceVulkan12Features32;
2276
2277 typedef struct VkPhysicalDeviceVulkan13Features32
2278 {
2279     VkStructureType sType;
2280     PTR32 pNext;
2281     VkBool32 robustImageAccess;
2282     VkBool32 inlineUniformBlock;
2283     VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
2284     VkBool32 pipelineCreationCacheControl;
2285     VkBool32 privateData;
2286     VkBool32 shaderDemoteToHelperInvocation;
2287     VkBool32 shaderTerminateInvocation;
2288     VkBool32 subgroupSizeControl;
2289     VkBool32 computeFullSubgroups;
2290     VkBool32 synchronization2;
2291     VkBool32 textureCompressionASTC_HDR;
2292     VkBool32 shaderZeroInitializeWorkgroupMemory;
2293     VkBool32 dynamicRendering;
2294     VkBool32 shaderIntegerDotProduct;
2295     VkBool32 maintenance4;
2296 } VkPhysicalDeviceVulkan13Features32;
2297
2298 typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD32
2299 {
2300     VkStructureType sType;
2301     PTR32 pNext;
2302     VkBool32 deviceCoherentMemory;
2303 } VkPhysicalDeviceCoherentMemoryFeaturesAMD32;
2304
2305 typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT32
2306 {
2307     VkStructureType sType;
2308     PTR32 pNext;
2309     VkBool32 customBorderColors;
2310     VkBool32 customBorderColorWithoutFormat;
2311 } VkPhysicalDeviceCustomBorderColorFeaturesEXT32;
2312
2313 typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32
2314 {
2315     VkStructureType sType;
2316     PTR32 pNext;
2317     VkBool32 borderColorSwizzle;
2318     VkBool32 borderColorSwizzleFromImage;
2319 } VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32;
2320
2321 typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32
2322 {
2323     VkStructureType sType;
2324     PTR32 pNext;
2325     VkBool32 extendedDynamicState;
2326 } VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32;
2327
2328 typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32
2329 {
2330     VkStructureType sType;
2331     PTR32 pNext;
2332     VkBool32 extendedDynamicState2;
2333     VkBool32 extendedDynamicState2LogicOp;
2334     VkBool32 extendedDynamicState2PatchControlPoints;
2335 } VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32;
2336
2337 typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32
2338 {
2339     VkStructureType sType;
2340     PTR32 pNext;
2341     VkBool32 extendedDynamicState3TessellationDomainOrigin;
2342     VkBool32 extendedDynamicState3DepthClampEnable;
2343     VkBool32 extendedDynamicState3PolygonMode;
2344     VkBool32 extendedDynamicState3RasterizationSamples;
2345     VkBool32 extendedDynamicState3SampleMask;
2346     VkBool32 extendedDynamicState3AlphaToCoverageEnable;
2347     VkBool32 extendedDynamicState3AlphaToOneEnable;
2348     VkBool32 extendedDynamicState3LogicOpEnable;
2349     VkBool32 extendedDynamicState3ColorBlendEnable;
2350     VkBool32 extendedDynamicState3ColorBlendEquation;
2351     VkBool32 extendedDynamicState3ColorWriteMask;
2352     VkBool32 extendedDynamicState3RasterizationStream;
2353     VkBool32 extendedDynamicState3ConservativeRasterizationMode;
2354     VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize;
2355     VkBool32 extendedDynamicState3DepthClipEnable;
2356     VkBool32 extendedDynamicState3SampleLocationsEnable;
2357     VkBool32 extendedDynamicState3ColorBlendAdvanced;
2358     VkBool32 extendedDynamicState3ProvokingVertexMode;
2359     VkBool32 extendedDynamicState3LineRasterizationMode;
2360     VkBool32 extendedDynamicState3LineStippleEnable;
2361     VkBool32 extendedDynamicState3DepthClipNegativeOneToOne;
2362     VkBool32 extendedDynamicState3ViewportWScalingEnable;
2363     VkBool32 extendedDynamicState3ViewportSwizzle;
2364     VkBool32 extendedDynamicState3CoverageToColorEnable;
2365     VkBool32 extendedDynamicState3CoverageToColorLocation;
2366     VkBool32 extendedDynamicState3CoverageModulationMode;
2367     VkBool32 extendedDynamicState3CoverageModulationTableEnable;
2368     VkBool32 extendedDynamicState3CoverageModulationTable;
2369     VkBool32 extendedDynamicState3CoverageReductionMode;
2370     VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable;
2371     VkBool32 extendedDynamicState3ShadingRateImageEnable;
2372 } VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32;
2373
2374 typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV32
2375 {
2376     VkStructureType sType;
2377     PTR32 pNext;
2378     VkBool32 diagnosticsConfig;
2379 } VkPhysicalDeviceDiagnosticsConfigFeaturesNV32;
2380
2381 typedef struct VkDeviceDiagnosticsConfigCreateInfoNV32
2382 {
2383     VkStructureType sType;
2384     PTR32 pNext;
2385     VkDeviceDiagnosticsConfigFlagsNV flags;
2386 } VkDeviceDiagnosticsConfigCreateInfoNV32;
2387
2388 typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32
2389 {
2390     VkStructureType sType;
2391     PTR32 pNext;
2392     VkBool32 shaderZeroInitializeWorkgroupMemory;
2393 } VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32;
2394 typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR32;
2395
2396 typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32
2397 {
2398     VkStructureType sType;
2399     PTR32 pNext;
2400     VkBool32 shaderSubgroupUniformControlFlow;
2401 } VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32;
2402
2403 typedef struct VkPhysicalDeviceRobustness2FeaturesEXT32
2404 {
2405     VkStructureType sType;
2406     PTR32 pNext;
2407     VkBool32 robustBufferAccess2;
2408     VkBool32 robustImageAccess2;
2409     VkBool32 nullDescriptor;
2410 } VkPhysicalDeviceRobustness2FeaturesEXT32;
2411
2412 typedef struct VkPhysicalDeviceImageRobustnessFeatures32
2413 {
2414     VkStructureType sType;
2415     PTR32 pNext;
2416     VkBool32 robustImageAccess;
2417 } VkPhysicalDeviceImageRobustnessFeatures32;
2418 typedef VkPhysicalDeviceImageRobustnessFeatures32 VkPhysicalDeviceImageRobustnessFeaturesEXT32;
2419
2420 typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32
2421 {
2422     VkStructureType sType;
2423     PTR32 pNext;
2424     VkBool32 workgroupMemoryExplicitLayout;
2425     VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout;
2426     VkBool32 workgroupMemoryExplicitLayout8BitAccess;
2427     VkBool32 workgroupMemoryExplicitLayout16BitAccess;
2428 } VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32;
2429
2430 typedef struct VkPhysicalDevice4444FormatsFeaturesEXT32
2431 {
2432     VkStructureType sType;
2433     PTR32 pNext;
2434     VkBool32 formatA4R4G4B4;
2435     VkBool32 formatA4B4G4R4;
2436 } VkPhysicalDevice4444FormatsFeaturesEXT32;
2437
2438 typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32
2439 {
2440     VkStructureType sType;
2441     PTR32 pNext;
2442     VkBool32 subpassShading;
2443 } VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32;
2444
2445 typedef struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32
2446 {
2447     VkStructureType sType;
2448     PTR32 pNext;
2449     VkBool32 clustercullingShader;
2450     VkBool32 multiviewClusterCullingShader;
2451 } VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32;
2452
2453 typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32
2454 {
2455     VkStructureType sType;
2456     PTR32 pNext;
2457     VkBool32 shaderImageInt64Atomics;
2458     VkBool32 sparseImageInt64Atomics;
2459 } VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32;
2460
2461 typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR32
2462 {
2463     VkStructureType sType;
2464     PTR32 pNext;
2465     VkBool32 pipelineFragmentShadingRate;
2466     VkBool32 primitiveFragmentShadingRate;
2467     VkBool32 attachmentFragmentShadingRate;
2468 } VkPhysicalDeviceFragmentShadingRateFeaturesKHR32;
2469
2470 typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures32
2471 {
2472     VkStructureType sType;
2473     PTR32 pNext;
2474     VkBool32 shaderTerminateInvocation;
2475 } VkPhysicalDeviceShaderTerminateInvocationFeatures32;
2476 typedef VkPhysicalDeviceShaderTerminateInvocationFeatures32 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR32;
2477
2478 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32
2479 {
2480     VkStructureType sType;
2481     PTR32 pNext;
2482     VkBool32 fragmentShadingRateEnums;
2483     VkBool32 supersampleFragmentShadingRates;
2484     VkBool32 noInvocationFragmentShadingRates;
2485 } VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32;
2486
2487 typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32
2488 {
2489     VkStructureType sType;
2490     PTR32 pNext;
2491     VkBool32 image2DViewOf3D;
2492     VkBool32 sampler2DViewOf3D;
2493 } VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32;
2494
2495 typedef struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32
2496 {
2497     VkStructureType sType;
2498     PTR32 pNext;
2499     VkBool32 imageSlicedViewOf3D;
2500 } VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32;
2501
2502 typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32
2503 {
2504     VkStructureType sType;
2505     PTR32 pNext;
2506     VkBool32 attachmentFeedbackLoopDynamicState;
2507 } VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32;
2508
2509 typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32
2510 {
2511     VkStructureType sType;
2512     PTR32 pNext;
2513     VkBool32 mutableDescriptorType;
2514 } VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32;
2515 typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE32;
2516
2517 typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT32
2518 {
2519     VkStructureType sType;
2520     PTR32 pNext;
2521     VkBool32 depthClipControl;
2522 } VkPhysicalDeviceDepthClipControlFeaturesEXT32;
2523
2524 typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32
2525 {
2526     VkStructureType sType;
2527     PTR32 pNext;
2528     VkBool32 vertexInputDynamicState;
2529 } VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32;
2530
2531 typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT32
2532 {
2533     VkStructureType sType;
2534     PTR32 pNext;
2535     VkBool32 colorWriteEnable;
2536 } VkPhysicalDeviceColorWriteEnableFeaturesEXT32;
2537
2538 typedef struct VkPhysicalDeviceSynchronization2Features32
2539 {
2540     VkStructureType sType;
2541     PTR32 pNext;
2542     VkBool32 synchronization2;
2543 } VkPhysicalDeviceSynchronization2Features32;
2544 typedef VkPhysicalDeviceSynchronization2Features32 VkPhysicalDeviceSynchronization2FeaturesKHR32;
2545
2546 typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32
2547 {
2548     VkStructureType sType;
2549     PTR32 pNext;
2550     VkBool32 primitivesGeneratedQuery;
2551     VkBool32 primitivesGeneratedQueryWithRasterizerDiscard;
2552     VkBool32 primitivesGeneratedQueryWithNonZeroStreams;
2553 } VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32;
2554
2555 typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT32
2556 {
2557     VkStructureType sType;
2558     PTR32 pNext;
2559     VkBool32 legacyDithering;
2560 } VkPhysicalDeviceLegacyDitheringFeaturesEXT32;
2561
2562 typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32
2563 {
2564     VkStructureType sType;
2565     PTR32 pNext;
2566     VkBool32 multisampledRenderToSingleSampled;
2567 } VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32;
2568
2569 typedef struct VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32
2570 {
2571     VkStructureType sType;
2572     PTR32 pNext;
2573     VkBool32 pipelineProtectedAccess;
2574 } VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32;
2575
2576 typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV32
2577 {
2578     VkStructureType sType;
2579     PTR32 pNext;
2580     VkBool32 inheritedViewportScissor2D;
2581 } VkPhysicalDeviceInheritedViewportScissorFeaturesNV32;
2582
2583 typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32
2584 {
2585     VkStructureType sType;
2586     PTR32 pNext;
2587     VkBool32 ycbcr2plane444Formats;
2588 } VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32;
2589
2590 typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT32
2591 {
2592     VkStructureType sType;
2593     PTR32 pNext;
2594     VkBool32 provokingVertexLast;
2595     VkBool32 transformFeedbackPreservesProvokingVertex;
2596 } VkPhysicalDeviceProvokingVertexFeaturesEXT32;
2597
2598 typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT32
2599 {
2600     VkStructureType sType;
2601     PTR32 pNext;
2602     VkBool32 descriptorBuffer;
2603     VkBool32 descriptorBufferCaptureReplay;
2604     VkBool32 descriptorBufferImageLayoutIgnored;
2605     VkBool32 descriptorBufferPushDescriptors;
2606 } VkPhysicalDeviceDescriptorBufferFeaturesEXT32;
2607
2608 typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures32
2609 {
2610     VkStructureType sType;
2611     PTR32 pNext;
2612     VkBool32 shaderIntegerDotProduct;
2613 } VkPhysicalDeviceShaderIntegerDotProductFeatures32;
2614 typedef VkPhysicalDeviceShaderIntegerDotProductFeatures32 VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR32;
2615
2616 typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32
2617 {
2618     VkStructureType sType;
2619     PTR32 pNext;
2620     VkBool32 fragmentShaderBarycentric;
2621 } VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32;
2622 typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV32;
2623
2624 typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32
2625 {
2626     VkStructureType sType;
2627     PTR32 pNext;
2628     VkBool32 rayTracingMotionBlur;
2629     VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect;
2630 } VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32;
2631
2632 typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32
2633 {
2634     VkStructureType sType;
2635     PTR32 pNext;
2636     VkBool32 formatRgba10x6WithoutYCbCrSampler;
2637 } VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32;
2638
2639 typedef struct VkPhysicalDeviceDynamicRenderingFeatures32
2640 {
2641     VkStructureType sType;
2642     PTR32 pNext;
2643     VkBool32 dynamicRendering;
2644 } VkPhysicalDeviceDynamicRenderingFeatures32;
2645 typedef VkPhysicalDeviceDynamicRenderingFeatures32 VkPhysicalDeviceDynamicRenderingFeaturesKHR32;
2646
2647 typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT32
2648 {
2649     VkStructureType sType;
2650     PTR32 pNext;
2651     VkBool32 minLod;
2652 } VkPhysicalDeviceImageViewMinLodFeaturesEXT32;
2653
2654 typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32
2655 {
2656     VkStructureType sType;
2657     PTR32 pNext;
2658     VkBool32 rasterizationOrderColorAttachmentAccess;
2659     VkBool32 rasterizationOrderDepthAttachmentAccess;
2660     VkBool32 rasterizationOrderStencilAttachmentAccess;
2661 } VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32;
2662 typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM32;
2663
2664 typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV32
2665 {
2666     VkStructureType sType;
2667     PTR32 pNext;
2668     VkBool32 linearColorAttachment;
2669 } VkPhysicalDeviceLinearColorAttachmentFeaturesNV32;
2670
2671 typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32
2672 {
2673     VkStructureType sType;
2674     PTR32 pNext;
2675     VkBool32 graphicsPipelineLibrary;
2676 } VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32;
2677
2678 typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32
2679 {
2680     VkStructureType sType;
2681     PTR32 pNext;
2682     VkBool32 descriptorSetHostMapping;
2683 } VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32;
2684
2685 typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32
2686 {
2687     VkStructureType sType;
2688     PTR32 pNext;
2689     VkBool32 shaderModuleIdentifier;
2690 } VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32;
2691
2692 typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT32
2693 {
2694     VkStructureType sType;
2695     PTR32 pNext;
2696     VkBool32 imageCompressionControl;
2697 } VkPhysicalDeviceImageCompressionControlFeaturesEXT32;
2698
2699 typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32
2700 {
2701     VkStructureType sType;
2702     PTR32 pNext;
2703     VkBool32 imageCompressionControlSwapchain;
2704 } VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32;
2705
2706 typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32
2707 {
2708     VkStructureType sType;
2709     PTR32 pNext;
2710     VkBool32 subpassMergeFeedback;
2711 } VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32;
2712
2713 typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT32
2714 {
2715     VkStructureType sType;
2716     PTR32 pNext;
2717     VkBool32 micromap;
2718     VkBool32 micromapCaptureReplay;
2719     VkBool32 micromapHostCommands;
2720 } VkPhysicalDeviceOpacityMicromapFeaturesEXT32;
2721
2722 typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT32
2723 {
2724     VkStructureType sType;
2725     PTR32 pNext;
2726     VkBool32 pipelinePropertiesIdentifier;
2727 } VkPhysicalDevicePipelinePropertiesFeaturesEXT32;
2728
2729 typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32
2730 {
2731     VkStructureType sType;
2732     PTR32 pNext;
2733     VkBool32 shaderEarlyAndLateFragmentTests;
2734 } VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32;
2735
2736 typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32
2737 {
2738     VkStructureType sType;
2739     PTR32 pNext;
2740     VkBool32 nonSeamlessCubeMap;
2741 } VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32;
2742
2743 typedef struct VkPhysicalDevicePipelineRobustnessFeaturesEXT32
2744 {
2745     VkStructureType sType;
2746     PTR32 pNext;
2747     VkBool32 pipelineRobustness;
2748 } VkPhysicalDevicePipelineRobustnessFeaturesEXT32;
2749
2750 typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM32
2751 {
2752     VkStructureType sType;
2753     PTR32 pNext;
2754     VkBool32 textureSampleWeighted;
2755     VkBool32 textureBoxFilter;
2756     VkBool32 textureBlockMatch;
2757 } VkPhysicalDeviceImageProcessingFeaturesQCOM32;
2758
2759 typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM32
2760 {
2761     VkStructureType sType;
2762     PTR32 pNext;
2763     VkBool32 tileProperties;
2764 } VkPhysicalDeviceTilePropertiesFeaturesQCOM32;
2765
2766 typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32
2767 {
2768     VkStructureType sType;
2769     PTR32 pNext;
2770     VkBool32 attachmentFeedbackLoopLayout;
2771 } VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32;
2772
2773 typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32
2774 {
2775     VkStructureType sType;
2776     PTR32 pNext;
2777     VkBool32 depthClampZeroOne;
2778 } VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32;
2779
2780 typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT32
2781 {
2782     VkStructureType sType;
2783     PTR32 pNext;
2784     VkBool32 reportAddressBinding;
2785 } VkPhysicalDeviceAddressBindingReportFeaturesEXT32;
2786
2787 typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV32
2788 {
2789     VkStructureType sType;
2790     PTR32 pNext;
2791     VkBool32 opticalFlow;
2792 } VkPhysicalDeviceOpticalFlowFeaturesNV32;
2793
2794 typedef struct VkPhysicalDeviceFaultFeaturesEXT32
2795 {
2796     VkStructureType sType;
2797     PTR32 pNext;
2798     VkBool32 deviceFault;
2799     VkBool32 deviceFaultVendorBinary;
2800 } VkPhysicalDeviceFaultFeaturesEXT32;
2801
2802 typedef struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32
2803 {
2804     VkStructureType sType;
2805     PTR32 pNext;
2806     VkBool32 pipelineLibraryGroupHandles;
2807 } VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32;
2808
2809 typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32
2810 {
2811     VkStructureType sType;
2812     PTR32 pNext;
2813     VkBool32 shaderCoreBuiltins;
2814 } VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32;
2815
2816 typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32
2817 {
2818     VkStructureType sType;
2819     PTR32 pNext;
2820     VkBool32 dynamicRenderingUnusedAttachments;
2821 } VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32;
2822
2823 typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32
2824 {
2825     VkStructureType sType;
2826     PTR32 pNext;
2827     VkBool32 swapchainMaintenance1;
2828 } VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32;
2829
2830 typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT32
2831 {
2832     VkStructureType sType;
2833     PTR32 pNext;
2834     VkBool32 depthBiasControl;
2835     VkBool32 leastRepresentableValueForceUnormRepresentation;
2836     VkBool32 floatRepresentation;
2837     VkBool32 depthBiasExact;
2838 } VkPhysicalDeviceDepthBiasControlFeaturesEXT32;
2839
2840 typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32
2841 {
2842     VkStructureType sType;
2843     PTR32 pNext;
2844     VkBool32 rayTracingInvocationReorder;
2845 } VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32;
2846
2847 typedef struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32
2848 {
2849     VkStructureType sType;
2850     PTR32 pNext;
2851     VkBool32 multiviewPerViewViewports;
2852 } VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32;
2853
2854 typedef struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32
2855 {
2856     VkStructureType sType;
2857     PTR32 pNext;
2858     VkBool32 rayTracingPositionFetch;
2859 } VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32;
2860
2861 typedef struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32
2862 {
2863     VkStructureType sType;
2864     PTR32 pNext;
2865     VkBool32 multiviewPerViewRenderAreas;
2866 } VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32;
2867
2868 typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT32
2869 {
2870     VkStructureType sType;
2871     PTR32 pNext;
2872     VkBool32 shaderObject;
2873 } VkPhysicalDeviceShaderObjectFeaturesEXT32;
2874
2875 typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT32
2876 {
2877     VkStructureType sType;
2878     PTR32 pNext;
2879     VkBool32 shaderTileImageColorReadAccess;
2880     VkBool32 shaderTileImageDepthReadAccess;
2881     VkBool32 shaderTileImageStencilReadAccess;
2882 } VkPhysicalDeviceShaderTileImageFeaturesEXT32;
2883
2884 typedef struct VkDeviceCreateInfo32
2885 {
2886     VkStructureType sType;
2887     PTR32 pNext;
2888     VkDeviceCreateFlags flags;
2889     uint32_t queueCreateInfoCount;
2890     PTR32 pQueueCreateInfos;
2891     uint32_t enabledLayerCount;
2892     PTR32 ppEnabledLayerNames;
2893     uint32_t enabledExtensionCount;
2894     PTR32 ppEnabledExtensionNames;
2895     PTR32 pEnabledFeatures;
2896 } VkDeviceCreateInfo32;
2897
2898 typedef struct VkEventCreateInfo32
2899 {
2900     VkStructureType sType;
2901     PTR32 pNext;
2902     VkEventCreateFlags flags;
2903 } VkEventCreateInfo32;
2904
2905 typedef struct VkExportFenceCreateInfo32
2906 {
2907     VkStructureType sType;
2908     PTR32 pNext;
2909     VkExternalFenceHandleTypeFlags handleTypes;
2910 } VkExportFenceCreateInfo32;
2911 typedef VkExportFenceCreateInfo32 VkExportFenceCreateInfoKHR32;
2912
2913 typedef struct VkFenceCreateInfo32
2914 {
2915     VkStructureType sType;
2916     PTR32 pNext;
2917     VkFenceCreateFlags flags;
2918 } VkFenceCreateInfo32;
2919
2920 typedef struct VkFramebufferAttachmentImageInfo32
2921 {
2922     VkStructureType sType;
2923     PTR32 pNext;
2924     VkImageCreateFlags flags;
2925     VkImageUsageFlags usage;
2926     uint32_t width;
2927     uint32_t height;
2928     uint32_t layerCount;
2929     uint32_t viewFormatCount;
2930     PTR32 pViewFormats;
2931 } VkFramebufferAttachmentImageInfo32;
2932 typedef VkFramebufferAttachmentImageInfo32 VkFramebufferAttachmentImageInfoKHR32;
2933
2934 typedef struct VkFramebufferAttachmentsCreateInfo32
2935 {
2936     VkStructureType sType;
2937     PTR32 pNext;
2938     uint32_t attachmentImageInfoCount;
2939     PTR32 pAttachmentImageInfos;
2940 } VkFramebufferAttachmentsCreateInfo32;
2941 typedef VkFramebufferAttachmentsCreateInfo32 VkFramebufferAttachmentsCreateInfoKHR32;
2942
2943 typedef struct VkFramebufferCreateInfo32
2944 {
2945     VkStructureType sType;
2946     PTR32 pNext;
2947     VkFramebufferCreateFlags flags;
2948     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
2949     uint32_t attachmentCount;
2950     PTR32 pAttachments;
2951     uint32_t width;
2952     uint32_t height;
2953     uint32_t layers;
2954 } VkFramebufferCreateInfo32;
2955
2956 typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT32
2957 {
2958     VkStructureType sType;
2959     PTR32 pNext;
2960     uint32_t vertexBindingDivisorCount;
2961     PTR32 pVertexBindingDivisors;
2962 } VkPipelineVertexInputDivisorStateCreateInfoEXT32;
2963
2964 typedef struct VkPipelineVertexInputStateCreateInfo32
2965 {
2966     VkStructureType sType;
2967     PTR32 pNext;
2968     VkPipelineVertexInputStateCreateFlags flags;
2969     uint32_t vertexBindingDescriptionCount;
2970     PTR32 pVertexBindingDescriptions;
2971     uint32_t vertexAttributeDescriptionCount;
2972     PTR32 pVertexAttributeDescriptions;
2973 } VkPipelineVertexInputStateCreateInfo32;
2974
2975 typedef struct VkPipelineTessellationDomainOriginStateCreateInfo32
2976 {
2977     VkStructureType sType;
2978     PTR32 pNext;
2979     VkTessellationDomainOrigin domainOrigin;
2980 } VkPipelineTessellationDomainOriginStateCreateInfo32;
2981 typedef VkPipelineTessellationDomainOriginStateCreateInfo32 VkPipelineTessellationDomainOriginStateCreateInfoKHR32;
2982
2983 typedef struct VkPipelineTessellationStateCreateInfo32
2984 {
2985     VkStructureType sType;
2986     PTR32 pNext;
2987     VkPipelineTessellationStateCreateFlags flags;
2988     uint32_t patchControlPoints;
2989 } VkPipelineTessellationStateCreateInfo32;
2990
2991 typedef struct VkGraphicsShaderGroupCreateInfoNV32
2992 {
2993     VkStructureType sType;
2994     PTR32 pNext;
2995     uint32_t stageCount;
2996     PTR32 pStages;
2997     PTR32 pVertexInputState;
2998     PTR32 pTessellationState;
2999 } VkGraphicsShaderGroupCreateInfoNV32;
3000
3001 typedef struct VkPipelineInputAssemblyStateCreateInfo32
3002 {
3003     VkStructureType sType;
3004     PTR32 pNext;
3005     VkPipelineInputAssemblyStateCreateFlags flags;
3006     VkPrimitiveTopology topology;
3007     VkBool32 primitiveRestartEnable;
3008 } VkPipelineInputAssemblyStateCreateInfo32;
3009
3010 typedef struct VkPipelineViewportWScalingStateCreateInfoNV32
3011 {
3012     VkStructureType sType;
3013     PTR32 pNext;
3014     VkBool32 viewportWScalingEnable;
3015     uint32_t viewportCount;
3016     PTR32 pViewportWScalings;
3017 } VkPipelineViewportWScalingStateCreateInfoNV32;
3018
3019 typedef struct VkPipelineViewportSwizzleStateCreateInfoNV32
3020 {
3021     VkStructureType sType;
3022     PTR32 pNext;
3023     VkPipelineViewportSwizzleStateCreateFlagsNV flags;
3024     uint32_t viewportCount;
3025     PTR32 pViewportSwizzles;
3026 } VkPipelineViewportSwizzleStateCreateInfoNV32;
3027
3028 typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV32
3029 {
3030     VkStructureType sType;
3031     PTR32 pNext;
3032     uint32_t exclusiveScissorCount;
3033     PTR32 pExclusiveScissors;
3034 } VkPipelineViewportExclusiveScissorStateCreateInfoNV32;
3035
3036 typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV32
3037 {
3038     VkStructureType sType;
3039     PTR32 pNext;
3040     VkBool32 shadingRateImageEnable;
3041     uint32_t viewportCount;
3042     PTR32 pShadingRatePalettes;
3043 } VkPipelineViewportShadingRateImageStateCreateInfoNV32;
3044
3045 typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32
3046 {
3047     VkStructureType sType;
3048     PTR32 pNext;
3049     VkCoarseSampleOrderTypeNV sampleOrderType;
3050     uint32_t customSampleOrderCount;
3051     PTR32 pCustomSampleOrders;
3052 } VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32;
3053
3054 typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT32
3055 {
3056     VkStructureType sType;
3057     PTR32 pNext;
3058     VkBool32 negativeOneToOne;
3059 } VkPipelineViewportDepthClipControlCreateInfoEXT32;
3060
3061 typedef struct VkPipelineViewportStateCreateInfo32
3062 {
3063     VkStructureType sType;
3064     PTR32 pNext;
3065     VkPipelineViewportStateCreateFlags flags;
3066     uint32_t viewportCount;
3067     PTR32 pViewports;
3068     uint32_t scissorCount;
3069     PTR32 pScissors;
3070 } VkPipelineViewportStateCreateInfo32;
3071
3072 typedef struct VkPipelineRasterizationStateRasterizationOrderAMD32
3073 {
3074     VkStructureType sType;
3075     PTR32 pNext;
3076     VkRasterizationOrderAMD rasterizationOrder;
3077 } VkPipelineRasterizationStateRasterizationOrderAMD32;
3078
3079 typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT32
3080 {
3081     VkStructureType sType;
3082     PTR32 pNext;
3083     VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
3084     VkConservativeRasterizationModeEXT conservativeRasterizationMode;
3085     float extraPrimitiveOverestimationSize;
3086 } VkPipelineRasterizationConservativeStateCreateInfoEXT32;
3087
3088 typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT32
3089 {
3090     VkStructureType sType;
3091     PTR32 pNext;
3092     VkPipelineRasterizationStateStreamCreateFlagsEXT flags;
3093     uint32_t rasterizationStream;
3094 } VkPipelineRasterizationStateStreamCreateInfoEXT32;
3095
3096 typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT32
3097 {
3098     VkStructureType sType;
3099     PTR32 pNext;
3100     VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags;
3101     VkBool32 depthClipEnable;
3102 } VkPipelineRasterizationDepthClipStateCreateInfoEXT32;
3103
3104 typedef struct VkPipelineRasterizationLineStateCreateInfoEXT32
3105 {
3106     VkStructureType sType;
3107     PTR32 pNext;
3108     VkLineRasterizationModeEXT lineRasterizationMode;
3109     VkBool32 stippledLineEnable;
3110     uint32_t lineStippleFactor;
3111     uint16_t lineStipplePattern;
3112 } VkPipelineRasterizationLineStateCreateInfoEXT32;
3113
3114 typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32
3115 {
3116     VkStructureType sType;
3117     PTR32 pNext;
3118     VkProvokingVertexModeEXT provokingVertexMode;
3119 } VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32;
3120
3121 typedef struct VkPipelineRasterizationStateCreateInfo32
3122 {
3123     VkStructureType sType;
3124     PTR32 pNext;
3125     VkPipelineRasterizationStateCreateFlags flags;
3126     VkBool32 depthClampEnable;
3127     VkBool32 rasterizerDiscardEnable;
3128     VkPolygonMode polygonMode;
3129     VkCullModeFlags cullMode;
3130     VkFrontFace frontFace;
3131     VkBool32 depthBiasEnable;
3132     float depthBiasConstantFactor;
3133     float depthBiasClamp;
3134     float depthBiasSlopeFactor;
3135     float lineWidth;
3136 } VkPipelineRasterizationStateCreateInfo32;
3137
3138 typedef struct VkPipelineCoverageToColorStateCreateInfoNV32
3139 {
3140     VkStructureType sType;
3141     PTR32 pNext;
3142     VkPipelineCoverageToColorStateCreateFlagsNV flags;
3143     VkBool32 coverageToColorEnable;
3144     uint32_t coverageToColorLocation;
3145 } VkPipelineCoverageToColorStateCreateInfoNV32;
3146
3147 typedef struct VkPipelineSampleLocationsStateCreateInfoEXT32
3148 {
3149     VkStructureType sType;
3150     PTR32 pNext;
3151     VkBool32 sampleLocationsEnable;
3152     VkSampleLocationsInfoEXT32 sampleLocationsInfo;
3153 } VkPipelineSampleLocationsStateCreateInfoEXT32;
3154
3155 typedef struct VkPipelineCoverageModulationStateCreateInfoNV32
3156 {
3157     VkStructureType sType;
3158     PTR32 pNext;
3159     VkPipelineCoverageModulationStateCreateFlagsNV flags;
3160     VkCoverageModulationModeNV coverageModulationMode;
3161     VkBool32 coverageModulationTableEnable;
3162     uint32_t coverageModulationTableCount;
3163     PTR32 pCoverageModulationTable;
3164 } VkPipelineCoverageModulationStateCreateInfoNV32;
3165
3166 typedef struct VkPipelineCoverageReductionStateCreateInfoNV32
3167 {
3168     VkStructureType sType;
3169     PTR32 pNext;
3170     VkPipelineCoverageReductionStateCreateFlagsNV flags;
3171     VkCoverageReductionModeNV coverageReductionMode;
3172 } VkPipelineCoverageReductionStateCreateInfoNV32;
3173
3174 typedef struct VkPipelineMultisampleStateCreateInfo32
3175 {
3176     VkStructureType sType;
3177     PTR32 pNext;
3178     VkPipelineMultisampleStateCreateFlags flags;
3179     VkSampleCountFlagBits rasterizationSamples;
3180     VkBool32 sampleShadingEnable;
3181     float minSampleShading;
3182     PTR32 pSampleMask;
3183     VkBool32 alphaToCoverageEnable;
3184     VkBool32 alphaToOneEnable;
3185 } VkPipelineMultisampleStateCreateInfo32;
3186
3187 typedef struct VkPipelineDepthStencilStateCreateInfo32
3188 {
3189     VkStructureType sType;
3190     PTR32 pNext;
3191     VkPipelineDepthStencilStateCreateFlags flags;
3192     VkBool32 depthTestEnable;
3193     VkBool32 depthWriteEnable;
3194     VkCompareOp depthCompareOp;
3195     VkBool32 depthBoundsTestEnable;
3196     VkBool32 stencilTestEnable;
3197     VkStencilOpState front;
3198     VkStencilOpState back;
3199     float minDepthBounds;
3200     float maxDepthBounds;
3201 } VkPipelineDepthStencilStateCreateInfo32;
3202
3203 typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT32
3204 {
3205     VkStructureType sType;
3206     PTR32 pNext;
3207     VkBool32 srcPremultiplied;
3208     VkBool32 dstPremultiplied;
3209     VkBlendOverlapEXT blendOverlap;
3210 } VkPipelineColorBlendAdvancedStateCreateInfoEXT32;
3211
3212 typedef struct VkPipelineColorWriteCreateInfoEXT32
3213 {
3214     VkStructureType sType;
3215     PTR32 pNext;
3216     uint32_t attachmentCount;
3217     PTR32 pColorWriteEnables;
3218 } VkPipelineColorWriteCreateInfoEXT32;
3219
3220 typedef struct VkPipelineColorBlendStateCreateInfo32
3221 {
3222     VkStructureType sType;
3223     PTR32 pNext;
3224     VkPipelineColorBlendStateCreateFlags flags;
3225     VkBool32 logicOpEnable;
3226     VkLogicOp logicOp;
3227     uint32_t attachmentCount;
3228     PTR32 pAttachments;
3229     float blendConstants[4];
3230 } VkPipelineColorBlendStateCreateInfo32;
3231
3232 typedef struct VkPipelineDynamicStateCreateInfo32
3233 {
3234     VkStructureType sType;
3235     PTR32 pNext;
3236     VkPipelineDynamicStateCreateFlags flags;
3237     uint32_t dynamicStateCount;
3238     PTR32 pDynamicStates;
3239 } VkPipelineDynamicStateCreateInfo32;
3240
3241 typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV32
3242 {
3243     VkStructureType sType;
3244     PTR32 pNext;
3245     uint32_t groupCount;
3246     PTR32 pGroups;
3247     uint32_t pipelineCount;
3248     PTR32 pPipelines;
3249 } VkGraphicsPipelineShaderGroupsCreateInfoNV32;
3250
3251 typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT32
3252 {
3253     VkStructureType sType;
3254     PTR32 pNext;
3255     VkPipelineDiscardRectangleStateCreateFlagsEXT flags;
3256     VkDiscardRectangleModeEXT discardRectangleMode;
3257     uint32_t discardRectangleCount;
3258     PTR32 pDiscardRectangles;
3259 } VkPipelineDiscardRectangleStateCreateInfoEXT32;
3260
3261 typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV32
3262 {
3263     VkStructureType sType;
3264     PTR32 pNext;
3265     VkBool32 representativeFragmentTestEnable;
3266 } VkPipelineRepresentativeFragmentTestStateCreateInfoNV32;
3267
3268 typedef struct VkPipelineLibraryCreateInfoKHR32
3269 {
3270     VkStructureType sType;
3271     PTR32 pNext;
3272     uint32_t libraryCount;
3273     PTR32 pLibraries;
3274 } VkPipelineLibraryCreateInfoKHR32;
3275
3276 typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR32
3277 {
3278     VkStructureType sType;
3279     PTR32 pNext;
3280     VkExtent2D fragmentSize;
3281     VkFragmentShadingRateCombinerOpKHR combinerOps[2];
3282 } VkPipelineFragmentShadingRateStateCreateInfoKHR32;
3283
3284 typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV32
3285 {
3286     VkStructureType sType;
3287     PTR32 pNext;
3288     VkFragmentShadingRateTypeNV shadingRateType;
3289     VkFragmentShadingRateNV shadingRate;
3290     VkFragmentShadingRateCombinerOpKHR combinerOps[2];
3291 } VkPipelineFragmentShadingRateEnumStateCreateInfoNV32;
3292
3293 typedef struct VkPipelineRenderingCreateInfo32
3294 {
3295     VkStructureType sType;
3296     PTR32 pNext;
3297     uint32_t viewMask;
3298     uint32_t colorAttachmentCount;
3299     PTR32 pColorAttachmentFormats;
3300     VkFormat depthAttachmentFormat;
3301     VkFormat stencilAttachmentFormat;
3302 } VkPipelineRenderingCreateInfo32;
3303 typedef VkPipelineRenderingCreateInfo32 VkPipelineRenderingCreateInfoKHR32;
3304
3305 typedef struct VkGraphicsPipelineLibraryCreateInfoEXT32
3306 {
3307     VkStructureType sType;
3308     PTR32 pNext;
3309     VkGraphicsPipelineLibraryFlagsEXT flags;
3310 } VkGraphicsPipelineLibraryCreateInfoEXT32;
3311
3312 typedef struct VkGraphicsPipelineCreateInfo32
3313 {
3314     VkStructureType sType;
3315     PTR32 pNext;
3316     VkPipelineCreateFlags flags;
3317     uint32_t stageCount;
3318     PTR32 pStages;
3319     PTR32 pVertexInputState;
3320     PTR32 pInputAssemblyState;
3321     PTR32 pTessellationState;
3322     PTR32 pViewportState;
3323     PTR32 pRasterizationState;
3324     PTR32 pMultisampleState;
3325     PTR32 pDepthStencilState;
3326     PTR32 pColorBlendState;
3327     PTR32 pDynamicState;
3328     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3329     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
3330     uint32_t subpass;
3331     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3332     int32_t basePipelineIndex;
3333 } VkGraphicsPipelineCreateInfo32;
3334
3335 typedef struct VkDedicatedAllocationImageCreateInfoNV32
3336 {
3337     VkStructureType sType;
3338     PTR32 pNext;
3339     VkBool32 dedicatedAllocation;
3340 } VkDedicatedAllocationImageCreateInfoNV32;
3341
3342 typedef struct VkExternalMemoryImageCreateInfo32
3343 {
3344     VkStructureType sType;
3345     PTR32 pNext;
3346     VkExternalMemoryHandleTypeFlags handleTypes;
3347 } VkExternalMemoryImageCreateInfo32;
3348 typedef VkExternalMemoryImageCreateInfo32 VkExternalMemoryImageCreateInfoKHR32;
3349
3350 typedef struct VkImageSwapchainCreateInfoKHR32
3351 {
3352     VkStructureType sType;
3353     PTR32 pNext;
3354     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
3355 } VkImageSwapchainCreateInfoKHR32;
3356
3357 typedef struct VkImageFormatListCreateInfo32
3358 {
3359     VkStructureType sType;
3360     PTR32 pNext;
3361     uint32_t viewFormatCount;
3362     PTR32 pViewFormats;
3363 } VkImageFormatListCreateInfo32;
3364 typedef VkImageFormatListCreateInfo32 VkImageFormatListCreateInfoKHR32;
3365
3366 typedef struct VkImageStencilUsageCreateInfo32
3367 {
3368     VkStructureType sType;
3369     PTR32 pNext;
3370     VkImageUsageFlags stencilUsage;
3371 } VkImageStencilUsageCreateInfo32;
3372 typedef VkImageStencilUsageCreateInfo32 VkImageStencilUsageCreateInfoEXT32;
3373
3374 typedef struct VkImageCompressionControlEXT32
3375 {
3376     VkStructureType sType;
3377     PTR32 pNext;
3378     VkImageCompressionFlagsEXT flags;
3379     uint32_t compressionControlPlaneCount;
3380     PTR32 pFixedRateFlags;
3381 } VkImageCompressionControlEXT32;
3382
3383 typedef struct VkOpticalFlowImageFormatInfoNV32
3384 {
3385     VkStructureType sType;
3386     PTR32 pNext;
3387     VkOpticalFlowUsageFlagsNV usage;
3388 } VkOpticalFlowImageFormatInfoNV32;
3389
3390 typedef struct VkImageCreateInfo32
3391 {
3392     VkStructureType sType;
3393     PTR32 pNext;
3394     VkImageCreateFlags flags;
3395     VkImageType imageType;
3396     VkFormat format;
3397     VkExtent3D extent;
3398     uint32_t mipLevels;
3399     uint32_t arrayLayers;
3400     VkSampleCountFlagBits samples;
3401     VkImageTiling tiling;
3402     VkImageUsageFlags usage;
3403     VkSharingMode sharingMode;
3404     uint32_t queueFamilyIndexCount;
3405     PTR32 pQueueFamilyIndices;
3406     VkImageLayout initialLayout;
3407 } VkImageCreateInfo32;
3408
3409 typedef struct VkImageViewUsageCreateInfo32
3410 {
3411     VkStructureType sType;
3412     PTR32 pNext;
3413     VkImageUsageFlags usage;
3414 } VkImageViewUsageCreateInfo32;
3415 typedef VkImageViewUsageCreateInfo32 VkImageViewUsageCreateInfoKHR32;
3416
3417 typedef struct VkImageViewSlicedCreateInfoEXT32
3418 {
3419     VkStructureType sType;
3420     PTR32 pNext;
3421     uint32_t sliceOffset;
3422     uint32_t sliceCount;
3423 } VkImageViewSlicedCreateInfoEXT32;
3424
3425 typedef struct VkSamplerYcbcrConversionInfo32
3426 {
3427     VkStructureType sType;
3428     PTR32 pNext;
3429     VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) conversion;
3430 } VkSamplerYcbcrConversionInfo32;
3431 typedef VkSamplerYcbcrConversionInfo32 VkSamplerYcbcrConversionInfoKHR32;
3432
3433 typedef struct VkImageViewASTCDecodeModeEXT32
3434 {
3435     VkStructureType sType;
3436     PTR32 pNext;
3437     VkFormat decodeMode;
3438 } VkImageViewASTCDecodeModeEXT32;
3439
3440 typedef struct VkImageViewMinLodCreateInfoEXT32
3441 {
3442     VkStructureType sType;
3443     PTR32 pNext;
3444     float minLod;
3445 } VkImageViewMinLodCreateInfoEXT32;
3446
3447 typedef struct VkImageViewSampleWeightCreateInfoQCOM32
3448 {
3449     VkStructureType sType;
3450     PTR32 pNext;
3451     VkOffset2D filterCenter;
3452     VkExtent2D filterSize;
3453     uint32_t numPhases;
3454 } VkImageViewSampleWeightCreateInfoQCOM32;
3455
3456 typedef struct VkImageViewCreateInfo32
3457 {
3458     VkStructureType sType;
3459     PTR32 pNext;
3460     VkImageViewCreateFlags flags;
3461     VkImage DECLSPEC_ALIGN(8) image;
3462     VkImageViewType viewType;
3463     VkFormat format;
3464     VkComponentMapping components;
3465     VkImageSubresourceRange subresourceRange;
3466 } VkImageViewCreateInfo32;
3467
3468 typedef struct VkIndirectCommandsLayoutTokenNV32
3469 {
3470     VkStructureType sType;
3471     PTR32 pNext;
3472     VkIndirectCommandsTokenTypeNV tokenType;
3473     uint32_t stream;
3474     uint32_t offset;
3475     uint32_t vertexBindingUnit;
3476     VkBool32 vertexDynamicStride;
3477     VkPipelineLayout DECLSPEC_ALIGN(8) pushconstantPipelineLayout;
3478     VkShaderStageFlags pushconstantShaderStageFlags;
3479     uint32_t pushconstantOffset;
3480     uint32_t pushconstantSize;
3481     VkIndirectStateFlagsNV indirectStateFlags;
3482     uint32_t indexTypeCount;
3483     PTR32 pIndexTypes;
3484     PTR32 pIndexTypeValues;
3485 } VkIndirectCommandsLayoutTokenNV32;
3486
3487 typedef struct VkIndirectCommandsLayoutCreateInfoNV32
3488 {
3489     VkStructureType sType;
3490     PTR32 pNext;
3491     VkIndirectCommandsLayoutUsageFlagsNV flags;
3492     VkPipelineBindPoint pipelineBindPoint;
3493     uint32_t tokenCount;
3494     PTR32 pTokens;
3495     uint32_t streamCount;
3496     PTR32 pStreamStrides;
3497 } VkIndirectCommandsLayoutCreateInfoNV32;
3498
3499 typedef struct VkApplicationInfo32
3500 {
3501     VkStructureType sType;
3502     PTR32 pNext;
3503     PTR32 pApplicationName;
3504     uint32_t applicationVersion;
3505     PTR32 pEngineName;
3506     uint32_t engineVersion;
3507     uint32_t apiVersion;
3508 } VkApplicationInfo32;
3509
3510 typedef struct VkValidationFlagsEXT32
3511 {
3512     VkStructureType sType;
3513     PTR32 pNext;
3514     uint32_t disabledValidationCheckCount;
3515     PTR32 pDisabledValidationChecks;
3516 } VkValidationFlagsEXT32;
3517
3518 typedef struct VkValidationFeaturesEXT32
3519 {
3520     VkStructureType sType;
3521     PTR32 pNext;
3522     uint32_t enabledValidationFeatureCount;
3523     PTR32 pEnabledValidationFeatures;
3524     uint32_t disabledValidationFeatureCount;
3525     PTR32 pDisabledValidationFeatures;
3526 } VkValidationFeaturesEXT32;
3527
3528 typedef struct VkInstanceCreateInfo32
3529 {
3530     VkStructureType sType;
3531     PTR32 pNext;
3532     VkInstanceCreateFlags flags;
3533     PTR32 pApplicationInfo;
3534     uint32_t enabledLayerCount;
3535     PTR32 ppEnabledLayerNames;
3536     uint32_t enabledExtensionCount;
3537     PTR32 ppEnabledExtensionNames;
3538 } VkInstanceCreateInfo32;
3539
3540 typedef struct VkMicromapCreateInfoEXT32
3541 {
3542     VkStructureType sType;
3543     PTR32 pNext;
3544     VkMicromapCreateFlagsEXT createFlags;
3545     VkBuffer DECLSPEC_ALIGN(8) buffer;
3546     VkDeviceSize DECLSPEC_ALIGN(8) offset;
3547     VkDeviceSize DECLSPEC_ALIGN(8) size;
3548     VkMicromapTypeEXT type;
3549     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
3550 } VkMicromapCreateInfoEXT32;
3551
3552 typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV32
3553 {
3554     VkStructureType sType;
3555     PTR32 pNext;
3556     uint32_t id;
3557     uint32_t size;
3558     PTR32 pPrivateData;
3559 } VkOpticalFlowSessionCreatePrivateDataInfoNV32;
3560
3561 typedef struct VkOpticalFlowSessionCreateInfoNV32
3562 {
3563     VkStructureType sType;
3564     PTR32 pNext;
3565     uint32_t width;
3566     uint32_t height;
3567     VkFormat imageFormat;
3568     VkFormat flowVectorFormat;
3569     VkFormat costFormat;
3570     VkOpticalFlowGridSizeFlagsNV outputGridSize;
3571     VkOpticalFlowGridSizeFlagsNV hintGridSize;
3572     VkOpticalFlowPerformanceLevelNV performanceLevel;
3573     VkOpticalFlowSessionCreateFlagsNV flags;
3574 } VkOpticalFlowSessionCreateInfoNV32;
3575
3576 typedef struct VkPipelineCacheCreateInfo32
3577 {
3578     VkStructureType sType;
3579     PTR32 pNext;
3580     VkPipelineCacheCreateFlags flags;
3581     PTR32 initialDataSize;
3582     PTR32 pInitialData;
3583 } VkPipelineCacheCreateInfo32;
3584
3585 typedef struct VkPipelineLayoutCreateInfo32
3586 {
3587     VkStructureType sType;
3588     PTR32 pNext;
3589     VkPipelineLayoutCreateFlags flags;
3590     uint32_t setLayoutCount;
3591     PTR32 pSetLayouts;
3592     uint32_t pushConstantRangeCount;
3593     PTR32 pPushConstantRanges;
3594 } VkPipelineLayoutCreateInfo32;
3595
3596 typedef struct VkPrivateDataSlotCreateInfo32
3597 {
3598     VkStructureType sType;
3599     PTR32 pNext;
3600     VkPrivateDataSlotCreateFlags flags;
3601 } VkPrivateDataSlotCreateInfo32;
3602 typedef VkPrivateDataSlotCreateInfo32 VkPrivateDataSlotCreateInfoEXT32;
3603
3604 typedef struct VkQueryPoolPerformanceCreateInfoKHR32
3605 {
3606     VkStructureType sType;
3607     PTR32 pNext;
3608     uint32_t queueFamilyIndex;
3609     uint32_t counterIndexCount;
3610     PTR32 pCounterIndices;
3611 } VkQueryPoolPerformanceCreateInfoKHR32;
3612
3613 typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL32
3614 {
3615     VkStructureType sType;
3616     PTR32 pNext;
3617     VkQueryPoolSamplingModeINTEL performanceCountersSampling;
3618 } VkQueryPoolPerformanceQueryCreateInfoINTEL32;
3619 typedef VkQueryPoolPerformanceQueryCreateInfoINTEL32 VkQueryPoolCreateInfoINTEL32;
3620
3621 typedef struct VkQueryPoolCreateInfo32
3622 {
3623     VkStructureType sType;
3624     PTR32 pNext;
3625     VkQueryPoolCreateFlags flags;
3626     VkQueryType queryType;
3627     uint32_t queryCount;
3628     VkQueryPipelineStatisticFlags pipelineStatistics;
3629 } VkQueryPoolCreateInfo32;
3630
3631 typedef struct VkRayTracingShaderGroupCreateInfoKHR32
3632 {
3633     VkStructureType sType;
3634     PTR32 pNext;
3635     VkRayTracingShaderGroupTypeKHR type;
3636     uint32_t generalShader;
3637     uint32_t closestHitShader;
3638     uint32_t anyHitShader;
3639     uint32_t intersectionShader;
3640     PTR32 pShaderGroupCaptureReplayHandle;
3641 } VkRayTracingShaderGroupCreateInfoKHR32;
3642
3643 typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR32
3644 {
3645     VkStructureType sType;
3646     PTR32 pNext;
3647     uint32_t maxPipelineRayPayloadSize;
3648     uint32_t maxPipelineRayHitAttributeSize;
3649 } VkRayTracingPipelineInterfaceCreateInfoKHR32;
3650
3651 typedef struct VkRayTracingPipelineCreateInfoKHR32
3652 {
3653     VkStructureType sType;
3654     PTR32 pNext;
3655     VkPipelineCreateFlags flags;
3656     uint32_t stageCount;
3657     PTR32 pStages;
3658     uint32_t groupCount;
3659     PTR32 pGroups;
3660     uint32_t maxPipelineRayRecursionDepth;
3661     PTR32 pLibraryInfo;
3662     PTR32 pLibraryInterface;
3663     PTR32 pDynamicState;
3664     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3665     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3666     int32_t basePipelineIndex;
3667 } VkRayTracingPipelineCreateInfoKHR32;
3668
3669 typedef struct VkRayTracingShaderGroupCreateInfoNV32
3670 {
3671     VkStructureType sType;
3672     PTR32 pNext;
3673     VkRayTracingShaderGroupTypeKHR type;
3674     uint32_t generalShader;
3675     uint32_t closestHitShader;
3676     uint32_t anyHitShader;
3677     uint32_t intersectionShader;
3678 } VkRayTracingShaderGroupCreateInfoNV32;
3679
3680 typedef struct VkRayTracingPipelineCreateInfoNV32
3681 {
3682     VkStructureType sType;
3683     PTR32 pNext;
3684     VkPipelineCreateFlags flags;
3685     uint32_t stageCount;
3686     PTR32 pStages;
3687     uint32_t groupCount;
3688     PTR32 pGroups;
3689     uint32_t maxRecursionDepth;
3690     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3691     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3692     int32_t basePipelineIndex;
3693 } VkRayTracingPipelineCreateInfoNV32;
3694
3695 typedef struct VkSubpassDescription32
3696 {
3697     VkSubpassDescriptionFlags flags;
3698     VkPipelineBindPoint pipelineBindPoint;
3699     uint32_t inputAttachmentCount;
3700     PTR32 pInputAttachments;
3701     uint32_t colorAttachmentCount;
3702     PTR32 pColorAttachments;
3703     PTR32 pResolveAttachments;
3704     PTR32 pDepthStencilAttachment;
3705     uint32_t preserveAttachmentCount;
3706     PTR32 pPreserveAttachments;
3707 } VkSubpassDescription32;
3708
3709 typedef struct VkRenderPassMultiviewCreateInfo32
3710 {
3711     VkStructureType sType;
3712     PTR32 pNext;
3713     uint32_t subpassCount;
3714     PTR32 pViewMasks;
3715     uint32_t dependencyCount;
3716     PTR32 pViewOffsets;
3717     uint32_t correlationMaskCount;
3718     PTR32 pCorrelationMasks;
3719 } VkRenderPassMultiviewCreateInfo32;
3720 typedef VkRenderPassMultiviewCreateInfo32 VkRenderPassMultiviewCreateInfoKHR32;
3721
3722 typedef struct VkRenderPassInputAttachmentAspectCreateInfo32
3723 {
3724     VkStructureType sType;
3725     PTR32 pNext;
3726     uint32_t aspectReferenceCount;
3727     PTR32 pAspectReferences;
3728 } VkRenderPassInputAttachmentAspectCreateInfo32;
3729 typedef VkRenderPassInputAttachmentAspectCreateInfo32 VkRenderPassInputAttachmentAspectCreateInfoKHR32;
3730
3731 typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT32
3732 {
3733     VkStructureType sType;
3734     PTR32 pNext;
3735     VkAttachmentReference fragmentDensityMapAttachment;
3736 } VkRenderPassFragmentDensityMapCreateInfoEXT32;
3737
3738 typedef struct VkRenderPassCreateInfo32
3739 {
3740     VkStructureType sType;
3741     PTR32 pNext;
3742     VkRenderPassCreateFlags flags;
3743     uint32_t attachmentCount;
3744     PTR32 pAttachments;
3745     uint32_t subpassCount;
3746     PTR32 pSubpasses;
3747     uint32_t dependencyCount;
3748     PTR32 pDependencies;
3749 } VkRenderPassCreateInfo32;
3750
3751 typedef struct VkAttachmentDescriptionStencilLayout32
3752 {
3753     VkStructureType sType;
3754     PTR32 pNext;
3755     VkImageLayout stencilInitialLayout;
3756     VkImageLayout stencilFinalLayout;
3757 } VkAttachmentDescriptionStencilLayout32;
3758 typedef VkAttachmentDescriptionStencilLayout32 VkAttachmentDescriptionStencilLayoutKHR32;
3759
3760 typedef struct VkAttachmentDescription232
3761 {
3762     VkStructureType sType;
3763     PTR32 pNext;
3764     VkAttachmentDescriptionFlags flags;
3765     VkFormat format;
3766     VkSampleCountFlagBits samples;
3767     VkAttachmentLoadOp loadOp;
3768     VkAttachmentStoreOp storeOp;
3769     VkAttachmentLoadOp stencilLoadOp;
3770     VkAttachmentStoreOp stencilStoreOp;
3771     VkImageLayout initialLayout;
3772     VkImageLayout finalLayout;
3773 } VkAttachmentDescription232;
3774 typedef VkAttachmentDescription232 VkAttachmentDescription2KHR32;
3775
3776 typedef struct VkAttachmentReferenceStencilLayout32
3777 {
3778     VkStructureType sType;
3779     PTR32 pNext;
3780     VkImageLayout stencilLayout;
3781 } VkAttachmentReferenceStencilLayout32;
3782 typedef VkAttachmentReferenceStencilLayout32 VkAttachmentReferenceStencilLayoutKHR32;
3783
3784 typedef struct VkAttachmentReference232
3785 {
3786     VkStructureType sType;
3787     PTR32 pNext;
3788     uint32_t attachment;
3789     VkImageLayout layout;
3790     VkImageAspectFlags aspectMask;
3791 } VkAttachmentReference232;
3792 typedef VkAttachmentReference232 VkAttachmentReference2KHR32;
3793
3794 typedef struct VkSubpassDescriptionDepthStencilResolve32
3795 {
3796     VkStructureType sType;
3797     PTR32 pNext;
3798     VkResolveModeFlagBits depthResolveMode;
3799     VkResolveModeFlagBits stencilResolveMode;
3800     PTR32 pDepthStencilResolveAttachment;
3801 } VkSubpassDescriptionDepthStencilResolve32;
3802 typedef VkSubpassDescriptionDepthStencilResolve32 VkSubpassDescriptionDepthStencilResolveKHR32;
3803
3804 typedef struct VkFragmentShadingRateAttachmentInfoKHR32
3805 {
3806     VkStructureType sType;
3807     PTR32 pNext;
3808     PTR32 pFragmentShadingRateAttachment;
3809     VkExtent2D shadingRateAttachmentTexelSize;
3810 } VkFragmentShadingRateAttachmentInfoKHR32;
3811
3812 typedef struct VkRenderPassCreationControlEXT32
3813 {
3814     VkStructureType sType;
3815     PTR32 pNext;
3816     VkBool32 disallowMerging;
3817 } VkRenderPassCreationControlEXT32;
3818
3819 typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT32
3820 {
3821     VkStructureType sType;
3822     PTR32 pNext;
3823     PTR32 pSubpassFeedback;
3824 } VkRenderPassSubpassFeedbackCreateInfoEXT32;
3825
3826 typedef struct VkSubpassDescription232
3827 {
3828     VkStructureType sType;
3829     PTR32 pNext;
3830     VkSubpassDescriptionFlags flags;
3831     VkPipelineBindPoint pipelineBindPoint;
3832     uint32_t viewMask;
3833     uint32_t inputAttachmentCount;
3834     PTR32 pInputAttachments;
3835     uint32_t colorAttachmentCount;
3836     PTR32 pColorAttachments;
3837     PTR32 pResolveAttachments;
3838     PTR32 pDepthStencilAttachment;
3839     uint32_t preserveAttachmentCount;
3840     PTR32 pPreserveAttachments;
3841 } VkSubpassDescription232;
3842 typedef VkSubpassDescription232 VkSubpassDescription2KHR32;
3843
3844 typedef struct VkSubpassDependency232
3845 {
3846     VkStructureType sType;
3847     PTR32 pNext;
3848     uint32_t srcSubpass;
3849     uint32_t dstSubpass;
3850     VkPipelineStageFlags srcStageMask;
3851     VkPipelineStageFlags dstStageMask;
3852     VkAccessFlags srcAccessMask;
3853     VkAccessFlags dstAccessMask;
3854     VkDependencyFlags dependencyFlags;
3855     int32_t viewOffset;
3856 } VkSubpassDependency232;
3857 typedef VkSubpassDependency232 VkSubpassDependency2KHR32;
3858
3859 typedef struct VkRenderPassCreationFeedbackCreateInfoEXT32
3860 {
3861     VkStructureType sType;
3862     PTR32 pNext;
3863     PTR32 pRenderPassFeedback;
3864 } VkRenderPassCreationFeedbackCreateInfoEXT32;
3865
3866 typedef struct VkRenderPassCreateInfo232
3867 {
3868     VkStructureType sType;
3869     PTR32 pNext;
3870     VkRenderPassCreateFlags flags;
3871     uint32_t attachmentCount;
3872     PTR32 pAttachments;
3873     uint32_t subpassCount;
3874     PTR32 pSubpasses;
3875     uint32_t dependencyCount;
3876     PTR32 pDependencies;
3877     uint32_t correlatedViewMaskCount;
3878     PTR32 pCorrelatedViewMasks;
3879 } VkRenderPassCreateInfo232;
3880 typedef VkRenderPassCreateInfo232 VkRenderPassCreateInfo2KHR32;
3881
3882 typedef struct VkSamplerReductionModeCreateInfo32
3883 {
3884     VkStructureType sType;
3885     PTR32 pNext;
3886     VkSamplerReductionMode reductionMode;
3887 } VkSamplerReductionModeCreateInfo32;
3888 typedef VkSamplerReductionModeCreateInfo32 VkSamplerReductionModeCreateInfoEXT32;
3889
3890 typedef struct VkSamplerCustomBorderColorCreateInfoEXT32
3891 {
3892     VkStructureType sType;
3893     PTR32 pNext;
3894     VkClearColorValue customBorderColor;
3895     VkFormat format;
3896 } VkSamplerCustomBorderColorCreateInfoEXT32;
3897
3898 typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT32
3899 {
3900     VkStructureType sType;
3901     PTR32 pNext;
3902     VkComponentMapping components;
3903     VkBool32 srgb;
3904 } VkSamplerBorderColorComponentMappingCreateInfoEXT32;
3905
3906 typedef struct VkSamplerCreateInfo32
3907 {
3908     VkStructureType sType;
3909     PTR32 pNext;
3910     VkSamplerCreateFlags flags;
3911     VkFilter magFilter;
3912     VkFilter minFilter;
3913     VkSamplerMipmapMode mipmapMode;
3914     VkSamplerAddressMode addressModeU;
3915     VkSamplerAddressMode addressModeV;
3916     VkSamplerAddressMode addressModeW;
3917     float mipLodBias;
3918     VkBool32 anisotropyEnable;
3919     float maxAnisotropy;
3920     VkBool32 compareEnable;
3921     VkCompareOp compareOp;
3922     float minLod;
3923     float maxLod;
3924     VkBorderColor borderColor;
3925     VkBool32 unnormalizedCoordinates;
3926 } VkSamplerCreateInfo32;
3927
3928 typedef struct VkSamplerYcbcrConversionCreateInfo32
3929 {
3930     VkStructureType sType;
3931     PTR32 pNext;
3932     VkFormat format;
3933     VkSamplerYcbcrModelConversion ycbcrModel;
3934     VkSamplerYcbcrRange ycbcrRange;
3935     VkComponentMapping components;
3936     VkChromaLocation xChromaOffset;
3937     VkChromaLocation yChromaOffset;
3938     VkFilter chromaFilter;
3939     VkBool32 forceExplicitReconstruction;
3940 } VkSamplerYcbcrConversionCreateInfo32;
3941 typedef VkSamplerYcbcrConversionCreateInfo32 VkSamplerYcbcrConversionCreateInfoKHR32;
3942
3943 typedef struct VkExportSemaphoreCreateInfo32
3944 {
3945     VkStructureType sType;
3946     PTR32 pNext;
3947     VkExternalSemaphoreHandleTypeFlags handleTypes;
3948 } VkExportSemaphoreCreateInfo32;
3949 typedef VkExportSemaphoreCreateInfo32 VkExportSemaphoreCreateInfoKHR32;
3950
3951 typedef struct VkSemaphoreTypeCreateInfo32
3952 {
3953     VkStructureType sType;
3954     PTR32 pNext;
3955     VkSemaphoreType semaphoreType;
3956     uint64_t DECLSPEC_ALIGN(8) initialValue;
3957 } VkSemaphoreTypeCreateInfo32;
3958 typedef VkSemaphoreTypeCreateInfo32 VkSemaphoreTypeCreateInfoKHR32;
3959
3960 typedef struct VkQueryLowLatencySupportNV32
3961 {
3962     VkStructureType sType;
3963     PTR32 pNext;
3964     PTR32 pQueriedLowLatencyData;
3965 } VkQueryLowLatencySupportNV32;
3966
3967 typedef struct VkSemaphoreCreateInfo32
3968 {
3969     VkStructureType sType;
3970     PTR32 pNext;
3971     VkSemaphoreCreateFlags flags;
3972 } VkSemaphoreCreateInfo32;
3973
3974 typedef struct VkShaderCreateInfoEXT32
3975 {
3976     VkStructureType sType;
3977     PTR32 pNext;
3978     VkShaderCreateFlagsEXT flags;
3979     VkShaderStageFlagBits stage;
3980     VkShaderStageFlags nextStage;
3981     VkShaderCodeTypeEXT codeType;
3982     PTR32 codeSize;
3983     PTR32 pCode;
3984     PTR32 pName;
3985     uint32_t setLayoutCount;
3986     PTR32 pSetLayouts;
3987     uint32_t pushConstantRangeCount;
3988     PTR32 pPushConstantRanges;
3989     PTR32 pSpecializationInfo;
3990 } VkShaderCreateInfoEXT32;
3991
3992 typedef struct VkDeviceGroupSwapchainCreateInfoKHR32
3993 {
3994     VkStructureType sType;
3995     PTR32 pNext;
3996     VkDeviceGroupPresentModeFlagsKHR modes;
3997 } VkDeviceGroupSwapchainCreateInfoKHR32;
3998
3999 typedef struct VkSwapchainPresentBarrierCreateInfoNV32
4000 {
4001     VkStructureType sType;
4002     PTR32 pNext;
4003     VkBool32 presentBarrierEnable;
4004 } VkSwapchainPresentBarrierCreateInfoNV32;
4005
4006 typedef struct VkSwapchainPresentModesCreateInfoEXT32
4007 {
4008     VkStructureType sType;
4009     PTR32 pNext;
4010     uint32_t presentModeCount;
4011     PTR32 pPresentModes;
4012 } VkSwapchainPresentModesCreateInfoEXT32;
4013
4014 typedef struct VkSwapchainPresentScalingCreateInfoEXT32
4015 {
4016     VkStructureType sType;
4017     PTR32 pNext;
4018     VkPresentScalingFlagsEXT scalingBehavior;
4019     VkPresentGravityFlagsEXT presentGravityX;
4020     VkPresentGravityFlagsEXT presentGravityY;
4021 } VkSwapchainPresentScalingCreateInfoEXT32;
4022
4023 typedef struct VkSwapchainCreateInfoKHR32
4024 {
4025     VkStructureType sType;
4026     PTR32 pNext;
4027     VkSwapchainCreateFlagsKHR flags;
4028     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
4029     uint32_t minImageCount;
4030     VkFormat imageFormat;
4031     VkColorSpaceKHR imageColorSpace;
4032     VkExtent2D imageExtent;
4033     uint32_t imageArrayLayers;
4034     VkImageUsageFlags imageUsage;
4035     VkSharingMode imageSharingMode;
4036     uint32_t queueFamilyIndexCount;
4037     PTR32 pQueueFamilyIndices;
4038     VkSurfaceTransformFlagBitsKHR preTransform;
4039     VkCompositeAlphaFlagBitsKHR compositeAlpha;
4040     VkPresentModeKHR presentMode;
4041     VkBool32 clipped;
4042     VkSwapchainKHR DECLSPEC_ALIGN(8) oldSwapchain;
4043 } VkSwapchainCreateInfoKHR32;
4044
4045 typedef struct VkValidationCacheCreateInfoEXT32
4046 {
4047     VkStructureType sType;
4048     PTR32 pNext;
4049     VkValidationCacheCreateFlagsEXT flags;
4050     PTR32 initialDataSize;
4051     PTR32 pInitialData;
4052 } VkValidationCacheCreateInfoEXT32;
4053
4054 typedef struct VkWin32SurfaceCreateInfoKHR32
4055 {
4056     VkStructureType sType;
4057     PTR32 pNext;
4058     VkWin32SurfaceCreateFlagsKHR flags;
4059     PTR32 hinstance;
4060     PTR32 hwnd;
4061 } VkWin32SurfaceCreateInfoKHR32;
4062
4063 typedef struct VkDebugMarkerObjectNameInfoEXT32
4064 {
4065     VkStructureType sType;
4066     PTR32 pNext;
4067     VkDebugReportObjectTypeEXT objectType;
4068     uint64_t DECLSPEC_ALIGN(8) object;
4069     PTR32 pObjectName;
4070 } VkDebugMarkerObjectNameInfoEXT32;
4071
4072 typedef struct VkDebugMarkerObjectTagInfoEXT32
4073 {
4074     VkStructureType sType;
4075     PTR32 pNext;
4076     VkDebugReportObjectTypeEXT objectType;
4077     uint64_t DECLSPEC_ALIGN(8) object;
4078     uint64_t DECLSPEC_ALIGN(8) tagName;
4079     PTR32 tagSize;
4080     PTR32 pTag;
4081 } VkDebugMarkerObjectTagInfoEXT32;
4082
4083 typedef struct VkPhysicalDeviceGroupProperties32
4084 {
4085     VkStructureType sType;
4086     PTR32 pNext;
4087     uint32_t physicalDeviceCount;
4088     PTR32 physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
4089     VkBool32 subsetAllocation;
4090 } VkPhysicalDeviceGroupProperties32;
4091 typedef VkPhysicalDeviceGroupProperties32 VkPhysicalDeviceGroupPropertiesKHR32;
4092
4093 typedef struct VkPerformanceCounterKHR32
4094 {
4095     VkStructureType sType;
4096     PTR32 pNext;
4097     VkPerformanceCounterUnitKHR unit;
4098     VkPerformanceCounterScopeKHR scope;
4099     VkPerformanceCounterStorageKHR storage;
4100     uint8_t uuid[VK_UUID_SIZE];
4101 } VkPerformanceCounterKHR32;
4102
4103 typedef struct VkPerformanceCounterDescriptionKHR32
4104 {
4105     VkStructureType sType;
4106     PTR32 pNext;
4107     VkPerformanceCounterDescriptionFlagsKHR flags;
4108     char name[VK_MAX_DESCRIPTION_SIZE];
4109     char category[VK_MAX_DESCRIPTION_SIZE];
4110     char description[VK_MAX_DESCRIPTION_SIZE];
4111 } VkPerformanceCounterDescriptionKHR32;
4112
4113 typedef struct VkMappedMemoryRange32
4114 {
4115     VkStructureType sType;
4116     PTR32 pNext;
4117     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
4118     VkDeviceSize DECLSPEC_ALIGN(8) offset;
4119     VkDeviceSize DECLSPEC_ALIGN(8) size;
4120 } VkMappedMemoryRange32;
4121
4122 typedef struct VkAccelerationStructureBuildSizesInfoKHR32
4123 {
4124     VkStructureType sType;
4125     PTR32 pNext;
4126     VkDeviceSize DECLSPEC_ALIGN(8) accelerationStructureSize;
4127     VkDeviceSize DECLSPEC_ALIGN(8) updateScratchSize;
4128     VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
4129 } VkAccelerationStructureBuildSizesInfoKHR32;
4130
4131 typedef struct VkAccelerationStructureDeviceAddressInfoKHR32
4132 {
4133     VkStructureType sType;
4134     PTR32 pNext;
4135     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
4136 } VkAccelerationStructureDeviceAddressInfoKHR32;
4137
4138 typedef struct VkAccelerationStructureMemoryRequirementsInfoNV32
4139 {
4140     VkStructureType sType;
4141     PTR32 pNext;
4142     VkAccelerationStructureMemoryRequirementsTypeNV type;
4143     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
4144 } VkAccelerationStructureMemoryRequirementsInfoNV32;
4145
4146 typedef struct VkMemoryRequirements32
4147 {
4148     VkDeviceSize DECLSPEC_ALIGN(8) size;
4149     VkDeviceSize DECLSPEC_ALIGN(8) alignment;
4150     uint32_t memoryTypeBits;
4151 } VkMemoryRequirements32;
4152
4153
4154 typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT32
4155 {
4156     VkStructureType sType;
4157     PTR32 pNext;
4158     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
4159     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructureNV;
4160 } VkAccelerationStructureCaptureDescriptorDataInfoEXT32;
4161
4162 typedef struct VkBufferDeviceAddressInfo32
4163 {
4164     VkStructureType sType;
4165     PTR32 pNext;
4166     VkBuffer DECLSPEC_ALIGN(8) buffer;
4167 } VkBufferDeviceAddressInfo32;
4168 typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoKHR32;
4169 typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoEXT32;
4170
4171 typedef struct VkBufferMemoryRequirementsInfo232
4172 {
4173     VkStructureType sType;
4174     PTR32 pNext;
4175     VkBuffer DECLSPEC_ALIGN(8) buffer;
4176 } VkBufferMemoryRequirementsInfo232;
4177 typedef VkBufferMemoryRequirementsInfo232 VkBufferMemoryRequirementsInfo2KHR32;
4178
4179 typedef struct VkMemoryDedicatedRequirements32
4180 {
4181     VkStructureType sType;
4182     PTR32 pNext;
4183     VkBool32 prefersDedicatedAllocation;
4184     VkBool32 requiresDedicatedAllocation;
4185 } VkMemoryDedicatedRequirements32;
4186 typedef VkMemoryDedicatedRequirements32 VkMemoryDedicatedRequirementsKHR32;
4187
4188 typedef struct VkMemoryRequirements232
4189 {
4190     VkStructureType sType;
4191     PTR32 pNext;
4192     VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
4193 } VkMemoryRequirements232;
4194 typedef VkMemoryRequirements232 VkMemoryRequirements2KHR32;
4195
4196 typedef struct VkBufferCaptureDescriptorDataInfoEXT32
4197 {
4198     VkStructureType sType;
4199     PTR32 pNext;
4200     VkBuffer DECLSPEC_ALIGN(8) buffer;
4201 } VkBufferCaptureDescriptorDataInfoEXT32;
4202
4203 typedef struct VkCalibratedTimestampInfoEXT32
4204 {
4205     VkStructureType sType;
4206     PTR32 pNext;
4207     VkTimeDomainEXT timeDomain;
4208 } VkCalibratedTimestampInfoEXT32;
4209
4210 typedef struct VkDescriptorAddressInfoEXT32
4211 {
4212     VkStructureType sType;
4213     PTR32 pNext;
4214     VkDeviceAddress DECLSPEC_ALIGN(8) address;
4215     VkDeviceSize DECLSPEC_ALIGN(8) range;
4216     VkFormat format;
4217 } VkDescriptorAddressInfoEXT32;
4218
4219 typedef union VkDescriptorDataEXT32
4220 {
4221     PTR32 pSampler;
4222     PTR32 pCombinedImageSampler;
4223     PTR32 pInputAttachmentImage;
4224     PTR32 pSampledImage;
4225     PTR32 pStorageImage;
4226     PTR32 pUniformTexelBuffer;
4227     PTR32 pStorageTexelBuffer;
4228     PTR32 pUniformBuffer;
4229     PTR32 pStorageBuffer;
4230     VkDeviceAddress DECLSPEC_ALIGN(8) accelerationStructure;
4231 } VkDescriptorDataEXT32;
4232
4233 typedef struct VkDescriptorGetInfoEXT32
4234 {
4235     VkStructureType sType;
4236     PTR32 pNext;
4237     VkDescriptorType type;
4238     VkDescriptorDataEXT32 DECLSPEC_ALIGN(8) data;
4239 } VkDescriptorGetInfoEXT32;
4240
4241 typedef struct VkDescriptorSetBindingReferenceVALVE32
4242 {
4243     VkStructureType sType;
4244     PTR32 pNext;
4245     VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
4246     uint32_t binding;
4247 } VkDescriptorSetBindingReferenceVALVE32;
4248
4249 typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE32
4250 {
4251     VkStructureType sType;
4252     PTR32 pNext;
4253     PTR32 descriptorOffset;
4254     uint32_t descriptorSize;
4255 } VkDescriptorSetLayoutHostMappingInfoVALVE32;
4256
4257 typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport32
4258 {
4259     VkStructureType sType;
4260     PTR32 pNext;
4261     uint32_t maxVariableDescriptorCount;
4262 } VkDescriptorSetVariableDescriptorCountLayoutSupport32;
4263 typedef VkDescriptorSetVariableDescriptorCountLayoutSupport32 VkDescriptorSetVariableDescriptorCountLayoutSupportEXT32;
4264
4265 typedef struct VkDescriptorSetLayoutSupport32
4266 {
4267     VkStructureType sType;
4268     PTR32 pNext;
4269     VkBool32 supported;
4270 } VkDescriptorSetLayoutSupport32;
4271 typedef VkDescriptorSetLayoutSupport32 VkDescriptorSetLayoutSupportKHR32;
4272
4273 typedef struct VkAccelerationStructureVersionInfoKHR32
4274 {
4275     VkStructureType sType;
4276     PTR32 pNext;
4277     PTR32 pVersionData;
4278 } VkAccelerationStructureVersionInfoKHR32;
4279
4280 typedef struct VkDeviceBufferMemoryRequirements32
4281 {
4282     VkStructureType sType;
4283     PTR32 pNext;
4284     PTR32 pCreateInfo;
4285 } VkDeviceBufferMemoryRequirements32;
4286 typedef VkDeviceBufferMemoryRequirements32 VkDeviceBufferMemoryRequirementsKHR32;
4287
4288 typedef struct VkDeviceFaultCountsEXT32
4289 {
4290     VkStructureType sType;
4291     PTR32 pNext;
4292     uint32_t addressInfoCount;
4293     uint32_t vendorInfoCount;
4294     VkDeviceSize DECLSPEC_ALIGN(8) vendorBinarySize;
4295 } VkDeviceFaultCountsEXT32;
4296
4297 typedef struct VkDeviceFaultAddressInfoEXT32
4298 {
4299     VkDeviceFaultAddressTypeEXT addressType;
4300     VkDeviceAddress DECLSPEC_ALIGN(8) reportedAddress;
4301     VkDeviceSize DECLSPEC_ALIGN(8) addressPrecision;
4302 } VkDeviceFaultAddressInfoEXT32;
4303
4304 typedef struct VkDeviceFaultVendorInfoEXT32
4305 {
4306     char description[VK_MAX_DESCRIPTION_SIZE];
4307     uint64_t DECLSPEC_ALIGN(8) vendorFaultCode;
4308     uint64_t DECLSPEC_ALIGN(8) vendorFaultData;
4309 } VkDeviceFaultVendorInfoEXT32;
4310
4311 typedef struct VkDeviceFaultInfoEXT32
4312 {
4313     VkStructureType sType;
4314     PTR32 pNext;
4315     char description[VK_MAX_DESCRIPTION_SIZE];
4316     PTR32 pAddressInfos;
4317     PTR32 pVendorInfos;
4318     PTR32 pVendorBinaryData;
4319 } VkDeviceFaultInfoEXT32;
4320
4321 typedef struct VkDeviceGroupPresentCapabilitiesKHR32
4322 {
4323     VkStructureType sType;
4324     PTR32 pNext;
4325     uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
4326     VkDeviceGroupPresentModeFlagsKHR modes;
4327 } VkDeviceGroupPresentCapabilitiesKHR32;
4328
4329 typedef struct VkDeviceImageMemoryRequirements32
4330 {
4331     VkStructureType sType;
4332     PTR32 pNext;
4333     PTR32 pCreateInfo;
4334     VkImageAspectFlagBits planeAspect;
4335 } VkDeviceImageMemoryRequirements32;
4336 typedef VkDeviceImageMemoryRequirements32 VkDeviceImageMemoryRequirementsKHR32;
4337
4338 typedef struct VkSparseImageMemoryRequirements32
4339 {
4340     VkSparseImageFormatProperties formatProperties;
4341     uint32_t imageMipTailFirstLod;
4342     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailSize;
4343     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailOffset;
4344     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailStride;
4345 } VkSparseImageMemoryRequirements32;
4346
4347 typedef struct VkSparseImageMemoryRequirements232
4348 {
4349     VkStructureType sType;
4350     PTR32 pNext;
4351     VkSparseImageMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
4352 } VkSparseImageMemoryRequirements232;
4353 typedef VkSparseImageMemoryRequirements232 VkSparseImageMemoryRequirements2KHR32;
4354
4355 typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo32
4356 {
4357     VkStructureType sType;
4358     PTR32 pNext;
4359     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
4360 } VkDeviceMemoryOpaqueCaptureAddressInfo32;
4361 typedef VkDeviceMemoryOpaqueCaptureAddressInfo32 VkDeviceMemoryOpaqueCaptureAddressInfoKHR32;
4362
4363 typedef struct VkMicromapVersionInfoEXT32
4364 {
4365     VkStructureType sType;
4366     PTR32 pNext;
4367     PTR32 pVersionData;
4368 } VkMicromapVersionInfoEXT32;
4369
4370 typedef struct VkDeviceQueueInfo232
4371 {
4372     VkStructureType sType;
4373     PTR32 pNext;
4374     VkDeviceQueueCreateFlags flags;
4375     uint32_t queueFamilyIndex;
4376     uint32_t queueIndex;
4377 } VkDeviceQueueInfo232;
4378
4379 typedef struct VkTilePropertiesQCOM32
4380 {
4381     VkStructureType sType;
4382     PTR32 pNext;
4383     VkExtent3D tileSize;
4384     VkExtent2D apronSize;
4385     VkOffset2D origin;
4386 } VkTilePropertiesQCOM32;
4387
4388 typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV32
4389 {
4390     VkStructureType sType;
4391     PTR32 pNext;
4392     VkPipelineBindPoint pipelineBindPoint;
4393     VkPipeline DECLSPEC_ALIGN(8) pipeline;
4394     VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
4395     uint32_t maxSequencesCount;
4396 } VkGeneratedCommandsMemoryRequirementsInfoNV32;
4397
4398 typedef struct VkImagePlaneMemoryRequirementsInfo32
4399 {
4400     VkStructureType sType;
4401     PTR32 pNext;
4402     VkImageAspectFlagBits planeAspect;
4403 } VkImagePlaneMemoryRequirementsInfo32;
4404 typedef VkImagePlaneMemoryRequirementsInfo32 VkImagePlaneMemoryRequirementsInfoKHR32;
4405
4406 typedef struct VkImageMemoryRequirementsInfo232
4407 {
4408     VkStructureType sType;
4409     PTR32 pNext;
4410     VkImage DECLSPEC_ALIGN(8) image;
4411 } VkImageMemoryRequirementsInfo232;
4412 typedef VkImageMemoryRequirementsInfo232 VkImageMemoryRequirementsInfo2KHR32;
4413
4414 typedef struct VkImageCaptureDescriptorDataInfoEXT32
4415 {
4416     VkStructureType sType;
4417     PTR32 pNext;
4418     VkImage DECLSPEC_ALIGN(8) image;
4419 } VkImageCaptureDescriptorDataInfoEXT32;
4420
4421 typedef struct VkImageSparseMemoryRequirementsInfo232
4422 {
4423     VkStructureType sType;
4424     PTR32 pNext;
4425     VkImage DECLSPEC_ALIGN(8) image;
4426 } VkImageSparseMemoryRequirementsInfo232;
4427 typedef VkImageSparseMemoryRequirementsInfo232 VkImageSparseMemoryRequirementsInfo2KHR32;
4428
4429 typedef struct VkSubresourceLayout32
4430 {
4431     VkDeviceSize DECLSPEC_ALIGN(8) offset;
4432     VkDeviceSize DECLSPEC_ALIGN(8) size;
4433     VkDeviceSize DECLSPEC_ALIGN(8) rowPitch;
4434     VkDeviceSize DECLSPEC_ALIGN(8) arrayPitch;
4435     VkDeviceSize DECLSPEC_ALIGN(8) depthPitch;
4436 } VkSubresourceLayout32;
4437
4438 typedef struct VkImageSubresource2EXT32
4439 {
4440     VkStructureType sType;
4441     PTR32 pNext;
4442     VkImageSubresource imageSubresource;
4443 } VkImageSubresource2EXT32;
4444
4445 typedef struct VkImageCompressionPropertiesEXT32
4446 {
4447     VkStructureType sType;
4448     PTR32 pNext;
4449     VkImageCompressionFlagsEXT imageCompressionFlags;
4450     VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags;
4451 } VkImageCompressionPropertiesEXT32;
4452
4453 typedef struct VkSubresourceLayout2EXT32
4454 {
4455     VkStructureType sType;
4456     PTR32 pNext;
4457     VkSubresourceLayout32 DECLSPEC_ALIGN(8) subresourceLayout;
4458 } VkSubresourceLayout2EXT32;
4459
4460 typedef struct VkImageViewAddressPropertiesNVX32
4461 {
4462     VkStructureType sType;
4463     PTR32 pNext;
4464     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
4465     VkDeviceSize DECLSPEC_ALIGN(8) size;
4466 } VkImageViewAddressPropertiesNVX32;
4467
4468 typedef struct VkImageViewHandleInfoNVX32
4469 {
4470     VkStructureType sType;
4471     PTR32 pNext;
4472     VkImageView DECLSPEC_ALIGN(8) imageView;
4473     VkDescriptorType descriptorType;
4474     VkSampler DECLSPEC_ALIGN(8) sampler;
4475 } VkImageViewHandleInfoNVX32;
4476
4477 typedef struct VkImageViewCaptureDescriptorDataInfoEXT32
4478 {
4479     VkStructureType sType;
4480     PTR32 pNext;
4481     VkImageView DECLSPEC_ALIGN(8) imageView;
4482 } VkImageViewCaptureDescriptorDataInfoEXT32;
4483
4484 typedef struct VkMemoryHostPointerPropertiesEXT32
4485 {
4486     VkStructureType sType;
4487     PTR32 pNext;
4488     uint32_t memoryTypeBits;
4489 } VkMemoryHostPointerPropertiesEXT32;
4490
4491 typedef struct VkMicromapBuildSizesInfoEXT32
4492 {
4493     VkStructureType sType;
4494     PTR32 pNext;
4495     VkDeviceSize DECLSPEC_ALIGN(8) micromapSize;
4496     VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
4497     VkBool32 discardable;
4498 } VkMicromapBuildSizesInfoEXT32;
4499
4500 typedef union VkPerformanceValueDataINTEL32
4501 {
4502     uint32_t value32;
4503     uint64_t DECLSPEC_ALIGN(8) value64;
4504     float valueFloat;
4505     VkBool32 valueBool;
4506     PTR32 valueString;
4507 } VkPerformanceValueDataINTEL32;
4508
4509 typedef struct VkPerformanceValueINTEL32
4510 {
4511     VkPerformanceValueTypeINTEL type;
4512     VkPerformanceValueDataINTEL32 DECLSPEC_ALIGN(8) data;
4513 } VkPerformanceValueINTEL32;
4514
4515 typedef struct VkCooperativeMatrixPropertiesNV32
4516 {
4517     VkStructureType sType;
4518     PTR32 pNext;
4519     uint32_t MSize;
4520     uint32_t NSize;
4521     uint32_t KSize;
4522     VkComponentTypeNV AType;
4523     VkComponentTypeNV BType;
4524     VkComponentTypeNV CType;
4525     VkComponentTypeNV DType;
4526     VkScopeNV scope;
4527 } VkCooperativeMatrixPropertiesNV32;
4528
4529 typedef struct VkPhysicalDeviceExternalBufferInfo32
4530 {
4531     VkStructureType sType;
4532     PTR32 pNext;
4533     VkBufferCreateFlags flags;
4534     VkBufferUsageFlags usage;
4535     VkExternalMemoryHandleTypeFlagBits handleType;
4536 } VkPhysicalDeviceExternalBufferInfo32;
4537 typedef VkPhysicalDeviceExternalBufferInfo32 VkPhysicalDeviceExternalBufferInfoKHR32;
4538
4539 typedef struct VkExternalBufferProperties32
4540 {
4541     VkStructureType sType;
4542     PTR32 pNext;
4543     VkExternalMemoryProperties externalMemoryProperties;
4544 } VkExternalBufferProperties32;
4545 typedef VkExternalBufferProperties32 VkExternalBufferPropertiesKHR32;
4546
4547 typedef struct VkPhysicalDeviceExternalFenceInfo32
4548 {
4549     VkStructureType sType;
4550     PTR32 pNext;
4551     VkExternalFenceHandleTypeFlagBits handleType;
4552 } VkPhysicalDeviceExternalFenceInfo32;
4553 typedef VkPhysicalDeviceExternalFenceInfo32 VkPhysicalDeviceExternalFenceInfoKHR32;
4554
4555 typedef struct VkExternalFenceProperties32
4556 {
4557     VkStructureType sType;
4558     PTR32 pNext;
4559     VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
4560     VkExternalFenceHandleTypeFlags compatibleHandleTypes;
4561     VkExternalFenceFeatureFlags externalFenceFeatures;
4562 } VkExternalFenceProperties32;
4563 typedef VkExternalFenceProperties32 VkExternalFencePropertiesKHR32;
4564
4565 typedef struct VkPhysicalDeviceExternalSemaphoreInfo32
4566 {
4567     VkStructureType sType;
4568     PTR32 pNext;
4569     VkExternalSemaphoreHandleTypeFlagBits handleType;
4570 } VkPhysicalDeviceExternalSemaphoreInfo32;
4571 typedef VkPhysicalDeviceExternalSemaphoreInfo32 VkPhysicalDeviceExternalSemaphoreInfoKHR32;
4572
4573 typedef struct VkExternalSemaphoreProperties32
4574 {
4575     VkStructureType sType;
4576     PTR32 pNext;
4577     VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
4578     VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
4579     VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
4580 } VkExternalSemaphoreProperties32;
4581 typedef VkExternalSemaphoreProperties32 VkExternalSemaphorePropertiesKHR32;
4582
4583 typedef struct VkSubpassResolvePerformanceQueryEXT32
4584 {
4585     VkStructureType sType;
4586     PTR32 pNext;
4587     VkBool32 optimal;
4588 } VkSubpassResolvePerformanceQueryEXT32;
4589
4590 typedef struct VkFormatProperties332
4591 {
4592     VkStructureType sType;
4593     PTR32 pNext;
4594     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingFeatures;
4595     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingFeatures;
4596     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) bufferFeatures;
4597 } VkFormatProperties332;
4598 typedef VkFormatProperties332 VkFormatProperties3KHR32;
4599
4600 typedef struct VkFormatProperties232
4601 {
4602     VkStructureType sType;
4603     PTR32 pNext;
4604     VkFormatProperties formatProperties;
4605 } VkFormatProperties232;
4606 typedef VkFormatProperties232 VkFormatProperties2KHR32;
4607
4608 typedef struct VkPhysicalDeviceFragmentShadingRateKHR32
4609 {
4610     VkStructureType sType;
4611     PTR32 pNext;
4612     VkSampleCountFlags sampleCounts;
4613     VkExtent2D fragmentSize;
4614 } VkPhysicalDeviceFragmentShadingRateKHR32;
4615
4616 typedef struct VkImageFormatProperties32
4617 {
4618     VkExtent3D maxExtent;
4619     uint32_t maxMipLevels;
4620     uint32_t maxArrayLayers;
4621     VkSampleCountFlags sampleCounts;
4622     VkDeviceSize DECLSPEC_ALIGN(8) maxResourceSize;
4623 } VkImageFormatProperties32;
4624
4625 typedef struct VkPhysicalDeviceExternalImageFormatInfo32
4626 {
4627     VkStructureType sType;
4628     PTR32 pNext;
4629     VkExternalMemoryHandleTypeFlagBits handleType;
4630 } VkPhysicalDeviceExternalImageFormatInfo32;
4631 typedef VkPhysicalDeviceExternalImageFormatInfo32 VkPhysicalDeviceExternalImageFormatInfoKHR32;
4632
4633 typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT32
4634 {
4635     VkStructureType sType;
4636     PTR32 pNext;
4637     VkImageViewType imageViewType;
4638 } VkPhysicalDeviceImageViewImageFormatInfoEXT32;
4639
4640 typedef struct VkPhysicalDeviceImageFormatInfo232
4641 {
4642     VkStructureType sType;
4643     PTR32 pNext;
4644     VkFormat format;
4645     VkImageType type;
4646     VkImageTiling tiling;
4647     VkImageUsageFlags usage;
4648     VkImageCreateFlags flags;
4649 } VkPhysicalDeviceImageFormatInfo232;
4650 typedef VkPhysicalDeviceImageFormatInfo232 VkPhysicalDeviceImageFormatInfo2KHR32;
4651
4652 typedef struct VkExternalImageFormatProperties32
4653 {
4654     VkStructureType sType;
4655     PTR32 pNext;
4656     VkExternalMemoryProperties externalMemoryProperties;
4657 } VkExternalImageFormatProperties32;
4658 typedef VkExternalImageFormatProperties32 VkExternalImageFormatPropertiesKHR32;
4659
4660 typedef struct VkSamplerYcbcrConversionImageFormatProperties32
4661 {
4662     VkStructureType sType;
4663     PTR32 pNext;
4664     uint32_t combinedImageSamplerDescriptorCount;
4665 } VkSamplerYcbcrConversionImageFormatProperties32;
4666 typedef VkSamplerYcbcrConversionImageFormatProperties32 VkSamplerYcbcrConversionImageFormatPropertiesKHR32;
4667
4668 typedef struct VkTextureLODGatherFormatPropertiesAMD32
4669 {
4670     VkStructureType sType;
4671     PTR32 pNext;
4672     VkBool32 supportsTextureGatherLODBiasAMD;
4673 } VkTextureLODGatherFormatPropertiesAMD32;
4674
4675 typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT32
4676 {
4677     VkStructureType sType;
4678     PTR32 pNext;
4679     VkBool32 filterCubic;
4680     VkBool32 filterCubicMinmax;
4681 } VkFilterCubicImageViewImageFormatPropertiesEXT32;
4682
4683 typedef struct VkImageFormatProperties232
4684 {
4685     VkStructureType sType;
4686     PTR32 pNext;
4687     VkImageFormatProperties32 DECLSPEC_ALIGN(8) imageFormatProperties;
4688 } VkImageFormatProperties232;
4689 typedef VkImageFormatProperties232 VkImageFormatProperties2KHR32;
4690
4691 typedef struct VkMemoryHeap32
4692 {
4693     VkDeviceSize DECLSPEC_ALIGN(8) size;
4694     VkMemoryHeapFlags flags;
4695 } VkMemoryHeap32;
4696
4697 typedef struct VkPhysicalDeviceMemoryProperties32
4698 {
4699     uint32_t memoryTypeCount;
4700     VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
4701     uint32_t memoryHeapCount;
4702     VkMemoryHeap32 DECLSPEC_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS];
4703 } VkPhysicalDeviceMemoryProperties32;
4704
4705 typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT32
4706 {
4707     VkStructureType sType;
4708     PTR32 pNext;
4709     VkDeviceSize DECLSPEC_ALIGN(8) heapBudget[VK_MAX_MEMORY_HEAPS];
4710     VkDeviceSize DECLSPEC_ALIGN(8) heapUsage[VK_MAX_MEMORY_HEAPS];
4711 } VkPhysicalDeviceMemoryBudgetPropertiesEXT32;
4712
4713 typedef struct VkPhysicalDeviceMemoryProperties232
4714 {
4715     VkStructureType sType;
4716     PTR32 pNext;
4717     VkPhysicalDeviceMemoryProperties32 DECLSPEC_ALIGN(8) memoryProperties;
4718 } VkPhysicalDeviceMemoryProperties232;
4719 typedef VkPhysicalDeviceMemoryProperties232 VkPhysicalDeviceMemoryProperties2KHR32;
4720
4721 typedef struct VkMultisamplePropertiesEXT32
4722 {
4723     VkStructureType sType;
4724     PTR32 pNext;
4725     VkExtent2D maxSampleLocationGridSize;
4726 } VkMultisamplePropertiesEXT32;
4727
4728 typedef struct VkOpticalFlowImageFormatPropertiesNV32
4729 {
4730     VkStructureType sType;
4731     PTR32 pNext;
4732     VkFormat format;
4733 } VkOpticalFlowImageFormatPropertiesNV32;
4734
4735 typedef struct VkPhysicalDeviceLimits32
4736 {
4737     uint32_t maxImageDimension1D;
4738     uint32_t maxImageDimension2D;
4739     uint32_t maxImageDimension3D;
4740     uint32_t maxImageDimensionCube;
4741     uint32_t maxImageArrayLayers;
4742     uint32_t maxTexelBufferElements;
4743     uint32_t maxUniformBufferRange;
4744     uint32_t maxStorageBufferRange;
4745     uint32_t maxPushConstantsSize;
4746     uint32_t maxMemoryAllocationCount;
4747     uint32_t maxSamplerAllocationCount;
4748     VkDeviceSize DECLSPEC_ALIGN(8) bufferImageGranularity;
4749     VkDeviceSize DECLSPEC_ALIGN(8) sparseAddressSpaceSize;
4750     uint32_t maxBoundDescriptorSets;
4751     uint32_t maxPerStageDescriptorSamplers;
4752     uint32_t maxPerStageDescriptorUniformBuffers;
4753     uint32_t maxPerStageDescriptorStorageBuffers;
4754     uint32_t maxPerStageDescriptorSampledImages;
4755     uint32_t maxPerStageDescriptorStorageImages;
4756     uint32_t maxPerStageDescriptorInputAttachments;
4757     uint32_t maxPerStageResources;
4758     uint32_t maxDescriptorSetSamplers;
4759     uint32_t maxDescriptorSetUniformBuffers;
4760     uint32_t maxDescriptorSetUniformBuffersDynamic;
4761     uint32_t maxDescriptorSetStorageBuffers;
4762     uint32_t maxDescriptorSetStorageBuffersDynamic;
4763     uint32_t maxDescriptorSetSampledImages;
4764     uint32_t maxDescriptorSetStorageImages;
4765     uint32_t maxDescriptorSetInputAttachments;
4766     uint32_t maxVertexInputAttributes;
4767     uint32_t maxVertexInputBindings;
4768     uint32_t maxVertexInputAttributeOffset;
4769     uint32_t maxVertexInputBindingStride;
4770     uint32_t maxVertexOutputComponents;
4771     uint32_t maxTessellationGenerationLevel;
4772     uint32_t maxTessellationPatchSize;
4773     uint32_t maxTessellationControlPerVertexInputComponents;
4774     uint32_t maxTessellationControlPerVertexOutputComponents;
4775     uint32_t maxTessellationControlPerPatchOutputComponents;
4776     uint32_t maxTessellationControlTotalOutputComponents;
4777     uint32_t maxTessellationEvaluationInputComponents;
4778     uint32_t maxTessellationEvaluationOutputComponents;
4779     uint32_t maxGeometryShaderInvocations;
4780     uint32_t maxGeometryInputComponents;
4781     uint32_t maxGeometryOutputComponents;
4782     uint32_t maxGeometryOutputVertices;
4783     uint32_t maxGeometryTotalOutputComponents;
4784     uint32_t maxFragmentInputComponents;
4785     uint32_t maxFragmentOutputAttachments;
4786     uint32_t maxFragmentDualSrcAttachments;
4787     uint32_t maxFragmentCombinedOutputResources;
4788     uint32_t maxComputeSharedMemorySize;
4789     uint32_t maxComputeWorkGroupCount[3];
4790     uint32_t maxComputeWorkGroupInvocations;
4791     uint32_t maxComputeWorkGroupSize[3];
4792     uint32_t subPixelPrecisionBits;
4793     uint32_t subTexelPrecisionBits;
4794     uint32_t mipmapPrecisionBits;
4795     uint32_t maxDrawIndexedIndexValue;
4796     uint32_t maxDrawIndirectCount;
4797     float maxSamplerLodBias;
4798     float maxSamplerAnisotropy;
4799     uint32_t maxViewports;
4800     uint32_t maxViewportDimensions[2];
4801     float viewportBoundsRange[2];
4802     uint32_t viewportSubPixelBits;
4803     PTR32 minMemoryMapAlignment;
4804     VkDeviceSize DECLSPEC_ALIGN(8) minTexelBufferOffsetAlignment;
4805     VkDeviceSize DECLSPEC_ALIGN(8) minUniformBufferOffsetAlignment;
4806     VkDeviceSize DECLSPEC_ALIGN(8) minStorageBufferOffsetAlignment;
4807     int32_t minTexelOffset;
4808     uint32_t maxTexelOffset;
4809     int32_t minTexelGatherOffset;
4810     uint32_t maxTexelGatherOffset;
4811     float minInterpolationOffset;
4812     float maxInterpolationOffset;
4813     uint32_t subPixelInterpolationOffsetBits;
4814     uint32_t maxFramebufferWidth;
4815     uint32_t maxFramebufferHeight;
4816     uint32_t maxFramebufferLayers;
4817     VkSampleCountFlags framebufferColorSampleCounts;
4818     VkSampleCountFlags framebufferDepthSampleCounts;
4819     VkSampleCountFlags framebufferStencilSampleCounts;
4820     VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
4821     uint32_t maxColorAttachments;
4822     VkSampleCountFlags sampledImageColorSampleCounts;
4823     VkSampleCountFlags sampledImageIntegerSampleCounts;
4824     VkSampleCountFlags sampledImageDepthSampleCounts;
4825     VkSampleCountFlags sampledImageStencilSampleCounts;
4826     VkSampleCountFlags storageImageSampleCounts;
4827     uint32_t maxSampleMaskWords;
4828     VkBool32 timestampComputeAndGraphics;
4829     float timestampPeriod;
4830     uint32_t maxClipDistances;
4831     uint32_t maxCullDistances;
4832     uint32_t maxCombinedClipAndCullDistances;
4833     uint32_t discreteQueuePriorities;
4834     float pointSizeRange[2];
4835     float lineWidthRange[2];
4836     float pointSizeGranularity;
4837     float lineWidthGranularity;
4838     VkBool32 strictLines;
4839     VkBool32 standardSampleLocations;
4840     VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyOffsetAlignment;
4841     VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyRowPitchAlignment;
4842     VkDeviceSize DECLSPEC_ALIGN(8) nonCoherentAtomSize;
4843 } VkPhysicalDeviceLimits32;
4844
4845 typedef struct VkPhysicalDeviceProperties32
4846 {
4847     uint32_t apiVersion;
4848     uint32_t driverVersion;
4849     uint32_t vendorID;
4850     uint32_t deviceID;
4851     VkPhysicalDeviceType deviceType;
4852     char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
4853     uint8_t pipelineCacheUUID[VK_UUID_SIZE];
4854     VkPhysicalDeviceLimits32 DECLSPEC_ALIGN(8) limits;
4855     VkPhysicalDeviceSparseProperties sparseProperties;
4856 } VkPhysicalDeviceProperties32;
4857
4858 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32
4859 {
4860     VkStructureType sType;
4861     PTR32 pNext;
4862     uint32_t maxGraphicsShaderGroupCount;
4863     uint32_t maxIndirectSequenceCount;
4864     uint32_t maxIndirectCommandsTokenCount;
4865     uint32_t maxIndirectCommandsStreamCount;
4866     uint32_t maxIndirectCommandsTokenOffset;
4867     uint32_t maxIndirectCommandsStreamStride;
4868     uint32_t minSequencesCountBufferOffsetAlignment;
4869     uint32_t minSequencesIndexBufferOffsetAlignment;
4870     uint32_t minIndirectCommandsBufferOffsetAlignment;
4871 } VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32;
4872
4873 typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT32
4874 {
4875     VkStructureType sType;
4876     PTR32 pNext;
4877     uint32_t maxMultiDrawCount;
4878 } VkPhysicalDeviceMultiDrawPropertiesEXT32;
4879
4880 typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR32
4881 {
4882     VkStructureType sType;
4883     PTR32 pNext;
4884     uint32_t maxPushDescriptors;
4885 } VkPhysicalDevicePushDescriptorPropertiesKHR32;
4886
4887 typedef struct VkPhysicalDeviceDriverProperties32
4888 {
4889     VkStructureType sType;
4890     PTR32 pNext;
4891     VkDriverId driverID;
4892     char driverName[VK_MAX_DRIVER_NAME_SIZE];
4893     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
4894     VkConformanceVersion conformanceVersion;
4895 } VkPhysicalDeviceDriverProperties32;
4896 typedef VkPhysicalDeviceDriverProperties32 VkPhysicalDeviceDriverPropertiesKHR32;
4897
4898 typedef struct VkPhysicalDeviceIDProperties32
4899 {
4900     VkStructureType sType;
4901     PTR32 pNext;
4902     uint8_t deviceUUID[VK_UUID_SIZE];
4903     uint8_t driverUUID[VK_UUID_SIZE];
4904     uint8_t deviceLUID[VK_LUID_SIZE];
4905     uint32_t deviceNodeMask;
4906     VkBool32 deviceLUIDValid;
4907 } VkPhysicalDeviceIDProperties32;
4908 typedef VkPhysicalDeviceIDProperties32 VkPhysicalDeviceIDPropertiesKHR32;
4909
4910 typedef struct VkPhysicalDeviceMultiviewProperties32
4911 {
4912     VkStructureType sType;
4913     PTR32 pNext;
4914     uint32_t maxMultiviewViewCount;
4915     uint32_t maxMultiviewInstanceIndex;
4916 } VkPhysicalDeviceMultiviewProperties32;
4917 typedef VkPhysicalDeviceMultiviewProperties32 VkPhysicalDeviceMultiviewPropertiesKHR32;
4918
4919 typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT32
4920 {
4921     VkStructureType sType;
4922     PTR32 pNext;
4923     uint32_t maxDiscardRectangles;
4924 } VkPhysicalDeviceDiscardRectanglePropertiesEXT32;
4925
4926 typedef struct VkPhysicalDeviceSubgroupProperties32
4927 {
4928     VkStructureType sType;
4929     PTR32 pNext;
4930     uint32_t subgroupSize;
4931     VkShaderStageFlags supportedStages;
4932     VkSubgroupFeatureFlags supportedOperations;
4933     VkBool32 quadOperationsInAllStages;
4934 } VkPhysicalDeviceSubgroupProperties32;
4935
4936 typedef struct VkPhysicalDevicePointClippingProperties32
4937 {
4938     VkStructureType sType;
4939     PTR32 pNext;
4940     VkPointClippingBehavior pointClippingBehavior;
4941 } VkPhysicalDevicePointClippingProperties32;
4942 typedef VkPhysicalDevicePointClippingProperties32 VkPhysicalDevicePointClippingPropertiesKHR32;
4943
4944 typedef struct VkPhysicalDeviceProtectedMemoryProperties32
4945 {
4946     VkStructureType sType;
4947     PTR32 pNext;
4948     VkBool32 protectedNoFault;
4949 } VkPhysicalDeviceProtectedMemoryProperties32;
4950
4951 typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties32
4952 {
4953     VkStructureType sType;
4954     PTR32 pNext;
4955     VkBool32 filterMinmaxSingleComponentFormats;
4956     VkBool32 filterMinmaxImageComponentMapping;
4957 } VkPhysicalDeviceSamplerFilterMinmaxProperties32;
4958 typedef VkPhysicalDeviceSamplerFilterMinmaxProperties32 VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT32;
4959
4960 typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT32
4961 {
4962     VkStructureType sType;
4963     PTR32 pNext;
4964     VkSampleCountFlags sampleLocationSampleCounts;
4965     VkExtent2D maxSampleLocationGridSize;
4966     float sampleLocationCoordinateRange[2];
4967     uint32_t sampleLocationSubPixelBits;
4968     VkBool32 variableSampleLocations;
4969 } VkPhysicalDeviceSampleLocationsPropertiesEXT32;
4970
4971 typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32
4972 {
4973     VkStructureType sType;
4974     PTR32 pNext;
4975     uint32_t advancedBlendMaxColorAttachments;
4976     VkBool32 advancedBlendIndependentBlend;
4977     VkBool32 advancedBlendNonPremultipliedSrcColor;
4978     VkBool32 advancedBlendNonPremultipliedDstColor;
4979     VkBool32 advancedBlendCorrelatedOverlap;
4980     VkBool32 advancedBlendAllOperations;
4981 } VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32;
4982
4983 typedef struct VkPhysicalDeviceInlineUniformBlockProperties32
4984 {
4985     VkStructureType sType;
4986     PTR32 pNext;
4987     uint32_t maxInlineUniformBlockSize;
4988     uint32_t maxPerStageDescriptorInlineUniformBlocks;
4989     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
4990     uint32_t maxDescriptorSetInlineUniformBlocks;
4991     uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
4992 } VkPhysicalDeviceInlineUniformBlockProperties32;
4993 typedef VkPhysicalDeviceInlineUniformBlockProperties32 VkPhysicalDeviceInlineUniformBlockPropertiesEXT32;
4994
4995 typedef struct VkPhysicalDeviceMaintenance3Properties32
4996 {
4997     VkStructureType sType;
4998     PTR32 pNext;
4999     uint32_t maxPerSetDescriptors;
5000     VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
5001 } VkPhysicalDeviceMaintenance3Properties32;
5002 typedef VkPhysicalDeviceMaintenance3Properties32 VkPhysicalDeviceMaintenance3PropertiesKHR32;
5003
5004 typedef struct VkPhysicalDeviceMaintenance4Properties32
5005 {
5006     VkStructureType sType;
5007     PTR32 pNext;
5008     VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
5009 } VkPhysicalDeviceMaintenance4Properties32;
5010 typedef VkPhysicalDeviceMaintenance4Properties32 VkPhysicalDeviceMaintenance4PropertiesKHR32;
5011
5012 typedef struct VkPhysicalDeviceFloatControlsProperties32
5013 {
5014     VkStructureType sType;
5015     PTR32 pNext;
5016     VkShaderFloatControlsIndependence denormBehaviorIndependence;
5017     VkShaderFloatControlsIndependence roundingModeIndependence;
5018     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
5019     VkBool32 shaderSignedZeroInfNanPreserveFloat32;
5020     VkBool32 shaderSignedZeroInfNanPreserveFloat64;
5021     VkBool32 shaderDenormPreserveFloat16;
5022     VkBool32 shaderDenormPreserveFloat32;
5023     VkBool32 shaderDenormPreserveFloat64;
5024     VkBool32 shaderDenormFlushToZeroFloat16;
5025     VkBool32 shaderDenormFlushToZeroFloat32;
5026     VkBool32 shaderDenormFlushToZeroFloat64;
5027     VkBool32 shaderRoundingModeRTEFloat16;
5028     VkBool32 shaderRoundingModeRTEFloat32;
5029     VkBool32 shaderRoundingModeRTEFloat64;
5030     VkBool32 shaderRoundingModeRTZFloat16;
5031     VkBool32 shaderRoundingModeRTZFloat32;
5032     VkBool32 shaderRoundingModeRTZFloat64;
5033 } VkPhysicalDeviceFloatControlsProperties32;
5034 typedef VkPhysicalDeviceFloatControlsProperties32 VkPhysicalDeviceFloatControlsPropertiesKHR32;
5035
5036 typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT32
5037 {
5038     VkStructureType sType;
5039     PTR32 pNext;
5040     VkDeviceSize DECLSPEC_ALIGN(8) minImportedHostPointerAlignment;
5041 } VkPhysicalDeviceExternalMemoryHostPropertiesEXT32;
5042
5043 typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT32
5044 {
5045     VkStructureType sType;
5046     PTR32 pNext;
5047     float primitiveOverestimationSize;
5048     float maxExtraPrimitiveOverestimationSize;
5049     float extraPrimitiveOverestimationSizeGranularity;
5050     VkBool32 primitiveUnderestimation;
5051     VkBool32 conservativePointAndLineRasterization;
5052     VkBool32 degenerateTrianglesRasterized;
5053     VkBool32 degenerateLinesRasterized;
5054     VkBool32 fullyCoveredFragmentShaderInputVariable;
5055     VkBool32 conservativeRasterizationPostDepthCoverage;
5056 } VkPhysicalDeviceConservativeRasterizationPropertiesEXT32;
5057
5058 typedef struct VkPhysicalDeviceShaderCorePropertiesAMD32
5059 {
5060     VkStructureType sType;
5061     PTR32 pNext;
5062     uint32_t shaderEngineCount;
5063     uint32_t shaderArraysPerEngineCount;
5064     uint32_t computeUnitsPerShaderArray;
5065     uint32_t simdPerComputeUnit;
5066     uint32_t wavefrontsPerSimd;
5067     uint32_t wavefrontSize;
5068     uint32_t sgprsPerSimd;
5069     uint32_t minSgprAllocation;
5070     uint32_t maxSgprAllocation;
5071     uint32_t sgprAllocationGranularity;
5072     uint32_t vgprsPerSimd;
5073     uint32_t minVgprAllocation;
5074     uint32_t maxVgprAllocation;
5075     uint32_t vgprAllocationGranularity;
5076 } VkPhysicalDeviceShaderCorePropertiesAMD32;
5077
5078 typedef struct VkPhysicalDeviceShaderCoreProperties2AMD32
5079 {
5080     VkStructureType sType;
5081     PTR32 pNext;
5082     VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;
5083     uint32_t activeComputeUnitCount;
5084 } VkPhysicalDeviceShaderCoreProperties2AMD32;
5085
5086 typedef struct VkPhysicalDeviceDescriptorIndexingProperties32
5087 {
5088     VkStructureType sType;
5089     PTR32 pNext;
5090     uint32_t maxUpdateAfterBindDescriptorsInAllPools;
5091     VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
5092     VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
5093     VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
5094     VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
5095     VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
5096     VkBool32 robustBufferAccessUpdateAfterBind;
5097     VkBool32 quadDivergentImplicitLod;
5098     uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
5099     uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
5100     uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
5101     uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
5102     uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
5103     uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
5104     uint32_t maxPerStageUpdateAfterBindResources;
5105     uint32_t maxDescriptorSetUpdateAfterBindSamplers;
5106     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
5107     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
5108     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
5109     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
5110     uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
5111     uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
5112     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
5113 } VkPhysicalDeviceDescriptorIndexingProperties32;
5114 typedef VkPhysicalDeviceDescriptorIndexingProperties32 VkPhysicalDeviceDescriptorIndexingPropertiesEXT32;
5115
5116 typedef struct VkPhysicalDeviceTimelineSemaphoreProperties32
5117 {
5118     VkStructureType sType;
5119     PTR32 pNext;
5120     uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
5121 } VkPhysicalDeviceTimelineSemaphoreProperties32;
5122 typedef VkPhysicalDeviceTimelineSemaphoreProperties32 VkPhysicalDeviceTimelineSemaphorePropertiesKHR32;
5123
5124 typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32
5125 {
5126     VkStructureType sType;
5127     PTR32 pNext;
5128     uint32_t maxVertexAttribDivisor;
5129 } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32;
5130
5131 typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT32
5132 {
5133     VkStructureType sType;
5134     PTR32 pNext;
5135     uint32_t pciDomain;
5136     uint32_t pciBus;
5137     uint32_t pciDevice;
5138     uint32_t pciFunction;
5139 } VkPhysicalDevicePCIBusInfoPropertiesEXT32;
5140
5141 typedef struct VkPhysicalDeviceDepthStencilResolveProperties32
5142 {
5143     VkStructureType sType;
5144     PTR32 pNext;
5145     VkResolveModeFlags supportedDepthResolveModes;
5146     VkResolveModeFlags supportedStencilResolveModes;
5147     VkBool32 independentResolveNone;
5148     VkBool32 independentResolve;
5149 } VkPhysicalDeviceDepthStencilResolveProperties32;
5150 typedef VkPhysicalDeviceDepthStencilResolveProperties32 VkPhysicalDeviceDepthStencilResolvePropertiesKHR32;
5151
5152 typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT32
5153 {
5154     VkStructureType sType;
5155     PTR32 pNext;
5156     uint32_t maxTransformFeedbackStreams;
5157     uint32_t maxTransformFeedbackBuffers;
5158     VkDeviceSize DECLSPEC_ALIGN(8) maxTransformFeedbackBufferSize;
5159     uint32_t maxTransformFeedbackStreamDataSize;
5160     uint32_t maxTransformFeedbackBufferDataSize;
5161     uint32_t maxTransformFeedbackBufferDataStride;
5162     VkBool32 transformFeedbackQueries;
5163     VkBool32 transformFeedbackStreamsLinesTriangles;
5164     VkBool32 transformFeedbackRasterizationStreamSelect;
5165     VkBool32 transformFeedbackDraw;
5166 } VkPhysicalDeviceTransformFeedbackPropertiesEXT32;
5167
5168 typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32
5169 {
5170     VkStructureType sType;
5171     PTR32 pNext;
5172     VkQueueFlags supportedQueues;
5173 } VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32;
5174
5175 typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV32
5176 {
5177     VkStructureType sType;
5178     PTR32 pNext;
5179     VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethods;
5180     uint64_t DECLSPEC_ALIGN(8) maxDecompressionIndirectCount;
5181 } VkPhysicalDeviceMemoryDecompressionPropertiesNV32;
5182
5183 typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV32
5184 {
5185     VkStructureType sType;
5186     PTR32 pNext;
5187     VkExtent2D shadingRateTexelSize;
5188     uint32_t shadingRatePaletteSize;
5189     uint32_t shadingRateMaxCoarseSamples;
5190 } VkPhysicalDeviceShadingRateImagePropertiesNV32;
5191
5192 typedef struct VkPhysicalDeviceMeshShaderPropertiesNV32
5193 {
5194     VkStructureType sType;
5195     PTR32 pNext;
5196     uint32_t maxDrawMeshTasksCount;
5197     uint32_t maxTaskWorkGroupInvocations;
5198     uint32_t maxTaskWorkGroupSize[3];
5199     uint32_t maxTaskTotalMemorySize;
5200     uint32_t maxTaskOutputCount;
5201     uint32_t maxMeshWorkGroupInvocations;
5202     uint32_t maxMeshWorkGroupSize[3];
5203     uint32_t maxMeshTotalMemorySize;
5204     uint32_t maxMeshOutputVertices;
5205     uint32_t maxMeshOutputPrimitives;
5206     uint32_t maxMeshMultiviewViewCount;
5207     uint32_t meshOutputPerVertexGranularity;
5208     uint32_t meshOutputPerPrimitiveGranularity;
5209 } VkPhysicalDeviceMeshShaderPropertiesNV32;
5210
5211 typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT32
5212 {
5213     VkStructureType sType;
5214     PTR32 pNext;
5215     uint32_t maxTaskWorkGroupTotalCount;
5216     uint32_t maxTaskWorkGroupCount[3];
5217     uint32_t maxTaskWorkGroupInvocations;
5218     uint32_t maxTaskWorkGroupSize[3];
5219     uint32_t maxTaskPayloadSize;
5220     uint32_t maxTaskSharedMemorySize;
5221     uint32_t maxTaskPayloadAndSharedMemorySize;
5222     uint32_t maxMeshWorkGroupTotalCount;
5223     uint32_t maxMeshWorkGroupCount[3];
5224     uint32_t maxMeshWorkGroupInvocations;
5225     uint32_t maxMeshWorkGroupSize[3];
5226     uint32_t maxMeshSharedMemorySize;
5227     uint32_t maxMeshPayloadAndSharedMemorySize;
5228     uint32_t maxMeshOutputMemorySize;
5229     uint32_t maxMeshPayloadAndOutputMemorySize;
5230     uint32_t maxMeshOutputComponents;
5231     uint32_t maxMeshOutputVertices;
5232     uint32_t maxMeshOutputPrimitives;
5233     uint32_t maxMeshOutputLayers;
5234     uint32_t maxMeshMultiviewViewCount;
5235     uint32_t meshOutputPerVertexGranularity;
5236     uint32_t meshOutputPerPrimitiveGranularity;
5237     uint32_t maxPreferredTaskWorkGroupInvocations;
5238     uint32_t maxPreferredMeshWorkGroupInvocations;
5239     VkBool32 prefersLocalInvocationVertexOutput;
5240     VkBool32 prefersLocalInvocationPrimitiveOutput;
5241     VkBool32 prefersCompactVertexOutput;
5242     VkBool32 prefersCompactPrimitiveOutput;
5243 } VkPhysicalDeviceMeshShaderPropertiesEXT32;
5244
5245 typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR32
5246 {
5247     VkStructureType sType;
5248     PTR32 pNext;
5249     uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
5250     uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
5251     uint64_t DECLSPEC_ALIGN(8) maxPrimitiveCount;
5252     uint32_t maxPerStageDescriptorAccelerationStructures;
5253     uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
5254     uint32_t maxDescriptorSetAccelerationStructures;
5255     uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures;
5256     uint32_t minAccelerationStructureScratchOffsetAlignment;
5257 } VkPhysicalDeviceAccelerationStructurePropertiesKHR32;
5258
5259 typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR32
5260 {
5261     VkStructureType sType;
5262     PTR32 pNext;
5263     uint32_t shaderGroupHandleSize;
5264     uint32_t maxRayRecursionDepth;
5265     uint32_t maxShaderGroupStride;
5266     uint32_t shaderGroupBaseAlignment;
5267     uint32_t shaderGroupHandleCaptureReplaySize;
5268     uint32_t maxRayDispatchInvocationCount;
5269     uint32_t shaderGroupHandleAlignment;
5270     uint32_t maxRayHitAttributeSize;
5271 } VkPhysicalDeviceRayTracingPipelinePropertiesKHR32;
5272
5273 typedef struct VkPhysicalDeviceRayTracingPropertiesNV32
5274 {
5275     VkStructureType sType;
5276     PTR32 pNext;
5277     uint32_t shaderGroupHandleSize;
5278     uint32_t maxRecursionDepth;
5279     uint32_t maxShaderGroupStride;
5280     uint32_t shaderGroupBaseAlignment;
5281     uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
5282     uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
5283     uint64_t DECLSPEC_ALIGN(8) maxTriangleCount;
5284     uint32_t maxDescriptorSetAccelerationStructures;
5285 } VkPhysicalDeviceRayTracingPropertiesNV32;
5286
5287 typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT32
5288 {
5289     VkStructureType sType;
5290     PTR32 pNext;
5291     VkExtent2D minFragmentDensityTexelSize;
5292     VkExtent2D maxFragmentDensityTexelSize;
5293     VkBool32 fragmentDensityInvocations;
5294 } VkPhysicalDeviceFragmentDensityMapPropertiesEXT32;
5295
5296 typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32
5297 {
5298     VkStructureType sType;
5299     PTR32 pNext;
5300     VkBool32 subsampledLoads;
5301     VkBool32 subsampledCoarseReconstructionEarlyAccess;
5302     uint32_t maxSubsampledArrayLayers;
5303     uint32_t maxDescriptorSetSubsampledSamplers;
5304 } VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32;
5305
5306 typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32
5307 {
5308     VkStructureType sType;
5309     PTR32 pNext;
5310     VkExtent2D fragmentDensityOffsetGranularity;
5311 } VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32;
5312
5313 typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV32
5314 {
5315     VkStructureType sType;
5316     PTR32 pNext;
5317     VkShaderStageFlags cooperativeMatrixSupportedStages;
5318 } VkPhysicalDeviceCooperativeMatrixPropertiesNV32;
5319
5320 typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR32
5321 {
5322     VkStructureType sType;
5323     PTR32 pNext;
5324     VkBool32 allowCommandBufferQueryCopies;
5325 } VkPhysicalDevicePerformanceQueryPropertiesKHR32;
5326
5327 typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32
5328 {
5329     VkStructureType sType;
5330     PTR32 pNext;
5331     uint32_t shaderSMCount;
5332     uint32_t shaderWarpsPerSM;
5333 } VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32;
5334
5335 typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties32
5336 {
5337     VkStructureType sType;
5338     PTR32 pNext;
5339     VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
5340     VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
5341     VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
5342     VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
5343 } VkPhysicalDeviceTexelBufferAlignmentProperties32;
5344 typedef VkPhysicalDeviceTexelBufferAlignmentProperties32 VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT32;
5345
5346 typedef struct VkPhysicalDeviceSubgroupSizeControlProperties32
5347 {
5348     VkStructureType sType;
5349     PTR32 pNext;
5350     uint32_t minSubgroupSize;
5351     uint32_t maxSubgroupSize;
5352     uint32_t maxComputeWorkgroupSubgroups;
5353     VkShaderStageFlags requiredSubgroupSizeStages;
5354 } VkPhysicalDeviceSubgroupSizeControlProperties32;
5355 typedef VkPhysicalDeviceSubgroupSizeControlProperties32 VkPhysicalDeviceSubgroupSizeControlPropertiesEXT32;
5356
5357 typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32
5358 {
5359     VkStructureType sType;
5360     PTR32 pNext;
5361     uint32_t maxSubpassShadingWorkgroupSizeAspectRatio;
5362 } VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32;
5363
5364 typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32
5365 {
5366     VkStructureType sType;
5367     PTR32 pNext;
5368     uint32_t maxWorkGroupCount[3];
5369     uint32_t maxWorkGroupSize[3];
5370     uint32_t maxOutputClusterCount;
5371     VkDeviceSize DECLSPEC_ALIGN(8) indirectBufferOffsetAlignment;
5372 } VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32;
5373
5374 typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT32
5375 {
5376     VkStructureType sType;
5377     PTR32 pNext;
5378     uint32_t lineSubPixelPrecisionBits;
5379 } VkPhysicalDeviceLineRasterizationPropertiesEXT32;
5380
5381 typedef struct VkPhysicalDeviceVulkan11Properties32
5382 {
5383     VkStructureType sType;
5384     PTR32 pNext;
5385     uint8_t deviceUUID[VK_UUID_SIZE];
5386     uint8_t driverUUID[VK_UUID_SIZE];
5387     uint8_t deviceLUID[VK_LUID_SIZE];
5388     uint32_t deviceNodeMask;
5389     VkBool32 deviceLUIDValid;
5390     uint32_t subgroupSize;
5391     VkShaderStageFlags subgroupSupportedStages;
5392     VkSubgroupFeatureFlags subgroupSupportedOperations;
5393     VkBool32 subgroupQuadOperationsInAllStages;
5394     VkPointClippingBehavior pointClippingBehavior;
5395     uint32_t maxMultiviewViewCount;
5396     uint32_t maxMultiviewInstanceIndex;
5397     VkBool32 protectedNoFault;
5398     uint32_t maxPerSetDescriptors;
5399     VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
5400 } VkPhysicalDeviceVulkan11Properties32;
5401
5402 typedef struct VkPhysicalDeviceVulkan12Properties32
5403 {
5404     VkStructureType sType;
5405     PTR32 pNext;
5406     VkDriverId driverID;
5407     char driverName[VK_MAX_DRIVER_NAME_SIZE];
5408     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
5409     VkConformanceVersion conformanceVersion;
5410     VkShaderFloatControlsIndependence denormBehaviorIndependence;
5411     VkShaderFloatControlsIndependence roundingModeIndependence;
5412     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
5413     VkBool32 shaderSignedZeroInfNanPreserveFloat32;
5414     VkBool32 shaderSignedZeroInfNanPreserveFloat64;
5415     VkBool32 shaderDenormPreserveFloat16;
5416     VkBool32 shaderDenormPreserveFloat32;
5417     VkBool32 shaderDenormPreserveFloat64;
5418     VkBool32 shaderDenormFlushToZeroFloat16;
5419     VkBool32 shaderDenormFlushToZeroFloat32;
5420     VkBool32 shaderDenormFlushToZeroFloat64;
5421     VkBool32 shaderRoundingModeRTEFloat16;
5422     VkBool32 shaderRoundingModeRTEFloat32;
5423     VkBool32 shaderRoundingModeRTEFloat64;
5424     VkBool32 shaderRoundingModeRTZFloat16;
5425     VkBool32 shaderRoundingModeRTZFloat32;
5426     VkBool32 shaderRoundingModeRTZFloat64;
5427     uint32_t maxUpdateAfterBindDescriptorsInAllPools;
5428     VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
5429     VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
5430     VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
5431     VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
5432     VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
5433     VkBool32 robustBufferAccessUpdateAfterBind;
5434     VkBool32 quadDivergentImplicitLod;
5435     uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
5436     uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
5437     uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
5438     uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
5439     uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
5440     uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
5441     uint32_t maxPerStageUpdateAfterBindResources;
5442     uint32_t maxDescriptorSetUpdateAfterBindSamplers;
5443     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
5444     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
5445     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
5446     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
5447     uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
5448     uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
5449     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
5450     VkResolveModeFlags supportedDepthResolveModes;
5451     VkResolveModeFlags supportedStencilResolveModes;
5452     VkBool32 independentResolveNone;
5453     VkBool32 independentResolve;
5454     VkBool32 filterMinmaxSingleComponentFormats;
5455     VkBool32 filterMinmaxImageComponentMapping;
5456     uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
5457     VkSampleCountFlags framebufferIntegerColorSampleCounts;
5458 } VkPhysicalDeviceVulkan12Properties32;
5459
5460 typedef struct VkPhysicalDeviceVulkan13Properties32
5461 {
5462     VkStructureType sType;
5463     PTR32 pNext;
5464     uint32_t minSubgroupSize;
5465     uint32_t maxSubgroupSize;
5466     uint32_t maxComputeWorkgroupSubgroups;
5467     VkShaderStageFlags requiredSubgroupSizeStages;
5468     uint32_t maxInlineUniformBlockSize;
5469     uint32_t maxPerStageDescriptorInlineUniformBlocks;
5470     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
5471     uint32_t maxDescriptorSetInlineUniformBlocks;
5472     uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
5473     uint32_t maxInlineUniformTotalSize;
5474     VkBool32 integerDotProduct8BitUnsignedAccelerated;
5475     VkBool32 integerDotProduct8BitSignedAccelerated;
5476     VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
5477     VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
5478     VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
5479     VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
5480     VkBool32 integerDotProduct16BitUnsignedAccelerated;
5481     VkBool32 integerDotProduct16BitSignedAccelerated;
5482     VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
5483     VkBool32 integerDotProduct32BitUnsignedAccelerated;
5484     VkBool32 integerDotProduct32BitSignedAccelerated;
5485     VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
5486     VkBool32 integerDotProduct64BitUnsignedAccelerated;
5487     VkBool32 integerDotProduct64BitSignedAccelerated;
5488     VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
5489     VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
5490     VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
5491     VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
5492     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
5493     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
5494     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
5495     VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
5496     VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
5497     VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
5498     VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
5499     VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
5500     VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
5501     VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
5502     VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
5503     VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
5504     VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
5505     VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
5506     VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
5507     VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
5508     VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
5509 } VkPhysicalDeviceVulkan13Properties32;
5510
5511 typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT32
5512 {
5513     VkStructureType sType;
5514     PTR32 pNext;
5515     uint32_t maxCustomBorderColorSamplers;
5516 } VkPhysicalDeviceCustomBorderColorPropertiesEXT32;
5517
5518 typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32
5519 {
5520     VkStructureType sType;
5521     PTR32 pNext;
5522     VkBool32 dynamicPrimitiveTopologyUnrestricted;
5523 } VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32;
5524
5525 typedef struct VkPhysicalDeviceRobustness2PropertiesEXT32
5526 {
5527     VkStructureType sType;
5528     PTR32 pNext;
5529     VkDeviceSize DECLSPEC_ALIGN(8) robustStorageBufferAccessSizeAlignment;
5530     VkDeviceSize DECLSPEC_ALIGN(8) robustUniformBufferAccessSizeAlignment;
5531 } VkPhysicalDeviceRobustness2PropertiesEXT32;
5532
5533 typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR32
5534 {
5535     VkStructureType sType;
5536     PTR32 pNext;
5537     VkExtent2D minFragmentShadingRateAttachmentTexelSize;
5538     VkExtent2D maxFragmentShadingRateAttachmentTexelSize;
5539     uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
5540     VkBool32 primitiveFragmentShadingRateWithMultipleViewports;
5541     VkBool32 layeredShadingRateAttachments;
5542     VkBool32 fragmentShadingRateNonTrivialCombinerOps;
5543     VkExtent2D maxFragmentSize;
5544     uint32_t maxFragmentSizeAspectRatio;
5545     uint32_t maxFragmentShadingRateCoverageSamples;
5546     VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples;
5547     VkBool32 fragmentShadingRateWithShaderDepthStencilWrites;
5548     VkBool32 fragmentShadingRateWithSampleMask;
5549     VkBool32 fragmentShadingRateWithShaderSampleMask;
5550     VkBool32 fragmentShadingRateWithConservativeRasterization;
5551     VkBool32 fragmentShadingRateWithFragmentShaderInterlock;
5552     VkBool32 fragmentShadingRateWithCustomSampleLocations;
5553     VkBool32 fragmentShadingRateStrictMultiplyCombiner;
5554 } VkPhysicalDeviceFragmentShadingRatePropertiesKHR32;
5555
5556 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32
5557 {
5558     VkStructureType sType;
5559     PTR32 pNext;
5560     VkSampleCountFlagBits maxFragmentShadingRateInvocationCount;
5561 } VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32;
5562
5563 typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT32
5564 {
5565     VkStructureType sType;
5566     PTR32 pNext;
5567     VkBool32 provokingVertexModePerPipeline;
5568     VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex;
5569 } VkPhysicalDeviceProvokingVertexPropertiesEXT32;
5570
5571 typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT32
5572 {
5573     VkStructureType sType;
5574     PTR32 pNext;
5575     VkBool32 combinedImageSamplerDescriptorSingleArray;
5576     VkBool32 bufferlessPushDescriptors;
5577     VkBool32 allowSamplerImageViewPostSubmitCreation;
5578     VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferOffsetAlignment;
5579     uint32_t maxDescriptorBufferBindings;
5580     uint32_t maxResourceDescriptorBufferBindings;
5581     uint32_t maxSamplerDescriptorBufferBindings;
5582     uint32_t maxEmbeddedImmutableSamplerBindings;
5583     uint32_t maxEmbeddedImmutableSamplers;
5584     PTR32 bufferCaptureReplayDescriptorDataSize;
5585     PTR32 imageCaptureReplayDescriptorDataSize;
5586     PTR32 imageViewCaptureReplayDescriptorDataSize;
5587     PTR32 samplerCaptureReplayDescriptorDataSize;
5588     PTR32 accelerationStructureCaptureReplayDescriptorDataSize;
5589     PTR32 samplerDescriptorSize;
5590     PTR32 combinedImageSamplerDescriptorSize;
5591     PTR32 sampledImageDescriptorSize;
5592     PTR32 storageImageDescriptorSize;
5593     PTR32 uniformTexelBufferDescriptorSize;
5594     PTR32 robustUniformTexelBufferDescriptorSize;
5595     PTR32 storageTexelBufferDescriptorSize;
5596     PTR32 robustStorageTexelBufferDescriptorSize;
5597     PTR32 uniformBufferDescriptorSize;
5598     PTR32 robustUniformBufferDescriptorSize;
5599     PTR32 storageBufferDescriptorSize;
5600     PTR32 robustStorageBufferDescriptorSize;
5601     PTR32 inputAttachmentDescriptorSize;
5602     PTR32 accelerationStructureDescriptorSize;
5603     VkDeviceSize DECLSPEC_ALIGN(8) maxSamplerDescriptorBufferRange;
5604     VkDeviceSize DECLSPEC_ALIGN(8) maxResourceDescriptorBufferRange;
5605     VkDeviceSize DECLSPEC_ALIGN(8) samplerDescriptorBufferAddressSpaceSize;
5606     VkDeviceSize DECLSPEC_ALIGN(8) resourceDescriptorBufferAddressSpaceSize;
5607     VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferAddressSpaceSize;
5608 } VkPhysicalDeviceDescriptorBufferPropertiesEXT32;
5609
5610 typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32
5611 {
5612     VkStructureType sType;
5613     PTR32 pNext;
5614     PTR32 combinedImageSamplerDensityMapDescriptorSize;
5615 } VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32;
5616
5617 typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties32
5618 {
5619     VkStructureType sType;
5620     PTR32 pNext;
5621     VkBool32 integerDotProduct8BitUnsignedAccelerated;
5622     VkBool32 integerDotProduct8BitSignedAccelerated;
5623     VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
5624     VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
5625     VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
5626     VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
5627     VkBool32 integerDotProduct16BitUnsignedAccelerated;
5628     VkBool32 integerDotProduct16BitSignedAccelerated;
5629     VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
5630     VkBool32 integerDotProduct32BitUnsignedAccelerated;
5631     VkBool32 integerDotProduct32BitSignedAccelerated;
5632     VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
5633     VkBool32 integerDotProduct64BitUnsignedAccelerated;
5634     VkBool32 integerDotProduct64BitSignedAccelerated;
5635     VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
5636     VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
5637     VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
5638     VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
5639     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
5640     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
5641     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
5642     VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
5643     VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
5644     VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
5645     VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
5646     VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
5647     VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
5648     VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
5649     VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
5650     VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
5651 } VkPhysicalDeviceShaderIntegerDotProductProperties32;
5652 typedef VkPhysicalDeviceShaderIntegerDotProductProperties32 VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR32;
5653
5654 typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32
5655 {
5656     VkStructureType sType;
5657     PTR32 pNext;
5658     VkBool32 triStripVertexOrderIndependentOfProvokingVertex;
5659 } VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32;
5660
5661 typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32
5662 {
5663     VkStructureType sType;
5664     PTR32 pNext;
5665     VkBool32 graphicsPipelineLibraryFastLinking;
5666     VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration;
5667 } VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32;
5668
5669 typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32
5670 {
5671     VkStructureType sType;
5672     PTR32 pNext;
5673     uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE];
5674 } VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32;
5675
5676 typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT32
5677 {
5678     VkStructureType sType;
5679     PTR32 pNext;
5680     uint32_t maxOpacity2StateSubdivisionLevel;
5681     uint32_t maxOpacity4StateSubdivisionLevel;
5682 } VkPhysicalDeviceOpacityMicromapPropertiesEXT32;
5683
5684 typedef struct VkPhysicalDevicePipelineRobustnessPropertiesEXT32
5685 {
5686     VkStructureType sType;
5687     PTR32 pNext;
5688     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers;
5689     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers;
5690     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs;
5691     VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages;
5692 } VkPhysicalDevicePipelineRobustnessPropertiesEXT32;
5693
5694 typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM32
5695 {
5696     VkStructureType sType;
5697     PTR32 pNext;
5698     uint32_t maxWeightFilterPhases;
5699     VkExtent2D maxWeightFilterDimension;
5700     VkExtent2D maxBlockMatchRegion;
5701     VkExtent2D maxBoxFilterBlockSize;
5702 } VkPhysicalDeviceImageProcessingPropertiesQCOM32;
5703
5704 typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV32
5705 {
5706     VkStructureType sType;
5707     PTR32 pNext;
5708     VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes;
5709     VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes;
5710     VkBool32 hintSupported;
5711     VkBool32 costSupported;
5712     VkBool32 bidirectionalFlowSupported;
5713     VkBool32 globalFlowSupported;
5714     uint32_t minWidth;
5715     uint32_t minHeight;
5716     uint32_t maxWidth;
5717     uint32_t maxHeight;
5718     uint32_t maxNumRegionsOfInterest;
5719 } VkPhysicalDeviceOpticalFlowPropertiesNV32;
5720
5721 typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32
5722 {
5723     VkStructureType sType;
5724     PTR32 pNext;
5725     uint64_t DECLSPEC_ALIGN(8) shaderCoreMask;
5726     uint32_t shaderCoreCount;
5727     uint32_t shaderWarpsPerCore;
5728 } VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32;
5729
5730 typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32
5731 {
5732     VkStructureType sType;
5733     PTR32 pNext;
5734     VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint;
5735 } VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32;
5736
5737 typedef struct VkPhysicalDeviceShaderCorePropertiesARM32
5738 {
5739     VkStructureType sType;
5740     PTR32 pNext;
5741     uint32_t pixelRate;
5742     uint32_t texelRate;
5743     uint32_t fmaRate;
5744 } VkPhysicalDeviceShaderCorePropertiesARM32;
5745
5746 typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT32
5747 {
5748     VkStructureType sType;
5749     PTR32 pNext;
5750     uint8_t shaderBinaryUUID[VK_UUID_SIZE];
5751     uint32_t shaderBinaryVersion;
5752 } VkPhysicalDeviceShaderObjectPropertiesEXT32;
5753
5754 typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT32
5755 {
5756     VkStructureType sType;
5757     PTR32 pNext;
5758     VkBool32 shaderTileImageCoherentReadAccelerated;
5759     VkBool32 shaderTileImageReadSampleFromPixelRateInvocation;
5760     VkBool32 shaderTileImageReadFromHelperInvocation;
5761 } VkPhysicalDeviceShaderTileImagePropertiesEXT32;
5762
5763 typedef struct VkPhysicalDeviceProperties232
5764 {
5765     VkStructureType sType;
5766     PTR32 pNext;
5767     VkPhysicalDeviceProperties32 DECLSPEC_ALIGN(8) properties;
5768 } VkPhysicalDeviceProperties232;
5769 typedef VkPhysicalDeviceProperties232 VkPhysicalDeviceProperties2KHR32;
5770
5771 typedef struct VkQueueFamilyGlobalPriorityPropertiesKHR32
5772 {
5773     VkStructureType sType;
5774     PTR32 pNext;
5775     uint32_t priorityCount;
5776     VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR];
5777 } VkQueueFamilyGlobalPriorityPropertiesKHR32;
5778 typedef VkQueueFamilyGlobalPriorityPropertiesKHR32 VkQueueFamilyGlobalPriorityPropertiesEXT32;
5779
5780 typedef struct VkQueueFamilyCheckpointPropertiesNV32
5781 {
5782     VkStructureType sType;
5783     PTR32 pNext;
5784     VkPipelineStageFlags checkpointExecutionStageMask;
5785 } VkQueueFamilyCheckpointPropertiesNV32;
5786
5787 typedef struct VkQueueFamilyCheckpointProperties2NV32
5788 {
5789     VkStructureType sType;
5790     PTR32 pNext;
5791     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) checkpointExecutionStageMask;
5792 } VkQueueFamilyCheckpointProperties2NV32;
5793
5794 typedef struct VkQueueFamilyProperties232
5795 {
5796     VkStructureType sType;
5797     PTR32 pNext;
5798     VkQueueFamilyProperties queueFamilyProperties;
5799 } VkQueueFamilyProperties232;
5800 typedef VkQueueFamilyProperties232 VkQueueFamilyProperties2KHR32;
5801
5802 typedef struct VkPhysicalDeviceSparseImageFormatInfo232
5803 {
5804     VkStructureType sType;
5805     PTR32 pNext;
5806     VkFormat format;
5807     VkImageType type;
5808     VkSampleCountFlagBits samples;
5809     VkImageUsageFlags usage;
5810     VkImageTiling tiling;
5811 } VkPhysicalDeviceSparseImageFormatInfo232;
5812 typedef VkPhysicalDeviceSparseImageFormatInfo232 VkPhysicalDeviceSparseImageFormatInfo2KHR32;
5813
5814 typedef struct VkSparseImageFormatProperties232
5815 {
5816     VkStructureType sType;
5817     PTR32 pNext;
5818     VkSparseImageFormatProperties properties;
5819 } VkSparseImageFormatProperties232;
5820 typedef VkSparseImageFormatProperties232 VkSparseImageFormatProperties2KHR32;
5821
5822 typedef struct VkFramebufferMixedSamplesCombinationNV32
5823 {
5824     VkStructureType sType;
5825     PTR32 pNext;
5826     VkCoverageReductionModeNV coverageReductionMode;
5827     VkSampleCountFlagBits rasterizationSamples;
5828     VkSampleCountFlags depthStencilSamples;
5829     VkSampleCountFlags colorSamples;
5830 } VkFramebufferMixedSamplesCombinationNV32;
5831
5832 typedef struct VkSurfacePresentModeEXT32
5833 {
5834     VkStructureType sType;
5835     PTR32 pNext;
5836     VkPresentModeKHR presentMode;
5837 } VkSurfacePresentModeEXT32;
5838
5839 typedef struct VkPhysicalDeviceSurfaceInfo2KHR32
5840 {
5841     VkStructureType sType;
5842     PTR32 pNext;
5843     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
5844 } VkPhysicalDeviceSurfaceInfo2KHR32;
5845
5846 typedef struct VkSurfaceCapabilitiesPresentBarrierNV32
5847 {
5848     VkStructureType sType;
5849     PTR32 pNext;
5850     VkBool32 presentBarrierSupported;
5851 } VkSurfaceCapabilitiesPresentBarrierNV32;
5852
5853 typedef struct VkSurfacePresentScalingCapabilitiesEXT32
5854 {
5855     VkStructureType sType;
5856     PTR32 pNext;
5857     VkPresentScalingFlagsEXT supportedPresentScaling;
5858     VkPresentGravityFlagsEXT supportedPresentGravityX;
5859     VkPresentGravityFlagsEXT supportedPresentGravityY;
5860     VkExtent2D minScaledImageExtent;
5861     VkExtent2D maxScaledImageExtent;
5862 } VkSurfacePresentScalingCapabilitiesEXT32;
5863
5864 typedef struct VkSurfacePresentModeCompatibilityEXT32
5865 {
5866     VkStructureType sType;
5867     PTR32 pNext;
5868     uint32_t presentModeCount;
5869     PTR32 pPresentModes;
5870 } VkSurfacePresentModeCompatibilityEXT32;
5871
5872 typedef struct VkSurfaceCapabilities2KHR32
5873 {
5874     VkStructureType sType;
5875     PTR32 pNext;
5876     VkSurfaceCapabilitiesKHR surfaceCapabilities;
5877 } VkSurfaceCapabilities2KHR32;
5878
5879 typedef struct VkSurfaceFormat2KHR32
5880 {
5881     VkStructureType sType;
5882     PTR32 pNext;
5883     VkSurfaceFormatKHR surfaceFormat;
5884 } VkSurfaceFormat2KHR32;
5885
5886 typedef struct VkPhysicalDeviceToolProperties32
5887 {
5888     VkStructureType sType;
5889     PTR32 pNext;
5890     char name[VK_MAX_EXTENSION_NAME_SIZE];
5891     char version[VK_MAX_EXTENSION_NAME_SIZE];
5892     VkToolPurposeFlags purposes;
5893     char description[VK_MAX_DESCRIPTION_SIZE];
5894     char layer[VK_MAX_EXTENSION_NAME_SIZE];
5895 } VkPhysicalDeviceToolProperties32;
5896 typedef VkPhysicalDeviceToolProperties32 VkPhysicalDeviceToolPropertiesEXT32;
5897
5898 typedef struct VkPipelineExecutableInfoKHR32
5899 {
5900     VkStructureType sType;
5901     PTR32 pNext;
5902     VkPipeline DECLSPEC_ALIGN(8) pipeline;
5903     uint32_t executableIndex;
5904 } VkPipelineExecutableInfoKHR32;
5905
5906 typedef struct VkPipelineExecutableInternalRepresentationKHR32
5907 {
5908     VkStructureType sType;
5909     PTR32 pNext;
5910     char name[VK_MAX_DESCRIPTION_SIZE];
5911     char description[VK_MAX_DESCRIPTION_SIZE];
5912     VkBool32 isText;
5913     PTR32 dataSize;
5914     PTR32 pData;
5915 } VkPipelineExecutableInternalRepresentationKHR32;
5916
5917 typedef struct VkPipelineInfoKHR32
5918 {
5919     VkStructureType sType;
5920     PTR32 pNext;
5921     VkPipeline DECLSPEC_ALIGN(8) pipeline;
5922 } VkPipelineInfoKHR32;
5923 typedef VkPipelineInfoKHR32 VkPipelineInfoEXT32;
5924
5925 typedef struct VkPipelineExecutablePropertiesKHR32
5926 {
5927     VkStructureType sType;
5928     PTR32 pNext;
5929     VkShaderStageFlags stages;
5930     char name[VK_MAX_DESCRIPTION_SIZE];
5931     char description[VK_MAX_DESCRIPTION_SIZE];
5932     uint32_t subgroupSize;
5933 } VkPipelineExecutablePropertiesKHR32;
5934
5935 typedef union VkPipelineExecutableStatisticValueKHR32
5936 {
5937     VkBool32 b32;
5938     int64_t i64;
5939     uint64_t DECLSPEC_ALIGN(8) u64;
5940     double f64;
5941 } VkPipelineExecutableStatisticValueKHR32;
5942
5943 typedef struct VkPipelineExecutableStatisticKHR32
5944 {
5945     VkStructureType sType;
5946     PTR32 pNext;
5947     char name[VK_MAX_DESCRIPTION_SIZE];
5948     char description[VK_MAX_DESCRIPTION_SIZE];
5949     VkPipelineExecutableStatisticFormatKHR format;
5950     VkPipelineExecutableStatisticValueKHR32 DECLSPEC_ALIGN(8) value;
5951 } VkPipelineExecutableStatisticKHR32;
5952
5953
5954 typedef struct VkCheckpointData2NV32
5955 {
5956     VkStructureType sType;
5957     PTR32 pNext;
5958     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
5959     PTR32 pCheckpointMarker;
5960 } VkCheckpointData2NV32;
5961
5962 typedef struct VkCheckpointDataNV32
5963 {
5964     VkStructureType sType;
5965     PTR32 pNext;
5966     VkPipelineStageFlagBits stage;
5967     PTR32 pCheckpointMarker;
5968 } VkCheckpointDataNV32;
5969
5970 typedef struct VkSamplerCaptureDescriptorDataInfoEXT32
5971 {
5972     VkStructureType sType;
5973     PTR32 pNext;
5974     VkSampler DECLSPEC_ALIGN(8) sampler;
5975 } VkSamplerCaptureDescriptorDataInfoEXT32;
5976
5977 typedef struct VkShaderModuleIdentifierEXT32
5978 {
5979     VkStructureType sType;
5980     PTR32 pNext;
5981     uint32_t identifierSize;
5982     uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT];
5983 } VkShaderModuleIdentifierEXT32;
5984
5985 typedef struct VkInitializePerformanceApiInfoINTEL32
5986 {
5987     VkStructureType sType;
5988     PTR32 pNext;
5989     PTR32 pUserData;
5990 } VkInitializePerformanceApiInfoINTEL32;
5991
5992 typedef struct VkMemoryMapInfoKHR32
5993 {
5994     VkStructureType sType;
5995     PTR32 pNext;
5996     VkMemoryMapFlags flags;
5997     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
5998     VkDeviceSize DECLSPEC_ALIGN(8) offset;
5999     VkDeviceSize DECLSPEC_ALIGN(8) size;
6000 } VkMemoryMapInfoKHR32;
6001
6002 typedef struct VkSparseMemoryBind32
6003 {
6004     VkDeviceSize DECLSPEC_ALIGN(8) resourceOffset;
6005     VkDeviceSize DECLSPEC_ALIGN(8) size;
6006     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
6007     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
6008     VkSparseMemoryBindFlags flags;
6009 } VkSparseMemoryBind32;
6010
6011 typedef struct VkSparseBufferMemoryBindInfo32
6012 {
6013     VkBuffer DECLSPEC_ALIGN(8) buffer;
6014     uint32_t bindCount;
6015     PTR32 pBinds;
6016 } VkSparseBufferMemoryBindInfo32;
6017
6018 typedef struct VkSparseImageOpaqueMemoryBindInfo32
6019 {
6020     VkImage DECLSPEC_ALIGN(8) image;
6021     uint32_t bindCount;
6022     PTR32 pBinds;
6023 } VkSparseImageOpaqueMemoryBindInfo32;
6024
6025 typedef struct VkSparseImageMemoryBind32
6026 {
6027     VkImageSubresource subresource;
6028     VkOffset3D offset;
6029     VkExtent3D extent;
6030     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
6031     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
6032     VkSparseMemoryBindFlags flags;
6033 } VkSparseImageMemoryBind32;
6034
6035 typedef struct VkSparseImageMemoryBindInfo32
6036 {
6037     VkImage DECLSPEC_ALIGN(8) image;
6038     uint32_t bindCount;
6039     PTR32 pBinds;
6040 } VkSparseImageMemoryBindInfo32;
6041
6042 typedef struct VkDeviceGroupBindSparseInfo32
6043 {
6044     VkStructureType sType;
6045     PTR32 pNext;
6046     uint32_t resourceDeviceIndex;
6047     uint32_t memoryDeviceIndex;
6048 } VkDeviceGroupBindSparseInfo32;
6049 typedef VkDeviceGroupBindSparseInfo32 VkDeviceGroupBindSparseInfoKHR32;
6050
6051 typedef struct VkTimelineSemaphoreSubmitInfo32
6052 {
6053     VkStructureType sType;
6054     PTR32 pNext;
6055     uint32_t waitSemaphoreValueCount;
6056     PTR32 pWaitSemaphoreValues;
6057     uint32_t signalSemaphoreValueCount;
6058     PTR32 pSignalSemaphoreValues;
6059 } VkTimelineSemaphoreSubmitInfo32;
6060 typedef VkTimelineSemaphoreSubmitInfo32 VkTimelineSemaphoreSubmitInfoKHR32;
6061
6062 typedef struct VkBindSparseInfo32
6063 {
6064     VkStructureType sType;
6065     PTR32 pNext;
6066     uint32_t waitSemaphoreCount;
6067     PTR32 pWaitSemaphores;
6068     uint32_t bufferBindCount;
6069     PTR32 pBufferBinds;
6070     uint32_t imageOpaqueBindCount;
6071     PTR32 pImageOpaqueBinds;
6072     uint32_t imageBindCount;
6073     PTR32 pImageBinds;
6074     uint32_t signalSemaphoreCount;
6075     PTR32 pSignalSemaphores;
6076 } VkBindSparseInfo32;
6077
6078 typedef struct VkPresentRegionKHR32
6079 {
6080     uint32_t rectangleCount;
6081     PTR32 pRectangles;
6082 } VkPresentRegionKHR32;
6083
6084 typedef struct VkPresentRegionsKHR32
6085 {
6086     VkStructureType sType;
6087     PTR32 pNext;
6088     uint32_t swapchainCount;
6089     PTR32 pRegions;
6090 } VkPresentRegionsKHR32;
6091
6092 typedef struct VkDeviceGroupPresentInfoKHR32
6093 {
6094     VkStructureType sType;
6095     PTR32 pNext;
6096     uint32_t swapchainCount;
6097     PTR32 pDeviceMasks;
6098     VkDeviceGroupPresentModeFlagBitsKHR mode;
6099 } VkDeviceGroupPresentInfoKHR32;
6100
6101 typedef struct VkPresentIdKHR32
6102 {
6103     VkStructureType sType;
6104     PTR32 pNext;
6105     uint32_t swapchainCount;
6106     PTR32 pPresentIds;
6107 } VkPresentIdKHR32;
6108
6109 typedef struct VkSwapchainPresentFenceInfoEXT32
6110 {
6111     VkStructureType sType;
6112     PTR32 pNext;
6113     uint32_t swapchainCount;
6114     PTR32 pFences;
6115 } VkSwapchainPresentFenceInfoEXT32;
6116
6117 typedef struct VkSwapchainPresentModeInfoEXT32
6118 {
6119     VkStructureType sType;
6120     PTR32 pNext;
6121     uint32_t swapchainCount;
6122     PTR32 pPresentModes;
6123 } VkSwapchainPresentModeInfoEXT32;
6124
6125 typedef struct VkPresentInfoKHR32
6126 {
6127     VkStructureType sType;
6128     PTR32 pNext;
6129     uint32_t waitSemaphoreCount;
6130     PTR32 pWaitSemaphores;
6131     uint32_t swapchainCount;
6132     PTR32 pSwapchains;
6133     PTR32 pImageIndices;
6134     PTR32 pResults;
6135 } VkPresentInfoKHR32;
6136
6137 typedef struct VkDeviceGroupSubmitInfo32
6138 {
6139     VkStructureType sType;
6140     PTR32 pNext;
6141     uint32_t waitSemaphoreCount;
6142     PTR32 pWaitSemaphoreDeviceIndices;
6143     uint32_t commandBufferCount;
6144     PTR32 pCommandBufferDeviceMasks;
6145     uint32_t signalSemaphoreCount;
6146     PTR32 pSignalSemaphoreDeviceIndices;
6147 } VkDeviceGroupSubmitInfo32;
6148 typedef VkDeviceGroupSubmitInfo32 VkDeviceGroupSubmitInfoKHR32;
6149
6150 typedef struct VkProtectedSubmitInfo32
6151 {
6152     VkStructureType sType;
6153     PTR32 pNext;
6154     VkBool32 protectedSubmit;
6155 } VkProtectedSubmitInfo32;
6156
6157 typedef struct VkPerformanceQuerySubmitInfoKHR32
6158 {
6159     VkStructureType sType;
6160     PTR32 pNext;
6161     uint32_t counterPassIndex;
6162 } VkPerformanceQuerySubmitInfoKHR32;
6163
6164 typedef struct VkSubmitInfo32
6165 {
6166     VkStructureType sType;
6167     PTR32 pNext;
6168     uint32_t waitSemaphoreCount;
6169     PTR32 pWaitSemaphores;
6170     PTR32 pWaitDstStageMask;
6171     uint32_t commandBufferCount;
6172     PTR32 pCommandBuffers;
6173     uint32_t signalSemaphoreCount;
6174     PTR32 pSignalSemaphores;
6175 } VkSubmitInfo32;
6176
6177 typedef struct VkSemaphoreSubmitInfo32
6178 {
6179     VkStructureType sType;
6180     PTR32 pNext;
6181     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
6182     uint64_t DECLSPEC_ALIGN(8) value;
6183     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
6184     uint32_t deviceIndex;
6185 } VkSemaphoreSubmitInfo32;
6186 typedef VkSemaphoreSubmitInfo32 VkSemaphoreSubmitInfoKHR32;
6187
6188 typedef struct VkCommandBufferSubmitInfo32
6189 {
6190     VkStructureType sType;
6191     PTR32 pNext;
6192     PTR32 commandBuffer;
6193     uint32_t deviceMask;
6194 } VkCommandBufferSubmitInfo32;
6195 typedef VkCommandBufferSubmitInfo32 VkCommandBufferSubmitInfoKHR32;
6196
6197 typedef struct VkSubmitInfo232
6198 {
6199     VkStructureType sType;
6200     PTR32 pNext;
6201     VkSubmitFlags flags;
6202     uint32_t waitSemaphoreInfoCount;
6203     PTR32 pWaitSemaphoreInfos;
6204     uint32_t commandBufferInfoCount;
6205     PTR32 pCommandBufferInfos;
6206     uint32_t signalSemaphoreInfoCount;
6207     PTR32 pSignalSemaphoreInfos;
6208 } VkSubmitInfo232;
6209 typedef VkSubmitInfo232 VkSubmitInfo2KHR32;
6210
6211 typedef struct VkReleaseSwapchainImagesInfoEXT32
6212 {
6213     VkStructureType sType;
6214     PTR32 pNext;
6215     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
6216     uint32_t imageIndexCount;
6217     PTR32 pImageIndices;
6218 } VkReleaseSwapchainImagesInfoEXT32;
6219
6220 typedef struct VkDebugUtilsObjectTagInfoEXT32
6221 {
6222     VkStructureType sType;
6223     PTR32 pNext;
6224     VkObjectType objectType;
6225     uint64_t DECLSPEC_ALIGN(8) objectHandle;
6226     uint64_t DECLSPEC_ALIGN(8) tagName;
6227     PTR32 tagSize;
6228     PTR32 pTag;
6229 } VkDebugUtilsObjectTagInfoEXT32;
6230
6231 typedef struct VkHdrMetadataEXT32
6232 {
6233     VkStructureType sType;
6234     PTR32 pNext;
6235     VkXYColorEXT displayPrimaryRed;
6236     VkXYColorEXT displayPrimaryGreen;
6237     VkXYColorEXT displayPrimaryBlue;
6238     VkXYColorEXT whitePoint;
6239     float maxLuminance;
6240     float minLuminance;
6241     float maxContentLightLevel;
6242     float maxFrameAverageLightLevel;
6243 } VkHdrMetadataEXT32;
6244
6245 typedef struct VkSemaphoreSignalInfo32
6246 {
6247     VkStructureType sType;
6248     PTR32 pNext;
6249     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
6250     uint64_t DECLSPEC_ALIGN(8) value;
6251 } VkSemaphoreSignalInfo32;
6252 typedef VkSemaphoreSignalInfo32 VkSemaphoreSignalInfoKHR32;
6253
6254 typedef struct VkDeviceAddressBindingCallbackDataEXT32
6255 {
6256     VkStructureType sType;
6257     PTR32 pNext;
6258     VkDeviceAddressBindingFlagsEXT flags;
6259     VkDeviceAddress DECLSPEC_ALIGN(8) baseAddress;
6260     VkDeviceSize DECLSPEC_ALIGN(8) size;
6261     VkDeviceAddressBindingTypeEXT bindingType;
6262 } VkDeviceAddressBindingCallbackDataEXT32;
6263
6264 typedef struct VkDebugUtilsMessengerCallbackDataEXT32
6265 {
6266     VkStructureType sType;
6267     PTR32 pNext;
6268     VkDebugUtilsMessengerCallbackDataFlagsEXT flags;
6269     PTR32 pMessageIdName;
6270     int32_t messageIdNumber;
6271     PTR32 pMessage;
6272     uint32_t queueLabelCount;
6273     PTR32 pQueueLabels;
6274     uint32_t cmdBufLabelCount;
6275     PTR32 pCmdBufLabels;
6276     uint32_t objectCount;
6277     PTR32 pObjects;
6278 } VkDebugUtilsMessengerCallbackDataEXT32;
6279
6280 typedef struct VkMemoryUnmapInfoKHR32
6281 {
6282     VkStructureType sType;
6283     PTR32 pNext;
6284     VkMemoryUnmapFlagsKHR flags;
6285     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
6286 } VkMemoryUnmapInfoKHR32;
6287
6288 typedef struct VkCopyDescriptorSet32
6289 {
6290     VkStructureType sType;
6291     PTR32 pNext;
6292     VkDescriptorSet DECLSPEC_ALIGN(8) srcSet;
6293     uint32_t srcBinding;
6294     uint32_t srcArrayElement;
6295     VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
6296     uint32_t dstBinding;
6297     uint32_t dstArrayElement;
6298     uint32_t descriptorCount;
6299 } VkCopyDescriptorSet32;
6300
6301 typedef struct VkSemaphoreWaitInfo32
6302 {
6303     VkStructureType sType;
6304     PTR32 pNext;
6305     VkSemaphoreWaitFlags flags;
6306     uint32_t semaphoreCount;
6307     PTR32 pSemaphores;
6308     PTR32 pValues;
6309 } VkSemaphoreWaitInfo32;
6310 typedef VkSemaphoreWaitInfo32 VkSemaphoreWaitInfoKHR32;
6311
6312 static uint64_t wine_vk_unwrap_handle(uint32_t type, uint64_t handle)
6313 {
6314     switch(type)
6315     {
6316     case VK_OBJECT_TYPE_COMMAND_BUFFER:
6317         return (uint64_t) (uintptr_t) wine_cmd_buffer_from_handle(((VkCommandBuffer) (uintptr_t) handle))->command_buffer;
6318     case VK_OBJECT_TYPE_COMMAND_POOL:
6319         return (uint64_t) wine_cmd_pool_from_handle(handle)->command_pool;
6320     case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
6321         return (uint64_t) wine_debug_report_callback_from_handle(handle)->debug_callback;
6322     case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
6323         return (uint64_t) wine_debug_utils_messenger_from_handle(handle)->debug_messenger;
6324     case VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR:
6325         return (uint64_t) wine_deferred_operation_from_handle(handle)->deferred_operation;
6326     case VK_OBJECT_TYPE_DEVICE:
6327         return (uint64_t) (uintptr_t) wine_device_from_handle(((VkDevice) (uintptr_t) handle))->device;
6328     case VK_OBJECT_TYPE_DEVICE_MEMORY:
6329         return (uint64_t) wine_device_memory_from_handle(handle)->memory;
6330     case VK_OBJECT_TYPE_INSTANCE:
6331         return (uint64_t) (uintptr_t) wine_instance_from_handle(((VkInstance) (uintptr_t) handle))->instance;
6332     case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
6333         return (uint64_t) (uintptr_t) wine_phys_dev_from_handle(((VkPhysicalDevice) (uintptr_t) handle))->phys_dev;
6334     case VK_OBJECT_TYPE_QUEUE:
6335         return (uint64_t) (uintptr_t) wine_queue_from_handle(((VkQueue) (uintptr_t) handle))->queue;
6336     case VK_OBJECT_TYPE_SURFACE_KHR:
6337         return (uint64_t) wine_surface_from_handle(handle)->surface;
6338     default:
6339        return handle;
6340     }
6341 }
6342
6343 static inline void convert_VkAcquireNextImageInfoKHR_win32_to_host(const VkAcquireNextImageInfoKHR32 *in, VkAcquireNextImageInfoKHR *out)
6344 {
6345     if (!in) return;
6346
6347     out->sType = in->sType;
6348     out->pNext = NULL;
6349     out->swapchain = in->swapchain;
6350     out->timeout = in->timeout;
6351     out->semaphore = in->semaphore;
6352     out->fence = in->fence;
6353     out->deviceMask = in->deviceMask;
6354     if (in->pNext)
6355         FIXME("Unexpected pNext\n");
6356 }
6357
6358 static inline void convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host(const VkPerformanceConfigurationAcquireInfoINTEL32 *in, VkPerformanceConfigurationAcquireInfoINTEL *out)
6359 {
6360     if (!in) return;
6361
6362     out->sType = in->sType;
6363     out->pNext = NULL;
6364     out->type = in->type;
6365     if (in->pNext)
6366         FIXME("Unexpected pNext\n");
6367 }
6368
6369 static inline void convert_VkAcquireProfilingLockInfoKHR_win32_to_host(const VkAcquireProfilingLockInfoKHR32 *in, VkAcquireProfilingLockInfoKHR *out)
6370 {
6371     if (!in) return;
6372
6373     out->sType = in->sType;
6374     out->pNext = NULL;
6375     out->flags = in->flags;
6376     out->timeout = in->timeout;
6377     if (in->pNext)
6378         FIXME("Unexpected pNext\n");
6379 }
6380
6381 static inline void convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(const VkCommandBufferAllocateInfo32 *in, VkCommandBufferAllocateInfo *out)
6382 {
6383     if (!in) return;
6384
6385     out->sType = in->sType;
6386     out->pNext = NULL;
6387     out->commandPool = in->commandPool;
6388     out->level = in->level;
6389     out->commandBufferCount = in->commandBufferCount;
6390     if (in->pNext)
6391         FIXME("Unexpected pNext\n");
6392 }
6393
6394 static inline VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_unwrapped_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
6395 {
6396     VkCommandBuffer *out;
6397     unsigned int i;
6398
6399     if (!in || !count) return NULL;
6400
6401     out = conversion_context_alloc(ctx, count * sizeof(*out));
6402     for (i = 0; i < count; i++)
6403     {
6404         out[i] = UlongToPtr(in[i]);
6405     }
6406
6407     return out;
6408 }
6409
6410 static inline void convert_VkDescriptorSetAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetAllocateInfo32 *in, VkDescriptorSetAllocateInfo *out)
6411 {
6412     const VkBaseInStructure32 *in_header;
6413     VkBaseOutStructure *out_header = (void *)out;
6414
6415     if (!in) return;
6416
6417     out->sType = in->sType;
6418     out->pNext = NULL;
6419     out->descriptorPool = in->descriptorPool;
6420     out->descriptorSetCount = in->descriptorSetCount;
6421     out->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in->pSetLayouts);
6422
6423     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6424     {
6425         switch (in_header->sType)
6426         {
6427         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
6428         {
6429             VkDescriptorSetVariableDescriptorCountAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6430             const VkDescriptorSetVariableDescriptorCountAllocateInfo32 *in_ext = (const VkDescriptorSetVariableDescriptorCountAllocateInfo32 *)in_header;
6431             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
6432             out_ext->pNext = NULL;
6433             out_ext->descriptorSetCount = in_ext->descriptorSetCount;
6434             out_ext->pDescriptorCounts = (const uint32_t *)UlongToPtr(in_ext->pDescriptorCounts);
6435             out_header->pNext = (void *)out_ext;
6436             out_header = (void *)out_ext;
6437             break;
6438         }
6439         default:
6440             FIXME("Unhandled sType %u.\n", in_header->sType);
6441             break;
6442         }
6443     }
6444 }
6445
6446 static inline void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryAllocateInfo32 *in, VkMemoryAllocateInfo *out)
6447 {
6448     const VkBaseInStructure32 *in_header;
6449     VkBaseOutStructure *out_header = (void *)out;
6450
6451     if (!in) return;
6452
6453     out->sType = in->sType;
6454     out->pNext = NULL;
6455     out->allocationSize = in->allocationSize;
6456     out->memoryTypeIndex = in->memoryTypeIndex;
6457
6458     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6459     {
6460         switch (in_header->sType)
6461         {
6462         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
6463         {
6464             VkDedicatedAllocationMemoryAllocateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6465             const VkDedicatedAllocationMemoryAllocateInfoNV32 *in_ext = (const VkDedicatedAllocationMemoryAllocateInfoNV32 *)in_header;
6466             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV;
6467             out_ext->pNext = NULL;
6468             out_ext->image = in_ext->image;
6469             out_ext->buffer = in_ext->buffer;
6470             out_header->pNext = (void *)out_ext;
6471             out_header = (void *)out_ext;
6472             break;
6473         }
6474         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
6475         {
6476             VkExportMemoryAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6477             const VkExportMemoryAllocateInfo32 *in_ext = (const VkExportMemoryAllocateInfo32 *)in_header;
6478             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
6479             out_ext->pNext = NULL;
6480             out_ext->handleTypes = in_ext->handleTypes;
6481             out_header->pNext = (void *)out_ext;
6482             out_header = (void *)out_ext;
6483             break;
6484         }
6485         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
6486         {
6487             VkImportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6488             const VkImportMemoryWin32HandleInfoKHR32 *in_ext = (const VkImportMemoryWin32HandleInfoKHR32 *)in_header;
6489             out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
6490             out_ext->pNext = NULL;
6491             out_ext->handleType = in_ext->handleType;
6492             out_ext->handle = in_ext->handle;
6493             out_ext->name = in_ext->name;
6494             out_header->pNext = (void *)out_ext;
6495             out_header = (void *)out_ext;
6496             break;
6497         }
6498         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
6499         {
6500             VkExportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6501             const VkExportMemoryWin32HandleInfoKHR32 *in_ext = (const VkExportMemoryWin32HandleInfoKHR32 *)in_header;
6502             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
6503             out_ext->pNext = NULL;
6504             out_ext->pAttributes = (const SECURITY_ATTRIBUTES *)UlongToPtr(in_ext->pAttributes);
6505             out_ext->dwAccess = in_ext->dwAccess;
6506             out_ext->name = in_ext->name;
6507             out_header->pNext = (void *)out_ext;
6508             out_header = (void *)out_ext;
6509             break;
6510         }
6511         case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
6512         {
6513             VkMemoryAllocateFlagsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6514             const VkMemoryAllocateFlagsInfo32 *in_ext = (const VkMemoryAllocateFlagsInfo32 *)in_header;
6515             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO;
6516             out_ext->pNext = NULL;
6517             out_ext->flags = in_ext->flags;
6518             out_ext->deviceMask = in_ext->deviceMask;
6519             out_header->pNext = (void *)out_ext;
6520             out_header = (void *)out_ext;
6521             break;
6522         }
6523         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
6524         {
6525             VkMemoryDedicatedAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6526             const VkMemoryDedicatedAllocateInfo32 *in_ext = (const VkMemoryDedicatedAllocateInfo32 *)in_header;
6527             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
6528             out_ext->pNext = NULL;
6529             out_ext->image = in_ext->image;
6530             out_ext->buffer = in_ext->buffer;
6531             out_header->pNext = (void *)out_ext;
6532             out_header = (void *)out_ext;
6533             break;
6534         }
6535         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
6536         {
6537             VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6538             const VkImportMemoryHostPointerInfoEXT32 *in_ext = (const VkImportMemoryHostPointerInfoEXT32 *)in_header;
6539             out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT;
6540             out_ext->pNext = NULL;
6541             out_ext->handleType = in_ext->handleType;
6542             out_ext->pHostPointer = (void *)UlongToPtr(in_ext->pHostPointer);
6543             out_header->pNext = (void *)out_ext;
6544             out_header = (void *)out_ext;
6545             break;
6546         }
6547         case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
6548         {
6549             VkMemoryPriorityAllocateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6550             const VkMemoryPriorityAllocateInfoEXT32 *in_ext = (const VkMemoryPriorityAllocateInfoEXT32 *)in_header;
6551             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT;
6552             out_ext->pNext = NULL;
6553             out_ext->priority = in_ext->priority;
6554             out_header->pNext = (void *)out_ext;
6555             out_header = (void *)out_ext;
6556             break;
6557         }
6558         case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
6559         {
6560             VkMemoryOpaqueCaptureAddressAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6561             const VkMemoryOpaqueCaptureAddressAllocateInfo32 *in_ext = (const VkMemoryOpaqueCaptureAddressAllocateInfo32 *)in_header;
6562             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
6563             out_ext->pNext = NULL;
6564             out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress;
6565             out_header->pNext = (void *)out_ext;
6566             out_header = (void *)out_ext;
6567             break;
6568         }
6569         default:
6570             FIXME("Unhandled sType %u.\n", in_header->sType);
6571             break;
6572         }
6573     }
6574 }
6575
6576 static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, VkCommandBufferInheritanceInfo *out)
6577 {
6578     const VkBaseInStructure32 *in_header;
6579     VkBaseOutStructure *out_header = (void *)out;
6580
6581     if (!in) return;
6582
6583     out->sType = in->sType;
6584     out->pNext = NULL;
6585     out->renderPass = in->renderPass;
6586     out->subpass = in->subpass;
6587     out->framebuffer = in->framebuffer;
6588     out->occlusionQueryEnable = in->occlusionQueryEnable;
6589     out->queryFlags = in->queryFlags;
6590     out->pipelineStatistics = in->pipelineStatistics;
6591
6592     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6593     {
6594         switch (in_header->sType)
6595         {
6596         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
6597         {
6598             VkCommandBufferInheritanceConditionalRenderingInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6599             const VkCommandBufferInheritanceConditionalRenderingInfoEXT32 *in_ext = (const VkCommandBufferInheritanceConditionalRenderingInfoEXT32 *)in_header;
6600             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT;
6601             out_ext->pNext = NULL;
6602             out_ext->conditionalRenderingEnable = in_ext->conditionalRenderingEnable;
6603             out_header->pNext = (void *)out_ext;
6604             out_header = (void *)out_ext;
6605             break;
6606         }
6607         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
6608         {
6609             VkCommandBufferInheritanceRenderPassTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6610             const VkCommandBufferInheritanceRenderPassTransformInfoQCOM32 *in_ext = (const VkCommandBufferInheritanceRenderPassTransformInfoQCOM32 *)in_header;
6611             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM;
6612             out_ext->pNext = NULL;
6613             out_ext->transform = in_ext->transform;
6614             out_ext->renderArea = in_ext->renderArea;
6615             out_header->pNext = (void *)out_ext;
6616             out_header = (void *)out_ext;
6617             break;
6618         }
6619         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
6620         {
6621             VkCommandBufferInheritanceViewportScissorInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6622             const VkCommandBufferInheritanceViewportScissorInfoNV32 *in_ext = (const VkCommandBufferInheritanceViewportScissorInfoNV32 *)in_header;
6623             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV;
6624             out_ext->pNext = NULL;
6625             out_ext->viewportScissor2D = in_ext->viewportScissor2D;
6626             out_ext->viewportDepthCount = in_ext->viewportDepthCount;
6627             out_ext->pViewportDepths = (const VkViewport *)UlongToPtr(in_ext->pViewportDepths);
6628             out_header->pNext = (void *)out_ext;
6629             out_header = (void *)out_ext;
6630             break;
6631         }
6632         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
6633         {
6634             VkCommandBufferInheritanceRenderingInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6635             const VkCommandBufferInheritanceRenderingInfo32 *in_ext = (const VkCommandBufferInheritanceRenderingInfo32 *)in_header;
6636             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
6637             out_ext->pNext = NULL;
6638             out_ext->flags = in_ext->flags;
6639             out_ext->viewMask = in_ext->viewMask;
6640             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
6641             out_ext->pColorAttachmentFormats = (const VkFormat *)UlongToPtr(in_ext->pColorAttachmentFormats);
6642             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
6643             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
6644             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
6645             out_header->pNext = (void *)out_ext;
6646             out_header = (void *)out_ext;
6647             break;
6648         }
6649         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
6650         {
6651             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6652             const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header;
6653             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
6654             out_ext->pNext = NULL;
6655             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
6656             out_ext->pColorAttachmentSamples = (const VkSampleCountFlagBits *)UlongToPtr(in_ext->pColorAttachmentSamples);
6657             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
6658             out_header->pNext = (void *)out_ext;
6659             out_header = (void *)out_ext;
6660             break;
6661         }
6662         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
6663         {
6664             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6665             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
6666             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
6667             out_ext->pNext = NULL;
6668             out_ext->perViewAttributes = in_ext->perViewAttributes;
6669             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
6670             out_header->pNext = (void *)out_ext;
6671             out_header = (void *)out_ext;
6672             break;
6673         }
6674         default:
6675             FIXME("Unhandled sType %u.\n", in_header->sType);
6676             break;
6677         }
6678     }
6679 }
6680
6681 static inline const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInheritanceInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, uint32_t count)
6682 {
6683     VkCommandBufferInheritanceInfo *out;
6684     unsigned int i;
6685
6686     if (!in || !count) return NULL;
6687
6688     out = conversion_context_alloc(ctx, count * sizeof(*out));
6689     for (i = 0; i < count; i++)
6690     {
6691         convert_VkCommandBufferInheritanceInfo_win32_to_host(ctx, &in[i], &out[i]);
6692     }
6693
6694     return out;
6695 }
6696
6697 static inline void convert_VkCommandBufferBeginInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferBeginInfo32 *in, VkCommandBufferBeginInfo *out)
6698 {
6699     const VkBaseInStructure32 *in_header;
6700     VkBaseOutStructure *out_header = (void *)out;
6701
6702     if (!in) return;
6703
6704     out->sType = in->sType;
6705     out->pNext = NULL;
6706     out->flags = in->flags;
6707     out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win32_to_host(ctx, (const VkCommandBufferInheritanceInfo32 *)UlongToPtr(in->pInheritanceInfo), 1);
6708
6709     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6710     {
6711         switch (in_header->sType)
6712         {
6713         case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
6714         {
6715             VkDeviceGroupCommandBufferBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6716             const VkDeviceGroupCommandBufferBeginInfo32 *in_ext = (const VkDeviceGroupCommandBufferBeginInfo32 *)in_header;
6717             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
6718             out_ext->pNext = NULL;
6719             out_ext->deviceMask = in_ext->deviceMask;
6720             out_header->pNext = (void *)out_ext;
6721             out_header = (void *)out_ext;
6722             break;
6723         }
6724         default:
6725             FIXME("Unhandled sType %u.\n", in_header->sType);
6726             break;
6727         }
6728     }
6729 }
6730
6731 #ifdef _WIN64
6732 static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win64_to_host(const VkBindAccelerationStructureMemoryInfoNV *in, VkBindAccelerationStructureMemoryInfoNV *out)
6733 {
6734     if (!in) return;
6735
6736     out->sType = in->sType;
6737     out->pNext = in->pNext;
6738     out->accelerationStructure = in->accelerationStructure;
6739     out->memory = wine_device_memory_from_handle(in->memory)->memory;
6740     out->memoryOffset = in->memoryOffset;
6741     out->deviceIndexCount = in->deviceIndexCount;
6742     out->pDeviceIndices = in->pDeviceIndices;
6743 }
6744 #endif /* _WIN64 */
6745
6746 static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(const VkBindAccelerationStructureMemoryInfoNV32 *in, VkBindAccelerationStructureMemoryInfoNV *out)
6747 {
6748     if (!in) return;
6749
6750     out->sType = in->sType;
6751     out->pNext = NULL;
6752     out->accelerationStructure = in->accelerationStructure;
6753     out->memory = wine_device_memory_from_handle(in->memory)->memory;
6754     out->memoryOffset = in->memoryOffset;
6755     out->deviceIndexCount = in->deviceIndexCount;
6756     out->pDeviceIndices = (const uint32_t *)UlongToPtr(in->pDeviceIndices);
6757     if (in->pNext)
6758         FIXME("Unexpected pNext\n");
6759 }
6760
6761 #ifdef _WIN64
6762 static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV *in, uint32_t count)
6763 {
6764     VkBindAccelerationStructureMemoryInfoNV *out;
6765     unsigned int i;
6766
6767     if (!in || !count) return NULL;
6768
6769     out = conversion_context_alloc(ctx, count * sizeof(*out));
6770     for (i = 0; i < count; i++)
6771     {
6772         convert_VkBindAccelerationStructureMemoryInfoNV_win64_to_host(&in[i], &out[i]);
6773     }
6774
6775     return out;
6776 }
6777 #endif /* _WIN64 */
6778
6779 static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV32 *in, uint32_t count)
6780 {
6781     VkBindAccelerationStructureMemoryInfoNV *out;
6782     unsigned int i;
6783
6784     if (!in || !count) return NULL;
6785
6786     out = conversion_context_alloc(ctx, count * sizeof(*out));
6787     for (i = 0; i < count; i++)
6788     {
6789         convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(&in[i], &out[i]);
6790     }
6791
6792     return out;
6793 }
6794
6795 #ifdef _WIN64
6796 static inline void convert_VkBindBufferMemoryInfo_win64_to_host(const VkBindBufferMemoryInfo *in, VkBindBufferMemoryInfo *out)
6797 {
6798     if (!in) return;
6799
6800     out->sType = in->sType;
6801     out->pNext = in->pNext;
6802     out->buffer = in->buffer;
6803     out->memory = wine_device_memory_from_handle(in->memory)->memory;
6804     out->memoryOffset = in->memoryOffset;
6805 }
6806 #endif /* _WIN64 */
6807
6808 static inline void convert_VkBindBufferMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, VkBindBufferMemoryInfo *out)
6809 {
6810     const VkBaseInStructure32 *in_header;
6811     VkBaseOutStructure *out_header = (void *)out;
6812
6813     if (!in) return;
6814
6815     out->sType = in->sType;
6816     out->pNext = NULL;
6817     out->buffer = in->buffer;
6818     out->memory = wine_device_memory_from_handle(in->memory)->memory;
6819     out->memoryOffset = in->memoryOffset;
6820
6821     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6822     {
6823         switch (in_header->sType)
6824         {
6825         case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
6826         {
6827             VkBindBufferMemoryDeviceGroupInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6828             const VkBindBufferMemoryDeviceGroupInfo32 *in_ext = (const VkBindBufferMemoryDeviceGroupInfo32 *)in_header;
6829             out_ext->sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
6830             out_ext->pNext = NULL;
6831             out_ext->deviceIndexCount = in_ext->deviceIndexCount;
6832             out_ext->pDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pDeviceIndices);
6833             out_header->pNext = (void *)out_ext;
6834             out_header = (void *)out_ext;
6835             break;
6836         }
6837         default:
6838             FIXME("Unhandled sType %u.\n", in_header->sType);
6839             break;
6840         }
6841     }
6842 }
6843
6844 #ifdef _WIN64
6845 static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo *in, uint32_t count)
6846 {
6847     VkBindBufferMemoryInfo *out;
6848     unsigned int i;
6849
6850     if (!in || !count) return NULL;
6851
6852     out = conversion_context_alloc(ctx, count * sizeof(*out));
6853     for (i = 0; i < count; i++)
6854     {
6855         convert_VkBindBufferMemoryInfo_win64_to_host(&in[i], &out[i]);
6856     }
6857
6858     return out;
6859 }
6860 #endif /* _WIN64 */
6861
6862 static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, uint32_t count)
6863 {
6864     VkBindBufferMemoryInfo *out;
6865     unsigned int i;
6866
6867     if (!in || !count) return NULL;
6868
6869     out = conversion_context_alloc(ctx, count * sizeof(*out));
6870     for (i = 0; i < count; i++)
6871     {
6872         convert_VkBindBufferMemoryInfo_win32_to_host(ctx, &in[i], &out[i]);
6873     }
6874
6875     return out;
6876 }
6877
6878 #ifdef _WIN64
6879 static inline void convert_VkBindImageMemoryInfo_win64_to_host(const VkBindImageMemoryInfo *in, VkBindImageMemoryInfo *out)
6880 {
6881     if (!in) return;
6882
6883     out->sType = in->sType;
6884     out->pNext = in->pNext;
6885     out->image = in->image;
6886     out->memory = wine_device_memory_from_handle(in->memory)->memory;
6887     out->memoryOffset = in->memoryOffset;
6888 }
6889 #endif /* _WIN64 */
6890
6891 static inline void convert_VkBindImageMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, VkBindImageMemoryInfo *out)
6892 {
6893     const VkBaseInStructure32 *in_header;
6894     VkBaseOutStructure *out_header = (void *)out;
6895
6896     if (!in) return;
6897
6898     out->sType = in->sType;
6899     out->pNext = NULL;
6900     out->image = in->image;
6901     out->memory = wine_device_memory_from_handle(in->memory)->memory;
6902     out->memoryOffset = in->memoryOffset;
6903
6904     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6905     {
6906         switch (in_header->sType)
6907         {
6908         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
6909         {
6910             VkBindImageMemoryDeviceGroupInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6911             const VkBindImageMemoryDeviceGroupInfo32 *in_ext = (const VkBindImageMemoryDeviceGroupInfo32 *)in_header;
6912             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
6913             out_ext->pNext = NULL;
6914             out_ext->deviceIndexCount = in_ext->deviceIndexCount;
6915             out_ext->pDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pDeviceIndices);
6916             out_ext->splitInstanceBindRegionCount = in_ext->splitInstanceBindRegionCount;
6917             out_ext->pSplitInstanceBindRegions = (const VkRect2D *)UlongToPtr(in_ext->pSplitInstanceBindRegions);
6918             out_header->pNext = (void *)out_ext;
6919             out_header = (void *)out_ext;
6920             break;
6921         }
6922         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
6923         {
6924             VkBindImageMemorySwapchainInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6925             const VkBindImageMemorySwapchainInfoKHR32 *in_ext = (const VkBindImageMemorySwapchainInfoKHR32 *)in_header;
6926             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR;
6927             out_ext->pNext = NULL;
6928             out_ext->swapchain = in_ext->swapchain;
6929             out_ext->imageIndex = in_ext->imageIndex;
6930             out_header->pNext = (void *)out_ext;
6931             out_header = (void *)out_ext;
6932             break;
6933         }
6934         case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
6935         {
6936             VkBindImagePlaneMemoryInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6937             const VkBindImagePlaneMemoryInfo32 *in_ext = (const VkBindImagePlaneMemoryInfo32 *)in_header;
6938             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO;
6939             out_ext->pNext = NULL;
6940             out_ext->planeAspect = in_ext->planeAspect;
6941             out_header->pNext = (void *)out_ext;
6942             out_header = (void *)out_ext;
6943             break;
6944         }
6945         default:
6946             FIXME("Unhandled sType %u.\n", in_header->sType);
6947             break;
6948         }
6949     }
6950 }
6951
6952 #ifdef _WIN64
6953 static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo *in, uint32_t count)
6954 {
6955     VkBindImageMemoryInfo *out;
6956     unsigned int i;
6957
6958     if (!in || !count) return NULL;
6959
6960     out = conversion_context_alloc(ctx, count * sizeof(*out));
6961     for (i = 0; i < count; i++)
6962     {
6963         convert_VkBindImageMemoryInfo_win64_to_host(&in[i], &out[i]);
6964     }
6965
6966     return out;
6967 }
6968 #endif /* _WIN64 */
6969
6970 static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, uint32_t count)
6971 {
6972     VkBindImageMemoryInfo *out;
6973     unsigned int i;
6974
6975     if (!in || !count) return NULL;
6976
6977     out = conversion_context_alloc(ctx, count * sizeof(*out));
6978     for (i = 0; i < count; i++)
6979     {
6980         convert_VkBindImageMemoryInfo_win32_to_host(ctx, &in[i], &out[i]);
6981     }
6982
6983     return out;
6984 }
6985
6986 static inline const VkMicromapUsageEXT * const*convert_VkMicromapUsageEXT_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
6987 {
6988     VkMicromapUsageEXT **out;
6989     unsigned int i;
6990
6991     if (!in || !count) return NULL;
6992
6993     out = conversion_context_alloc(ctx, count * sizeof(*out));
6994     for (i = 0; i < count; i++)
6995     {
6996         out[i] = UlongToPtr(in[i]);
6997     }
6998
6999     return (void *)out;
7000 }
7001
7002 static inline void convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryTrianglesDataKHR32 *in, VkAccelerationStructureGeometryTrianglesDataKHR *out)
7003 {
7004     const VkBaseInStructure32 *in_header;
7005     VkBaseOutStructure *out_header = (void *)out;
7006
7007     if (!in) return;
7008
7009     out->sType = in->sType;
7010     out->pNext = NULL;
7011     out->vertexFormat = in->vertexFormat;
7012     out->vertexData = in->vertexData;
7013     out->vertexStride = in->vertexStride;
7014     out->maxVertex = in->maxVertex;
7015     out->indexType = in->indexType;
7016     out->indexData = in->indexData;
7017     out->transformData = in->transformData;
7018
7019     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7020     {
7021         switch (in_header->sType)
7022         {
7023         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
7024         {
7025             VkAccelerationStructureGeometryMotionTrianglesDataNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7026             const VkAccelerationStructureGeometryMotionTrianglesDataNV32 *in_ext = (const VkAccelerationStructureGeometryMotionTrianglesDataNV32 *)in_header;
7027             out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV;
7028             out_ext->pNext = NULL;
7029             out_ext->vertexData = in_ext->vertexData;
7030             out_header->pNext = (void *)out_ext;
7031             out_header = (void *)out_ext;
7032             break;
7033         }
7034         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
7035         {
7036             VkAccelerationStructureTrianglesOpacityMicromapEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7037             const VkAccelerationStructureTrianglesOpacityMicromapEXT32 *in_ext = (const VkAccelerationStructureTrianglesOpacityMicromapEXT32 *)in_header;
7038             out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT;
7039             out_ext->pNext = NULL;
7040             out_ext->indexType = in_ext->indexType;
7041             out_ext->indexBuffer = in_ext->indexBuffer;
7042             out_ext->indexStride = in_ext->indexStride;
7043             out_ext->baseTriangle = in_ext->baseTriangle;
7044             out_ext->usageCountsCount = in_ext->usageCountsCount;
7045             out_ext->pUsageCounts = (const VkMicromapUsageEXT *)UlongToPtr(in_ext->pUsageCounts);
7046             out_ext->ppUsageCounts = convert_VkMicromapUsageEXT_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->ppUsageCounts), in_ext->usageCountsCount);
7047             out_ext->micromap = in_ext->micromap;
7048             out_header->pNext = (void *)out_ext;
7049             out_header = (void *)out_ext;
7050             break;
7051         }
7052         default:
7053             FIXME("Unhandled sType %u.\n", in_header->sType);
7054             break;
7055         }
7056     }
7057 }
7058
7059 static inline void convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_host(const VkAccelerationStructureGeometryAabbsDataKHR32 *in, VkAccelerationStructureGeometryAabbsDataKHR *out)
7060 {
7061     if (!in) return;
7062
7063     out->sType = in->sType;
7064     out->pNext = NULL;
7065     out->data = in->data;
7066     out->stride = in->stride;
7067     if (in->pNext)
7068         FIXME("Unexpected pNext\n");
7069 }
7070
7071 static inline void convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(const VkAccelerationStructureGeometryInstancesDataKHR32 *in, VkAccelerationStructureGeometryInstancesDataKHR *out)
7072 {
7073     if (!in) return;
7074
7075     out->sType = in->sType;
7076     out->pNext = NULL;
7077     out->arrayOfPointers = in->arrayOfPointers;
7078     out->data = in->data;
7079     if (in->pNext)
7080         FIXME("Unexpected pNext\n");
7081 }
7082
7083 static inline void convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryDataKHR32 *in, VkAccelerationStructureGeometryDataKHR *out, VkFlags selector)
7084 {
7085     if (!in) return;
7086
7087     if (selector == VK_GEOMETRY_TYPE_TRIANGLES_KHR)
7088         convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_host(ctx, &in->triangles, &out->triangles);
7089     if (selector == VK_GEOMETRY_TYPE_AABBS_KHR)
7090         convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_host(&in->aabbs, &out->aabbs);
7091     if (selector == VK_GEOMETRY_TYPE_INSTANCES_KHR)
7092         convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(&in->instances, &out->instances);
7093 }
7094
7095 static inline void convert_VkAccelerationStructureGeometryKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, VkAccelerationStructureGeometryKHR *out)
7096 {
7097     if (!in) return;
7098
7099     out->sType = in->sType;
7100     out->pNext = NULL;
7101     out->geometryType = in->geometryType;
7102     convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(ctx, &in->geometry, &out->geometry, in->geometryType);
7103     out->flags = in->flags;
7104     if (in->pNext)
7105         FIXME("Unexpected pNext\n");
7106 }
7107
7108 static inline const VkAccelerationStructureGeometryKHR *convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, uint32_t count)
7109 {
7110     VkAccelerationStructureGeometryKHR *out;
7111     unsigned int i;
7112
7113     if (!in || !count) return NULL;
7114
7115     out = conversion_context_alloc(ctx, count * sizeof(*out));
7116     for (i = 0; i < count; i++)
7117     {
7118         convert_VkAccelerationStructureGeometryKHR_win32_to_host(ctx, &in[i], &out[i]);
7119     }
7120
7121     return out;
7122 }
7123
7124 static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
7125 {
7126     VkAccelerationStructureGeometryKHR **out;
7127     unsigned int i;
7128
7129     if (!in || !count) return NULL;
7130
7131     out = conversion_context_alloc(ctx, count * sizeof(*out));
7132     for (i = 0; i < count; i++)
7133     {
7134         if (in[i])
7135         {
7136             out[i] = conversion_context_alloc(ctx, sizeof(*out[i]));
7137             convert_VkAccelerationStructureGeometryKHR_win32_to_host(ctx, (VkAccelerationStructureGeometryKHR32 *)UlongToPtr(in[i]), out[i]);
7138         }
7139         else
7140             out[i] = NULL;
7141     }
7142
7143     return (void *)out;
7144 }
7145
7146 static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, VkAccelerationStructureBuildGeometryInfoKHR *out)
7147 {
7148     if (!in) return;
7149
7150     out->sType = in->sType;
7151     out->pNext = NULL;
7152     out->type = in->type;
7153     out->flags = in->flags;
7154     out->mode = in->mode;
7155     out->srcAccelerationStructure = in->srcAccelerationStructure;
7156     out->dstAccelerationStructure = in->dstAccelerationStructure;
7157     out->geometryCount = in->geometryCount;
7158     out->pGeometries = convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(ctx, (const VkAccelerationStructureGeometryKHR32 *)UlongToPtr(in->pGeometries), in->geometryCount);
7159     out->ppGeometries = convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppGeometries), in->geometryCount);
7160     out->scratchData = in->scratchData;
7161     if (in->pNext)
7162         FIXME("Unexpected pNext\n");
7163 }
7164
7165 static inline const VkAccelerationStructureBuildGeometryInfoKHR *convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, uint32_t count)
7166 {
7167     VkAccelerationStructureBuildGeometryInfoKHR *out;
7168     unsigned int i;
7169
7170     if (!in || !count) return NULL;
7171
7172     out = conversion_context_alloc(ctx, count * sizeof(*out));
7173     for (i = 0; i < count; i++)
7174     {
7175         convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
7176     }
7177
7178     return out;
7179 }
7180
7181 static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, VkMicromapBuildInfoEXT *out)
7182 {
7183     if (!in) return;
7184
7185     out->sType = in->sType;
7186     out->pNext = NULL;
7187     out->type = in->type;
7188     out->flags = in->flags;
7189     out->mode = in->mode;
7190     out->dstMicromap = in->dstMicromap;
7191     out->usageCountsCount = in->usageCountsCount;
7192     out->pUsageCounts = (const VkMicromapUsageEXT *)UlongToPtr(in->pUsageCounts);
7193     out->ppUsageCounts = convert_VkMicromapUsageEXT_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppUsageCounts), in->usageCountsCount);
7194     out->data = in->data;
7195     out->scratchData = in->scratchData;
7196     out->triangleArray = in->triangleArray;
7197     out->triangleArrayStride = in->triangleArrayStride;
7198     if (in->pNext)
7199         FIXME("Unexpected pNext\n");
7200 }
7201
7202 static inline const VkMicromapBuildInfoEXT *convert_VkMicromapBuildInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, uint32_t count)
7203 {
7204     VkMicromapBuildInfoEXT *out;
7205     unsigned int i;
7206
7207     if (!in || !count) return NULL;
7208
7209     out = conversion_context_alloc(ctx, count * sizeof(*out));
7210     for (i = 0; i < count; i++)
7211     {
7212         convert_VkMicromapBuildInfoEXT_win32_to_host(ctx, &in[i], &out[i]);
7213     }
7214
7215     return out;
7216 }
7217
7218 static inline void convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(const VkConditionalRenderingBeginInfoEXT32 *in, VkConditionalRenderingBeginInfoEXT *out)
7219 {
7220     if (!in) return;
7221
7222     out->sType = in->sType;
7223     out->pNext = NULL;
7224     out->buffer = in->buffer;
7225     out->offset = in->offset;
7226     out->flags = in->flags;
7227     if (in->pNext)
7228         FIXME("Unexpected pNext\n");
7229 }
7230
7231 static inline void convert_VkDebugUtilsLabelEXT_win32_to_host(const VkDebugUtilsLabelEXT32 *in, VkDebugUtilsLabelEXT *out)
7232 {
7233     if (!in) return;
7234
7235     out->sType = in->sType;
7236     out->pNext = NULL;
7237     out->pLabelName = (const char *)UlongToPtr(in->pLabelName);
7238     memcpy(out->color, in->color, 4 * sizeof(float));
7239     if (in->pNext)
7240         FIXME("Unexpected pNext\n");
7241 }
7242
7243 static inline void convert_VkSampleLocationsInfoEXT_win32_to_host(const VkSampleLocationsInfoEXT32 *in, VkSampleLocationsInfoEXT *out)
7244 {
7245     if (!in) return;
7246
7247     out->sType = in->sType;
7248     out->pNext = NULL;
7249     out->sampleLocationsPerPixel = in->sampleLocationsPerPixel;
7250     out->sampleLocationGridSize = in->sampleLocationGridSize;
7251     out->sampleLocationsCount = in->sampleLocationsCount;
7252     out->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in->pSampleLocations);
7253     if (in->pNext)
7254         FIXME("Unexpected pNext\n");
7255 }
7256
7257 static inline void convert_VkAttachmentSampleLocationsEXT_win32_to_host(const VkAttachmentSampleLocationsEXT32 *in, VkAttachmentSampleLocationsEXT *out)
7258 {
7259     if (!in) return;
7260
7261     out->attachmentIndex = in->attachmentIndex;
7262     convert_VkSampleLocationsInfoEXT_win32_to_host(&in->sampleLocationsInfo, &out->sampleLocationsInfo);
7263 }
7264
7265 static inline const VkAttachmentSampleLocationsEXT *convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentSampleLocationsEXT32 *in, uint32_t count)
7266 {
7267     VkAttachmentSampleLocationsEXT *out;
7268     unsigned int i;
7269
7270     if (!in || !count) return NULL;
7271
7272     out = conversion_context_alloc(ctx, count * sizeof(*out));
7273     for (i = 0; i < count; i++)
7274     {
7275         convert_VkAttachmentSampleLocationsEXT_win32_to_host(&in[i], &out[i]);
7276     }
7277
7278     return out;
7279 }
7280
7281 static inline void convert_VkSubpassSampleLocationsEXT_win32_to_host(const VkSubpassSampleLocationsEXT32 *in, VkSubpassSampleLocationsEXT *out)
7282 {
7283     if (!in) return;
7284
7285     out->subpassIndex = in->subpassIndex;
7286     convert_VkSampleLocationsInfoEXT_win32_to_host(&in->sampleLocationsInfo, &out->sampleLocationsInfo);
7287 }
7288
7289 static inline const VkSubpassSampleLocationsEXT *convert_VkSubpassSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkSubpassSampleLocationsEXT32 *in, uint32_t count)
7290 {
7291     VkSubpassSampleLocationsEXT *out;
7292     unsigned int i;
7293
7294     if (!in || !count) return NULL;
7295
7296     out = conversion_context_alloc(ctx, count * sizeof(*out));
7297     for (i = 0; i < count; i++)
7298     {
7299         convert_VkSubpassSampleLocationsEXT_win32_to_host(&in[i], &out[i]);
7300     }
7301
7302     return out;
7303 }
7304
7305 static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassBeginInfo32 *in, VkRenderPassBeginInfo *out)
7306 {
7307     const VkBaseInStructure32 *in_header;
7308     VkBaseOutStructure *out_header = (void *)out;
7309
7310     if (!in) return;
7311
7312     out->sType = in->sType;
7313     out->pNext = NULL;
7314     out->renderPass = in->renderPass;
7315     out->framebuffer = in->framebuffer;
7316     out->renderArea = in->renderArea;
7317     out->clearValueCount = in->clearValueCount;
7318     out->pClearValues = (const VkClearValue *)UlongToPtr(in->pClearValues);
7319
7320     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7321     {
7322         switch (in_header->sType)
7323         {
7324         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
7325         {
7326             VkDeviceGroupRenderPassBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7327             const VkDeviceGroupRenderPassBeginInfo32 *in_ext = (const VkDeviceGroupRenderPassBeginInfo32 *)in_header;
7328             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
7329             out_ext->pNext = NULL;
7330             out_ext->deviceMask = in_ext->deviceMask;
7331             out_ext->deviceRenderAreaCount = in_ext->deviceRenderAreaCount;
7332             out_ext->pDeviceRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pDeviceRenderAreas);
7333             out_header->pNext = (void *)out_ext;
7334             out_header = (void *)out_ext;
7335             break;
7336         }
7337         case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
7338         {
7339             VkRenderPassSampleLocationsBeginInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7340             const VkRenderPassSampleLocationsBeginInfoEXT32 *in_ext = (const VkRenderPassSampleLocationsBeginInfoEXT32 *)in_header;
7341             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT;
7342             out_ext->pNext = NULL;
7343             out_ext->attachmentInitialSampleLocationsCount = in_ext->attachmentInitialSampleLocationsCount;
7344             out_ext->pAttachmentInitialSampleLocations = convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(ctx, (const VkAttachmentSampleLocationsEXT32 *)UlongToPtr(in_ext->pAttachmentInitialSampleLocations), in_ext->attachmentInitialSampleLocationsCount);
7345             out_ext->postSubpassSampleLocationsCount = in_ext->postSubpassSampleLocationsCount;
7346             out_ext->pPostSubpassSampleLocations = convert_VkSubpassSampleLocationsEXT_array_win32_to_host(ctx, (const VkSubpassSampleLocationsEXT32 *)UlongToPtr(in_ext->pPostSubpassSampleLocations), in_ext->postSubpassSampleLocationsCount);
7347             out_header->pNext = (void *)out_ext;
7348             out_header = (void *)out_ext;
7349             break;
7350         }
7351         case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
7352         {
7353             VkRenderPassAttachmentBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7354             const VkRenderPassAttachmentBeginInfo32 *in_ext = (const VkRenderPassAttachmentBeginInfo32 *)in_header;
7355             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO;
7356             out_ext->pNext = NULL;
7357             out_ext->attachmentCount = in_ext->attachmentCount;
7358             out_ext->pAttachments = (const VkImageView *)UlongToPtr(in_ext->pAttachments);
7359             out_header->pNext = (void *)out_ext;
7360             out_header = (void *)out_ext;
7361             break;
7362         }
7363         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
7364         {
7365             VkRenderPassTransformBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7366             const VkRenderPassTransformBeginInfoQCOM32 *in_ext = (const VkRenderPassTransformBeginInfoQCOM32 *)in_header;
7367             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM;
7368             out_ext->pNext = NULL;
7369             out_ext->transform = in_ext->transform;
7370             out_header->pNext = (void *)out_ext;
7371             out_header = (void *)out_ext;
7372             break;
7373         }
7374         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
7375         {
7376             VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7377             const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *in_ext = (const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *)in_header;
7378             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM;
7379             out_ext->pNext = NULL;
7380             out_ext->perViewRenderAreaCount = in_ext->perViewRenderAreaCount;
7381             out_ext->pPerViewRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pPerViewRenderAreas);
7382             out_header->pNext = (void *)out_ext;
7383             out_header = (void *)out_ext;
7384             break;
7385         }
7386         default:
7387             FIXME("Unhandled sType %u.\n", in_header->sType);
7388             break;
7389         }
7390     }
7391 }
7392
7393 static inline void convert_VkSubpassBeginInfo_win32_to_host(const VkSubpassBeginInfo32 *in, VkSubpassBeginInfo *out)
7394 {
7395     if (!in) return;
7396
7397     out->sType = in->sType;
7398     out->pNext = NULL;
7399     out->contents = in->contents;
7400     if (in->pNext)
7401         FIXME("Unexpected pNext\n");
7402 }
7403
7404 static inline void convert_VkRenderingAttachmentInfo_win32_to_host(const VkRenderingAttachmentInfo32 *in, VkRenderingAttachmentInfo *out)
7405 {
7406     if (!in) return;
7407
7408     out->sType = in->sType;
7409     out->pNext = NULL;
7410     out->imageView = in->imageView;
7411     out->imageLayout = in->imageLayout;
7412     out->resolveMode = in->resolveMode;
7413     out->resolveImageView = in->resolveImageView;
7414     out->resolveImageLayout = in->resolveImageLayout;
7415     out->loadOp = in->loadOp;
7416     out->storeOp = in->storeOp;
7417     out->clearValue = in->clearValue;
7418     if (in->pNext)
7419         FIXME("Unexpected pNext\n");
7420 }
7421
7422 static inline const VkRenderingAttachmentInfo *convert_VkRenderingAttachmentInfo_array_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, uint32_t count)
7423 {
7424     VkRenderingAttachmentInfo *out;
7425     unsigned int i;
7426
7427     if (!in || !count) return NULL;
7428
7429     out = conversion_context_alloc(ctx, count * sizeof(*out));
7430     for (i = 0; i < count; i++)
7431     {
7432         convert_VkRenderingAttachmentInfo_win32_to_host(&in[i], &out[i]);
7433     }
7434
7435     return out;
7436 }
7437
7438 static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingInfo32 *in, VkRenderingInfo *out)
7439 {
7440     const VkBaseInStructure32 *in_header;
7441     VkBaseOutStructure *out_header = (void *)out;
7442
7443     if (!in) return;
7444
7445     out->sType = in->sType;
7446     out->pNext = NULL;
7447     out->flags = in->flags;
7448     out->renderArea = in->renderArea;
7449     out->layerCount = in->layerCount;
7450     out->viewMask = in->viewMask;
7451     out->colorAttachmentCount = in->colorAttachmentCount;
7452     out->pColorAttachments = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pColorAttachments), in->colorAttachmentCount);
7453     out->pDepthAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pDepthAttachment), 1);
7454     out->pStencilAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pStencilAttachment), 1);
7455
7456     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7457     {
7458         switch (in_header->sType)
7459         {
7460         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
7461         {
7462             VkDeviceGroupRenderPassBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7463             const VkDeviceGroupRenderPassBeginInfo32 *in_ext = (const VkDeviceGroupRenderPassBeginInfo32 *)in_header;
7464             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
7465             out_ext->pNext = NULL;
7466             out_ext->deviceMask = in_ext->deviceMask;
7467             out_ext->deviceRenderAreaCount = in_ext->deviceRenderAreaCount;
7468             out_ext->pDeviceRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pDeviceRenderAreas);
7469             out_header->pNext = (void *)out_ext;
7470             out_header = (void *)out_ext;
7471             break;
7472         }
7473         case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
7474         {
7475             VkMultisampledRenderToSingleSampledInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7476             const VkMultisampledRenderToSingleSampledInfoEXT32 *in_ext = (const VkMultisampledRenderToSingleSampledInfoEXT32 *)in_header;
7477             out_ext->sType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
7478             out_ext->pNext = NULL;
7479             out_ext->multisampledRenderToSingleSampledEnable = in_ext->multisampledRenderToSingleSampledEnable;
7480             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
7481             out_header->pNext = (void *)out_ext;
7482             out_header = (void *)out_ext;
7483             break;
7484         }
7485         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
7486         {
7487             VkRenderingFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7488             const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *)in_header;
7489             out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
7490             out_ext->pNext = NULL;
7491             out_ext->imageView = in_ext->imageView;
7492             out_ext->imageLayout = in_ext->imageLayout;
7493             out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize;
7494             out_header->pNext = (void *)out_ext;
7495             out_header = (void *)out_ext;
7496             break;
7497         }
7498         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
7499         {
7500             VkRenderingFragmentDensityMapAttachmentInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7501             const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *in_ext = (const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *)in_header;
7502             out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT;
7503             out_ext->pNext = NULL;
7504             out_ext->imageView = in_ext->imageView;
7505             out_ext->imageLayout = in_ext->imageLayout;
7506             out_header->pNext = (void *)out_ext;
7507             out_header = (void *)out_ext;
7508             break;
7509         }
7510         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
7511         {
7512             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7513             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
7514             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
7515             out_ext->pNext = NULL;
7516             out_ext->perViewAttributes = in_ext->perViewAttributes;
7517             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
7518             out_header->pNext = (void *)out_ext;
7519             out_header = (void *)out_ext;
7520             break;
7521         }
7522         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
7523         {
7524             VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7525             const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *in_ext = (const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *)in_header;
7526             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM;
7527             out_ext->pNext = NULL;
7528             out_ext->perViewRenderAreaCount = in_ext->perViewRenderAreaCount;
7529             out_ext->pPerViewRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pPerViewRenderAreas);
7530             out_header->pNext = (void *)out_ext;
7531             out_header = (void *)out_ext;
7532             break;
7533         }
7534         default:
7535             FIXME("Unhandled sType %u.\n", in_header->sType);
7536             break;
7537         }
7538     }
7539 }
7540
7541 static inline void convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, VkDescriptorBufferBindingInfoEXT *out)
7542 {
7543     const VkBaseInStructure32 *in_header;
7544     VkBaseOutStructure *out_header = (void *)out;
7545
7546     if (!in) return;
7547
7548     out->sType = in->sType;
7549     out->pNext = NULL;
7550     out->address = in->address;
7551     out->usage = in->usage;
7552
7553     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7554     {
7555         switch (in_header->sType)
7556         {
7557         case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
7558         {
7559             VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7560             const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32 *in_ext = (const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32 *)in_header;
7561             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT;
7562             out_ext->pNext = NULL;
7563             out_ext->buffer = in_ext->buffer;
7564             out_header->pNext = (void *)out_ext;
7565             out_header = (void *)out_ext;
7566             break;
7567         }
7568         default:
7569             FIXME("Unhandled sType %u.\n", in_header->sType);
7570             break;
7571         }
7572     }
7573 }
7574
7575 static inline const VkDescriptorBufferBindingInfoEXT *convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, uint32_t count)
7576 {
7577     VkDescriptorBufferBindingInfoEXT *out;
7578     unsigned int i;
7579
7580     if (!in || !count) return NULL;
7581
7582     out = conversion_context_alloc(ctx, count * sizeof(*out));
7583     for (i = 0; i < count; i++)
7584     {
7585         convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(ctx, &in[i], &out[i]);
7586     }
7587
7588     return out;
7589 }
7590
7591 static inline void convert_VkImageBlit2_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, VkImageBlit2 *out)
7592 {
7593     const VkBaseInStructure32 *in_header;
7594     VkBaseOutStructure *out_header = (void *)out;
7595
7596     if (!in) return;
7597
7598     out->sType = in->sType;
7599     out->pNext = NULL;
7600     out->srcSubresource = in->srcSubresource;
7601     memcpy(out->srcOffsets, in->srcOffsets, 2 * sizeof(VkOffset3D));
7602     out->dstSubresource = in->dstSubresource;
7603     memcpy(out->dstOffsets, in->dstOffsets, 2 * sizeof(VkOffset3D));
7604
7605     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7606     {
7607         switch (in_header->sType)
7608         {
7609         case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
7610         {
7611             VkCopyCommandTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7612             const VkCopyCommandTransformInfoQCOM32 *in_ext = (const VkCopyCommandTransformInfoQCOM32 *)in_header;
7613             out_ext->sType = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM;
7614             out_ext->pNext = NULL;
7615             out_ext->transform = in_ext->transform;
7616             out_header->pNext = (void *)out_ext;
7617             out_header = (void *)out_ext;
7618             break;
7619         }
7620         default:
7621             FIXME("Unhandled sType %u.\n", in_header->sType);
7622             break;
7623         }
7624     }
7625 }
7626
7627 static inline const VkImageBlit2 *convert_VkImageBlit2_array_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, uint32_t count)
7628 {
7629     VkImageBlit2 *out;
7630     unsigned int i;
7631
7632     if (!in || !count) return NULL;
7633
7634     out = conversion_context_alloc(ctx, count * sizeof(*out));
7635     for (i = 0; i < count; i++)
7636     {
7637         convert_VkImageBlit2_win32_to_host(ctx, &in[i], &out[i]);
7638     }
7639
7640     return out;
7641 }
7642
7643 static inline void convert_VkBlitImageInfo2_win32_to_host(struct conversion_context *ctx, const VkBlitImageInfo232 *in, VkBlitImageInfo2 *out)
7644 {
7645     if (!in) return;
7646
7647     out->sType = in->sType;
7648     out->pNext = NULL;
7649     out->srcImage = in->srcImage;
7650     out->srcImageLayout = in->srcImageLayout;
7651     out->dstImage = in->dstImage;
7652     out->dstImageLayout = in->dstImageLayout;
7653     out->regionCount = in->regionCount;
7654     out->pRegions = convert_VkImageBlit2_array_win32_to_host(ctx, (const VkImageBlit232 *)UlongToPtr(in->pRegions), in->regionCount);
7655     out->filter = in->filter;
7656     if (in->pNext)
7657         FIXME("Unexpected pNext\n");
7658 }
7659
7660 static inline void convert_VkGeometryTrianglesNV_win32_to_host(const VkGeometryTrianglesNV32 *in, VkGeometryTrianglesNV *out)
7661 {
7662     if (!in) return;
7663
7664     out->sType = in->sType;
7665     out->pNext = NULL;
7666     out->vertexData = in->vertexData;
7667     out->vertexOffset = in->vertexOffset;
7668     out->vertexCount = in->vertexCount;
7669     out->vertexStride = in->vertexStride;
7670     out->vertexFormat = in->vertexFormat;
7671     out->indexData = in->indexData;
7672     out->indexOffset = in->indexOffset;
7673     out->indexCount = in->indexCount;
7674     out->indexType = in->indexType;
7675     out->transformData = in->transformData;
7676     out->transformOffset = in->transformOffset;
7677     if (in->pNext)
7678         FIXME("Unexpected pNext\n");
7679 }
7680
7681 static inline void convert_VkGeometryAABBNV_win32_to_host(const VkGeometryAABBNV32 *in, VkGeometryAABBNV *out)
7682 {
7683     if (!in) return;
7684
7685     out->sType = in->sType;
7686     out->pNext = NULL;
7687     out->aabbData = in->aabbData;
7688     out->numAABBs = in->numAABBs;
7689     out->stride = in->stride;
7690     out->offset = in->offset;
7691     if (in->pNext)
7692         FIXME("Unexpected pNext\n");
7693 }
7694
7695 static inline void convert_VkGeometryDataNV_win32_to_host(const VkGeometryDataNV32 *in, VkGeometryDataNV *out)
7696 {
7697     if (!in) return;
7698
7699     convert_VkGeometryTrianglesNV_win32_to_host(&in->triangles, &out->triangles);
7700     convert_VkGeometryAABBNV_win32_to_host(&in->aabbs, &out->aabbs);
7701 }
7702
7703 static inline void convert_VkGeometryNV_win32_to_host(const VkGeometryNV32 *in, VkGeometryNV *out)
7704 {
7705     if (!in) return;
7706
7707     out->sType = in->sType;
7708     out->pNext = NULL;
7709     out->geometryType = in->geometryType;
7710     convert_VkGeometryDataNV_win32_to_host(&in->geometry, &out->geometry);
7711     out->flags = in->flags;
7712     if (in->pNext)
7713         FIXME("Unexpected pNext\n");
7714 }
7715
7716 static inline const VkGeometryNV *convert_VkGeometryNV_array_win32_to_host(struct conversion_context *ctx, const VkGeometryNV32 *in, uint32_t count)
7717 {
7718     VkGeometryNV *out;
7719     unsigned int i;
7720
7721     if (!in || !count) return NULL;
7722
7723     out = conversion_context_alloc(ctx, count * sizeof(*out));
7724     for (i = 0; i < count; i++)
7725     {
7726         convert_VkGeometryNV_win32_to_host(&in[i], &out[i]);
7727     }
7728
7729     return out;
7730 }
7731
7732 static inline void convert_VkAccelerationStructureInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureInfoNV32 *in, VkAccelerationStructureInfoNV *out)
7733 {
7734     if (!in) return;
7735
7736     out->sType = in->sType;
7737     out->pNext = NULL;
7738     out->type = in->type;
7739     out->flags = in->flags;
7740     out->instanceCount = in->instanceCount;
7741     out->geometryCount = in->geometryCount;
7742     out->pGeometries = convert_VkGeometryNV_array_win32_to_host(ctx, (const VkGeometryNV32 *)UlongToPtr(in->pGeometries), in->geometryCount);
7743     if (in->pNext)
7744         FIXME("Unexpected pNext\n");
7745 }
7746
7747 static inline void convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(const VkCopyAccelerationStructureInfoKHR32 *in, VkCopyAccelerationStructureInfoKHR *out)
7748 {
7749     if (!in) return;
7750
7751     out->sType = in->sType;
7752     out->pNext = NULL;
7753     out->src = in->src;
7754     out->dst = in->dst;
7755     out->mode = in->mode;
7756     if (in->pNext)
7757         FIXME("Unexpected pNext\n");
7758 }
7759
7760 static inline void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(const VkCopyAccelerationStructureToMemoryInfoKHR32 *in, VkCopyAccelerationStructureToMemoryInfoKHR *out)
7761 {
7762     if (!in) return;
7763
7764     out->sType = in->sType;
7765     out->pNext = NULL;
7766     out->src = in->src;
7767     out->dst = in->dst;
7768     out->mode = in->mode;
7769     if (in->pNext)
7770         FIXME("Unexpected pNext\n");
7771 }
7772
7773 static inline void convert_VkBufferCopy_win32_to_host(const VkBufferCopy32 *in, VkBufferCopy *out)
7774 {
7775     if (!in) return;
7776
7777     out->srcOffset = in->srcOffset;
7778     out->dstOffset = in->dstOffset;
7779     out->size = in->size;
7780 }
7781
7782 static inline const VkBufferCopy *convert_VkBufferCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy32 *in, uint32_t count)
7783 {
7784     VkBufferCopy *out;
7785     unsigned int i;
7786
7787     if (!in || !count) return NULL;
7788
7789     out = conversion_context_alloc(ctx, count * sizeof(*out));
7790     for (i = 0; i < count; i++)
7791     {
7792         convert_VkBufferCopy_win32_to_host(&in[i], &out[i]);
7793     }
7794
7795     return out;
7796 }
7797
7798 static inline void convert_VkBufferCopy2_win32_to_host(const VkBufferCopy232 *in, VkBufferCopy2 *out)
7799 {
7800     if (!in) return;
7801
7802     out->sType = in->sType;
7803     out->pNext = NULL;
7804     out->srcOffset = in->srcOffset;
7805     out->dstOffset = in->dstOffset;
7806     out->size = in->size;
7807     if (in->pNext)
7808         FIXME("Unexpected pNext\n");
7809 }
7810
7811 static inline const VkBufferCopy2 *convert_VkBufferCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy232 *in, uint32_t count)
7812 {
7813     VkBufferCopy2 *out;
7814     unsigned int i;
7815
7816     if (!in || !count) return NULL;
7817
7818     out = conversion_context_alloc(ctx, count * sizeof(*out));
7819     for (i = 0; i < count; i++)
7820     {
7821         convert_VkBufferCopy2_win32_to_host(&in[i], &out[i]);
7822     }
7823
7824     return out;
7825 }
7826
7827 static inline void convert_VkCopyBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferInfo232 *in, VkCopyBufferInfo2 *out)
7828 {
7829     if (!in) return;
7830
7831     out->sType = in->sType;
7832     out->pNext = NULL;
7833     out->srcBuffer = in->srcBuffer;
7834     out->dstBuffer = in->dstBuffer;
7835     out->regionCount = in->regionCount;
7836     out->pRegions = convert_VkBufferCopy2_array_win32_to_host(ctx, (const VkBufferCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
7837     if (in->pNext)
7838         FIXME("Unexpected pNext\n");
7839 }
7840
7841 static inline void convert_VkBufferImageCopy_win32_to_host(const VkBufferImageCopy32 *in, VkBufferImageCopy *out)
7842 {
7843     if (!in) return;
7844
7845     out->bufferOffset = in->bufferOffset;
7846     out->bufferRowLength = in->bufferRowLength;
7847     out->bufferImageHeight = in->bufferImageHeight;
7848     out->imageSubresource = in->imageSubresource;
7849     out->imageOffset = in->imageOffset;
7850     out->imageExtent = in->imageExtent;
7851 }
7852
7853 static inline const VkBufferImageCopy *convert_VkBufferImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy32 *in, uint32_t count)
7854 {
7855     VkBufferImageCopy *out;
7856     unsigned int i;
7857
7858     if (!in || !count) return NULL;
7859
7860     out = conversion_context_alloc(ctx, count * sizeof(*out));
7861     for (i = 0; i < count; i++)
7862     {
7863         convert_VkBufferImageCopy_win32_to_host(&in[i], &out[i]);
7864     }
7865
7866     return out;
7867 }
7868
7869 static inline void convert_VkBufferImageCopy2_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, VkBufferImageCopy2 *out)
7870 {
7871     const VkBaseInStructure32 *in_header;
7872     VkBaseOutStructure *out_header = (void *)out;
7873
7874     if (!in) return;
7875
7876     out->sType = in->sType;
7877     out->pNext = NULL;
7878     out->bufferOffset = in->bufferOffset;
7879     out->bufferRowLength = in->bufferRowLength;
7880     out->bufferImageHeight = in->bufferImageHeight;
7881     out->imageSubresource = in->imageSubresource;
7882     out->imageOffset = in->imageOffset;
7883     out->imageExtent = in->imageExtent;
7884
7885     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7886     {
7887         switch (in_header->sType)
7888         {
7889         case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
7890         {
7891             VkCopyCommandTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7892             const VkCopyCommandTransformInfoQCOM32 *in_ext = (const VkCopyCommandTransformInfoQCOM32 *)in_header;
7893             out_ext->sType = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM;
7894             out_ext->pNext = NULL;
7895             out_ext->transform = in_ext->transform;
7896             out_header->pNext = (void *)out_ext;
7897             out_header = (void *)out_ext;
7898             break;
7899         }
7900         default:
7901             FIXME("Unhandled sType %u.\n", in_header->sType);
7902             break;
7903         }
7904     }
7905 }
7906
7907 static inline const VkBufferImageCopy2 *convert_VkBufferImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, uint32_t count)
7908 {
7909     VkBufferImageCopy2 *out;
7910     unsigned int i;
7911
7912     if (!in || !count) return NULL;
7913
7914     out = conversion_context_alloc(ctx, count * sizeof(*out));
7915     for (i = 0; i < count; i++)
7916     {
7917         convert_VkBufferImageCopy2_win32_to_host(ctx, &in[i], &out[i]);
7918     }
7919
7920     return out;
7921 }
7922
7923 static inline void convert_VkCopyBufferToImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferToImageInfo232 *in, VkCopyBufferToImageInfo2 *out)
7924 {
7925     if (!in) return;
7926
7927     out->sType = in->sType;
7928     out->pNext = NULL;
7929     out->srcBuffer = in->srcBuffer;
7930     out->dstImage = in->dstImage;
7931     out->dstImageLayout = in->dstImageLayout;
7932     out->regionCount = in->regionCount;
7933     out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, (const VkBufferImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
7934     if (in->pNext)
7935         FIXME("Unexpected pNext\n");
7936 }
7937
7938 static inline void convert_VkImageCopy2_win32_to_host(const VkImageCopy232 *in, VkImageCopy2 *out)
7939 {
7940     if (!in) return;
7941
7942     out->sType = in->sType;
7943     out->pNext = NULL;
7944     out->srcSubresource = in->srcSubresource;
7945     out->srcOffset = in->srcOffset;
7946     out->dstSubresource = in->dstSubresource;
7947     out->dstOffset = in->dstOffset;
7948     out->extent = in->extent;
7949     if (in->pNext)
7950         FIXME("Unexpected pNext\n");
7951 }
7952
7953 static inline const VkImageCopy2 *convert_VkImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkImageCopy232 *in, uint32_t count)
7954 {
7955     VkImageCopy2 *out;
7956     unsigned int i;
7957
7958     if (!in || !count) return NULL;
7959
7960     out = conversion_context_alloc(ctx, count * sizeof(*out));
7961     for (i = 0; i < count; i++)
7962     {
7963         convert_VkImageCopy2_win32_to_host(&in[i], &out[i]);
7964     }
7965
7966     return out;
7967 }
7968
7969 static inline void convert_VkCopyImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageInfo232 *in, VkCopyImageInfo2 *out)
7970 {
7971     if (!in) return;
7972
7973     out->sType = in->sType;
7974     out->pNext = NULL;
7975     out->srcImage = in->srcImage;
7976     out->srcImageLayout = in->srcImageLayout;
7977     out->dstImage = in->dstImage;
7978     out->dstImageLayout = in->dstImageLayout;
7979     out->regionCount = in->regionCount;
7980     out->pRegions = convert_VkImageCopy2_array_win32_to_host(ctx, (const VkImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
7981     if (in->pNext)
7982         FIXME("Unexpected pNext\n");
7983 }
7984
7985 static inline void convert_VkCopyImageToBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageToBufferInfo232 *in, VkCopyImageToBufferInfo2 *out)
7986 {
7987     if (!in) return;
7988
7989     out->sType = in->sType;
7990     out->pNext = NULL;
7991     out->srcImage = in->srcImage;
7992     out->srcImageLayout = in->srcImageLayout;
7993     out->dstBuffer = in->dstBuffer;
7994     out->regionCount = in->regionCount;
7995     out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, (const VkBufferImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
7996     if (in->pNext)
7997         FIXME("Unexpected pNext\n");
7998 }
7999
8000 static inline void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(const VkCopyMemoryToAccelerationStructureInfoKHR32 *in, VkCopyMemoryToAccelerationStructureInfoKHR *out)
8001 {
8002     if (!in) return;
8003
8004     out->sType = in->sType;
8005     out->pNext = NULL;
8006     out->src = in->src;
8007     out->dst = in->dst;
8008     out->mode = in->mode;
8009     if (in->pNext)
8010         FIXME("Unexpected pNext\n");
8011 }
8012
8013 static inline void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkCopyMemoryToMicromapInfoEXT32 *in, VkCopyMemoryToMicromapInfoEXT *out)
8014 {
8015     if (!in) return;
8016
8017     out->sType = in->sType;
8018     out->pNext = NULL;
8019     out->src = in->src;
8020     out->dst = in->dst;
8021     out->mode = in->mode;
8022     if (in->pNext)
8023         FIXME("Unexpected pNext\n");
8024 }
8025
8026 static inline void convert_VkCopyMicromapInfoEXT_win32_to_host(const VkCopyMicromapInfoEXT32 *in, VkCopyMicromapInfoEXT *out)
8027 {
8028     if (!in) return;
8029
8030     out->sType = in->sType;
8031     out->pNext = NULL;
8032     out->src = in->src;
8033     out->dst = in->dst;
8034     out->mode = in->mode;
8035     if (in->pNext)
8036         FIXME("Unexpected pNext\n");
8037 }
8038
8039 static inline void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkCopyMicromapToMemoryInfoEXT32 *in, VkCopyMicromapToMemoryInfoEXT *out)
8040 {
8041     if (!in) return;
8042
8043     out->sType = in->sType;
8044     out->pNext = NULL;
8045     out->src = in->src;
8046     out->dst = in->dst;
8047     out->mode = in->mode;
8048     if (in->pNext)
8049         FIXME("Unexpected pNext\n");
8050 }
8051
8052 static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoNVX32 *in, VkCuLaunchInfoNVX *out)
8053 {
8054     if (!in) return;
8055
8056     out->sType = in->sType;
8057     out->pNext = NULL;
8058     out->function = in->function;
8059     out->gridDimX = in->gridDimX;
8060     out->gridDimY = in->gridDimY;
8061     out->gridDimZ = in->gridDimZ;
8062     out->blockDimX = in->blockDimX;
8063     out->blockDimY = in->blockDimY;
8064     out->blockDimZ = in->blockDimZ;
8065     out->sharedMemBytes = in->sharedMemBytes;
8066     out->paramCount = in->paramCount;
8067     out->pParams = (const void * const *)UlongToPtr(in->pParams);
8068     out->extraCount = in->extraCount;
8069     out->pExtras = (const void * const *)UlongToPtr(in->pExtras);
8070     if (in->pNext)
8071         FIXME("Unexpected pNext\n");
8072 }
8073
8074 static inline void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebugMarkerMarkerInfoEXT32 *in, VkDebugMarkerMarkerInfoEXT *out)
8075 {
8076     if (!in) return;
8077
8078     out->sType = in->sType;
8079     out->pNext = NULL;
8080     out->pMarkerName = (const char *)UlongToPtr(in->pMarkerName);
8081     memcpy(out->color, in->color, 4 * sizeof(float));
8082     if (in->pNext)
8083         FIXME("Unexpected pNext\n");
8084 }
8085
8086 static inline void convert_VkDecompressMemoryRegionNV_win32_to_host(const VkDecompressMemoryRegionNV32 *in, VkDecompressMemoryRegionNV *out)
8087 {
8088     if (!in) return;
8089
8090     out->srcAddress = in->srcAddress;
8091     out->dstAddress = in->dstAddress;
8092     out->compressedSize = in->compressedSize;
8093     out->decompressedSize = in->decompressedSize;
8094     out->decompressionMethod = in->decompressionMethod;
8095 }
8096
8097 static inline const VkDecompressMemoryRegionNV *convert_VkDecompressMemoryRegionNV_array_win32_to_host(struct conversion_context *ctx, const VkDecompressMemoryRegionNV32 *in, uint32_t count)
8098 {
8099     VkDecompressMemoryRegionNV *out;
8100     unsigned int i;
8101
8102     if (!in || !count) return NULL;
8103
8104     out = conversion_context_alloc(ctx, count * sizeof(*out));
8105     for (i = 0; i < count; i++)
8106     {
8107         convert_VkDecompressMemoryRegionNV_win32_to_host(&in[i], &out[i]);
8108     }
8109
8110     return out;
8111 }
8112
8113 static inline void convert_VkSubpassEndInfo_win32_to_host(struct conversion_context *ctx, const VkSubpassEndInfo32 *in, VkSubpassEndInfo *out)
8114 {
8115     const VkBaseInStructure32 *in_header;
8116     VkBaseOutStructure *out_header = (void *)out;
8117
8118     if (!in) return;
8119
8120     out->sType = in->sType;
8121     out->pNext = NULL;
8122
8123     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8124     {
8125         switch (in_header->sType)
8126         {
8127         case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
8128         {
8129             VkSubpassFragmentDensityMapOffsetEndInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8130             const VkSubpassFragmentDensityMapOffsetEndInfoQCOM32 *in_ext = (const VkSubpassFragmentDensityMapOffsetEndInfoQCOM32 *)in_header;
8131             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM;
8132             out_ext->pNext = NULL;
8133             out_ext->fragmentDensityOffsetCount = in_ext->fragmentDensityOffsetCount;
8134             out_ext->pFragmentDensityOffsets = (const VkOffset2D *)UlongToPtr(in_ext->pFragmentDensityOffsets);
8135             out_header->pNext = (void *)out_ext;
8136             out_header = (void *)out_ext;
8137             break;
8138         }
8139         default:
8140             FIXME("Unhandled sType %u.\n", in_header->sType);
8141             break;
8142         }
8143     }
8144 }
8145
8146 #ifdef _WIN64
8147 static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win64_to_host(struct conversion_context *ctx, const VkCommandBuffer *in, uint32_t count)
8148 {
8149     VkCommandBuffer *out;
8150     unsigned int i;
8151
8152     if (!in || !count) return NULL;
8153
8154     out = conversion_context_alloc(ctx, count * sizeof(*out));
8155     for (i = 0; i < count; i++)
8156     {
8157         out[i] = wine_cmd_buffer_from_handle(in[i])->command_buffer;
8158     }
8159
8160     return out;
8161 }
8162 #endif /* _WIN64 */
8163
8164 static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
8165 {
8166     VkCommandBuffer *out;
8167     unsigned int i;
8168
8169     if (!in || !count) return NULL;
8170
8171     out = conversion_context_alloc(ctx, count * sizeof(*out));
8172     for (i = 0; i < count; i++)
8173     {
8174         out[i] = wine_cmd_buffer_from_handle(UlongToPtr(in[i]))->command_buffer;
8175     }
8176
8177     return out;
8178 }
8179
8180 static inline void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndirectCommandsStreamNV32 *in, VkIndirectCommandsStreamNV *out)
8181 {
8182     if (!in) return;
8183
8184     out->buffer = in->buffer;
8185     out->offset = in->offset;
8186 }
8187
8188 static inline const VkIndirectCommandsStreamNV *convert_VkIndirectCommandsStreamNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsStreamNV32 *in, uint32_t count)
8189 {
8190     VkIndirectCommandsStreamNV *out;
8191     unsigned int i;
8192
8193     if (!in || !count) return NULL;
8194
8195     out = conversion_context_alloc(ctx, count * sizeof(*out));
8196     for (i = 0; i < count; i++)
8197     {
8198         convert_VkIndirectCommandsStreamNV_win32_to_host(&in[i], &out[i]);
8199     }
8200
8201     return out;
8202 }
8203
8204 static inline void convert_VkGeneratedCommandsInfoNV_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoNV32 *in, VkGeneratedCommandsInfoNV *out)
8205 {
8206     if (!in) return;
8207
8208     out->sType = in->sType;
8209     out->pNext = NULL;
8210     out->pipelineBindPoint = in->pipelineBindPoint;
8211     out->pipeline = in->pipeline;
8212     out->indirectCommandsLayout = in->indirectCommandsLayout;
8213     out->streamCount = in->streamCount;
8214     out->pStreams = convert_VkIndirectCommandsStreamNV_array_win32_to_host(ctx, (const VkIndirectCommandsStreamNV32 *)UlongToPtr(in->pStreams), in->streamCount);
8215     out->sequencesCount = in->sequencesCount;
8216     out->preprocessBuffer = in->preprocessBuffer;
8217     out->preprocessOffset = in->preprocessOffset;
8218     out->preprocessSize = in->preprocessSize;
8219     out->sequencesCountBuffer = in->sequencesCountBuffer;
8220     out->sequencesCountOffset = in->sequencesCountOffset;
8221     out->sequencesIndexBuffer = in->sequencesIndexBuffer;
8222     out->sequencesIndexOffset = in->sequencesIndexOffset;
8223     if (in->pNext)
8224         FIXME("Unexpected pNext\n");
8225 }
8226
8227 static inline void convert_VkOpticalFlowExecuteInfoNV_win32_to_host(const VkOpticalFlowExecuteInfoNV32 *in, VkOpticalFlowExecuteInfoNV *out)
8228 {
8229     if (!in) return;
8230
8231     out->sType = in->sType;
8232     out->pNext = NULL;
8233     out->flags = in->flags;
8234     out->regionCount = in->regionCount;
8235     out->pRegions = (const VkRect2D *)UlongToPtr(in->pRegions);
8236     if (in->pNext)
8237         FIXME("Unexpected pNext\n");
8238 }
8239
8240 static inline void convert_VkMemoryBarrier_win32_to_host(const VkMemoryBarrier32 *in, VkMemoryBarrier *out)
8241 {
8242     if (!in) return;
8243
8244     out->sType = in->sType;
8245     out->pNext = NULL;
8246     out->srcAccessMask = in->srcAccessMask;
8247     out->dstAccessMask = in->dstAccessMask;
8248     if (in->pNext)
8249         FIXME("Unexpected pNext\n");
8250 }
8251
8252 static inline const VkMemoryBarrier *convert_VkMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier32 *in, uint32_t count)
8253 {
8254     VkMemoryBarrier *out;
8255     unsigned int i;
8256
8257     if (!in || !count) return NULL;
8258
8259     out = conversion_context_alloc(ctx, count * sizeof(*out));
8260     for (i = 0; i < count; i++)
8261     {
8262         convert_VkMemoryBarrier_win32_to_host(&in[i], &out[i]);
8263     }
8264
8265     return out;
8266 }
8267
8268 static inline void convert_VkBufferMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, VkBufferMemoryBarrier *out)
8269 {
8270     const VkBaseInStructure32 *in_header;
8271     VkBaseOutStructure *out_header = (void *)out;
8272
8273     if (!in) return;
8274
8275     out->sType = in->sType;
8276     out->pNext = NULL;
8277     out->srcAccessMask = in->srcAccessMask;
8278     out->dstAccessMask = in->dstAccessMask;
8279     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
8280     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
8281     out->buffer = in->buffer;
8282     out->offset = in->offset;
8283     out->size = in->size;
8284
8285     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8286     {
8287         switch (in_header->sType)
8288         {
8289         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
8290         {
8291             VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8292             const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header;
8293             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
8294             out_ext->pNext = NULL;
8295             out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory;
8296             out_header->pNext = (void *)out_ext;
8297             out_header = (void *)out_ext;
8298             break;
8299         }
8300         default:
8301             FIXME("Unhandled sType %u.\n", in_header->sType);
8302             break;
8303         }
8304     }
8305 }
8306
8307 static inline const VkBufferMemoryBarrier *convert_VkBufferMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, uint32_t count)
8308 {
8309     VkBufferMemoryBarrier *out;
8310     unsigned int i;
8311
8312     if (!in || !count) return NULL;
8313
8314     out = conversion_context_alloc(ctx, count * sizeof(*out));
8315     for (i = 0; i < count; i++)
8316     {
8317         convert_VkBufferMemoryBarrier_win32_to_host(ctx, &in[i], &out[i]);
8318     }
8319
8320     return out;
8321 }
8322
8323 static inline void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, VkImageMemoryBarrier *out)
8324 {
8325     const VkBaseInStructure32 *in_header;
8326     VkBaseOutStructure *out_header = (void *)out;
8327
8328     if (!in) return;
8329
8330     out->sType = in->sType;
8331     out->pNext = NULL;
8332     out->srcAccessMask = in->srcAccessMask;
8333     out->dstAccessMask = in->dstAccessMask;
8334     out->oldLayout = in->oldLayout;
8335     out->newLayout = in->newLayout;
8336     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
8337     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
8338     out->image = in->image;
8339     out->subresourceRange = in->subresourceRange;
8340
8341     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8342     {
8343         switch (in_header->sType)
8344         {
8345         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
8346         {
8347             VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8348             const VkSampleLocationsInfoEXT32 *in_ext = (const VkSampleLocationsInfoEXT32 *)in_header;
8349             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT;
8350             out_ext->pNext = NULL;
8351             out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel;
8352             out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize;
8353             out_ext->sampleLocationsCount = in_ext->sampleLocationsCount;
8354             out_ext->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in_ext->pSampleLocations);
8355             out_header->pNext = (void *)out_ext;
8356             out_header = (void *)out_ext;
8357             break;
8358         }
8359         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
8360         {
8361             VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8362             const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header;
8363             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
8364             out_ext->pNext = NULL;
8365             out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory;
8366             out_header->pNext = (void *)out_ext;
8367             out_header = (void *)out_ext;
8368             break;
8369         }
8370         default:
8371             FIXME("Unhandled sType %u.\n", in_header->sType);
8372             break;
8373         }
8374     }
8375 }
8376
8377 static inline const VkImageMemoryBarrier *convert_VkImageMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, uint32_t count)
8378 {
8379     VkImageMemoryBarrier *out;
8380     unsigned int i;
8381
8382     if (!in || !count) return NULL;
8383
8384     out = conversion_context_alloc(ctx, count * sizeof(*out));
8385     for (i = 0; i < count; i++)
8386     {
8387         convert_VkImageMemoryBarrier_win32_to_host(ctx, &in[i], &out[i]);
8388     }
8389
8390     return out;
8391 }
8392
8393 static inline void convert_VkMemoryBarrier2_win32_to_host(const VkMemoryBarrier232 *in, VkMemoryBarrier2 *out)
8394 {
8395     if (!in) return;
8396
8397     out->sType = in->sType;
8398     out->pNext = NULL;
8399     out->srcStageMask = in->srcStageMask;
8400     out->srcAccessMask = in->srcAccessMask;
8401     out->dstStageMask = in->dstStageMask;
8402     out->dstAccessMask = in->dstAccessMask;
8403     if (in->pNext)
8404         FIXME("Unexpected pNext\n");
8405 }
8406
8407 static inline const VkMemoryBarrier2 *convert_VkMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier232 *in, uint32_t count)
8408 {
8409     VkMemoryBarrier2 *out;
8410     unsigned int i;
8411
8412     if (!in || !count) return NULL;
8413
8414     out = conversion_context_alloc(ctx, count * sizeof(*out));
8415     for (i = 0; i < count; i++)
8416     {
8417         convert_VkMemoryBarrier2_win32_to_host(&in[i], &out[i]);
8418     }
8419
8420     return out;
8421 }
8422
8423 static inline void convert_VkBufferMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, VkBufferMemoryBarrier2 *out)
8424 {
8425     const VkBaseInStructure32 *in_header;
8426     VkBaseOutStructure *out_header = (void *)out;
8427
8428     if (!in) return;
8429
8430     out->sType = in->sType;
8431     out->pNext = NULL;
8432     out->srcStageMask = in->srcStageMask;
8433     out->srcAccessMask = in->srcAccessMask;
8434     out->dstStageMask = in->dstStageMask;
8435     out->dstAccessMask = in->dstAccessMask;
8436     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
8437     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
8438     out->buffer = in->buffer;
8439     out->offset = in->offset;
8440     out->size = in->size;
8441
8442     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8443     {
8444         switch (in_header->sType)
8445         {
8446         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
8447         {
8448             VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8449             const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header;
8450             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
8451             out_ext->pNext = NULL;
8452             out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory;
8453             out_header->pNext = (void *)out_ext;
8454             out_header = (void *)out_ext;
8455             break;
8456         }
8457         default:
8458             FIXME("Unhandled sType %u.\n", in_header->sType);
8459             break;
8460         }
8461     }
8462 }
8463
8464 static inline const VkBufferMemoryBarrier2 *convert_VkBufferMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, uint32_t count)
8465 {
8466     VkBufferMemoryBarrier2 *out;
8467     unsigned int i;
8468
8469     if (!in || !count) return NULL;
8470
8471     out = conversion_context_alloc(ctx, count * sizeof(*out));
8472     for (i = 0; i < count; i++)
8473     {
8474         convert_VkBufferMemoryBarrier2_win32_to_host(ctx, &in[i], &out[i]);
8475     }
8476
8477     return out;
8478 }
8479
8480 static inline void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, VkImageMemoryBarrier2 *out)
8481 {
8482     const VkBaseInStructure32 *in_header;
8483     VkBaseOutStructure *out_header = (void *)out;
8484
8485     if (!in) return;
8486
8487     out->sType = in->sType;
8488     out->pNext = NULL;
8489     out->srcStageMask = in->srcStageMask;
8490     out->srcAccessMask = in->srcAccessMask;
8491     out->dstStageMask = in->dstStageMask;
8492     out->dstAccessMask = in->dstAccessMask;
8493     out->oldLayout = in->oldLayout;
8494     out->newLayout = in->newLayout;
8495     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
8496     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
8497     out->image = in->image;
8498     out->subresourceRange = in->subresourceRange;
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_SAMPLE_LOCATIONS_INFO_EXT:
8505         {
8506             VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8507             const VkSampleLocationsInfoEXT32 *in_ext = (const VkSampleLocationsInfoEXT32 *)in_header;
8508             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT;
8509             out_ext->pNext = NULL;
8510             out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel;
8511             out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize;
8512             out_ext->sampleLocationsCount = in_ext->sampleLocationsCount;
8513             out_ext->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in_ext->pSampleLocations);
8514             out_header->pNext = (void *)out_ext;
8515             out_header = (void *)out_ext;
8516             break;
8517         }
8518         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
8519         {
8520             VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8521             const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header;
8522             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT;
8523             out_ext->pNext = NULL;
8524             out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory;
8525             out_header->pNext = (void *)out_ext;
8526             out_header = (void *)out_ext;
8527             break;
8528         }
8529         default:
8530             FIXME("Unhandled sType %u.\n", in_header->sType);
8531             break;
8532         }
8533     }
8534 }
8535
8536 static inline const VkImageMemoryBarrier2 *convert_VkImageMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, uint32_t count)
8537 {
8538     VkImageMemoryBarrier2 *out;
8539     unsigned int i;
8540
8541     if (!in || !count) return NULL;
8542
8543     out = conversion_context_alloc(ctx, count * sizeof(*out));
8544     for (i = 0; i < count; i++)
8545     {
8546         convert_VkImageMemoryBarrier2_win32_to_host(ctx, &in[i], &out[i]);
8547     }
8548
8549     return out;
8550 }
8551
8552 static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, VkDependencyInfo *out)
8553 {
8554     if (!in) return;
8555
8556     out->sType = in->sType;
8557     out->pNext = NULL;
8558     out->dependencyFlags = in->dependencyFlags;
8559     out->memoryBarrierCount = in->memoryBarrierCount;
8560     out->pMemoryBarriers = convert_VkMemoryBarrier2_array_win32_to_host(ctx, (const VkMemoryBarrier232 *)UlongToPtr(in->pMemoryBarriers), in->memoryBarrierCount);
8561     out->bufferMemoryBarrierCount = in->bufferMemoryBarrierCount;
8562     out->pBufferMemoryBarriers = convert_VkBufferMemoryBarrier2_array_win32_to_host(ctx, (const VkBufferMemoryBarrier232 *)UlongToPtr(in->pBufferMemoryBarriers), in->bufferMemoryBarrierCount);
8563     out->imageMemoryBarrierCount = in->imageMemoryBarrierCount;
8564     out->pImageMemoryBarriers = convert_VkImageMemoryBarrier2_array_win32_to_host(ctx, (const VkImageMemoryBarrier232 *)UlongToPtr(in->pImageMemoryBarriers), in->imageMemoryBarrierCount);
8565     if (in->pNext)
8566         FIXME("Unexpected pNext\n");
8567 }
8568
8569 static inline void convert_VkDescriptorImageInfo_win32_to_host(const VkDescriptorImageInfo32 *in, VkDescriptorImageInfo *out)
8570 {
8571     if (!in) return;
8572
8573     out->sampler = in->sampler;
8574     out->imageView = in->imageView;
8575     out->imageLayout = in->imageLayout;
8576 }
8577
8578 static inline const VkDescriptorImageInfo *convert_VkDescriptorImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorImageInfo32 *in, uint32_t count)
8579 {
8580     VkDescriptorImageInfo *out;
8581     unsigned int i;
8582
8583     if (!in || !count) return NULL;
8584
8585     out = conversion_context_alloc(ctx, count * sizeof(*out));
8586     for (i = 0; i < count; i++)
8587     {
8588         convert_VkDescriptorImageInfo_win32_to_host(&in[i], &out[i]);
8589     }
8590
8591     return out;
8592 }
8593
8594 static inline void convert_VkDescriptorBufferInfo_win32_to_host(const VkDescriptorBufferInfo32 *in, VkDescriptorBufferInfo *out)
8595 {
8596     if (!in) return;
8597
8598     out->buffer = in->buffer;
8599     out->offset = in->offset;
8600     out->range = in->range;
8601 }
8602
8603 static inline const VkDescriptorBufferInfo *convert_VkDescriptorBufferInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferInfo32 *in, uint32_t count)
8604 {
8605     VkDescriptorBufferInfo *out;
8606     unsigned int i;
8607
8608     if (!in || !count) return NULL;
8609
8610     out = conversion_context_alloc(ctx, count * sizeof(*out));
8611     for (i = 0; i < count; i++)
8612     {
8613         convert_VkDescriptorBufferInfo_win32_to_host(&in[i], &out[i]);
8614     }
8615
8616     return out;
8617 }
8618
8619 static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, VkWriteDescriptorSet *out)
8620 {
8621     const VkBaseInStructure32 *in_header;
8622     VkBaseOutStructure *out_header = (void *)out;
8623
8624     if (!in) return;
8625
8626     out->sType = in->sType;
8627     out->pNext = NULL;
8628     out->dstSet = in->dstSet;
8629     out->dstBinding = in->dstBinding;
8630     out->dstArrayElement = in->dstArrayElement;
8631     out->descriptorCount = in->descriptorCount;
8632     out->descriptorType = in->descriptorType;
8633     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);
8634     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);
8635     out->pTexelBufferView = (const VkBufferView *)UlongToPtr(in->pTexelBufferView);
8636
8637     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8638     {
8639         switch (in_header->sType)
8640         {
8641         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
8642         {
8643             VkWriteDescriptorSetInlineUniformBlock *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8644             const VkWriteDescriptorSetInlineUniformBlock32 *in_ext = (const VkWriteDescriptorSetInlineUniformBlock32 *)in_header;
8645             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
8646             out_ext->pNext = NULL;
8647             out_ext->dataSize = in_ext->dataSize;
8648             out_ext->pData = (const void *)UlongToPtr(in_ext->pData);
8649             out_header->pNext = (void *)out_ext;
8650             out_header = (void *)out_ext;
8651             break;
8652         }
8653         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
8654         {
8655             VkWriteDescriptorSetAccelerationStructureKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8656             const VkWriteDescriptorSetAccelerationStructureKHR32 *in_ext = (const VkWriteDescriptorSetAccelerationStructureKHR32 *)in_header;
8657             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR;
8658             out_ext->pNext = NULL;
8659             out_ext->accelerationStructureCount = in_ext->accelerationStructureCount;
8660             out_ext->pAccelerationStructures = (const VkAccelerationStructureKHR *)UlongToPtr(in_ext->pAccelerationStructures);
8661             out_header->pNext = (void *)out_ext;
8662             out_header = (void *)out_ext;
8663             break;
8664         }
8665         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
8666         {
8667             VkWriteDescriptorSetAccelerationStructureNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8668             const VkWriteDescriptorSetAccelerationStructureNV32 *in_ext = (const VkWriteDescriptorSetAccelerationStructureNV32 *)in_header;
8669             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV;
8670             out_ext->pNext = NULL;
8671             out_ext->accelerationStructureCount = in_ext->accelerationStructureCount;
8672             out_ext->pAccelerationStructures = (const VkAccelerationStructureNV *)UlongToPtr(in_ext->pAccelerationStructures);
8673             out_header->pNext = (void *)out_ext;
8674             out_header = (void *)out_ext;
8675             break;
8676         }
8677         default:
8678             FIXME("Unhandled sType %u.\n", in_header->sType);
8679             break;
8680         }
8681     }
8682 }
8683
8684 static inline const VkWriteDescriptorSet *convert_VkWriteDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, uint32_t count)
8685 {
8686     VkWriteDescriptorSet *out;
8687     unsigned int i;
8688
8689     if (!in || !count) return NULL;
8690
8691     out = conversion_context_alloc(ctx, count * sizeof(*out));
8692     for (i = 0; i < count; i++)
8693     {
8694         convert_VkWriteDescriptorSet_win32_to_host(ctx, &in[i], &out[i]);
8695     }
8696
8697     return out;
8698 }
8699
8700 static inline void convert_VkImageResolve2_win32_to_host(const VkImageResolve232 *in, VkImageResolve2 *out)
8701 {
8702     if (!in) return;
8703
8704     out->sType = in->sType;
8705     out->pNext = NULL;
8706     out->srcSubresource = in->srcSubresource;
8707     out->srcOffset = in->srcOffset;
8708     out->dstSubresource = in->dstSubresource;
8709     out->dstOffset = in->dstOffset;
8710     out->extent = in->extent;
8711     if (in->pNext)
8712         FIXME("Unexpected pNext\n");
8713 }
8714
8715 static inline const VkImageResolve2 *convert_VkImageResolve2_array_win32_to_host(struct conversion_context *ctx, const VkImageResolve232 *in, uint32_t count)
8716 {
8717     VkImageResolve2 *out;
8718     unsigned int i;
8719
8720     if (!in || !count) return NULL;
8721
8722     out = conversion_context_alloc(ctx, count * sizeof(*out));
8723     for (i = 0; i < count; i++)
8724     {
8725         convert_VkImageResolve2_win32_to_host(&in[i], &out[i]);
8726     }
8727
8728     return out;
8729 }
8730
8731 static inline void convert_VkResolveImageInfo2_win32_to_host(struct conversion_context *ctx, const VkResolveImageInfo232 *in, VkResolveImageInfo2 *out)
8732 {
8733     if (!in) return;
8734
8735     out->sType = in->sType;
8736     out->pNext = NULL;
8737     out->srcImage = in->srcImage;
8738     out->srcImageLayout = in->srcImageLayout;
8739     out->dstImage = in->dstImage;
8740     out->dstImageLayout = in->dstImageLayout;
8741     out->regionCount = in->regionCount;
8742     out->pRegions = convert_VkImageResolve2_array_win32_to_host(ctx, (const VkImageResolve232 *)UlongToPtr(in->pRegions), in->regionCount);
8743     if (in->pNext)
8744         FIXME("Unexpected pNext\n");
8745 }
8746
8747 static inline void convert_VkCoarseSampleOrderCustomNV_win32_to_host(const VkCoarseSampleOrderCustomNV32 *in, VkCoarseSampleOrderCustomNV *out)
8748 {
8749     if (!in) return;
8750
8751     out->shadingRate = in->shadingRate;
8752     out->sampleCount = in->sampleCount;
8753     out->sampleLocationCount = in->sampleLocationCount;
8754     out->pSampleLocations = (const VkCoarseSampleLocationNV *)UlongToPtr(in->pSampleLocations);
8755 }
8756
8757 static inline const VkCoarseSampleOrderCustomNV *convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(struct conversion_context *ctx, const VkCoarseSampleOrderCustomNV32 *in, uint32_t count)
8758 {
8759     VkCoarseSampleOrderCustomNV *out;
8760     unsigned int i;
8761
8762     if (!in || !count) return NULL;
8763
8764     out = conversion_context_alloc(ctx, count * sizeof(*out));
8765     for (i = 0; i < count; i++)
8766     {
8767         convert_VkCoarseSampleOrderCustomNV_win32_to_host(&in[i], &out[i]);
8768     }
8769
8770     return out;
8771 }
8772
8773 static inline void convert_VkDepthBiasInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDepthBiasInfoEXT32 *in, VkDepthBiasInfoEXT *out)
8774 {
8775     const VkBaseInStructure32 *in_header;
8776     VkBaseOutStructure *out_header = (void *)out;
8777
8778     if (!in) return;
8779
8780     out->sType = in->sType;
8781     out->pNext = NULL;
8782     out->depthBiasConstantFactor = in->depthBiasConstantFactor;
8783     out->depthBiasClamp = in->depthBiasClamp;
8784     out->depthBiasSlopeFactor = in->depthBiasSlopeFactor;
8785
8786     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8787     {
8788         switch (in_header->sType)
8789         {
8790         case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
8791         {
8792             VkDepthBiasRepresentationInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8793             const VkDepthBiasRepresentationInfoEXT32 *in_ext = (const VkDepthBiasRepresentationInfoEXT32 *)in_header;
8794             out_ext->sType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT;
8795             out_ext->pNext = NULL;
8796             out_ext->depthBiasRepresentation = in_ext->depthBiasRepresentation;
8797             out_ext->depthBiasExact = in_ext->depthBiasExact;
8798             out_header->pNext = (void *)out_ext;
8799             out_header = (void *)out_ext;
8800             break;
8801         }
8802         default:
8803             FIXME("Unhandled sType %u.\n", in_header->sType);
8804             break;
8805         }
8806     }
8807 }
8808
8809 static inline void convert_VkPerformanceMarkerInfoINTEL_win32_to_host(const VkPerformanceMarkerInfoINTEL32 *in, VkPerformanceMarkerInfoINTEL *out)
8810 {
8811     if (!in) return;
8812
8813     out->sType = in->sType;
8814     out->pNext = NULL;
8815     out->marker = in->marker;
8816     if (in->pNext)
8817         FIXME("Unexpected pNext\n");
8818 }
8819
8820 static inline void convert_VkPerformanceOverrideInfoINTEL_win32_to_host(const VkPerformanceOverrideInfoINTEL32 *in, VkPerformanceOverrideInfoINTEL *out)
8821 {
8822     if (!in) return;
8823
8824     out->sType = in->sType;
8825     out->pNext = NULL;
8826     out->type = in->type;
8827     out->enable = in->enable;
8828     out->parameter = in->parameter;
8829     if (in->pNext)
8830         FIXME("Unexpected pNext\n");
8831 }
8832
8833 static inline void convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(const VkPerformanceStreamMarkerInfoINTEL32 *in, VkPerformanceStreamMarkerInfoINTEL *out)
8834 {
8835     if (!in) return;
8836
8837     out->sType = in->sType;
8838     out->pNext = NULL;
8839     out->marker = in->marker;
8840     if (in->pNext)
8841         FIXME("Unexpected pNext\n");
8842 }
8843
8844 static inline void convert_VkVertexInputBindingDescription2EXT_win32_to_host(const VkVertexInputBindingDescription2EXT32 *in, VkVertexInputBindingDescription2EXT *out)
8845 {
8846     if (!in) return;
8847
8848     out->sType = in->sType;
8849     out->pNext = NULL;
8850     out->binding = in->binding;
8851     out->stride = in->stride;
8852     out->inputRate = in->inputRate;
8853     out->divisor = in->divisor;
8854     if (in->pNext)
8855         FIXME("Unexpected pNext\n");
8856 }
8857
8858 static inline const VkVertexInputBindingDescription2EXT *convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputBindingDescription2EXT32 *in, uint32_t count)
8859 {
8860     VkVertexInputBindingDescription2EXT *out;
8861     unsigned int i;
8862
8863     if (!in || !count) return NULL;
8864
8865     out = conversion_context_alloc(ctx, count * sizeof(*out));
8866     for (i = 0; i < count; i++)
8867     {
8868         convert_VkVertexInputBindingDescription2EXT_win32_to_host(&in[i], &out[i]);
8869     }
8870
8871     return out;
8872 }
8873
8874 static inline void convert_VkVertexInputAttributeDescription2EXT_win32_to_host(const VkVertexInputAttributeDescription2EXT32 *in, VkVertexInputAttributeDescription2EXT *out)
8875 {
8876     if (!in) return;
8877
8878     out->sType = in->sType;
8879     out->pNext = NULL;
8880     out->location = in->location;
8881     out->binding = in->binding;
8882     out->format = in->format;
8883     out->offset = in->offset;
8884     if (in->pNext)
8885         FIXME("Unexpected pNext\n");
8886 }
8887
8888 static inline const VkVertexInputAttributeDescription2EXT *convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputAttributeDescription2EXT32 *in, uint32_t count)
8889 {
8890     VkVertexInputAttributeDescription2EXT *out;
8891     unsigned int i;
8892
8893     if (!in || !count) return NULL;
8894
8895     out = conversion_context_alloc(ctx, count * sizeof(*out));
8896     for (i = 0; i < count; i++)
8897     {
8898         convert_VkVertexInputAttributeDescription2EXT_win32_to_host(&in[i], &out[i]);
8899     }
8900
8901     return out;
8902 }
8903
8904 static inline void convert_VkShadingRatePaletteNV_win32_to_host(const VkShadingRatePaletteNV32 *in, VkShadingRatePaletteNV *out)
8905 {
8906     if (!in) return;
8907
8908     out->shadingRatePaletteEntryCount = in->shadingRatePaletteEntryCount;
8909     out->pShadingRatePaletteEntries = (const VkShadingRatePaletteEntryNV *)UlongToPtr(in->pShadingRatePaletteEntries);
8910 }
8911
8912 static inline const VkShadingRatePaletteNV *convert_VkShadingRatePaletteNV_array_win32_to_host(struct conversion_context *ctx, const VkShadingRatePaletteNV32 *in, uint32_t count)
8913 {
8914     VkShadingRatePaletteNV *out;
8915     unsigned int i;
8916
8917     if (!in || !count) return NULL;
8918
8919     out = conversion_context_alloc(ctx, count * sizeof(*out));
8920     for (i = 0; i < count; i++)
8921     {
8922         convert_VkShadingRatePaletteNV_win32_to_host(&in[i], &out[i]);
8923     }
8924
8925     return out;
8926 }
8927
8928 static inline void convert_VkStridedDeviceAddressRegionKHR_win32_to_host(const VkStridedDeviceAddressRegionKHR32 *in, VkStridedDeviceAddressRegionKHR *out)
8929 {
8930     if (!in) return;
8931
8932     out->deviceAddress = in->deviceAddress;
8933     out->stride = in->stride;
8934     out->size = in->size;
8935 }
8936
8937 static inline const VkDependencyInfo *convert_VkDependencyInfo_array_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, uint32_t count)
8938 {
8939     VkDependencyInfo *out;
8940     unsigned int i;
8941
8942     if (!in || !count) return NULL;
8943
8944     out = conversion_context_alloc(ctx, count * sizeof(*out));
8945     for (i = 0; i < count; i++)
8946     {
8947         convert_VkDependencyInfo_win32_to_host(ctx, &in[i], &out[i]);
8948     }
8949
8950     return out;
8951 }
8952
8953 static inline void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoKHR32 *in, VkAccelerationStructureCreateInfoKHR *out)
8954 {
8955     const VkBaseInStructure32 *in_header;
8956     VkBaseOutStructure *out_header = (void *)out;
8957
8958     if (!in) return;
8959
8960     out->sType = in->sType;
8961     out->pNext = NULL;
8962     out->createFlags = in->createFlags;
8963     out->buffer = in->buffer;
8964     out->offset = in->offset;
8965     out->size = in->size;
8966     out->type = in->type;
8967     out->deviceAddress = in->deviceAddress;
8968
8969     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8970     {
8971         switch (in_header->sType)
8972         {
8973         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
8974         {
8975             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8976             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
8977             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
8978             out_ext->pNext = NULL;
8979             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
8980             out_header->pNext = (void *)out_ext;
8981             out_header = (void *)out_ext;
8982             break;
8983         }
8984         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
8985         {
8986             VkAccelerationStructureMotionInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8987             const VkAccelerationStructureMotionInfoNV32 *in_ext = (const VkAccelerationStructureMotionInfoNV32 *)in_header;
8988             out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV;
8989             out_ext->pNext = NULL;
8990             out_ext->maxInstances = in_ext->maxInstances;
8991             out_ext->flags = in_ext->flags;
8992             out_header->pNext = (void *)out_ext;
8993             out_header = (void *)out_ext;
8994             break;
8995         }
8996         default:
8997             FIXME("Unhandled sType %u.\n", in_header->sType);
8998             break;
8999         }
9000     }
9001 }
9002
9003 static inline void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoNV32 *in, VkAccelerationStructureCreateInfoNV *out)
9004 {
9005     const VkBaseInStructure32 *in_header;
9006     VkBaseOutStructure *out_header = (void *)out;
9007
9008     if (!in) return;
9009
9010     out->sType = in->sType;
9011     out->pNext = NULL;
9012     out->compactedSize = in->compactedSize;
9013     convert_VkAccelerationStructureInfoNV_win32_to_host(ctx, &in->info, &out->info);
9014
9015     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9016     {
9017         switch (in_header->sType)
9018         {
9019         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
9020         {
9021             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9022             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
9023             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
9024             out_ext->pNext = NULL;
9025             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
9026             out_header->pNext = (void *)out_ext;
9027             out_header = (void *)out_ext;
9028             break;
9029         }
9030         default:
9031             FIXME("Unhandled sType %u.\n", in_header->sType);
9032             break;
9033         }
9034     }
9035 }
9036
9037 static inline void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, VkBufferCreateInfo *out)
9038 {
9039     const VkBaseInStructure32 *in_header;
9040     VkBaseOutStructure *out_header = (void *)out;
9041
9042     if (!in) return;
9043
9044     out->sType = in->sType;
9045     out->pNext = NULL;
9046     out->flags = in->flags;
9047     out->size = in->size;
9048     out->usage = in->usage;
9049     out->sharingMode = in->sharingMode;
9050     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
9051     out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);
9052
9053     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9054     {
9055         switch (in_header->sType)
9056         {
9057         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
9058         {
9059             VkDedicatedAllocationBufferCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9060             const VkDedicatedAllocationBufferCreateInfoNV32 *in_ext = (const VkDedicatedAllocationBufferCreateInfoNV32 *)in_header;
9061             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV;
9062             out_ext->pNext = NULL;
9063             out_ext->dedicatedAllocation = in_ext->dedicatedAllocation;
9064             out_header->pNext = (void *)out_ext;
9065             out_header = (void *)out_ext;
9066             break;
9067         }
9068         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
9069         {
9070             VkExternalMemoryBufferCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9071             const VkExternalMemoryBufferCreateInfo32 *in_ext = (const VkExternalMemoryBufferCreateInfo32 *)in_header;
9072             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
9073             out_ext->pNext = NULL;
9074             out_ext->handleTypes = in_ext->handleTypes;
9075             out_header->pNext = (void *)out_ext;
9076             out_header = (void *)out_ext;
9077             break;
9078         }
9079         case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
9080         {
9081             VkBufferOpaqueCaptureAddressCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9082             const VkBufferOpaqueCaptureAddressCreateInfo32 *in_ext = (const VkBufferOpaqueCaptureAddressCreateInfo32 *)in_header;
9083             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
9084             out_ext->pNext = NULL;
9085             out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress;
9086             out_header->pNext = (void *)out_ext;
9087             out_header = (void *)out_ext;
9088             break;
9089         }
9090         case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
9091         {
9092             VkBufferDeviceAddressCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9093             const VkBufferDeviceAddressCreateInfoEXT32 *in_ext = (const VkBufferDeviceAddressCreateInfoEXT32 *)in_header;
9094             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT;
9095             out_ext->pNext = NULL;
9096             out_ext->deviceAddress = in_ext->deviceAddress;
9097             out_header->pNext = (void *)out_ext;
9098             out_header = (void *)out_ext;
9099             break;
9100         }
9101         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
9102         {
9103             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9104             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
9105             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
9106             out_ext->pNext = NULL;
9107             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
9108             out_header->pNext = (void *)out_ext;
9109             out_header = (void *)out_ext;
9110             break;
9111         }
9112         default:
9113             FIXME("Unhandled sType %u.\n", in_header->sType);
9114             break;
9115         }
9116     }
9117 }
9118
9119 static inline void convert_VkBufferViewCreateInfo_win32_to_host(const VkBufferViewCreateInfo32 *in, VkBufferViewCreateInfo *out)
9120 {
9121     if (!in) return;
9122
9123     out->sType = in->sType;
9124     out->pNext = NULL;
9125     out->flags = in->flags;
9126     out->buffer = in->buffer;
9127     out->format = in->format;
9128     out->offset = in->offset;
9129     out->range = in->range;
9130     if (in->pNext)
9131         FIXME("Unexpected pNext\n");
9132 }
9133
9134 static inline void convert_VkCommandPoolCreateInfo_win32_to_host(const VkCommandPoolCreateInfo32 *in, VkCommandPoolCreateInfo *out)
9135 {
9136     if (!in) return;
9137
9138     out->sType = in->sType;
9139     out->pNext = NULL;
9140     out->flags = in->flags;
9141     out->queueFamilyIndex = in->queueFamilyIndex;
9142     if (in->pNext)
9143         FIXME("Unexpected pNext\n");
9144 }
9145
9146 static inline void convert_VkPipelineCreationFeedback_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out)
9147 {
9148     if (!in) return;
9149
9150     out->flags = in->flags;
9151     out->duration = in->duration;
9152 }
9153
9154 static inline VkPipelineCreationFeedback *convert_VkPipelineCreationFeedback_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreationFeedback32 *in, uint32_t count)
9155 {
9156     VkPipelineCreationFeedback *out;
9157     if (!in || !count) return NULL;
9158
9159     out = conversion_context_alloc(ctx, count * sizeof(*out));
9160
9161     return out;
9162 }
9163
9164 static inline void convert_VkPipelineCreationFeedback_array_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out, uint32_t count)
9165 {
9166     unsigned int i;
9167
9168     if (!in) return;
9169
9170     for (i = 0; i < count; i++)
9171     {
9172         convert_VkPipelineCreationFeedback_host_to_win32(&in[i], &out[i]);
9173     }
9174 }
9175
9176 static inline void convert_VkSpecializationMapEntry_win32_to_host(const VkSpecializationMapEntry32 *in, VkSpecializationMapEntry *out)
9177 {
9178     if (!in) return;
9179
9180     out->constantID = in->constantID;
9181     out->offset = in->offset;
9182     out->size = in->size;
9183 }
9184
9185 static inline const VkSpecializationMapEntry *convert_VkSpecializationMapEntry_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationMapEntry32 *in, uint32_t count)
9186 {
9187     VkSpecializationMapEntry *out;
9188     unsigned int i;
9189
9190     if (!in || !count) return NULL;
9191
9192     out = conversion_context_alloc(ctx, count * sizeof(*out));
9193     for (i = 0; i < count; i++)
9194     {
9195         convert_VkSpecializationMapEntry_win32_to_host(&in[i], &out[i]);
9196     }
9197
9198     return out;
9199 }
9200
9201 static inline void convert_VkSpecializationInfo_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, VkSpecializationInfo *out)
9202 {
9203     if (!in) return;
9204
9205     out->mapEntryCount = in->mapEntryCount;
9206     out->pMapEntries = convert_VkSpecializationMapEntry_array_win32_to_host(ctx, (const VkSpecializationMapEntry32 *)UlongToPtr(in->pMapEntries), in->mapEntryCount);
9207     out->dataSize = in->dataSize;
9208     out->pData = (const void *)UlongToPtr(in->pData);
9209 }
9210
9211 static inline const VkSpecializationInfo *convert_VkSpecializationInfo_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, uint32_t count)
9212 {
9213     VkSpecializationInfo *out;
9214     unsigned int i;
9215
9216     if (!in || !count) return NULL;
9217
9218     out = conversion_context_alloc(ctx, count * sizeof(*out));
9219     for (i = 0; i < count; i++)
9220     {
9221         convert_VkSpecializationInfo_win32_to_host(ctx, &in[i], &out[i]);
9222     }
9223
9224     return out;
9225 }
9226
9227 #ifdef _WIN64
9228 static inline void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo *out)
9229 {
9230     const VkBaseInStructure *in_header;
9231     VkBaseOutStructure *out_header = (void *)out;
9232
9233     if (!in) return;
9234
9235     out->sType = in->sType;
9236     out->pNext = NULL;
9237     out->flags = in->flags;
9238     out->stage = in->stage;
9239     out->module = in->module;
9240     out->pName = in->pName;
9241     out->pSpecializationInfo = in->pSpecializationInfo;
9242
9243     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
9244     {
9245         switch (in_header->sType)
9246         {
9247         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
9248         {
9249             VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9250             const VkShaderModuleCreateInfo *in_ext = (const VkShaderModuleCreateInfo *)in_header;
9251             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
9252             out_ext->pNext = NULL;
9253             out_ext->flags = in_ext->flags;
9254             out_ext->codeSize = in_ext->codeSize;
9255             out_ext->pCode = in_ext->pCode;
9256             out_header->pNext = (void *)out_ext;
9257             out_header = (void *)out_ext;
9258             break;
9259         }
9260         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
9261         {
9262             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9263             const VkShaderModuleValidationCacheCreateInfoEXT *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT *)in_header;
9264             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
9265             out_ext->pNext = NULL;
9266             out_ext->validationCache = in_ext->validationCache;
9267             out_header->pNext = (void *)out_ext;
9268             out_header = (void *)out_ext;
9269             break;
9270         }
9271         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
9272         {
9273             VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9274             const VkDebugUtilsObjectNameInfoEXT *in_ext = (const VkDebugUtilsObjectNameInfoEXT *)in_header;
9275             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
9276             out_ext->pNext = NULL;
9277             out_ext->objectType = in_ext->objectType;
9278             out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
9279             out_ext->pObjectName = in_ext->pObjectName;
9280             out_header->pNext = (void *)out_ext;
9281             out_header = (void *)out_ext;
9282             break;
9283         }
9284         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
9285         {
9286             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9287             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)in_header;
9288             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
9289             out_ext->pNext = NULL;
9290             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
9291             out_header->pNext = (void *)out_ext;
9292             out_header = (void *)out_ext;
9293             break;
9294         }
9295         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
9296         {
9297             VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9298             const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *)in_header;
9299             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
9300             out_ext->pNext = NULL;
9301             out_ext->identifierSize = in_ext->identifierSize;
9302             out_ext->pIdentifier = in_ext->pIdentifier;
9303             out_header->pNext = (void *)out_ext;
9304             out_header = (void *)out_ext;
9305             break;
9306         }
9307         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
9308         {
9309             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9310             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
9311             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
9312             out_ext->pNext = NULL;
9313             out_ext->storageBuffers = in_ext->storageBuffers;
9314             out_ext->uniformBuffers = in_ext->uniformBuffers;
9315             out_ext->vertexInputs = in_ext->vertexInputs;
9316             out_ext->images = in_ext->images;
9317             out_header->pNext = (void *)out_ext;
9318             out_header = (void *)out_ext;
9319             break;
9320         }
9321         default:
9322             FIXME("Unhandled sType %u.\n", in_header->sType);
9323             break;
9324         }
9325     }
9326 }
9327 #endif /* _WIN64 */
9328
9329 static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, VkPipelineShaderStageCreateInfo *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->flags = in->flags;
9339     out->stage = in->stage;
9340     out->module = in->module;
9341     out->pName = (const char *)UlongToPtr(in->pName);
9342     out->pSpecializationInfo = convert_VkSpecializationInfo_array_win32_to_host(ctx, (const VkSpecializationInfo32 *)UlongToPtr(in->pSpecializationInfo), 1);
9343
9344     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9345     {
9346         switch (in_header->sType)
9347         {
9348         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
9349         {
9350             VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9351             const VkShaderModuleCreateInfo32 *in_ext = (const VkShaderModuleCreateInfo32 *)in_header;
9352             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
9353             out_ext->pNext = NULL;
9354             out_ext->flags = in_ext->flags;
9355             out_ext->codeSize = in_ext->codeSize;
9356             out_ext->pCode = (const uint32_t *)UlongToPtr(in_ext->pCode);
9357             out_header->pNext = (void *)out_ext;
9358             out_header = (void *)out_ext;
9359             break;
9360         }
9361         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
9362         {
9363             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9364             const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
9365             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
9366             out_ext->pNext = NULL;
9367             out_ext->validationCache = in_ext->validationCache;
9368             out_header->pNext = (void *)out_ext;
9369             out_header = (void *)out_ext;
9370             break;
9371         }
9372         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
9373         {
9374             VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9375             const VkDebugUtilsObjectNameInfoEXT32 *in_ext = (const VkDebugUtilsObjectNameInfoEXT32 *)in_header;
9376             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
9377             out_ext->pNext = NULL;
9378             out_ext->objectType = in_ext->objectType;
9379             out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
9380             out_ext->pObjectName = (const char *)UlongToPtr(in_ext->pObjectName);
9381             out_header->pNext = (void *)out_ext;
9382             out_header = (void *)out_ext;
9383             break;
9384         }
9385         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
9386         {
9387             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9388             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *)in_header;
9389             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
9390             out_ext->pNext = NULL;
9391             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
9392             out_header->pNext = (void *)out_ext;
9393             out_header = (void *)out_ext;
9394             break;
9395         }
9396         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
9397         {
9398             VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9399             const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *)in_header;
9400             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
9401             out_ext->pNext = NULL;
9402             out_ext->identifierSize = in_ext->identifierSize;
9403             out_ext->pIdentifier = (const uint8_t *)UlongToPtr(in_ext->pIdentifier);
9404             out_header->pNext = (void *)out_ext;
9405             out_header = (void *)out_ext;
9406             break;
9407         }
9408         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
9409         {
9410             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9411             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
9412             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
9413             out_ext->pNext = NULL;
9414             out_ext->storageBuffers = in_ext->storageBuffers;
9415             out_ext->uniformBuffers = in_ext->uniformBuffers;
9416             out_ext->vertexInputs = in_ext->vertexInputs;
9417             out_ext->images = in_ext->images;
9418             out_header->pNext = (void *)out_ext;
9419             out_header = (void *)out_ext;
9420             break;
9421         }
9422         default:
9423             FIXME("Unhandled sType %u.\n", in_header->sType);
9424             break;
9425         }
9426     }
9427 }
9428
9429 #ifdef _WIN64
9430 static inline void convert_VkComputePipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, VkComputePipelineCreateInfo *out)
9431 {
9432     if (!in) return;
9433
9434     out->sType = in->sType;
9435     out->pNext = in->pNext;
9436     out->flags = in->flags;
9437     convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in->stage, &out->stage);
9438     out->layout = in->layout;
9439     out->basePipelineHandle = in->basePipelineHandle;
9440     out->basePipelineIndex = in->basePipelineIndex;
9441 }
9442 #endif /* _WIN64 */
9443
9444 static inline void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, VkComputePipelineCreateInfo *out)
9445 {
9446     const VkBaseInStructure32 *in_header;
9447     VkBaseOutStructure *out_header = (void *)out;
9448
9449     if (!in) return;
9450
9451     out->sType = in->sType;
9452     out->pNext = NULL;
9453     out->flags = in->flags;
9454     convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in->stage, &out->stage);
9455     out->layout = in->layout;
9456     out->basePipelineHandle = in->basePipelineHandle;
9457     out->basePipelineIndex = in->basePipelineIndex;
9458
9459     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9460     {
9461         switch (in_header->sType)
9462         {
9463         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
9464         {
9465             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9466             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
9467             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
9468             out_ext->pNext = NULL;
9469             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
9470             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
9471             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
9472             out_header->pNext = (void *)out_ext;
9473             out_header = (void *)out_ext;
9474             break;
9475         }
9476         case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
9477         {
9478             VkSubpassShadingPipelineCreateInfoHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9479             const VkSubpassShadingPipelineCreateInfoHUAWEI32 *in_ext = (const VkSubpassShadingPipelineCreateInfoHUAWEI32 *)in_header;
9480             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI;
9481             out_ext->pNext = NULL;
9482             out_ext->renderPass = in_ext->renderPass;
9483             out_ext->subpass = in_ext->subpass;
9484             out_header->pNext = (void *)out_ext;
9485             out_header = (void *)out_ext;
9486             break;
9487         }
9488         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
9489         {
9490             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9491             const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header;
9492             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
9493             out_ext->pNext = NULL;
9494             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
9495             out_header->pNext = (void *)out_ext;
9496             out_header = (void *)out_ext;
9497             break;
9498         }
9499         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
9500         {
9501             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9502             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
9503             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
9504             out_ext->pNext = NULL;
9505             out_ext->storageBuffers = in_ext->storageBuffers;
9506             out_ext->uniformBuffers = in_ext->uniformBuffers;
9507             out_ext->vertexInputs = in_ext->vertexInputs;
9508             out_ext->images = in_ext->images;
9509             out_header->pNext = (void *)out_ext;
9510             out_header = (void *)out_ext;
9511             break;
9512         }
9513         default:
9514             FIXME("Unhandled sType %u.\n", in_header->sType);
9515             break;
9516         }
9517     }
9518 }
9519
9520 static inline void convert_VkComputePipelineCreateInfo_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out)
9521 {
9522     const VkBaseInStructure *in_header;
9523     VkBaseOutStructure32 *out_header = (void *)out;
9524
9525     if (!in) return;
9526
9527
9528     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
9529     {
9530         switch (in_header->sType)
9531         {
9532         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
9533         {
9534             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
9535             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
9536             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
9537             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
9538             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
9539             out_header = (void *)out_ext;
9540             break;
9541         }
9542         default:
9543             break;
9544         }
9545     }
9546 }
9547
9548 #ifdef _WIN64
9549 static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, uint32_t count)
9550 {
9551     VkComputePipelineCreateInfo *out;
9552     unsigned int i;
9553
9554     if (!in || !count) return NULL;
9555
9556     out = conversion_context_alloc(ctx, count * sizeof(*out));
9557     for (i = 0; i < count; i++)
9558     {
9559         convert_VkComputePipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
9560     }
9561
9562     return out;
9563 }
9564 #endif /* _WIN64 */
9565
9566 static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, uint32_t count)
9567 {
9568     VkComputePipelineCreateInfo *out;
9569     unsigned int i;
9570
9571     if (!in || !count) return NULL;
9572
9573     out = conversion_context_alloc(ctx, count * sizeof(*out));
9574     for (i = 0; i < count; i++)
9575     {
9576         convert_VkComputePipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
9577     }
9578
9579     return out;
9580 }
9581
9582 static inline void convert_VkComputePipelineCreateInfo_array_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out, uint32_t count)
9583 {
9584     unsigned int i;
9585
9586     if (!in) return;
9587
9588     for (i = 0; i < count; i++)
9589     {
9590         convert_VkComputePipelineCreateInfo_host_to_win32(&in[i], &out[i]);
9591     }
9592 }
9593
9594 static inline void convert_VkCuFunctionCreateInfoNVX_win32_to_host(const VkCuFunctionCreateInfoNVX32 *in, VkCuFunctionCreateInfoNVX *out)
9595 {
9596     if (!in) return;
9597
9598     out->sType = in->sType;
9599     out->pNext = NULL;
9600     out->module = in->module;
9601     out->pName = (const char *)UlongToPtr(in->pName);
9602     if (in->pNext)
9603         FIXME("Unexpected pNext\n");
9604 }
9605
9606 static inline void convert_VkCuModuleCreateInfoNVX_win32_to_host(const VkCuModuleCreateInfoNVX32 *in, VkCuModuleCreateInfoNVX *out)
9607 {
9608     if (!in) return;
9609
9610     out->sType = in->sType;
9611     out->pNext = NULL;
9612     out->dataSize = in->dataSize;
9613     out->pData = (const void *)UlongToPtr(in->pData);
9614     if (in->pNext)
9615         FIXME("Unexpected pNext\n");
9616 }
9617
9618 static inline void convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(const VkDebugReportCallbackCreateInfoEXT32 *in, VkDebugReportCallbackCreateInfoEXT *out)
9619 {
9620     if (!in) return;
9621
9622     out->sType = in->sType;
9623     out->pNext = NULL;
9624     out->flags = in->flags;
9625     out->pfnCallback = in->pfnCallback;
9626     out->pUserData = (void *)UlongToPtr(in->pUserData);
9627     if (in->pNext)
9628         FIXME("Unexpected pNext\n");
9629 }
9630
9631 static inline void convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host(const VkDebugUtilsMessengerCreateInfoEXT32 *in, VkDebugUtilsMessengerCreateInfoEXT *out)
9632 {
9633     if (!in) return;
9634
9635     out->sType = in->sType;
9636     out->pNext = NULL;
9637     out->flags = in->flags;
9638     out->messageSeverity = in->messageSeverity;
9639     out->messageType = in->messageType;
9640     out->pfnUserCallback = in->pfnUserCallback;
9641     out->pUserData = (void *)UlongToPtr(in->pUserData);
9642     if (in->pNext)
9643         FIXME("Unexpected pNext\n");
9644 }
9645
9646 static inline void convert_VkMutableDescriptorTypeListEXT_win32_to_host(const VkMutableDescriptorTypeListEXT32 *in, VkMutableDescriptorTypeListEXT *out)
9647 {
9648     if (!in) return;
9649
9650     out->descriptorTypeCount = in->descriptorTypeCount;
9651     out->pDescriptorTypes = (const VkDescriptorType *)UlongToPtr(in->pDescriptorTypes);
9652 }
9653
9654 static inline const VkMutableDescriptorTypeListEXT *convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(struct conversion_context *ctx, const VkMutableDescriptorTypeListEXT32 *in, uint32_t count)
9655 {
9656     VkMutableDescriptorTypeListEXT *out;
9657     unsigned int i;
9658
9659     if (!in || !count) return NULL;
9660
9661     out = conversion_context_alloc(ctx, count * sizeof(*out));
9662     for (i = 0; i < count; i++)
9663     {
9664         convert_VkMutableDescriptorTypeListEXT_win32_to_host(&in[i], &out[i]);
9665     }
9666
9667     return out;
9668 }
9669
9670 static inline void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorPoolCreateInfo32 *in, VkDescriptorPoolCreateInfo *out)
9671 {
9672     const VkBaseInStructure32 *in_header;
9673     VkBaseOutStructure *out_header = (void *)out;
9674
9675     if (!in) return;
9676
9677     out->sType = in->sType;
9678     out->pNext = NULL;
9679     out->flags = in->flags;
9680     out->maxSets = in->maxSets;
9681     out->poolSizeCount = in->poolSizeCount;
9682     out->pPoolSizes = (const VkDescriptorPoolSize *)UlongToPtr(in->pPoolSizes);
9683
9684     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9685     {
9686         switch (in_header->sType)
9687         {
9688         case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
9689         {
9690             VkDescriptorPoolInlineUniformBlockCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9691             const VkDescriptorPoolInlineUniformBlockCreateInfo32 *in_ext = (const VkDescriptorPoolInlineUniformBlockCreateInfo32 *)in_header;
9692             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
9693             out_ext->pNext = NULL;
9694             out_ext->maxInlineUniformBlockBindings = in_ext->maxInlineUniformBlockBindings;
9695             out_header->pNext = (void *)out_ext;
9696             out_header = (void *)out_ext;
9697             break;
9698         }
9699         case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
9700         {
9701             VkMutableDescriptorTypeCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9702             const VkMutableDescriptorTypeCreateInfoEXT32 *in_ext = (const VkMutableDescriptorTypeCreateInfoEXT32 *)in_header;
9703             out_ext->sType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
9704             out_ext->pNext = NULL;
9705             out_ext->mutableDescriptorTypeListCount = in_ext->mutableDescriptorTypeListCount;
9706             out_ext->pMutableDescriptorTypeLists = convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(ctx, (const VkMutableDescriptorTypeListEXT32 *)UlongToPtr(in_ext->pMutableDescriptorTypeLists), in_ext->mutableDescriptorTypeListCount);
9707             out_header->pNext = (void *)out_ext;
9708             out_header = (void *)out_ext;
9709             break;
9710         }
9711         default:
9712             FIXME("Unhandled sType %u.\n", in_header->sType);
9713             break;
9714         }
9715     }
9716 }
9717
9718 static inline void convert_VkDescriptorSetLayoutBinding_win32_to_host(const VkDescriptorSetLayoutBinding32 *in, VkDescriptorSetLayoutBinding *out)
9719 {
9720     if (!in) return;
9721
9722     out->binding = in->binding;
9723     out->descriptorType = in->descriptorType;
9724     out->descriptorCount = in->descriptorCount;
9725     out->stageFlags = in->stageFlags;
9726     out->pImmutableSamplers = (const VkSampler *)UlongToPtr(in->pImmutableSamplers);
9727 }
9728
9729 static inline const VkDescriptorSetLayoutBinding *convert_VkDescriptorSetLayoutBinding_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutBinding32 *in, uint32_t count)
9730 {
9731     VkDescriptorSetLayoutBinding *out;
9732     unsigned int i;
9733
9734     if (!in || !count) return NULL;
9735
9736     out = conversion_context_alloc(ctx, count * sizeof(*out));
9737     for (i = 0; i < count; i++)
9738     {
9739         convert_VkDescriptorSetLayoutBinding_win32_to_host(&in[i], &out[i]);
9740     }
9741
9742     return out;
9743 }
9744
9745 static inline void convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutCreateInfo32 *in, VkDescriptorSetLayoutCreateInfo *out)
9746 {
9747     const VkBaseInStructure32 *in_header;
9748     VkBaseOutStructure *out_header = (void *)out;
9749
9750     if (!in) return;
9751
9752     out->sType = in->sType;
9753     out->pNext = NULL;
9754     out->flags = in->flags;
9755     out->bindingCount = in->bindingCount;
9756     out->pBindings = convert_VkDescriptorSetLayoutBinding_array_win32_to_host(ctx, (const VkDescriptorSetLayoutBinding32 *)UlongToPtr(in->pBindings), in->bindingCount);
9757
9758     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9759     {
9760         switch (in_header->sType)
9761         {
9762         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
9763         {
9764             VkDescriptorSetLayoutBindingFlagsCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9765             const VkDescriptorSetLayoutBindingFlagsCreateInfo32 *in_ext = (const VkDescriptorSetLayoutBindingFlagsCreateInfo32 *)in_header;
9766             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
9767             out_ext->pNext = NULL;
9768             out_ext->bindingCount = in_ext->bindingCount;
9769             out_ext->pBindingFlags = (const VkDescriptorBindingFlags *)UlongToPtr(in_ext->pBindingFlags);
9770             out_header->pNext = (void *)out_ext;
9771             out_header = (void *)out_ext;
9772             break;
9773         }
9774         case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
9775         {
9776             VkMutableDescriptorTypeCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9777             const VkMutableDescriptorTypeCreateInfoEXT32 *in_ext = (const VkMutableDescriptorTypeCreateInfoEXT32 *)in_header;
9778             out_ext->sType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
9779             out_ext->pNext = NULL;
9780             out_ext->mutableDescriptorTypeListCount = in_ext->mutableDescriptorTypeListCount;
9781             out_ext->pMutableDescriptorTypeLists = convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(ctx, (const VkMutableDescriptorTypeListEXT32 *)UlongToPtr(in_ext->pMutableDescriptorTypeLists), in_ext->mutableDescriptorTypeListCount);
9782             out_header->pNext = (void *)out_ext;
9783             out_header = (void *)out_ext;
9784             break;
9785         }
9786         default:
9787             FIXME("Unhandled sType %u.\n", in_header->sType);
9788             break;
9789         }
9790     }
9791 }
9792
9793 static inline void convert_VkDescriptorUpdateTemplateEntry_win32_to_host(const VkDescriptorUpdateTemplateEntry32 *in, VkDescriptorUpdateTemplateEntry *out)
9794 {
9795     if (!in) return;
9796
9797     out->dstBinding = in->dstBinding;
9798     out->dstArrayElement = in->dstArrayElement;
9799     out->descriptorCount = in->descriptorCount;
9800     out->descriptorType = in->descriptorType;
9801     out->offset = in->offset;
9802     out->stride = in->stride;
9803 }
9804
9805 static inline const VkDescriptorUpdateTemplateEntry *convert_VkDescriptorUpdateTemplateEntry_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateEntry32 *in, uint32_t count)
9806 {
9807     VkDescriptorUpdateTemplateEntry *out;
9808     unsigned int i;
9809
9810     if (!in || !count) return NULL;
9811
9812     out = conversion_context_alloc(ctx, count * sizeof(*out));
9813     for (i = 0; i < count; i++)
9814     {
9815         convert_VkDescriptorUpdateTemplateEntry_win32_to_host(&in[i], &out[i]);
9816     }
9817
9818     return out;
9819 }
9820
9821 static inline void convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateCreateInfo32 *in, VkDescriptorUpdateTemplateCreateInfo *out)
9822 {
9823     if (!in) return;
9824
9825     out->sType = in->sType;
9826     out->pNext = NULL;
9827     out->flags = in->flags;
9828     out->descriptorUpdateEntryCount = in->descriptorUpdateEntryCount;
9829     out->pDescriptorUpdateEntries = convert_VkDescriptorUpdateTemplateEntry_array_win32_to_host(ctx, (const VkDescriptorUpdateTemplateEntry32 *)UlongToPtr(in->pDescriptorUpdateEntries), in->descriptorUpdateEntryCount);
9830     out->templateType = in->templateType;
9831     out->descriptorSetLayout = in->descriptorSetLayout;
9832     out->pipelineBindPoint = in->pipelineBindPoint;
9833     out->pipelineLayout = in->pipelineLayout;
9834     out->set = in->set;
9835     if (in->pNext)
9836         FIXME("Unexpected pNext\n");
9837 }
9838
9839 #ifdef _WIN64
9840 static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win64_to_host(struct conversion_context *ctx, const VkPhysicalDevice *in, uint32_t count)
9841 {
9842     VkPhysicalDevice *out;
9843     unsigned int i;
9844
9845     if (!in || !count) return NULL;
9846
9847     out = conversion_context_alloc(ctx, count * sizeof(*out));
9848     for (i = 0; i < count; i++)
9849     {
9850         out[i] = wine_phys_dev_from_handle(in[i])->phys_dev;
9851     }
9852
9853     return out;
9854 }
9855 #endif /* _WIN64 */
9856
9857 static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
9858 {
9859     VkPhysicalDevice *out;
9860     unsigned int i;
9861
9862     if (!in || !count) return NULL;
9863
9864     out = conversion_context_alloc(ctx, count * sizeof(*out));
9865     for (i = 0; i < count; i++)
9866     {
9867         out[i] = wine_phys_dev_from_handle(UlongToPtr(in[i]))->phys_dev;
9868     }
9869
9870     return out;
9871 }
9872
9873 static inline void convert_VkDeviceQueueCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, VkDeviceQueueCreateInfo *out)
9874 {
9875     const VkBaseInStructure32 *in_header;
9876     VkBaseOutStructure *out_header = (void *)out;
9877
9878     if (!in) return;
9879
9880     out->sType = in->sType;
9881     out->pNext = NULL;
9882     out->flags = in->flags;
9883     out->queueFamilyIndex = in->queueFamilyIndex;
9884     out->queueCount = in->queueCount;
9885     out->pQueuePriorities = (const float *)UlongToPtr(in->pQueuePriorities);
9886
9887     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9888     {
9889         switch (in_header->sType)
9890         {
9891         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
9892         {
9893             VkDeviceQueueGlobalPriorityCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9894             const VkDeviceQueueGlobalPriorityCreateInfoKHR32 *in_ext = (const VkDeviceQueueGlobalPriorityCreateInfoKHR32 *)in_header;
9895             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR;
9896             out_ext->pNext = NULL;
9897             out_ext->globalPriority = in_ext->globalPriority;
9898             out_header->pNext = (void *)out_ext;
9899             out_header = (void *)out_ext;
9900             break;
9901         }
9902         default:
9903             FIXME("Unhandled sType %u.\n", in_header->sType);
9904             break;
9905         }
9906     }
9907 }
9908
9909 static inline const VkDeviceQueueCreateInfo *convert_VkDeviceQueueCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, uint32_t count)
9910 {
9911     VkDeviceQueueCreateInfo *out;
9912     unsigned int i;
9913
9914     if (!in || !count) return NULL;
9915
9916     out = conversion_context_alloc(ctx, count * sizeof(*out));
9917     for (i = 0; i < count; i++)
9918     {
9919         convert_VkDeviceQueueCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
9920     }
9921
9922     return out;
9923 }
9924
9925 static inline const char * const*convert_char_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
9926 {
9927     char **out;
9928     unsigned int i;
9929
9930     if (!in || !count) return NULL;
9931
9932     out = conversion_context_alloc(ctx, count * sizeof(*out));
9933     for (i = 0; i < count; i++)
9934     {
9935         out[i] = UlongToPtr(in[i]);
9936     }
9937
9938     return (void *)out;
9939 }
9940
9941 #ifdef _WIN64
9942 static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo *in, VkDeviceCreateInfo *out)
9943 {
9944     const VkBaseInStructure *in_header;
9945     VkBaseOutStructure *out_header = (void *)out;
9946
9947     if (!in) return;
9948
9949     out->sType = in->sType;
9950     out->pNext = NULL;
9951     out->flags = in->flags;
9952     out->queueCreateInfoCount = in->queueCreateInfoCount;
9953     out->pQueueCreateInfos = in->pQueueCreateInfos;
9954     out->enabledLayerCount = in->enabledLayerCount;
9955     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
9956     out->enabledExtensionCount = in->enabledExtensionCount;
9957     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
9958     out->pEnabledFeatures = in->pEnabledFeatures;
9959
9960     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
9961     {
9962         switch (in_header->sType)
9963         {
9964         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
9965             break;
9966         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
9967         {
9968             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9969             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
9970             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
9971             out_ext->pNext = NULL;
9972             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
9973             out_header->pNext = (void *)out_ext;
9974             out_header = (void *)out_ext;
9975             break;
9976         }
9977         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
9978         {
9979             VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9980             const VkDevicePrivateDataCreateInfo *in_ext = (const VkDevicePrivateDataCreateInfo *)in_header;
9981             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
9982             out_ext->pNext = NULL;
9983             out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
9984             out_header->pNext = (void *)out_ext;
9985             out_header = (void *)out_ext;
9986             break;
9987         }
9988         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
9989         {
9990             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9991             const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
9992             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
9993             out_ext->pNext = NULL;
9994             out_ext->privateData = in_ext->privateData;
9995             out_header->pNext = (void *)out_ext;
9996             out_header = (void *)out_ext;
9997             break;
9998         }
9999         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
10000         {
10001             VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10002             const VkPhysicalDeviceFeatures2 *in_ext = (const VkPhysicalDeviceFeatures2 *)in_header;
10003             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
10004             out_ext->pNext = NULL;
10005             out_ext->features = in_ext->features;
10006             out_header->pNext = (void *)out_ext;
10007             out_header = (void *)out_ext;
10008             break;
10009         }
10010         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
10011         {
10012             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10013             const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
10014             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
10015             out_ext->pNext = NULL;
10016             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
10017             out_ext->variablePointers = in_ext->variablePointers;
10018             out_header->pNext = (void *)out_ext;
10019             out_header = (void *)out_ext;
10020             break;
10021         }
10022         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
10023         {
10024             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10025             const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
10026             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
10027             out_ext->pNext = NULL;
10028             out_ext->multiview = in_ext->multiview;
10029             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
10030             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
10031             out_header->pNext = (void *)out_ext;
10032             out_header = (void *)out_ext;
10033             break;
10034         }
10035         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
10036         {
10037             VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10038             const VkDeviceGroupDeviceCreateInfo *in_ext = (const VkDeviceGroupDeviceCreateInfo *)in_header;
10039             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
10040             out_ext->pNext = NULL;
10041             out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
10042             out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win64_to_host(ctx, in_ext->pPhysicalDevices, in_ext->physicalDeviceCount);
10043             out_header->pNext = (void *)out_ext;
10044             out_header = (void *)out_ext;
10045             break;
10046         }
10047         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
10048         {
10049             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10050             const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
10051             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
10052             out_ext->pNext = NULL;
10053             out_ext->presentId = in_ext->presentId;
10054             out_header->pNext = (void *)out_ext;
10055             out_header = (void *)out_ext;
10056             break;
10057         }
10058         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
10059         {
10060             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10061             const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
10062             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
10063             out_ext->pNext = NULL;
10064             out_ext->presentWait = in_ext->presentWait;
10065             out_header->pNext = (void *)out_ext;
10066             out_header = (void *)out_ext;
10067             break;
10068         }
10069         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
10070         {
10071             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10072             const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
10073             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
10074             out_ext->pNext = NULL;
10075             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
10076             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
10077             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
10078             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
10079             out_header->pNext = (void *)out_ext;
10080             out_header = (void *)out_ext;
10081             break;
10082         }
10083         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
10084         {
10085             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10086             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
10087             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
10088             out_ext->pNext = NULL;
10089             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
10090             out_header->pNext = (void *)out_ext;
10091             out_header = (void *)out_ext;
10092             break;
10093         }
10094         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
10095         {
10096             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10097             const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
10098             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
10099             out_ext->pNext = NULL;
10100             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
10101             out_header->pNext = (void *)out_ext;
10102             out_header = (void *)out_ext;
10103             break;
10104         }
10105         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
10106         {
10107             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10108             const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
10109             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
10110             out_ext->pNext = NULL;
10111             out_ext->protectedMemory = in_ext->protectedMemory;
10112             out_header->pNext = (void *)out_ext;
10113             out_header = (void *)out_ext;
10114             break;
10115         }
10116         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
10117         {
10118             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10119             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
10120             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
10121             out_ext->pNext = NULL;
10122             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
10123             out_header->pNext = (void *)out_ext;
10124             out_header = (void *)out_ext;
10125             break;
10126         }
10127         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
10128         {
10129             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10130             const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
10131             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
10132             out_ext->pNext = NULL;
10133             out_ext->multiDraw = in_ext->multiDraw;
10134             out_header->pNext = (void *)out_ext;
10135             out_header = (void *)out_ext;
10136             break;
10137         }
10138         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
10139         {
10140             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10141             const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
10142             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
10143             out_ext->pNext = NULL;
10144             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
10145             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
10146             out_header->pNext = (void *)out_ext;
10147             out_header = (void *)out_ext;
10148             break;
10149         }
10150         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
10151         {
10152             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10153             const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
10154             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
10155             out_ext->pNext = NULL;
10156             out_ext->maintenance4 = in_ext->maintenance4;
10157             out_header->pNext = (void *)out_ext;
10158             out_header = (void *)out_ext;
10159             break;
10160         }
10161         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
10162         {
10163             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10164             const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
10165             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
10166             out_ext->pNext = NULL;
10167             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
10168             out_header->pNext = (void *)out_ext;
10169             out_header = (void *)out_ext;
10170             break;
10171         }
10172         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
10173         {
10174             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10175             const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
10176             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
10177             out_ext->pNext = NULL;
10178             out_ext->shaderFloat16 = in_ext->shaderFloat16;
10179             out_ext->shaderInt8 = in_ext->shaderInt8;
10180             out_header->pNext = (void *)out_ext;
10181             out_header = (void *)out_ext;
10182             break;
10183         }
10184         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
10185         {
10186             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10187             const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
10188             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
10189             out_ext->pNext = NULL;
10190             out_ext->hostQueryReset = in_ext->hostQueryReset;
10191             out_header->pNext = (void *)out_ext;
10192             out_header = (void *)out_ext;
10193             break;
10194         }
10195         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
10196         {
10197             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10198             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *)in_header;
10199             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
10200             out_ext->pNext = NULL;
10201             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
10202             out_header->pNext = (void *)out_ext;
10203             out_header = (void *)out_ext;
10204             break;
10205         }
10206         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
10207         {
10208             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10209             const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
10210             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
10211             out_ext->pNext = NULL;
10212             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
10213             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
10214             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
10215             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
10216             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
10217             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
10218             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
10219             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
10220             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
10221             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
10222             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
10223             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
10224             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
10225             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
10226             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
10227             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
10228             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
10229             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
10230             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
10231             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
10232             out_header->pNext = (void *)out_ext;
10233             out_header = (void *)out_ext;
10234             break;
10235         }
10236         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
10237         {
10238             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10239             const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
10240             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
10241             out_ext->pNext = NULL;
10242             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
10243             out_header->pNext = (void *)out_ext;
10244             out_header = (void *)out_ext;
10245             break;
10246         }
10247         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
10248         {
10249             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10250             const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
10251             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
10252             out_ext->pNext = NULL;
10253             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
10254             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
10255             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
10256             out_header->pNext = (void *)out_ext;
10257             out_header = (void *)out_ext;
10258             break;
10259         }
10260         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
10261         {
10262             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10263             const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
10264             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
10265             out_ext->pNext = NULL;
10266             out_ext->conditionalRendering = in_ext->conditionalRendering;
10267             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
10268             out_header->pNext = (void *)out_ext;
10269             out_header = (void *)out_ext;
10270             break;
10271         }
10272         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
10273         {
10274             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10275             const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
10276             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
10277             out_ext->pNext = NULL;
10278             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
10279             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
10280             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
10281             out_header->pNext = (void *)out_ext;
10282             out_header = (void *)out_ext;
10283             break;
10284         }
10285         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
10286         {
10287             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10288             const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
10289             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
10290             out_ext->pNext = NULL;
10291             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
10292             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
10293             out_header->pNext = (void *)out_ext;
10294             out_header = (void *)out_ext;
10295             break;
10296         }
10297         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
10298         {
10299             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10300             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
10301             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
10302             out_ext->pNext = NULL;
10303             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
10304             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
10305             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
10306             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
10307             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
10308             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
10309             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
10310             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
10311             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
10312             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
10313             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
10314             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
10315             out_header->pNext = (void *)out_ext;
10316             out_header = (void *)out_ext;
10317             break;
10318         }
10319         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
10320         {
10321             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10322             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
10323             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
10324             out_ext->pNext = NULL;
10325             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
10326             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
10327             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
10328             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
10329             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
10330             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
10331             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
10332             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
10333             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
10334             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
10335             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
10336             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
10337             out_header->pNext = (void *)out_ext;
10338             out_header = (void *)out_ext;
10339             break;
10340         }
10341         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
10342         {
10343             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10344             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header;
10345             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
10346             out_ext->pNext = NULL;
10347             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
10348             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
10349             out_header->pNext = (void *)out_ext;
10350             out_header = (void *)out_ext;
10351             break;
10352         }
10353         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
10354         {
10355             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10356             const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
10357             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
10358             out_ext->pNext = NULL;
10359             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
10360             out_header->pNext = (void *)out_ext;
10361             out_header = (void *)out_ext;
10362             break;
10363         }
10364         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
10365         {
10366             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10367             const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
10368             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
10369             out_ext->pNext = NULL;
10370             out_ext->transformFeedback = in_ext->transformFeedback;
10371             out_ext->geometryStreams = in_ext->geometryStreams;
10372             out_header->pNext = (void *)out_ext;
10373             out_header = (void *)out_ext;
10374             break;
10375         }
10376         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
10377         {
10378             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10379             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
10380             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
10381             out_ext->pNext = NULL;
10382             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
10383             out_header->pNext = (void *)out_ext;
10384             out_header = (void *)out_ext;
10385             break;
10386         }
10387         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
10388         {
10389             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10390             const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
10391             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
10392             out_ext->pNext = NULL;
10393             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
10394             out_header->pNext = (void *)out_ext;
10395             out_header = (void *)out_ext;
10396             break;
10397         }
10398         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
10399         {
10400             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10401             const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
10402             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
10403             out_ext->pNext = NULL;
10404             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
10405             out_header->pNext = (void *)out_ext;
10406             out_header = (void *)out_ext;
10407             break;
10408         }
10409         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
10410         {
10411             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10412             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header;
10413             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
10414             out_ext->pNext = NULL;
10415             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
10416             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
10417             out_header->pNext = (void *)out_ext;
10418             out_header = (void *)out_ext;
10419             break;
10420         }
10421         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
10422         {
10423             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10424             const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
10425             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
10426             out_ext->pNext = NULL;
10427             out_ext->imageFootprint = in_ext->imageFootprint;
10428             out_header->pNext = (void *)out_ext;
10429             out_header = (void *)out_ext;
10430             break;
10431         }
10432         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
10433         {
10434             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10435             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
10436             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
10437             out_ext->pNext = NULL;
10438             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
10439             out_header->pNext = (void *)out_ext;
10440             out_header = (void *)out_ext;
10441             break;
10442         }
10443         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
10444         {
10445             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10446             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
10447             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
10448             out_ext->pNext = NULL;
10449             out_ext->indirectCopy = in_ext->indirectCopy;
10450             out_header->pNext = (void *)out_ext;
10451             out_header = (void *)out_ext;
10452             break;
10453         }
10454         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
10455         {
10456             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10457             const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
10458             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
10459             out_ext->pNext = NULL;
10460             out_ext->memoryDecompression = in_ext->memoryDecompression;
10461             out_header->pNext = (void *)out_ext;
10462             out_header = (void *)out_ext;
10463             break;
10464         }
10465         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
10466         {
10467             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10468             const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
10469             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
10470             out_ext->pNext = NULL;
10471             out_ext->shadingRateImage = in_ext->shadingRateImage;
10472             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
10473             out_header->pNext = (void *)out_ext;
10474             out_header = (void *)out_ext;
10475             break;
10476         }
10477         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
10478         {
10479             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10480             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
10481             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
10482             out_ext->pNext = NULL;
10483             out_ext->invocationMask = in_ext->invocationMask;
10484             out_header->pNext = (void *)out_ext;
10485             out_header = (void *)out_ext;
10486             break;
10487         }
10488         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
10489         {
10490             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10491             const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
10492             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
10493             out_ext->pNext = NULL;
10494             out_ext->taskShader = in_ext->taskShader;
10495             out_ext->meshShader = in_ext->meshShader;
10496             out_header->pNext = (void *)out_ext;
10497             out_header = (void *)out_ext;
10498             break;
10499         }
10500         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
10501         {
10502             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10503             const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
10504             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
10505             out_ext->pNext = NULL;
10506             out_ext->taskShader = in_ext->taskShader;
10507             out_ext->meshShader = in_ext->meshShader;
10508             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
10509             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
10510             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
10511             out_header->pNext = (void *)out_ext;
10512             out_header = (void *)out_ext;
10513             break;
10514         }
10515         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
10516         {
10517             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10518             const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
10519             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
10520             out_ext->pNext = NULL;
10521             out_ext->accelerationStructure = in_ext->accelerationStructure;
10522             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
10523             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
10524             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
10525             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
10526             out_header->pNext = (void *)out_ext;
10527             out_header = (void *)out_ext;
10528             break;
10529         }
10530         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
10531         {
10532             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10533             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
10534             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
10535             out_ext->pNext = NULL;
10536             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
10537             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
10538             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
10539             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
10540             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
10541             out_header->pNext = (void *)out_ext;
10542             out_header = (void *)out_ext;
10543             break;
10544         }
10545         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
10546         {
10547             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10548             const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
10549             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
10550             out_ext->pNext = NULL;
10551             out_ext->rayQuery = in_ext->rayQuery;
10552             out_header->pNext = (void *)out_ext;
10553             out_header = (void *)out_ext;
10554             break;
10555         }
10556         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
10557         {
10558             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10559             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
10560             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
10561             out_ext->pNext = NULL;
10562             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
10563             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
10564             out_header->pNext = (void *)out_ext;
10565             out_header = (void *)out_ext;
10566             break;
10567         }
10568         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
10569         {
10570             VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10571             const VkDeviceMemoryOverallocationCreateInfoAMD *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD *)in_header;
10572             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
10573             out_ext->pNext = NULL;
10574             out_ext->overallocationBehavior = in_ext->overallocationBehavior;
10575             out_header->pNext = (void *)out_ext;
10576             out_header = (void *)out_ext;
10577             break;
10578         }
10579         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
10580         {
10581             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10582             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
10583             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
10584             out_ext->pNext = NULL;
10585             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
10586             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
10587             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
10588             out_header->pNext = (void *)out_ext;
10589             out_header = (void *)out_ext;
10590             break;
10591         }
10592         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
10593         {
10594             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10595             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
10596             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
10597             out_ext->pNext = NULL;
10598             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
10599             out_header->pNext = (void *)out_ext;
10600             out_header = (void *)out_ext;
10601             break;
10602         }
10603         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
10604         {
10605             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10606             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *)in_header;
10607             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
10608             out_ext->pNext = NULL;
10609             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
10610             out_header->pNext = (void *)out_ext;
10611             out_header = (void *)out_ext;
10612             break;
10613         }
10614         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
10615         {
10616             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10617             const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
10618             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
10619             out_ext->pNext = NULL;
10620             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
10621             out_header->pNext = (void *)out_ext;
10622             out_header = (void *)out_ext;
10623             break;
10624         }
10625         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
10626         {
10627             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10628             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
10629             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
10630             out_ext->pNext = NULL;
10631             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
10632             out_header->pNext = (void *)out_ext;
10633             out_header = (void *)out_ext;
10634             break;
10635         }
10636         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
10637         {
10638             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10639             const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
10640             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
10641             out_ext->pNext = NULL;
10642             out_ext->depthClipEnable = in_ext->depthClipEnable;
10643             out_header->pNext = (void *)out_ext;
10644             out_header = (void *)out_ext;
10645             break;
10646         }
10647         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
10648         {
10649             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10650             const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
10651             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
10652             out_ext->pNext = NULL;
10653             out_ext->memoryPriority = in_ext->memoryPriority;
10654             out_header->pNext = (void *)out_ext;
10655             out_header = (void *)out_ext;
10656             break;
10657         }
10658         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
10659         {
10660             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10661             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
10662             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
10663             out_ext->pNext = NULL;
10664             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
10665             out_header->pNext = (void *)out_ext;
10666             out_header = (void *)out_ext;
10667             break;
10668         }
10669         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
10670         {
10671             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10672             const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
10673             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
10674             out_ext->pNext = NULL;
10675             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
10676             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
10677             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
10678             out_header->pNext = (void *)out_ext;
10679             out_header = (void *)out_ext;
10680             break;
10681         }
10682         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
10683         {
10684             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10685             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
10686             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
10687             out_ext->pNext = NULL;
10688             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
10689             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
10690             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
10691             out_header->pNext = (void *)out_ext;
10692             out_header = (void *)out_ext;
10693             break;
10694         }
10695         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
10696         {
10697             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10698             const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
10699             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
10700             out_ext->pNext = NULL;
10701             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
10702             out_header->pNext = (void *)out_ext;
10703             out_header = (void *)out_ext;
10704             break;
10705         }
10706         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
10707         {
10708             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10709             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
10710             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
10711             out_ext->pNext = NULL;
10712             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
10713             out_header->pNext = (void *)out_ext;
10714             out_header = (void *)out_ext;
10715             break;
10716         }
10717         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
10718         {
10719             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10720             const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
10721             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
10722             out_ext->pNext = NULL;
10723             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
10724             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
10725             out_header->pNext = (void *)out_ext;
10726             out_header = (void *)out_ext;
10727             break;
10728         }
10729         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
10730         {
10731             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10732             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
10733             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
10734             out_ext->pNext = NULL;
10735             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
10736             out_header->pNext = (void *)out_ext;
10737             out_header = (void *)out_ext;
10738             break;
10739         }
10740         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
10741         {
10742             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10743             const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
10744             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
10745             out_ext->pNext = NULL;
10746             out_ext->presentBarrier = in_ext->presentBarrier;
10747             out_header->pNext = (void *)out_ext;
10748             out_header = (void *)out_ext;
10749             break;
10750         }
10751         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
10752         {
10753             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10754             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
10755             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
10756             out_ext->pNext = NULL;
10757             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
10758             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
10759             out_header->pNext = (void *)out_ext;
10760             out_header = (void *)out_ext;
10761             break;
10762         }
10763         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR:
10764         {
10765             VkPerformanceQueryReservationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10766             const VkPerformanceQueryReservationInfoKHR *in_ext = (const VkPerformanceQueryReservationInfoKHR *)in_header;
10767             out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR;
10768             out_ext->pNext = NULL;
10769             out_ext->maxPerformanceQueriesPerPool = in_ext->maxPerformanceQueriesPerPool;
10770             out_header->pNext = (void *)out_ext;
10771             out_header = (void *)out_ext;
10772             break;
10773         }
10774         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
10775         {
10776             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10777             const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
10778             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
10779             out_ext->pNext = NULL;
10780             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
10781             out_header->pNext = (void *)out_ext;
10782             out_header = (void *)out_ext;
10783             break;
10784         }
10785         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
10786         {
10787             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10788             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
10789             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
10790             out_ext->pNext = NULL;
10791             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
10792             out_header->pNext = (void *)out_ext;
10793             out_header = (void *)out_ext;
10794             break;
10795         }
10796         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
10797         {
10798             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10799             const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
10800             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
10801             out_ext->pNext = NULL;
10802             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
10803             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
10804             out_header->pNext = (void *)out_ext;
10805             out_header = (void *)out_ext;
10806             break;
10807         }
10808         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
10809         {
10810             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10811             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header;
10812             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
10813             out_ext->pNext = NULL;
10814             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
10815             out_header->pNext = (void *)out_ext;
10816             out_header = (void *)out_ext;
10817             break;
10818         }
10819         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
10820         {
10821             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10822             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
10823             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
10824             out_ext->pNext = NULL;
10825             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
10826             out_header->pNext = (void *)out_ext;
10827             out_header = (void *)out_ext;
10828             break;
10829         }
10830         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
10831         {
10832             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10833             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
10834             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
10835             out_ext->pNext = NULL;
10836             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
10837             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
10838             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
10839             out_header->pNext = (void *)out_ext;
10840             out_header = (void *)out_ext;
10841             break;
10842         }
10843         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
10844         {
10845             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10846             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
10847             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
10848             out_ext->pNext = NULL;
10849             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
10850             out_header->pNext = (void *)out_ext;
10851             out_header = (void *)out_ext;
10852             break;
10853         }
10854         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
10855         {
10856             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10857             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
10858             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
10859             out_ext->pNext = NULL;
10860             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
10861             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
10862             out_header->pNext = (void *)out_ext;
10863             out_header = (void *)out_ext;
10864             break;
10865         }
10866         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
10867         {
10868             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10869             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
10870             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
10871             out_ext->pNext = NULL;
10872             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
10873             out_header->pNext = (void *)out_ext;
10874             out_header = (void *)out_ext;
10875             break;
10876         }
10877         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
10878         {
10879             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10880             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
10881             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
10882             out_ext->pNext = NULL;
10883             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
10884             out_header->pNext = (void *)out_ext;
10885             out_header = (void *)out_ext;
10886             break;
10887         }
10888         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
10889         {
10890             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10891             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
10892             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
10893             out_ext->pNext = NULL;
10894             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
10895             out_header->pNext = (void *)out_ext;
10896             out_header = (void *)out_ext;
10897             break;
10898         }
10899         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
10900         {
10901             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10902             const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
10903             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
10904             out_ext->pNext = NULL;
10905             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
10906             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
10907             out_header->pNext = (void *)out_ext;
10908             out_header = (void *)out_ext;
10909             break;
10910         }
10911         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
10912         {
10913             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10914             const VkPhysicalDeviceLineRasterizationFeaturesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header;
10915             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
10916             out_ext->pNext = NULL;
10917             out_ext->rectangularLines = in_ext->rectangularLines;
10918             out_ext->bresenhamLines = in_ext->bresenhamLines;
10919             out_ext->smoothLines = in_ext->smoothLines;
10920             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
10921             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
10922             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
10923             out_header->pNext = (void *)out_ext;
10924             out_header = (void *)out_ext;
10925             break;
10926         }
10927         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
10928         {
10929             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10930             const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
10931             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
10932             out_ext->pNext = NULL;
10933             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
10934             out_header->pNext = (void *)out_ext;
10935             out_header = (void *)out_ext;
10936             break;
10937         }
10938         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
10939         {
10940             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10941             const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
10942             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
10943             out_ext->pNext = NULL;
10944             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
10945             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
10946             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
10947             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
10948             out_ext->multiview = in_ext->multiview;
10949             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
10950             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
10951             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
10952             out_ext->variablePointers = in_ext->variablePointers;
10953             out_ext->protectedMemory = in_ext->protectedMemory;
10954             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
10955             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
10956             out_header->pNext = (void *)out_ext;
10957             out_header = (void *)out_ext;
10958             break;
10959         }
10960         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
10961         {
10962             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10963             const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
10964             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
10965             out_ext->pNext = NULL;
10966             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
10967             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
10968             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
10969             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
10970             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
10971             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
10972             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
10973             out_ext->shaderFloat16 = in_ext->shaderFloat16;
10974             out_ext->shaderInt8 = in_ext->shaderInt8;
10975             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
10976             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
10977             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
10978             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
10979             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
10980             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
10981             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
10982             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
10983             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
10984             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
10985             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
10986             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
10987             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
10988             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
10989             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
10990             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
10991             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
10992             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
10993             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
10994             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
10995             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
10996             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
10997             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
10998             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
10999             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
11000             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
11001             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
11002             out_ext->hostQueryReset = in_ext->hostQueryReset;
11003             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
11004             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
11005             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
11006             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
11007             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
11008             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
11009             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
11010             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
11011             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
11012             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
11013             out_header->pNext = (void *)out_ext;
11014             out_header = (void *)out_ext;
11015             break;
11016         }
11017         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
11018         {
11019             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11020             const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
11021             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
11022             out_ext->pNext = NULL;
11023             out_ext->robustImageAccess = in_ext->robustImageAccess;
11024             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
11025             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
11026             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
11027             out_ext->privateData = in_ext->privateData;
11028             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
11029             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
11030             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
11031             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
11032             out_ext->synchronization2 = in_ext->synchronization2;
11033             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
11034             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
11035             out_ext->dynamicRendering = in_ext->dynamicRendering;
11036             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
11037             out_ext->maintenance4 = in_ext->maintenance4;
11038             out_header->pNext = (void *)out_ext;
11039             out_header = (void *)out_ext;
11040             break;
11041         }
11042         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
11043         {
11044             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11045             const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
11046             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
11047             out_ext->pNext = NULL;
11048             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
11049             out_header->pNext = (void *)out_ext;
11050             out_header = (void *)out_ext;
11051             break;
11052         }
11053         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
11054         {
11055             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11056             const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
11057             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
11058             out_ext->pNext = NULL;
11059             out_ext->customBorderColors = in_ext->customBorderColors;
11060             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
11061             out_header->pNext = (void *)out_ext;
11062             out_header = (void *)out_ext;
11063             break;
11064         }
11065         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
11066         {
11067             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11068             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
11069             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
11070             out_ext->pNext = NULL;
11071             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
11072             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
11073             out_header->pNext = (void *)out_ext;
11074             out_header = (void *)out_ext;
11075             break;
11076         }
11077         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
11078         {
11079             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11080             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
11081             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
11082             out_ext->pNext = NULL;
11083             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
11084             out_header->pNext = (void *)out_ext;
11085             out_header = (void *)out_ext;
11086             break;
11087         }
11088         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
11089         {
11090             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11091             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
11092             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
11093             out_ext->pNext = NULL;
11094             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
11095             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
11096             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
11097             out_header->pNext = (void *)out_ext;
11098             out_header = (void *)out_ext;
11099             break;
11100         }
11101         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
11102         {
11103             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11104             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
11105             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
11106             out_ext->pNext = NULL;
11107             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
11108             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
11109             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
11110             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
11111             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
11112             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
11113             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
11114             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
11115             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
11116             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
11117             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
11118             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
11119             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
11120             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
11121             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
11122             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
11123             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
11124             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
11125             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
11126             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
11127             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
11128             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
11129             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
11130             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
11131             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
11132             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
11133             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
11134             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
11135             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
11136             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
11137             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
11138             out_header->pNext = (void *)out_ext;
11139             out_header = (void *)out_ext;
11140             break;
11141         }
11142         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
11143         {
11144             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11145             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
11146             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
11147             out_ext->pNext = NULL;
11148             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
11149             out_header->pNext = (void *)out_ext;
11150             out_header = (void *)out_ext;
11151             break;
11152         }
11153         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
11154         {
11155             VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11156             const VkDeviceDiagnosticsConfigCreateInfoNV *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV *)in_header;
11157             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
11158             out_ext->pNext = NULL;
11159             out_ext->flags = in_ext->flags;
11160             out_header->pNext = (void *)out_ext;
11161             out_header = (void *)out_ext;
11162             break;
11163         }
11164         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
11165         {
11166             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11167             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
11168             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
11169             out_ext->pNext = NULL;
11170             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
11171             out_header->pNext = (void *)out_ext;
11172             out_header = (void *)out_ext;
11173             break;
11174         }
11175         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
11176         {
11177             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11178             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
11179             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
11180             out_ext->pNext = NULL;
11181             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
11182             out_header->pNext = (void *)out_ext;
11183             out_header = (void *)out_ext;
11184             break;
11185         }
11186         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
11187         {
11188             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11189             const VkPhysicalDeviceRobustness2FeaturesEXT *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT *)in_header;
11190             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
11191             out_ext->pNext = NULL;
11192             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
11193             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
11194             out_ext->nullDescriptor = in_ext->nullDescriptor;
11195             out_header->pNext = (void *)out_ext;
11196             out_header = (void *)out_ext;
11197             break;
11198         }
11199         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
11200         {
11201             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11202             const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
11203             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
11204             out_ext->pNext = NULL;
11205             out_ext->robustImageAccess = in_ext->robustImageAccess;
11206             out_header->pNext = (void *)out_ext;
11207             out_header = (void *)out_ext;
11208             break;
11209         }
11210         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
11211         {
11212             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11213             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
11214             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
11215             out_ext->pNext = NULL;
11216             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
11217             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
11218             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
11219             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
11220             out_header->pNext = (void *)out_ext;
11221             out_header = (void *)out_ext;
11222             break;
11223         }
11224         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
11225         {
11226             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11227             const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
11228             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
11229             out_ext->pNext = NULL;
11230             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
11231             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
11232             out_header->pNext = (void *)out_ext;
11233             out_header = (void *)out_ext;
11234             break;
11235         }
11236         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
11237         {
11238             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11239             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
11240             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
11241             out_ext->pNext = NULL;
11242             out_ext->subpassShading = in_ext->subpassShading;
11243             out_header->pNext = (void *)out_ext;
11244             out_header = (void *)out_ext;
11245             break;
11246         }
11247         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
11248         {
11249             VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11250             const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *)in_header;
11251             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
11252             out_ext->pNext = NULL;
11253             out_ext->clustercullingShader = in_ext->clustercullingShader;
11254             out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
11255             out_header->pNext = (void *)out_ext;
11256             out_header = (void *)out_ext;
11257             break;
11258         }
11259         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
11260         {
11261             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11262             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
11263             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
11264             out_ext->pNext = NULL;
11265             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
11266             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
11267             out_header->pNext = (void *)out_ext;
11268             out_header = (void *)out_ext;
11269             break;
11270         }
11271         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
11272         {
11273             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11274             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
11275             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
11276             out_ext->pNext = NULL;
11277             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
11278             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
11279             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
11280             out_header->pNext = (void *)out_ext;
11281             out_header = (void *)out_ext;
11282             break;
11283         }
11284         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
11285         {
11286             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11287             const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
11288             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
11289             out_ext->pNext = NULL;
11290             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
11291             out_header->pNext = (void *)out_ext;
11292             out_header = (void *)out_ext;
11293             break;
11294         }
11295         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
11296         {
11297             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11298             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
11299             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
11300             out_ext->pNext = NULL;
11301             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
11302             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
11303             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
11304             out_header->pNext = (void *)out_ext;
11305             out_header = (void *)out_ext;
11306             break;
11307         }
11308         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
11309         {
11310             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11311             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
11312             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
11313             out_ext->pNext = NULL;
11314             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
11315             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
11316             out_header->pNext = (void *)out_ext;
11317             out_header = (void *)out_ext;
11318             break;
11319         }
11320         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
11321         {
11322             VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11323             const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)in_header;
11324             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
11325             out_ext->pNext = NULL;
11326             out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
11327             out_header->pNext = (void *)out_ext;
11328             out_header = (void *)out_ext;
11329             break;
11330         }
11331         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
11332         {
11333             VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11334             const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)in_header;
11335             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
11336             out_ext->pNext = NULL;
11337             out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
11338             out_header->pNext = (void *)out_ext;
11339             out_header = (void *)out_ext;
11340             break;
11341         }
11342         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
11343         {
11344             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11345             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
11346             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
11347             out_ext->pNext = NULL;
11348             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
11349             out_header->pNext = (void *)out_ext;
11350             out_header = (void *)out_ext;
11351             break;
11352         }
11353         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
11354         {
11355             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11356             const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
11357             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
11358             out_ext->pNext = NULL;
11359             out_ext->depthClipControl = in_ext->depthClipControl;
11360             out_header->pNext = (void *)out_ext;
11361             out_header = (void *)out_ext;
11362             break;
11363         }
11364         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
11365         {
11366             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11367             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
11368             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
11369             out_ext->pNext = NULL;
11370             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
11371             out_header->pNext = (void *)out_ext;
11372             out_header = (void *)out_ext;
11373             break;
11374         }
11375         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
11376         {
11377             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11378             const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
11379             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
11380             out_ext->pNext = NULL;
11381             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
11382             out_header->pNext = (void *)out_ext;
11383             out_header = (void *)out_ext;
11384             break;
11385         }
11386         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
11387         {
11388             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11389             const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
11390             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
11391             out_ext->pNext = NULL;
11392             out_ext->synchronization2 = in_ext->synchronization2;
11393             out_header->pNext = (void *)out_ext;
11394             out_header = (void *)out_ext;
11395             break;
11396         }
11397         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
11398         {
11399             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11400             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
11401             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
11402             out_ext->pNext = NULL;
11403             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
11404             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
11405             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
11406             out_header->pNext = (void *)out_ext;
11407             out_header = (void *)out_ext;
11408             break;
11409         }
11410         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
11411         {
11412             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11413             const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
11414             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
11415             out_ext->pNext = NULL;
11416             out_ext->legacyDithering = in_ext->legacyDithering;
11417             out_header->pNext = (void *)out_ext;
11418             out_header = (void *)out_ext;
11419             break;
11420         }
11421         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
11422         {
11423             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11424             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
11425             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
11426             out_ext->pNext = NULL;
11427             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
11428             out_header->pNext = (void *)out_ext;
11429             out_header = (void *)out_ext;
11430             break;
11431         }
11432         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
11433         {
11434             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11435             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)in_header;
11436             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
11437             out_ext->pNext = NULL;
11438             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
11439             out_header->pNext = (void *)out_ext;
11440             out_header = (void *)out_ext;
11441             break;
11442         }
11443         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
11444         {
11445             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11446             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
11447             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
11448             out_ext->pNext = NULL;
11449             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
11450             out_header->pNext = (void *)out_ext;
11451             out_header = (void *)out_ext;
11452             break;
11453         }
11454         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
11455         {
11456             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11457             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
11458             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
11459             out_ext->pNext = NULL;
11460             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
11461             out_header->pNext = (void *)out_ext;
11462             out_header = (void *)out_ext;
11463             break;
11464         }
11465         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
11466         {
11467             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11468             const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
11469             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
11470             out_ext->pNext = NULL;
11471             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
11472             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
11473             out_header->pNext = (void *)out_ext;
11474             out_header = (void *)out_ext;
11475             break;
11476         }
11477         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
11478         {
11479             VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11480             const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header;
11481             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
11482             out_ext->pNext = NULL;
11483             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
11484             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
11485             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
11486             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
11487             out_header->pNext = (void *)out_ext;
11488             out_header = (void *)out_ext;
11489             break;
11490         }
11491         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
11492         {
11493             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11494             const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
11495             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
11496             out_ext->pNext = NULL;
11497             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
11498             out_header->pNext = (void *)out_ext;
11499             out_header = (void *)out_ext;
11500             break;
11501         }
11502         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
11503         {
11504             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11505             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
11506             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
11507             out_ext->pNext = NULL;
11508             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
11509             out_header->pNext = (void *)out_ext;
11510             out_header = (void *)out_ext;
11511             break;
11512         }
11513         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
11514         {
11515             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11516             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
11517             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
11518             out_ext->pNext = NULL;
11519             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
11520             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
11521             out_header->pNext = (void *)out_ext;
11522             out_header = (void *)out_ext;
11523             break;
11524         }
11525         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
11526         {
11527             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11528             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
11529             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
11530             out_ext->pNext = NULL;
11531             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
11532             out_header->pNext = (void *)out_ext;
11533             out_header = (void *)out_ext;
11534             break;
11535         }
11536         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
11537         {
11538             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11539             const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
11540             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
11541             out_ext->pNext = NULL;
11542             out_ext->dynamicRendering = in_ext->dynamicRendering;
11543             out_header->pNext = (void *)out_ext;
11544             out_header = (void *)out_ext;
11545             break;
11546         }
11547         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
11548         {
11549             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11550             const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
11551             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
11552             out_ext->pNext = NULL;
11553             out_ext->minLod = in_ext->minLod;
11554             out_header->pNext = (void *)out_ext;
11555             out_header = (void *)out_ext;
11556             break;
11557         }
11558         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
11559         {
11560             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11561             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
11562             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
11563             out_ext->pNext = NULL;
11564             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
11565             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
11566             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
11567             out_header->pNext = (void *)out_ext;
11568             out_header = (void *)out_ext;
11569             break;
11570         }
11571         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
11572         {
11573             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11574             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
11575             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
11576             out_ext->pNext = NULL;
11577             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
11578             out_header->pNext = (void *)out_ext;
11579             out_header = (void *)out_ext;
11580             break;
11581         }
11582         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
11583         {
11584             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11585             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
11586             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
11587             out_ext->pNext = NULL;
11588             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
11589             out_header->pNext = (void *)out_ext;
11590             out_header = (void *)out_ext;
11591             break;
11592         }
11593         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
11594         {
11595             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11596             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
11597             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
11598             out_ext->pNext = NULL;
11599             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
11600             out_header->pNext = (void *)out_ext;
11601             out_header = (void *)out_ext;
11602             break;
11603         }
11604         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
11605         {
11606             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11607             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
11608             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
11609             out_ext->pNext = NULL;
11610             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
11611             out_header->pNext = (void *)out_ext;
11612             out_header = (void *)out_ext;
11613             break;
11614         }
11615         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
11616         {
11617             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11618             const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
11619             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
11620             out_ext->pNext = NULL;
11621             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
11622             out_header->pNext = (void *)out_ext;
11623             out_header = (void *)out_ext;
11624             break;
11625         }
11626         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
11627         {
11628             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11629             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
11630             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
11631             out_ext->pNext = NULL;
11632             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
11633             out_header->pNext = (void *)out_ext;
11634             out_header = (void *)out_ext;
11635             break;
11636         }
11637         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
11638         {
11639             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11640             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
11641             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
11642             out_ext->pNext = NULL;
11643             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
11644             out_header->pNext = (void *)out_ext;
11645             out_header = (void *)out_ext;
11646             break;
11647         }
11648         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
11649         {
11650             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11651             const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
11652             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
11653             out_ext->pNext = NULL;
11654             out_ext->micromap = in_ext->micromap;
11655             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
11656             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
11657             out_header->pNext = (void *)out_ext;
11658             out_header = (void *)out_ext;
11659             break;
11660         }
11661         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
11662         {
11663             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11664             const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
11665             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
11666             out_ext->pNext = NULL;
11667             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
11668             out_header->pNext = (void *)out_ext;
11669             out_header = (void *)out_ext;
11670             break;
11671         }
11672         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
11673         {
11674             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11675             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header;
11676             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
11677             out_ext->pNext = NULL;
11678             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
11679             out_header->pNext = (void *)out_ext;
11680             out_header = (void *)out_ext;
11681             break;
11682         }
11683         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
11684         {
11685             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11686             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
11687             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
11688             out_ext->pNext = NULL;
11689             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
11690             out_header->pNext = (void *)out_ext;
11691             out_header = (void *)out_ext;
11692             break;
11693         }
11694         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
11695         {
11696             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11697             const VkPhysicalDevicePipelineRobustnessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT *)in_header;
11698             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
11699             out_ext->pNext = NULL;
11700             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
11701             out_header->pNext = (void *)out_ext;
11702             out_header = (void *)out_ext;
11703             break;
11704         }
11705         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
11706         {
11707             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11708             const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
11709             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
11710             out_ext->pNext = NULL;
11711             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
11712             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
11713             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
11714             out_header->pNext = (void *)out_ext;
11715             out_header = (void *)out_ext;
11716             break;
11717         }
11718         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
11719         {
11720             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11721             const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
11722             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
11723             out_ext->pNext = NULL;
11724             out_ext->tileProperties = in_ext->tileProperties;
11725             out_header->pNext = (void *)out_ext;
11726             out_header = (void *)out_ext;
11727             break;
11728         }
11729         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
11730         {
11731             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11732             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
11733             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
11734             out_ext->pNext = NULL;
11735             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
11736             out_header->pNext = (void *)out_ext;
11737             out_header = (void *)out_ext;
11738             break;
11739         }
11740         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
11741         {
11742             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11743             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *)in_header;
11744             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
11745             out_ext->pNext = NULL;
11746             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
11747             out_header->pNext = (void *)out_ext;
11748             out_header = (void *)out_ext;
11749             break;
11750         }
11751         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
11752         {
11753             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11754             const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
11755             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
11756             out_ext->pNext = NULL;
11757             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
11758             out_header->pNext = (void *)out_ext;
11759             out_header = (void *)out_ext;
11760             break;
11761         }
11762         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
11763         {
11764             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11765             const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
11766             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
11767             out_ext->pNext = NULL;
11768             out_ext->opticalFlow = in_ext->opticalFlow;
11769             out_header->pNext = (void *)out_ext;
11770             out_header = (void *)out_ext;
11771             break;
11772         }
11773         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
11774         {
11775             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11776             const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
11777             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
11778             out_ext->pNext = NULL;
11779             out_ext->deviceFault = in_ext->deviceFault;
11780             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
11781             out_header->pNext = (void *)out_ext;
11782             out_header = (void *)out_ext;
11783             break;
11784         }
11785         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
11786         {
11787             VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11788             const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)in_header;
11789             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
11790             out_ext->pNext = NULL;
11791             out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
11792             out_header->pNext = (void *)out_ext;
11793             out_header = (void *)out_ext;
11794             break;
11795         }
11796         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
11797         {
11798             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11799             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
11800             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
11801             out_ext->pNext = NULL;
11802             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
11803             out_header->pNext = (void *)out_ext;
11804             out_header = (void *)out_ext;
11805             break;
11806         }
11807         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
11808         {
11809             VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11810             const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)in_header;
11811             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
11812             out_ext->pNext = NULL;
11813             out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
11814             out_header->pNext = (void *)out_ext;
11815             out_header = (void *)out_ext;
11816             break;
11817         }
11818         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
11819         {
11820             VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11821             const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *)in_header;
11822             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT;
11823             out_ext->pNext = NULL;
11824             out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
11825             out_header->pNext = (void *)out_ext;
11826             out_header = (void *)out_ext;
11827             break;
11828         }
11829         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
11830         {
11831             VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11832             const VkPhysicalDeviceDepthBiasControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT *)in_header;
11833             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
11834             out_ext->pNext = NULL;
11835             out_ext->depthBiasControl = in_ext->depthBiasControl;
11836             out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
11837             out_ext->floatRepresentation = in_ext->floatRepresentation;
11838             out_ext->depthBiasExact = in_ext->depthBiasExact;
11839             out_header->pNext = (void *)out_ext;
11840             out_header = (void *)out_ext;
11841             break;
11842         }
11843         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
11844         {
11845             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11846             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
11847             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
11848             out_ext->pNext = NULL;
11849             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
11850             out_header->pNext = (void *)out_ext;
11851             out_header = (void *)out_ext;
11852             break;
11853         }
11854         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
11855         {
11856             VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11857             const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *)in_header;
11858             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
11859             out_ext->pNext = NULL;
11860             out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
11861             out_header->pNext = (void *)out_ext;
11862             out_header = (void *)out_ext;
11863             break;
11864         }
11865         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
11866         {
11867             VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11868             const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)in_header;
11869             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
11870             out_ext->pNext = NULL;
11871             out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
11872             out_header->pNext = (void *)out_ext;
11873             out_header = (void *)out_ext;
11874             break;
11875         }
11876         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
11877         {
11878             VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11879             const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *)in_header;
11880             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
11881             out_ext->pNext = NULL;
11882             out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
11883             out_header->pNext = (void *)out_ext;
11884             out_header = (void *)out_ext;
11885             break;
11886         }
11887         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
11888         {
11889             VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11890             const VkPhysicalDeviceShaderObjectFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)in_header;
11891             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
11892             out_ext->pNext = NULL;
11893             out_ext->shaderObject = in_ext->shaderObject;
11894             out_header->pNext = (void *)out_ext;
11895             out_header = (void *)out_ext;
11896             break;
11897         }
11898         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
11899         {
11900             VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11901             const VkPhysicalDeviceShaderTileImageFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT *)in_header;
11902             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
11903             out_ext->pNext = NULL;
11904             out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
11905             out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
11906             out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
11907             out_header->pNext = (void *)out_ext;
11908             out_header = (void *)out_ext;
11909             break;
11910         }
11911         default:
11912             FIXME("Unhandled sType %u.\n", in_header->sType);
11913             break;
11914         }
11915     }
11916 }
11917 #endif /* _WIN64 */
11918
11919 static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo32 *in, VkDeviceCreateInfo *out)
11920 {
11921     const VkBaseInStructure32 *in_header;
11922     VkBaseOutStructure *out_header = (void *)out;
11923
11924     if (!in) return;
11925
11926     out->sType = in->sType;
11927     out->pNext = NULL;
11928     out->flags = in->flags;
11929     out->queueCreateInfoCount = in->queueCreateInfoCount;
11930     out->pQueueCreateInfos = convert_VkDeviceQueueCreateInfo_array_win32_to_host(ctx, (const VkDeviceQueueCreateInfo32 *)UlongToPtr(in->pQueueCreateInfos), in->queueCreateInfoCount);
11931     out->enabledLayerCount = in->enabledLayerCount;
11932     out->ppEnabledLayerNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledLayerNames), in->enabledLayerCount);
11933     out->enabledExtensionCount = in->enabledExtensionCount;
11934     out->ppEnabledExtensionNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledExtensionNames), in->enabledExtensionCount);
11935     out->pEnabledFeatures = (const VkPhysicalDeviceFeatures *)UlongToPtr(in->pEnabledFeatures);
11936
11937     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
11938     {
11939         switch (in_header->sType)
11940         {
11941         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
11942             break;
11943         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
11944         {
11945             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11946             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header;
11947             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
11948             out_ext->pNext = NULL;
11949             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
11950             out_header->pNext = (void *)out_ext;
11951             out_header = (void *)out_ext;
11952             break;
11953         }
11954         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
11955         {
11956             VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11957             const VkDevicePrivateDataCreateInfo32 *in_ext = (const VkDevicePrivateDataCreateInfo32 *)in_header;
11958             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
11959             out_ext->pNext = NULL;
11960             out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
11961             out_header->pNext = (void *)out_ext;
11962             out_header = (void *)out_ext;
11963             break;
11964         }
11965         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
11966         {
11967             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11968             const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header;
11969             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
11970             out_ext->pNext = NULL;
11971             out_ext->privateData = in_ext->privateData;
11972             out_header->pNext = (void *)out_ext;
11973             out_header = (void *)out_ext;
11974             break;
11975         }
11976         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
11977         {
11978             VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11979             const VkPhysicalDeviceFeatures232 *in_ext = (const VkPhysicalDeviceFeatures232 *)in_header;
11980             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
11981             out_ext->pNext = NULL;
11982             out_ext->features = in_ext->features;
11983             out_header->pNext = (void *)out_ext;
11984             out_header = (void *)out_ext;
11985             break;
11986         }
11987         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
11988         {
11989             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11990             const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header;
11991             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
11992             out_ext->pNext = NULL;
11993             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
11994             out_ext->variablePointers = in_ext->variablePointers;
11995             out_header->pNext = (void *)out_ext;
11996             out_header = (void *)out_ext;
11997             break;
11998         }
11999         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
12000         {
12001             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12002             const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header;
12003             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
12004             out_ext->pNext = NULL;
12005             out_ext->multiview = in_ext->multiview;
12006             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
12007             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
12008             out_header->pNext = (void *)out_ext;
12009             out_header = (void *)out_ext;
12010             break;
12011         }
12012         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
12013         {
12014             VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12015             const VkDeviceGroupDeviceCreateInfo32 *in_ext = (const VkDeviceGroupDeviceCreateInfo32 *)in_header;
12016             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
12017             out_ext->pNext = NULL;
12018             out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
12019             out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->pPhysicalDevices), in_ext->physicalDeviceCount);
12020             out_header->pNext = (void *)out_ext;
12021             out_header = (void *)out_ext;
12022             break;
12023         }
12024         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
12025         {
12026             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12027             const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header;
12028             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
12029             out_ext->pNext = NULL;
12030             out_ext->presentId = in_ext->presentId;
12031             out_header->pNext = (void *)out_ext;
12032             out_header = (void *)out_ext;
12033             break;
12034         }
12035         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
12036         {
12037             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12038             const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header;
12039             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
12040             out_ext->pNext = NULL;
12041             out_ext->presentWait = in_ext->presentWait;
12042             out_header->pNext = (void *)out_ext;
12043             out_header = (void *)out_ext;
12044             break;
12045         }
12046         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
12047         {
12048             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12049             const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header;
12050             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
12051             out_ext->pNext = NULL;
12052             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
12053             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
12054             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
12055             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
12056             out_header->pNext = (void *)out_ext;
12057             out_header = (void *)out_ext;
12058             break;
12059         }
12060         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
12061         {
12062             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12063             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header;
12064             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
12065             out_ext->pNext = NULL;
12066             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
12067             out_header->pNext = (void *)out_ext;
12068             out_header = (void *)out_ext;
12069             break;
12070         }
12071         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
12072         {
12073             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12074             const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header;
12075             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
12076             out_ext->pNext = NULL;
12077             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
12078             out_header->pNext = (void *)out_ext;
12079             out_header = (void *)out_ext;
12080             break;
12081         }
12082         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
12083         {
12084             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12085             const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header;
12086             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
12087             out_ext->pNext = NULL;
12088             out_ext->protectedMemory = in_ext->protectedMemory;
12089             out_header->pNext = (void *)out_ext;
12090             out_header = (void *)out_ext;
12091             break;
12092         }
12093         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
12094         {
12095             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12096             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *)in_header;
12097             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
12098             out_ext->pNext = NULL;
12099             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
12100             out_header->pNext = (void *)out_ext;
12101             out_header = (void *)out_ext;
12102             break;
12103         }
12104         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
12105         {
12106             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12107             const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header;
12108             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
12109             out_ext->pNext = NULL;
12110             out_ext->multiDraw = in_ext->multiDraw;
12111             out_header->pNext = (void *)out_ext;
12112             out_header = (void *)out_ext;
12113             break;
12114         }
12115         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
12116         {
12117             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12118             const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header;
12119             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
12120             out_ext->pNext = NULL;
12121             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
12122             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
12123             out_header->pNext = (void *)out_ext;
12124             out_header = (void *)out_ext;
12125             break;
12126         }
12127         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
12128         {
12129             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12130             const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header;
12131             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
12132             out_ext->pNext = NULL;
12133             out_ext->maintenance4 = in_ext->maintenance4;
12134             out_header->pNext = (void *)out_ext;
12135             out_header = (void *)out_ext;
12136             break;
12137         }
12138         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
12139         {
12140             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12141             const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header;
12142             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
12143             out_ext->pNext = NULL;
12144             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
12145             out_header->pNext = (void *)out_ext;
12146             out_header = (void *)out_ext;
12147             break;
12148         }
12149         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
12150         {
12151             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12152             const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header;
12153             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
12154             out_ext->pNext = NULL;
12155             out_ext->shaderFloat16 = in_ext->shaderFloat16;
12156             out_ext->shaderInt8 = in_ext->shaderInt8;
12157             out_header->pNext = (void *)out_ext;
12158             out_header = (void *)out_ext;
12159             break;
12160         }
12161         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
12162         {
12163             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12164             const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header;
12165             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
12166             out_ext->pNext = NULL;
12167             out_ext->hostQueryReset = in_ext->hostQueryReset;
12168             out_header->pNext = (void *)out_ext;
12169             out_header = (void *)out_ext;
12170             break;
12171         }
12172         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
12173         {
12174             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12175             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *)in_header;
12176             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
12177             out_ext->pNext = NULL;
12178             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
12179             out_header->pNext = (void *)out_ext;
12180             out_header = (void *)out_ext;
12181             break;
12182         }
12183         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
12184         {
12185             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12186             const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header;
12187             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
12188             out_ext->pNext = NULL;
12189             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
12190             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
12191             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
12192             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
12193             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
12194             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
12195             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
12196             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
12197             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
12198             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
12199             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
12200             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
12201             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
12202             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
12203             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
12204             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
12205             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
12206             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
12207             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
12208             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
12209             out_header->pNext = (void *)out_ext;
12210             out_header = (void *)out_ext;
12211             break;
12212         }
12213         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
12214         {
12215             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12216             const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header;
12217             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
12218             out_ext->pNext = NULL;
12219             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
12220             out_header->pNext = (void *)out_ext;
12221             out_header = (void *)out_ext;
12222             break;
12223         }
12224         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
12225         {
12226             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12227             const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header;
12228             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
12229             out_ext->pNext = NULL;
12230             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
12231             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
12232             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
12233             out_header->pNext = (void *)out_ext;
12234             out_header = (void *)out_ext;
12235             break;
12236         }
12237         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
12238         {
12239             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12240             const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header;
12241             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
12242             out_ext->pNext = NULL;
12243             out_ext->conditionalRendering = in_ext->conditionalRendering;
12244             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
12245             out_header->pNext = (void *)out_ext;
12246             out_header = (void *)out_ext;
12247             break;
12248         }
12249         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
12250         {
12251             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12252             const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header;
12253             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
12254             out_ext->pNext = NULL;
12255             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
12256             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
12257             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
12258             out_header->pNext = (void *)out_ext;
12259             out_header = (void *)out_ext;
12260             break;
12261         }
12262         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
12263         {
12264             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12265             const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header;
12266             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
12267             out_ext->pNext = NULL;
12268             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
12269             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
12270             out_header->pNext = (void *)out_ext;
12271             out_header = (void *)out_ext;
12272             break;
12273         }
12274         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
12275         {
12276             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12277             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header;
12278             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
12279             out_ext->pNext = NULL;
12280             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
12281             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
12282             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
12283             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
12284             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
12285             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
12286             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
12287             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
12288             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
12289             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
12290             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
12291             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
12292             out_header->pNext = (void *)out_ext;
12293             out_header = (void *)out_ext;
12294             break;
12295         }
12296         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
12297         {
12298             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12299             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header;
12300             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
12301             out_ext->pNext = NULL;
12302             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
12303             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
12304             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
12305             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
12306             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
12307             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
12308             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
12309             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
12310             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
12311             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
12312             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
12313             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
12314             out_header->pNext = (void *)out_ext;
12315             out_header = (void *)out_ext;
12316             break;
12317         }
12318         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
12319         {
12320             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12321             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *)in_header;
12322             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
12323             out_ext->pNext = NULL;
12324             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
12325             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
12326             out_header->pNext = (void *)out_ext;
12327             out_header = (void *)out_ext;
12328             break;
12329         }
12330         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
12331         {
12332             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12333             const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header;
12334             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
12335             out_ext->pNext = NULL;
12336             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
12337             out_header->pNext = (void *)out_ext;
12338             out_header = (void *)out_ext;
12339             break;
12340         }
12341         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
12342         {
12343             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12344             const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header;
12345             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
12346             out_ext->pNext = NULL;
12347             out_ext->transformFeedback = in_ext->transformFeedback;
12348             out_ext->geometryStreams = in_ext->geometryStreams;
12349             out_header->pNext = (void *)out_ext;
12350             out_header = (void *)out_ext;
12351             break;
12352         }
12353         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
12354         {
12355             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12356             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header;
12357             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
12358             out_ext->pNext = NULL;
12359             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
12360             out_header->pNext = (void *)out_ext;
12361             out_header = (void *)out_ext;
12362             break;
12363         }
12364         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
12365         {
12366             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12367             const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header;
12368             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
12369             out_ext->pNext = NULL;
12370             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
12371             out_header->pNext = (void *)out_ext;
12372             out_header = (void *)out_ext;
12373             break;
12374         }
12375         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
12376         {
12377             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12378             const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header;
12379             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
12380             out_ext->pNext = NULL;
12381             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
12382             out_header->pNext = (void *)out_ext;
12383             out_header = (void *)out_ext;
12384             break;
12385         }
12386         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
12387         {
12388             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12389             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *)in_header;
12390             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
12391             out_ext->pNext = NULL;
12392             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
12393             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
12394             out_header->pNext = (void *)out_ext;
12395             out_header = (void *)out_ext;
12396             break;
12397         }
12398         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
12399         {
12400             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12401             const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header;
12402             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
12403             out_ext->pNext = NULL;
12404             out_ext->imageFootprint = in_ext->imageFootprint;
12405             out_header->pNext = (void *)out_ext;
12406             out_header = (void *)out_ext;
12407             break;
12408         }
12409         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
12410         {
12411             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12412             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header;
12413             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
12414             out_ext->pNext = NULL;
12415             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
12416             out_header->pNext = (void *)out_ext;
12417             out_header = (void *)out_ext;
12418             break;
12419         }
12420         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
12421         {
12422             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12423             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header;
12424             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
12425             out_ext->pNext = NULL;
12426             out_ext->indirectCopy = in_ext->indirectCopy;
12427             out_header->pNext = (void *)out_ext;
12428             out_header = (void *)out_ext;
12429             break;
12430         }
12431         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
12432         {
12433             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12434             const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header;
12435             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
12436             out_ext->pNext = NULL;
12437             out_ext->memoryDecompression = in_ext->memoryDecompression;
12438             out_header->pNext = (void *)out_ext;
12439             out_header = (void *)out_ext;
12440             break;
12441         }
12442         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
12443         {
12444             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12445             const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header;
12446             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
12447             out_ext->pNext = NULL;
12448             out_ext->shadingRateImage = in_ext->shadingRateImage;
12449             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
12450             out_header->pNext = (void *)out_ext;
12451             out_header = (void *)out_ext;
12452             break;
12453         }
12454         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
12455         {
12456             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12457             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header;
12458             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
12459             out_ext->pNext = NULL;
12460             out_ext->invocationMask = in_ext->invocationMask;
12461             out_header->pNext = (void *)out_ext;
12462             out_header = (void *)out_ext;
12463             break;
12464         }
12465         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
12466         {
12467             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12468             const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header;
12469             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
12470             out_ext->pNext = NULL;
12471             out_ext->taskShader = in_ext->taskShader;
12472             out_ext->meshShader = in_ext->meshShader;
12473             out_header->pNext = (void *)out_ext;
12474             out_header = (void *)out_ext;
12475             break;
12476         }
12477         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
12478         {
12479             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12480             const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header;
12481             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
12482             out_ext->pNext = NULL;
12483             out_ext->taskShader = in_ext->taskShader;
12484             out_ext->meshShader = in_ext->meshShader;
12485             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
12486             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
12487             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
12488             out_header->pNext = (void *)out_ext;
12489             out_header = (void *)out_ext;
12490             break;
12491         }
12492         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
12493         {
12494             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12495             const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header;
12496             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
12497             out_ext->pNext = NULL;
12498             out_ext->accelerationStructure = in_ext->accelerationStructure;
12499             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
12500             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
12501             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
12502             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
12503             out_header->pNext = (void *)out_ext;
12504             out_header = (void *)out_ext;
12505             break;
12506         }
12507         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
12508         {
12509             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12510             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header;
12511             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
12512             out_ext->pNext = NULL;
12513             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
12514             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
12515             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
12516             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
12517             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
12518             out_header->pNext = (void *)out_ext;
12519             out_header = (void *)out_ext;
12520             break;
12521         }
12522         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
12523         {
12524             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12525             const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header;
12526             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
12527             out_ext->pNext = NULL;
12528             out_ext->rayQuery = in_ext->rayQuery;
12529             out_header->pNext = (void *)out_ext;
12530             out_header = (void *)out_ext;
12531             break;
12532         }
12533         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
12534         {
12535             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12536             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header;
12537             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
12538             out_ext->pNext = NULL;
12539             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
12540             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
12541             out_header->pNext = (void *)out_ext;
12542             out_header = (void *)out_ext;
12543             break;
12544         }
12545         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
12546         {
12547             VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12548             const VkDeviceMemoryOverallocationCreateInfoAMD32 *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD32 *)in_header;
12549             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
12550             out_ext->pNext = NULL;
12551             out_ext->overallocationBehavior = in_ext->overallocationBehavior;
12552             out_header->pNext = (void *)out_ext;
12553             out_header = (void *)out_ext;
12554             break;
12555         }
12556         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
12557         {
12558             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12559             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header;
12560             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
12561             out_ext->pNext = NULL;
12562             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
12563             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
12564             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
12565             out_header->pNext = (void *)out_ext;
12566             out_header = (void *)out_ext;
12567             break;
12568         }
12569         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
12570         {
12571             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12572             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header;
12573             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
12574             out_ext->pNext = NULL;
12575             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
12576             out_header->pNext = (void *)out_ext;
12577             out_header = (void *)out_ext;
12578             break;
12579         }
12580         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
12581         {
12582             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12583             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *)in_header;
12584             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
12585             out_ext->pNext = NULL;
12586             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
12587             out_header->pNext = (void *)out_ext;
12588             out_header = (void *)out_ext;
12589             break;
12590         }
12591         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
12592         {
12593             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12594             const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header;
12595             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
12596             out_ext->pNext = NULL;
12597             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
12598             out_header->pNext = (void *)out_ext;
12599             out_header = (void *)out_ext;
12600             break;
12601         }
12602         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
12603         {
12604             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12605             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header;
12606             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
12607             out_ext->pNext = NULL;
12608             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
12609             out_header->pNext = (void *)out_ext;
12610             out_header = (void *)out_ext;
12611             break;
12612         }
12613         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
12614         {
12615             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12616             const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header;
12617             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
12618             out_ext->pNext = NULL;
12619             out_ext->depthClipEnable = in_ext->depthClipEnable;
12620             out_header->pNext = (void *)out_ext;
12621             out_header = (void *)out_ext;
12622             break;
12623         }
12624         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
12625         {
12626             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12627             const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header;
12628             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
12629             out_ext->pNext = NULL;
12630             out_ext->memoryPriority = in_ext->memoryPriority;
12631             out_header->pNext = (void *)out_ext;
12632             out_header = (void *)out_ext;
12633             break;
12634         }
12635         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
12636         {
12637             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12638             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header;
12639             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
12640             out_ext->pNext = NULL;
12641             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
12642             out_header->pNext = (void *)out_ext;
12643             out_header = (void *)out_ext;
12644             break;
12645         }
12646         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
12647         {
12648             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12649             const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header;
12650             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
12651             out_ext->pNext = NULL;
12652             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
12653             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
12654             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
12655             out_header->pNext = (void *)out_ext;
12656             out_header = (void *)out_ext;
12657             break;
12658         }
12659         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
12660         {
12661             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12662             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header;
12663             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
12664             out_ext->pNext = NULL;
12665             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
12666             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
12667             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
12668             out_header->pNext = (void *)out_ext;
12669             out_header = (void *)out_ext;
12670             break;
12671         }
12672         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
12673         {
12674             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12675             const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header;
12676             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
12677             out_ext->pNext = NULL;
12678             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
12679             out_header->pNext = (void *)out_ext;
12680             out_header = (void *)out_ext;
12681             break;
12682         }
12683         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
12684         {
12685             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12686             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header;
12687             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
12688             out_ext->pNext = NULL;
12689             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
12690             out_header->pNext = (void *)out_ext;
12691             out_header = (void *)out_ext;
12692             break;
12693         }
12694         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
12695         {
12696             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12697             const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header;
12698             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
12699             out_ext->pNext = NULL;
12700             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
12701             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
12702             out_header->pNext = (void *)out_ext;
12703             out_header = (void *)out_ext;
12704             break;
12705         }
12706         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
12707         {
12708             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12709             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header;
12710             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
12711             out_ext->pNext = NULL;
12712             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
12713             out_header->pNext = (void *)out_ext;
12714             out_header = (void *)out_ext;
12715             break;
12716         }
12717         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
12718         {
12719             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12720             const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header;
12721             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
12722             out_ext->pNext = NULL;
12723             out_ext->presentBarrier = in_ext->presentBarrier;
12724             out_header->pNext = (void *)out_ext;
12725             out_header = (void *)out_ext;
12726             break;
12727         }
12728         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
12729         {
12730             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12731             const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header;
12732             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
12733             out_ext->pNext = NULL;
12734             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
12735             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
12736             out_header->pNext = (void *)out_ext;
12737             out_header = (void *)out_ext;
12738             break;
12739         }
12740         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR:
12741         {
12742             VkPerformanceQueryReservationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12743             const VkPerformanceQueryReservationInfoKHR32 *in_ext = (const VkPerformanceQueryReservationInfoKHR32 *)in_header;
12744             out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR;
12745             out_ext->pNext = NULL;
12746             out_ext->maxPerformanceQueriesPerPool = in_ext->maxPerformanceQueriesPerPool;
12747             out_header->pNext = (void *)out_ext;
12748             out_header = (void *)out_ext;
12749             break;
12750         }
12751         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
12752         {
12753             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12754             const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header;
12755             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
12756             out_ext->pNext = NULL;
12757             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
12758             out_header->pNext = (void *)out_ext;
12759             out_header = (void *)out_ext;
12760             break;
12761         }
12762         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
12763         {
12764             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12765             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header;
12766             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
12767             out_ext->pNext = NULL;
12768             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
12769             out_header->pNext = (void *)out_ext;
12770             out_header = (void *)out_ext;
12771             break;
12772         }
12773         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
12774         {
12775             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12776             const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header;
12777             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
12778             out_ext->pNext = NULL;
12779             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
12780             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
12781             out_header->pNext = (void *)out_ext;
12782             out_header = (void *)out_ext;
12783             break;
12784         }
12785         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
12786         {
12787             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12788             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *)in_header;
12789             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
12790             out_ext->pNext = NULL;
12791             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
12792             out_header->pNext = (void *)out_ext;
12793             out_header = (void *)out_ext;
12794             break;
12795         }
12796         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
12797         {
12798             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12799             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header;
12800             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
12801             out_ext->pNext = NULL;
12802             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
12803             out_header->pNext = (void *)out_ext;
12804             out_header = (void *)out_ext;
12805             break;
12806         }
12807         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
12808         {
12809             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12810             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header;
12811             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
12812             out_ext->pNext = NULL;
12813             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
12814             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
12815             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
12816             out_header->pNext = (void *)out_ext;
12817             out_header = (void *)out_ext;
12818             break;
12819         }
12820         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
12821         {
12822             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12823             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header;
12824             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
12825             out_ext->pNext = NULL;
12826             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
12827             out_header->pNext = (void *)out_ext;
12828             out_header = (void *)out_ext;
12829             break;
12830         }
12831         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
12832         {
12833             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12834             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header;
12835             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
12836             out_ext->pNext = NULL;
12837             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
12838             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
12839             out_header->pNext = (void *)out_ext;
12840             out_header = (void *)out_ext;
12841             break;
12842         }
12843         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
12844         {
12845             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12846             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header;
12847             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
12848             out_ext->pNext = NULL;
12849             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
12850             out_header->pNext = (void *)out_ext;
12851             out_header = (void *)out_ext;
12852             break;
12853         }
12854         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
12855         {
12856             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12857             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header;
12858             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
12859             out_ext->pNext = NULL;
12860             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
12861             out_header->pNext = (void *)out_ext;
12862             out_header = (void *)out_ext;
12863             break;
12864         }
12865         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
12866         {
12867             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12868             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header;
12869             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
12870             out_ext->pNext = NULL;
12871             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
12872             out_header->pNext = (void *)out_ext;
12873             out_header = (void *)out_ext;
12874             break;
12875         }
12876         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
12877         {
12878             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12879             const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header;
12880             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
12881             out_ext->pNext = NULL;
12882             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
12883             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
12884             out_header->pNext = (void *)out_ext;
12885             out_header = (void *)out_ext;
12886             break;
12887         }
12888         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
12889         {
12890             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12891             const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *)in_header;
12892             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
12893             out_ext->pNext = NULL;
12894             out_ext->rectangularLines = in_ext->rectangularLines;
12895             out_ext->bresenhamLines = in_ext->bresenhamLines;
12896             out_ext->smoothLines = in_ext->smoothLines;
12897             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
12898             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
12899             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
12900             out_header->pNext = (void *)out_ext;
12901             out_header = (void *)out_ext;
12902             break;
12903         }
12904         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
12905         {
12906             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12907             const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header;
12908             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
12909             out_ext->pNext = NULL;
12910             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
12911             out_header->pNext = (void *)out_ext;
12912             out_header = (void *)out_ext;
12913             break;
12914         }
12915         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
12916         {
12917             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12918             const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header;
12919             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
12920             out_ext->pNext = NULL;
12921             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
12922             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
12923             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
12924             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
12925             out_ext->multiview = in_ext->multiview;
12926             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
12927             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
12928             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
12929             out_ext->variablePointers = in_ext->variablePointers;
12930             out_ext->protectedMemory = in_ext->protectedMemory;
12931             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
12932             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
12933             out_header->pNext = (void *)out_ext;
12934             out_header = (void *)out_ext;
12935             break;
12936         }
12937         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
12938         {
12939             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12940             const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header;
12941             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
12942             out_ext->pNext = NULL;
12943             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
12944             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
12945             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
12946             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
12947             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
12948             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
12949             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
12950             out_ext->shaderFloat16 = in_ext->shaderFloat16;
12951             out_ext->shaderInt8 = in_ext->shaderInt8;
12952             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
12953             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
12954             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
12955             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
12956             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
12957             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
12958             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
12959             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
12960             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
12961             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
12962             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
12963             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
12964             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
12965             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
12966             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
12967             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
12968             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
12969             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
12970             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
12971             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
12972             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
12973             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
12974             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
12975             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
12976             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
12977             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
12978             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
12979             out_ext->hostQueryReset = in_ext->hostQueryReset;
12980             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
12981             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
12982             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
12983             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
12984             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
12985             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
12986             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
12987             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
12988             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
12989             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
12990             out_header->pNext = (void *)out_ext;
12991             out_header = (void *)out_ext;
12992             break;
12993         }
12994         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
12995         {
12996             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12997             const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header;
12998             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
12999             out_ext->pNext = NULL;
13000             out_ext->robustImageAccess = in_ext->robustImageAccess;
13001             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
13002             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
13003             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
13004             out_ext->privateData = in_ext->privateData;
13005             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
13006             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
13007             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
13008             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
13009             out_ext->synchronization2 = in_ext->synchronization2;
13010             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
13011             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
13012             out_ext->dynamicRendering = in_ext->dynamicRendering;
13013             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
13014             out_ext->maintenance4 = in_ext->maintenance4;
13015             out_header->pNext = (void *)out_ext;
13016             out_header = (void *)out_ext;
13017             break;
13018         }
13019         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
13020         {
13021             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13022             const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header;
13023             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
13024             out_ext->pNext = NULL;
13025             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
13026             out_header->pNext = (void *)out_ext;
13027             out_header = (void *)out_ext;
13028             break;
13029         }
13030         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
13031         {
13032             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13033             const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header;
13034             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
13035             out_ext->pNext = NULL;
13036             out_ext->customBorderColors = in_ext->customBorderColors;
13037             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
13038             out_header->pNext = (void *)out_ext;
13039             out_header = (void *)out_ext;
13040             break;
13041         }
13042         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
13043         {
13044             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13045             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header;
13046             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
13047             out_ext->pNext = NULL;
13048             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
13049             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
13050             out_header->pNext = (void *)out_ext;
13051             out_header = (void *)out_ext;
13052             break;
13053         }
13054         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
13055         {
13056             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13057             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header;
13058             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
13059             out_ext->pNext = NULL;
13060             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
13061             out_header->pNext = (void *)out_ext;
13062             out_header = (void *)out_ext;
13063             break;
13064         }
13065         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
13066         {
13067             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13068             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header;
13069             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
13070             out_ext->pNext = NULL;
13071             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
13072             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
13073             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
13074             out_header->pNext = (void *)out_ext;
13075             out_header = (void *)out_ext;
13076             break;
13077         }
13078         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
13079         {
13080             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13081             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header;
13082             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
13083             out_ext->pNext = NULL;
13084             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
13085             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
13086             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
13087             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
13088             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
13089             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
13090             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
13091             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
13092             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
13093             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
13094             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
13095             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
13096             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
13097             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
13098             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
13099             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
13100             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
13101             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
13102             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
13103             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
13104             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
13105             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
13106             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
13107             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
13108             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
13109             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
13110             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
13111             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
13112             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
13113             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
13114             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
13115             out_header->pNext = (void *)out_ext;
13116             out_header = (void *)out_ext;
13117             break;
13118         }
13119         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
13120         {
13121             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13122             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header;
13123             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
13124             out_ext->pNext = NULL;
13125             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
13126             out_header->pNext = (void *)out_ext;
13127             out_header = (void *)out_ext;
13128             break;
13129         }
13130         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
13131         {
13132             VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13133             const VkDeviceDiagnosticsConfigCreateInfoNV32 *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV32 *)in_header;
13134             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
13135             out_ext->pNext = NULL;
13136             out_ext->flags = in_ext->flags;
13137             out_header->pNext = (void *)out_ext;
13138             out_header = (void *)out_ext;
13139             break;
13140         }
13141         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
13142         {
13143             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13144             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header;
13145             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
13146             out_ext->pNext = NULL;
13147             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
13148             out_header->pNext = (void *)out_ext;
13149             out_header = (void *)out_ext;
13150             break;
13151         }
13152         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
13153         {
13154             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13155             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header;
13156             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
13157             out_ext->pNext = NULL;
13158             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
13159             out_header->pNext = (void *)out_ext;
13160             out_header = (void *)out_ext;
13161             break;
13162         }
13163         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
13164         {
13165             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13166             const VkPhysicalDeviceRobustness2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT32 *)in_header;
13167             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
13168             out_ext->pNext = NULL;
13169             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
13170             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
13171             out_ext->nullDescriptor = in_ext->nullDescriptor;
13172             out_header->pNext = (void *)out_ext;
13173             out_header = (void *)out_ext;
13174             break;
13175         }
13176         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
13177         {
13178             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13179             const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header;
13180             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
13181             out_ext->pNext = NULL;
13182             out_ext->robustImageAccess = in_ext->robustImageAccess;
13183             out_header->pNext = (void *)out_ext;
13184             out_header = (void *)out_ext;
13185             break;
13186         }
13187         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
13188         {
13189             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13190             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header;
13191             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
13192             out_ext->pNext = NULL;
13193             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
13194             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
13195             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
13196             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
13197             out_header->pNext = (void *)out_ext;
13198             out_header = (void *)out_ext;
13199             break;
13200         }
13201         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
13202         {
13203             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13204             const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header;
13205             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
13206             out_ext->pNext = NULL;
13207             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
13208             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
13209             out_header->pNext = (void *)out_ext;
13210             out_header = (void *)out_ext;
13211             break;
13212         }
13213         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
13214         {
13215             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13216             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header;
13217             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
13218             out_ext->pNext = NULL;
13219             out_ext->subpassShading = in_ext->subpassShading;
13220             out_header->pNext = (void *)out_ext;
13221             out_header = (void *)out_ext;
13222             break;
13223         }
13224         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
13225         {
13226             VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13227             const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *)in_header;
13228             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
13229             out_ext->pNext = NULL;
13230             out_ext->clustercullingShader = in_ext->clustercullingShader;
13231             out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
13232             out_header->pNext = (void *)out_ext;
13233             out_header = (void *)out_ext;
13234             break;
13235         }
13236         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
13237         {
13238             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13239             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header;
13240             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
13241             out_ext->pNext = NULL;
13242             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
13243             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
13244             out_header->pNext = (void *)out_ext;
13245             out_header = (void *)out_ext;
13246             break;
13247         }
13248         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
13249         {
13250             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13251             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header;
13252             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
13253             out_ext->pNext = NULL;
13254             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
13255             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
13256             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
13257             out_header->pNext = (void *)out_ext;
13258             out_header = (void *)out_ext;
13259             break;
13260         }
13261         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
13262         {
13263             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13264             const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header;
13265             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
13266             out_ext->pNext = NULL;
13267             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
13268             out_header->pNext = (void *)out_ext;
13269             out_header = (void *)out_ext;
13270             break;
13271         }
13272         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
13273         {
13274             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13275             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header;
13276             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
13277             out_ext->pNext = NULL;
13278             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
13279             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
13280             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
13281             out_header->pNext = (void *)out_ext;
13282             out_header = (void *)out_ext;
13283             break;
13284         }
13285         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
13286         {
13287             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13288             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header;
13289             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
13290             out_ext->pNext = NULL;
13291             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
13292             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
13293             out_header->pNext = (void *)out_ext;
13294             out_header = (void *)out_ext;
13295             break;
13296         }
13297         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
13298         {
13299             VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13300             const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *)in_header;
13301             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
13302             out_ext->pNext = NULL;
13303             out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
13304             out_header->pNext = (void *)out_ext;
13305             out_header = (void *)out_ext;
13306             break;
13307         }
13308         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
13309         {
13310             VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13311             const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *)in_header;
13312             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
13313             out_ext->pNext = NULL;
13314             out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
13315             out_header->pNext = (void *)out_ext;
13316             out_header = (void *)out_ext;
13317             break;
13318         }
13319         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
13320         {
13321             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13322             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header;
13323             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
13324             out_ext->pNext = NULL;
13325             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
13326             out_header->pNext = (void *)out_ext;
13327             out_header = (void *)out_ext;
13328             break;
13329         }
13330         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
13331         {
13332             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13333             const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header;
13334             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
13335             out_ext->pNext = NULL;
13336             out_ext->depthClipControl = in_ext->depthClipControl;
13337             out_header->pNext = (void *)out_ext;
13338             out_header = (void *)out_ext;
13339             break;
13340         }
13341         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
13342         {
13343             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13344             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header;
13345             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
13346             out_ext->pNext = NULL;
13347             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
13348             out_header->pNext = (void *)out_ext;
13349             out_header = (void *)out_ext;
13350             break;
13351         }
13352         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
13353         {
13354             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13355             const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header;
13356             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
13357             out_ext->pNext = NULL;
13358             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
13359             out_header->pNext = (void *)out_ext;
13360             out_header = (void *)out_ext;
13361             break;
13362         }
13363         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
13364         {
13365             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13366             const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header;
13367             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
13368             out_ext->pNext = NULL;
13369             out_ext->synchronization2 = in_ext->synchronization2;
13370             out_header->pNext = (void *)out_ext;
13371             out_header = (void *)out_ext;
13372             break;
13373         }
13374         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
13375         {
13376             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13377             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header;
13378             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
13379             out_ext->pNext = NULL;
13380             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
13381             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
13382             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
13383             out_header->pNext = (void *)out_ext;
13384             out_header = (void *)out_ext;
13385             break;
13386         }
13387         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
13388         {
13389             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13390             const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header;
13391             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
13392             out_ext->pNext = NULL;
13393             out_ext->legacyDithering = in_ext->legacyDithering;
13394             out_header->pNext = (void *)out_ext;
13395             out_header = (void *)out_ext;
13396             break;
13397         }
13398         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
13399         {
13400             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13401             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header;
13402             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
13403             out_ext->pNext = NULL;
13404             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
13405             out_header->pNext = (void *)out_ext;
13406             out_header = (void *)out_ext;
13407             break;
13408         }
13409         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
13410         {
13411             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13412             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *)in_header;
13413             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
13414             out_ext->pNext = NULL;
13415             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
13416             out_header->pNext = (void *)out_ext;
13417             out_header = (void *)out_ext;
13418             break;
13419         }
13420         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
13421         {
13422             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13423             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header;
13424             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
13425             out_ext->pNext = NULL;
13426             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
13427             out_header->pNext = (void *)out_ext;
13428             out_header = (void *)out_ext;
13429             break;
13430         }
13431         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
13432         {
13433             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13434             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header;
13435             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
13436             out_ext->pNext = NULL;
13437             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
13438             out_header->pNext = (void *)out_ext;
13439             out_header = (void *)out_ext;
13440             break;
13441         }
13442         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
13443         {
13444             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13445             const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *)in_header;
13446             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
13447             out_ext->pNext = NULL;
13448             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
13449             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
13450             out_header->pNext = (void *)out_ext;
13451             out_header = (void *)out_ext;
13452             break;
13453         }
13454         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
13455         {
13456             VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13457             const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header;
13458             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
13459             out_ext->pNext = NULL;
13460             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
13461             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
13462             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
13463             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
13464             out_header->pNext = (void *)out_ext;
13465             out_header = (void *)out_ext;
13466             break;
13467         }
13468         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
13469         {
13470             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13471             const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header;
13472             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
13473             out_ext->pNext = NULL;
13474             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
13475             out_header->pNext = (void *)out_ext;
13476             out_header = (void *)out_ext;
13477             break;
13478         }
13479         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
13480         {
13481             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13482             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header;
13483             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
13484             out_ext->pNext = NULL;
13485             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
13486             out_header->pNext = (void *)out_ext;
13487             out_header = (void *)out_ext;
13488             break;
13489         }
13490         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
13491         {
13492             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13493             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header;
13494             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
13495             out_ext->pNext = NULL;
13496             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
13497             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
13498             out_header->pNext = (void *)out_ext;
13499             out_header = (void *)out_ext;
13500             break;
13501         }
13502         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
13503         {
13504             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13505             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header;
13506             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
13507             out_ext->pNext = NULL;
13508             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
13509             out_header->pNext = (void *)out_ext;
13510             out_header = (void *)out_ext;
13511             break;
13512         }
13513         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
13514         {
13515             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13516             const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header;
13517             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
13518             out_ext->pNext = NULL;
13519             out_ext->dynamicRendering = in_ext->dynamicRendering;
13520             out_header->pNext = (void *)out_ext;
13521             out_header = (void *)out_ext;
13522             break;
13523         }
13524         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
13525         {
13526             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13527             const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header;
13528             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
13529             out_ext->pNext = NULL;
13530             out_ext->minLod = in_ext->minLod;
13531             out_header->pNext = (void *)out_ext;
13532             out_header = (void *)out_ext;
13533             break;
13534         }
13535         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
13536         {
13537             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13538             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header;
13539             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
13540             out_ext->pNext = NULL;
13541             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
13542             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
13543             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
13544             out_header->pNext = (void *)out_ext;
13545             out_header = (void *)out_ext;
13546             break;
13547         }
13548         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
13549         {
13550             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13551             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header;
13552             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
13553             out_ext->pNext = NULL;
13554             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
13555             out_header->pNext = (void *)out_ext;
13556             out_header = (void *)out_ext;
13557             break;
13558         }
13559         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
13560         {
13561             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13562             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header;
13563             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
13564             out_ext->pNext = NULL;
13565             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
13566             out_header->pNext = (void *)out_ext;
13567             out_header = (void *)out_ext;
13568             break;
13569         }
13570         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
13571         {
13572             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13573             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header;
13574             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
13575             out_ext->pNext = NULL;
13576             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
13577             out_header->pNext = (void *)out_ext;
13578             out_header = (void *)out_ext;
13579             break;
13580         }
13581         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
13582         {
13583             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13584             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header;
13585             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
13586             out_ext->pNext = NULL;
13587             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
13588             out_header->pNext = (void *)out_ext;
13589             out_header = (void *)out_ext;
13590             break;
13591         }
13592         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
13593         {
13594             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13595             const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header;
13596             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
13597             out_ext->pNext = NULL;
13598             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
13599             out_header->pNext = (void *)out_ext;
13600             out_header = (void *)out_ext;
13601             break;
13602         }
13603         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
13604         {
13605             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13606             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header;
13607             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
13608             out_ext->pNext = NULL;
13609             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
13610             out_header->pNext = (void *)out_ext;
13611             out_header = (void *)out_ext;
13612             break;
13613         }
13614         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
13615         {
13616             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13617             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header;
13618             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
13619             out_ext->pNext = NULL;
13620             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
13621             out_header->pNext = (void *)out_ext;
13622             out_header = (void *)out_ext;
13623             break;
13624         }
13625         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
13626         {
13627             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13628             const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header;
13629             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
13630             out_ext->pNext = NULL;
13631             out_ext->micromap = in_ext->micromap;
13632             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
13633             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
13634             out_header->pNext = (void *)out_ext;
13635             out_header = (void *)out_ext;
13636             break;
13637         }
13638         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
13639         {
13640             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13641             const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header;
13642             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
13643             out_ext->pNext = NULL;
13644             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
13645             out_header->pNext = (void *)out_ext;
13646             out_header = (void *)out_ext;
13647             break;
13648         }
13649         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
13650         {
13651             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13652             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header;
13653             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
13654             out_ext->pNext = NULL;
13655             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
13656             out_header->pNext = (void *)out_ext;
13657             out_header = (void *)out_ext;
13658             break;
13659         }
13660         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
13661         {
13662             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13663             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header;
13664             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
13665             out_ext->pNext = NULL;
13666             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
13667             out_header->pNext = (void *)out_ext;
13668             out_header = (void *)out_ext;
13669             break;
13670         }
13671         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
13672         {
13673             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13674             const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *)in_header;
13675             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
13676             out_ext->pNext = NULL;
13677             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
13678             out_header->pNext = (void *)out_ext;
13679             out_header = (void *)out_ext;
13680             break;
13681         }
13682         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
13683         {
13684             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13685             const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header;
13686             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
13687             out_ext->pNext = NULL;
13688             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
13689             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
13690             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
13691             out_header->pNext = (void *)out_ext;
13692             out_header = (void *)out_ext;
13693             break;
13694         }
13695         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
13696         {
13697             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13698             const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header;
13699             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
13700             out_ext->pNext = NULL;
13701             out_ext->tileProperties = in_ext->tileProperties;
13702             out_header->pNext = (void *)out_ext;
13703             out_header = (void *)out_ext;
13704             break;
13705         }
13706         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
13707         {
13708             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13709             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header;
13710             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
13711             out_ext->pNext = NULL;
13712             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
13713             out_header->pNext = (void *)out_ext;
13714             out_header = (void *)out_ext;
13715             break;
13716         }
13717         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
13718         {
13719             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13720             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *)in_header;
13721             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
13722             out_ext->pNext = NULL;
13723             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
13724             out_header->pNext = (void *)out_ext;
13725             out_header = (void *)out_ext;
13726             break;
13727         }
13728         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
13729         {
13730             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13731             const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header;
13732             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
13733             out_ext->pNext = NULL;
13734             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
13735             out_header->pNext = (void *)out_ext;
13736             out_header = (void *)out_ext;
13737             break;
13738         }
13739         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
13740         {
13741             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13742             const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header;
13743             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
13744             out_ext->pNext = NULL;
13745             out_ext->opticalFlow = in_ext->opticalFlow;
13746             out_header->pNext = (void *)out_ext;
13747             out_header = (void *)out_ext;
13748             break;
13749         }
13750         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
13751         {
13752             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13753             const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header;
13754             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
13755             out_ext->pNext = NULL;
13756             out_ext->deviceFault = in_ext->deviceFault;
13757             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
13758             out_header->pNext = (void *)out_ext;
13759             out_header = (void *)out_ext;
13760             break;
13761         }
13762         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
13763         {
13764             VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13765             const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *)in_header;
13766             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
13767             out_ext->pNext = NULL;
13768             out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
13769             out_header->pNext = (void *)out_ext;
13770             out_header = (void *)out_ext;
13771             break;
13772         }
13773         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
13774         {
13775             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13776             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header;
13777             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
13778             out_ext->pNext = NULL;
13779             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
13780             out_header->pNext = (void *)out_ext;
13781             out_header = (void *)out_ext;
13782             break;
13783         }
13784         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
13785         {
13786             VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13787             const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *)in_header;
13788             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
13789             out_ext->pNext = NULL;
13790             out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
13791             out_header->pNext = (void *)out_ext;
13792             out_header = (void *)out_ext;
13793             break;
13794         }
13795         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
13796         {
13797             VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13798             const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *)in_header;
13799             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT;
13800             out_ext->pNext = NULL;
13801             out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
13802             out_header->pNext = (void *)out_ext;
13803             out_header = (void *)out_ext;
13804             break;
13805         }
13806         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
13807         {
13808             VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13809             const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *)in_header;
13810             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
13811             out_ext->pNext = NULL;
13812             out_ext->depthBiasControl = in_ext->depthBiasControl;
13813             out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
13814             out_ext->floatRepresentation = in_ext->floatRepresentation;
13815             out_ext->depthBiasExact = in_ext->depthBiasExact;
13816             out_header->pNext = (void *)out_ext;
13817             out_header = (void *)out_ext;
13818             break;
13819         }
13820         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
13821         {
13822             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13823             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header;
13824             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
13825             out_ext->pNext = NULL;
13826             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
13827             out_header->pNext = (void *)out_ext;
13828             out_header = (void *)out_ext;
13829             break;
13830         }
13831         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
13832         {
13833             VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13834             const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *)in_header;
13835             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
13836             out_ext->pNext = NULL;
13837             out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
13838             out_header->pNext = (void *)out_ext;
13839             out_header = (void *)out_ext;
13840             break;
13841         }
13842         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
13843         {
13844             VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13845             const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *)in_header;
13846             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
13847             out_ext->pNext = NULL;
13848             out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
13849             out_header->pNext = (void *)out_ext;
13850             out_header = (void *)out_ext;
13851             break;
13852         }
13853         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
13854         {
13855             VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13856             const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *)in_header;
13857             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
13858             out_ext->pNext = NULL;
13859             out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
13860             out_header->pNext = (void *)out_ext;
13861             out_header = (void *)out_ext;
13862             break;
13863         }
13864         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
13865         {
13866             VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13867             const VkPhysicalDeviceShaderObjectFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT32 *)in_header;
13868             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
13869             out_ext->pNext = NULL;
13870             out_ext->shaderObject = in_ext->shaderObject;
13871             out_header->pNext = (void *)out_ext;
13872             out_header = (void *)out_ext;
13873             break;
13874         }
13875         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
13876         {
13877             VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13878             const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *)in_header;
13879             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
13880             out_ext->pNext = NULL;
13881             out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
13882             out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
13883             out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
13884             out_header->pNext = (void *)out_ext;
13885             out_header = (void *)out_ext;
13886             break;
13887         }
13888         default:
13889             FIXME("Unhandled sType %u.\n", in_header->sType);
13890             break;
13891         }
13892     }
13893 }
13894
13895 static inline void convert_VkEventCreateInfo_win32_to_host(const VkEventCreateInfo32 *in, VkEventCreateInfo *out)
13896 {
13897     if (!in) return;
13898
13899     out->sType = in->sType;
13900     out->pNext = NULL;
13901     out->flags = in->flags;
13902     if (in->pNext)
13903         FIXME("Unexpected pNext\n");
13904 }
13905
13906 static inline void convert_VkFenceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFenceCreateInfo32 *in, VkFenceCreateInfo *out)
13907 {
13908     const VkBaseInStructure32 *in_header;
13909     VkBaseOutStructure *out_header = (void *)out;
13910
13911     if (!in) return;
13912
13913     out->sType = in->sType;
13914     out->pNext = NULL;
13915     out->flags = in->flags;
13916
13917     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
13918     {
13919         switch (in_header->sType)
13920         {
13921         case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
13922         {
13923             VkExportFenceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13924             const VkExportFenceCreateInfo32 *in_ext = (const VkExportFenceCreateInfo32 *)in_header;
13925             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO;
13926             out_ext->pNext = NULL;
13927             out_ext->handleTypes = in_ext->handleTypes;
13928             out_header->pNext = (void *)out_ext;
13929             out_header = (void *)out_ext;
13930             break;
13931         }
13932         default:
13933             FIXME("Unhandled sType %u.\n", in_header->sType);
13934             break;
13935         }
13936     }
13937 }
13938
13939 static inline void convert_VkFramebufferAttachmentImageInfo_win32_to_host(const VkFramebufferAttachmentImageInfo32 *in, VkFramebufferAttachmentImageInfo *out)
13940 {
13941     if (!in) return;
13942
13943     out->sType = in->sType;
13944     out->pNext = NULL;
13945     out->flags = in->flags;
13946     out->usage = in->usage;
13947     out->width = in->width;
13948     out->height = in->height;
13949     out->layerCount = in->layerCount;
13950     out->viewFormatCount = in->viewFormatCount;
13951     out->pViewFormats = (const VkFormat *)UlongToPtr(in->pViewFormats);
13952     if (in->pNext)
13953         FIXME("Unexpected pNext\n");
13954 }
13955
13956 static inline const VkFramebufferAttachmentImageInfo *convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferAttachmentImageInfo32 *in, uint32_t count)
13957 {
13958     VkFramebufferAttachmentImageInfo *out;
13959     unsigned int i;
13960
13961     if (!in || !count) return NULL;
13962
13963     out = conversion_context_alloc(ctx, count * sizeof(*out));
13964     for (i = 0; i < count; i++)
13965     {
13966         convert_VkFramebufferAttachmentImageInfo_win32_to_host(&in[i], &out[i]);
13967     }
13968
13969     return out;
13970 }
13971
13972 static inline void convert_VkFramebufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFramebufferCreateInfo32 *in, VkFramebufferCreateInfo *out)
13973 {
13974     const VkBaseInStructure32 *in_header;
13975     VkBaseOutStructure *out_header = (void *)out;
13976
13977     if (!in) return;
13978
13979     out->sType = in->sType;
13980     out->pNext = NULL;
13981     out->flags = in->flags;
13982     out->renderPass = in->renderPass;
13983     out->attachmentCount = in->attachmentCount;
13984     out->pAttachments = (const VkImageView *)UlongToPtr(in->pAttachments);
13985     out->width = in->width;
13986     out->height = in->height;
13987     out->layers = in->layers;
13988
13989     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
13990     {
13991         switch (in_header->sType)
13992         {
13993         case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
13994         {
13995             VkFramebufferAttachmentsCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13996             const VkFramebufferAttachmentsCreateInfo32 *in_ext = (const VkFramebufferAttachmentsCreateInfo32 *)in_header;
13997             out_ext->sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
13998             out_ext->pNext = NULL;
13999             out_ext->attachmentImageInfoCount = in_ext->attachmentImageInfoCount;
14000             out_ext->pAttachmentImageInfos = convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(ctx, (const VkFramebufferAttachmentImageInfo32 *)UlongToPtr(in_ext->pAttachmentImageInfos), in_ext->attachmentImageInfoCount);
14001             out_header->pNext = (void *)out_ext;
14002             out_header = (void *)out_ext;
14003             break;
14004         }
14005         default:
14006             FIXME("Unhandled sType %u.\n", in_header->sType);
14007             break;
14008         }
14009     }
14010 }
14011
14012 #ifdef _WIN64
14013 static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, uint32_t count)
14014 {
14015     VkPipelineShaderStageCreateInfo *out;
14016     unsigned int i;
14017
14018     if (!in || !count) return NULL;
14019
14020     out = conversion_context_alloc(ctx, count * sizeof(*out));
14021     for (i = 0; i < count; i++)
14022     {
14023         convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
14024     }
14025
14026     return out;
14027 }
14028 #endif /* _WIN64 */
14029
14030 static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, uint32_t count)
14031 {
14032     VkPipelineShaderStageCreateInfo *out;
14033     unsigned int i;
14034
14035     if (!in || !count) return NULL;
14036
14037     out = conversion_context_alloc(ctx, count * sizeof(*out));
14038     for (i = 0; i < count; i++)
14039     {
14040         convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14041     }
14042
14043     return out;
14044 }
14045
14046 static inline void convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, VkPipelineVertexInputStateCreateInfo *out)
14047 {
14048     const VkBaseInStructure32 *in_header;
14049     VkBaseOutStructure *out_header = (void *)out;
14050
14051     if (!in) return;
14052
14053     out->sType = in->sType;
14054     out->pNext = NULL;
14055     out->flags = in->flags;
14056     out->vertexBindingDescriptionCount = in->vertexBindingDescriptionCount;
14057     out->pVertexBindingDescriptions = (const VkVertexInputBindingDescription *)UlongToPtr(in->pVertexBindingDescriptions);
14058     out->vertexAttributeDescriptionCount = in->vertexAttributeDescriptionCount;
14059     out->pVertexAttributeDescriptions = (const VkVertexInputAttributeDescription *)UlongToPtr(in->pVertexAttributeDescriptions);
14060
14061     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14062     {
14063         switch (in_header->sType)
14064         {
14065         case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
14066         {
14067             VkPipelineVertexInputDivisorStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14068             const VkPipelineVertexInputDivisorStateCreateInfoEXT32 *in_ext = (const VkPipelineVertexInputDivisorStateCreateInfoEXT32 *)in_header;
14069             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT;
14070             out_ext->pNext = NULL;
14071             out_ext->vertexBindingDivisorCount = in_ext->vertexBindingDivisorCount;
14072             out_ext->pVertexBindingDivisors = (const VkVertexInputBindingDivisorDescriptionEXT *)UlongToPtr(in_ext->pVertexBindingDivisors);
14073             out_header->pNext = (void *)out_ext;
14074             out_header = (void *)out_ext;
14075             break;
14076         }
14077         default:
14078             FIXME("Unhandled sType %u.\n", in_header->sType);
14079             break;
14080         }
14081     }
14082 }
14083
14084 static inline const VkPipelineVertexInputStateCreateInfo *convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, uint32_t count)
14085 {
14086     VkPipelineVertexInputStateCreateInfo *out;
14087     unsigned int i;
14088
14089     if (!in || !count) return NULL;
14090
14091     out = conversion_context_alloc(ctx, count * sizeof(*out));
14092     for (i = 0; i < count; i++)
14093     {
14094         convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14095     }
14096
14097     return out;
14098 }
14099
14100 static inline void convert_VkPipelineTessellationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, VkPipelineTessellationStateCreateInfo *out)
14101 {
14102     const VkBaseInStructure32 *in_header;
14103     VkBaseOutStructure *out_header = (void *)out;
14104
14105     if (!in) return;
14106
14107     out->sType = in->sType;
14108     out->pNext = NULL;
14109     out->flags = in->flags;
14110     out->patchControlPoints = in->patchControlPoints;
14111
14112     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14113     {
14114         switch (in_header->sType)
14115         {
14116         case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
14117         {
14118             VkPipelineTessellationDomainOriginStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14119             const VkPipelineTessellationDomainOriginStateCreateInfo32 *in_ext = (const VkPipelineTessellationDomainOriginStateCreateInfo32 *)in_header;
14120             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
14121             out_ext->pNext = NULL;
14122             out_ext->domainOrigin = in_ext->domainOrigin;
14123             out_header->pNext = (void *)out_ext;
14124             out_header = (void *)out_ext;
14125             break;
14126         }
14127         default:
14128             FIXME("Unhandled sType %u.\n", in_header->sType);
14129             break;
14130         }
14131     }
14132 }
14133
14134 static inline const VkPipelineTessellationStateCreateInfo *convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, uint32_t count)
14135 {
14136     VkPipelineTessellationStateCreateInfo *out;
14137     unsigned int i;
14138
14139     if (!in || !count) return NULL;
14140
14141     out = conversion_context_alloc(ctx, count * sizeof(*out));
14142     for (i = 0; i < count; i++)
14143     {
14144         convert_VkPipelineTessellationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14145     }
14146
14147     return out;
14148 }
14149
14150 #ifdef _WIN64
14151 static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, VkGraphicsShaderGroupCreateInfoNV *out)
14152 {
14153     if (!in) return;
14154
14155     out->sType = in->sType;
14156     out->pNext = in->pNext;
14157     out->stageCount = in->stageCount;
14158     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
14159     out->pVertexInputState = in->pVertexInputState;
14160     out->pTessellationState = in->pTessellationState;
14161 }
14162 #endif /* _WIN64 */
14163
14164 static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, VkGraphicsShaderGroupCreateInfoNV *out)
14165 {
14166     if (!in) return;
14167
14168     out->sType = in->sType;
14169     out->pNext = NULL;
14170     out->stageCount = in->stageCount;
14171     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
14172     out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineVertexInputStateCreateInfo32 *)UlongToPtr(in->pVertexInputState), 1);
14173     out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineTessellationStateCreateInfo32 *)UlongToPtr(in->pTessellationState), 1);
14174     if (in->pNext)
14175         FIXME("Unexpected pNext\n");
14176 }
14177
14178 #ifdef _WIN64
14179 static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, uint32_t count)
14180 {
14181     VkGraphicsShaderGroupCreateInfoNV *out;
14182     unsigned int i;
14183
14184     if (!in || !count) return NULL;
14185
14186     out = conversion_context_alloc(ctx, count * sizeof(*out));
14187     for (i = 0; i < count; i++)
14188     {
14189         convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
14190     }
14191
14192     return out;
14193 }
14194 #endif /* _WIN64 */
14195
14196 static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, uint32_t count)
14197 {
14198     VkGraphicsShaderGroupCreateInfoNV *out;
14199     unsigned int i;
14200
14201     if (!in || !count) return NULL;
14202
14203     out = conversion_context_alloc(ctx, count * sizeof(*out));
14204     for (i = 0; i < count; i++)
14205     {
14206         convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
14207     }
14208
14209     return out;
14210 }
14211
14212 static inline void convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(const VkPipelineInputAssemblyStateCreateInfo32 *in, VkPipelineInputAssemblyStateCreateInfo *out)
14213 {
14214     if (!in) return;
14215
14216     out->sType = in->sType;
14217     out->pNext = NULL;
14218     out->flags = in->flags;
14219     out->topology = in->topology;
14220     out->primitiveRestartEnable = in->primitiveRestartEnable;
14221     if (in->pNext)
14222         FIXME("Unexpected pNext\n");
14223 }
14224
14225 static inline const VkPipelineInputAssemblyStateCreateInfo *convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineInputAssemblyStateCreateInfo32 *in, uint32_t count)
14226 {
14227     VkPipelineInputAssemblyStateCreateInfo *out;
14228     unsigned int i;
14229
14230     if (!in || !count) return NULL;
14231
14232     out = conversion_context_alloc(ctx, count * sizeof(*out));
14233     for (i = 0; i < count; i++)
14234     {
14235         convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(&in[i], &out[i]);
14236     }
14237
14238     return out;
14239 }
14240
14241 static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, VkPipelineViewportStateCreateInfo *out)
14242 {
14243     const VkBaseInStructure32 *in_header;
14244     VkBaseOutStructure *out_header = (void *)out;
14245
14246     if (!in) return;
14247
14248     out->sType = in->sType;
14249     out->pNext = NULL;
14250     out->flags = in->flags;
14251     out->viewportCount = in->viewportCount;
14252     out->pViewports = (const VkViewport *)UlongToPtr(in->pViewports);
14253     out->scissorCount = in->scissorCount;
14254     out->pScissors = (const VkRect2D *)UlongToPtr(in->pScissors);
14255
14256     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14257     {
14258         switch (in_header->sType)
14259         {
14260         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
14261         {
14262             VkPipelineViewportWScalingStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14263             const VkPipelineViewportWScalingStateCreateInfoNV32 *in_ext = (const VkPipelineViewportWScalingStateCreateInfoNV32 *)in_header;
14264             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV;
14265             out_ext->pNext = NULL;
14266             out_ext->viewportWScalingEnable = in_ext->viewportWScalingEnable;
14267             out_ext->viewportCount = in_ext->viewportCount;
14268             out_ext->pViewportWScalings = (const VkViewportWScalingNV *)UlongToPtr(in_ext->pViewportWScalings);
14269             out_header->pNext = (void *)out_ext;
14270             out_header = (void *)out_ext;
14271             break;
14272         }
14273         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
14274         {
14275             VkPipelineViewportSwizzleStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14276             const VkPipelineViewportSwizzleStateCreateInfoNV32 *in_ext = (const VkPipelineViewportSwizzleStateCreateInfoNV32 *)in_header;
14277             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV;
14278             out_ext->pNext = NULL;
14279             out_ext->flags = in_ext->flags;
14280             out_ext->viewportCount = in_ext->viewportCount;
14281             out_ext->pViewportSwizzles = (const VkViewportSwizzleNV *)UlongToPtr(in_ext->pViewportSwizzles);
14282             out_header->pNext = (void *)out_ext;
14283             out_header = (void *)out_ext;
14284             break;
14285         }
14286         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
14287         {
14288             VkPipelineViewportExclusiveScissorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14289             const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *in_ext = (const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *)in_header;
14290             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV;
14291             out_ext->pNext = NULL;
14292             out_ext->exclusiveScissorCount = in_ext->exclusiveScissorCount;
14293             out_ext->pExclusiveScissors = (const VkRect2D *)UlongToPtr(in_ext->pExclusiveScissors);
14294             out_header->pNext = (void *)out_ext;
14295             out_header = (void *)out_ext;
14296             break;
14297         }
14298         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
14299         {
14300             VkPipelineViewportShadingRateImageStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14301             const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *in_ext = (const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *)in_header;
14302             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV;
14303             out_ext->pNext = NULL;
14304             out_ext->shadingRateImageEnable = in_ext->shadingRateImageEnable;
14305             out_ext->viewportCount = in_ext->viewportCount;
14306             out_ext->pShadingRatePalettes = convert_VkShadingRatePaletteNV_array_win32_to_host(ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(in_ext->pShadingRatePalettes), in_ext->viewportCount);
14307             out_header->pNext = (void *)out_ext;
14308             out_header = (void *)out_ext;
14309             break;
14310         }
14311         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
14312         {
14313             VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14314             const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *in_ext = (const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *)in_header;
14315             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV;
14316             out_ext->pNext = NULL;
14317             out_ext->sampleOrderType = in_ext->sampleOrderType;
14318             out_ext->customSampleOrderCount = in_ext->customSampleOrderCount;
14319             out_ext->pCustomSampleOrders = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(in_ext->pCustomSampleOrders), in_ext->customSampleOrderCount);
14320             out_header->pNext = (void *)out_ext;
14321             out_header = (void *)out_ext;
14322             break;
14323         }
14324         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
14325         {
14326             VkPipelineViewportDepthClipControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14327             const VkPipelineViewportDepthClipControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClipControlCreateInfoEXT32 *)in_header;
14328             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT;
14329             out_ext->pNext = NULL;
14330             out_ext->negativeOneToOne = in_ext->negativeOneToOne;
14331             out_header->pNext = (void *)out_ext;
14332             out_header = (void *)out_ext;
14333             break;
14334         }
14335         default:
14336             FIXME("Unhandled sType %u.\n", in_header->sType);
14337             break;
14338         }
14339     }
14340 }
14341
14342 static inline const VkPipelineViewportStateCreateInfo *convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, uint32_t count)
14343 {
14344     VkPipelineViewportStateCreateInfo *out;
14345     unsigned int i;
14346
14347     if (!in || !count) return NULL;
14348
14349     out = conversion_context_alloc(ctx, count * sizeof(*out));
14350     for (i = 0; i < count; i++)
14351     {
14352         convert_VkPipelineViewportStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14353     }
14354
14355     return out;
14356 }
14357
14358 static inline void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, VkPipelineRasterizationStateCreateInfo *out)
14359 {
14360     const VkBaseInStructure32 *in_header;
14361     VkBaseOutStructure *out_header = (void *)out;
14362
14363     if (!in) return;
14364
14365     out->sType = in->sType;
14366     out->pNext = NULL;
14367     out->flags = in->flags;
14368     out->depthClampEnable = in->depthClampEnable;
14369     out->rasterizerDiscardEnable = in->rasterizerDiscardEnable;
14370     out->polygonMode = in->polygonMode;
14371     out->cullMode = in->cullMode;
14372     out->frontFace = in->frontFace;
14373     out->depthBiasEnable = in->depthBiasEnable;
14374     out->depthBiasConstantFactor = in->depthBiasConstantFactor;
14375     out->depthBiasClamp = in->depthBiasClamp;
14376     out->depthBiasSlopeFactor = in->depthBiasSlopeFactor;
14377     out->lineWidth = in->lineWidth;
14378
14379     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14380     {
14381         switch (in_header->sType)
14382         {
14383         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
14384         {
14385             VkPipelineRasterizationStateRasterizationOrderAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14386             const VkPipelineRasterizationStateRasterizationOrderAMD32 *in_ext = (const VkPipelineRasterizationStateRasterizationOrderAMD32 *)in_header;
14387             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD;
14388             out_ext->pNext = NULL;
14389             out_ext->rasterizationOrder = in_ext->rasterizationOrder;
14390             out_header->pNext = (void *)out_ext;
14391             out_header = (void *)out_ext;
14392             break;
14393         }
14394         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
14395         {
14396             VkPipelineRasterizationConservativeStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14397             const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *)in_header;
14398             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT;
14399             out_ext->pNext = NULL;
14400             out_ext->flags = in_ext->flags;
14401             out_ext->conservativeRasterizationMode = in_ext->conservativeRasterizationMode;
14402             out_ext->extraPrimitiveOverestimationSize = in_ext->extraPrimitiveOverestimationSize;
14403             out_header->pNext = (void *)out_ext;
14404             out_header = (void *)out_ext;
14405             break;
14406         }
14407         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
14408         {
14409             VkPipelineRasterizationStateStreamCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14410             const VkPipelineRasterizationStateStreamCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationStateStreamCreateInfoEXT32 *)in_header;
14411             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT;
14412             out_ext->pNext = NULL;
14413             out_ext->flags = in_ext->flags;
14414             out_ext->rasterizationStream = in_ext->rasterizationStream;
14415             out_header->pNext = (void *)out_ext;
14416             out_header = (void *)out_ext;
14417             break;
14418         }
14419         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
14420         {
14421             VkPipelineRasterizationDepthClipStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14422             const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *)in_header;
14423             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT;
14424             out_ext->pNext = NULL;
14425             out_ext->flags = in_ext->flags;
14426             out_ext->depthClipEnable = in_ext->depthClipEnable;
14427             out_header->pNext = (void *)out_ext;
14428             out_header = (void *)out_ext;
14429             break;
14430         }
14431         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
14432         {
14433             VkPipelineRasterizationLineStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14434             const VkPipelineRasterizationLineStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationLineStateCreateInfoEXT32 *)in_header;
14435             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT;
14436             out_ext->pNext = NULL;
14437             out_ext->lineRasterizationMode = in_ext->lineRasterizationMode;
14438             out_ext->stippledLineEnable = in_ext->stippledLineEnable;
14439             out_ext->lineStippleFactor = in_ext->lineStippleFactor;
14440             out_ext->lineStipplePattern = in_ext->lineStipplePattern;
14441             out_header->pNext = (void *)out_ext;
14442             out_header = (void *)out_ext;
14443             break;
14444         }
14445         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
14446         {
14447             VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14448             const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *)in_header;
14449             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT;
14450             out_ext->pNext = NULL;
14451             out_ext->provokingVertexMode = in_ext->provokingVertexMode;
14452             out_header->pNext = (void *)out_ext;
14453             out_header = (void *)out_ext;
14454             break;
14455         }
14456         case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
14457         {
14458             VkDepthBiasRepresentationInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14459             const VkDepthBiasRepresentationInfoEXT32 *in_ext = (const VkDepthBiasRepresentationInfoEXT32 *)in_header;
14460             out_ext->sType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT;
14461             out_ext->pNext = NULL;
14462             out_ext->depthBiasRepresentation = in_ext->depthBiasRepresentation;
14463             out_ext->depthBiasExact = in_ext->depthBiasExact;
14464             out_header->pNext = (void *)out_ext;
14465             out_header = (void *)out_ext;
14466             break;
14467         }
14468         default:
14469             FIXME("Unhandled sType %u.\n", in_header->sType);
14470             break;
14471         }
14472     }
14473 }
14474
14475 static inline const VkPipelineRasterizationStateCreateInfo *convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, uint32_t count)
14476 {
14477     VkPipelineRasterizationStateCreateInfo *out;
14478     unsigned int i;
14479
14480     if (!in || !count) return NULL;
14481
14482     out = conversion_context_alloc(ctx, count * sizeof(*out));
14483     for (i = 0; i < count; i++)
14484     {
14485         convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14486     }
14487
14488     return out;
14489 }
14490
14491 static inline void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, VkPipelineMultisampleStateCreateInfo *out)
14492 {
14493     const VkBaseInStructure32 *in_header;
14494     VkBaseOutStructure *out_header = (void *)out;
14495
14496     if (!in) return;
14497
14498     out->sType = in->sType;
14499     out->pNext = NULL;
14500     out->flags = in->flags;
14501     out->rasterizationSamples = in->rasterizationSamples;
14502     out->sampleShadingEnable = in->sampleShadingEnable;
14503     out->minSampleShading = in->minSampleShading;
14504     out->pSampleMask = (const VkSampleMask *)UlongToPtr(in->pSampleMask);
14505     out->alphaToCoverageEnable = in->alphaToCoverageEnable;
14506     out->alphaToOneEnable = in->alphaToOneEnable;
14507
14508     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14509     {
14510         switch (in_header->sType)
14511         {
14512         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
14513         {
14514             VkPipelineCoverageToColorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14515             const VkPipelineCoverageToColorStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageToColorStateCreateInfoNV32 *)in_header;
14516             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV;
14517             out_ext->pNext = NULL;
14518             out_ext->flags = in_ext->flags;
14519             out_ext->coverageToColorEnable = in_ext->coverageToColorEnable;
14520             out_ext->coverageToColorLocation = in_ext->coverageToColorLocation;
14521             out_header->pNext = (void *)out_ext;
14522             out_header = (void *)out_ext;
14523             break;
14524         }
14525         case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
14526         {
14527             VkPipelineSampleLocationsStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14528             const VkPipelineSampleLocationsStateCreateInfoEXT32 *in_ext = (const VkPipelineSampleLocationsStateCreateInfoEXT32 *)in_header;
14529             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT;
14530             out_ext->pNext = NULL;
14531             out_ext->sampleLocationsEnable = in_ext->sampleLocationsEnable;
14532             convert_VkSampleLocationsInfoEXT_win32_to_host(&in_ext->sampleLocationsInfo, &out_ext->sampleLocationsInfo);
14533             out_header->pNext = (void *)out_ext;
14534             out_header = (void *)out_ext;
14535             break;
14536         }
14537         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
14538         {
14539             VkPipelineCoverageModulationStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14540             const VkPipelineCoverageModulationStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageModulationStateCreateInfoNV32 *)in_header;
14541             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV;
14542             out_ext->pNext = NULL;
14543             out_ext->flags = in_ext->flags;
14544             out_ext->coverageModulationMode = in_ext->coverageModulationMode;
14545             out_ext->coverageModulationTableEnable = in_ext->coverageModulationTableEnable;
14546             out_ext->coverageModulationTableCount = in_ext->coverageModulationTableCount;
14547             out_ext->pCoverageModulationTable = (const float *)UlongToPtr(in_ext->pCoverageModulationTable);
14548             out_header->pNext = (void *)out_ext;
14549             out_header = (void *)out_ext;
14550             break;
14551         }
14552         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
14553         {
14554             VkPipelineCoverageReductionStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14555             const VkPipelineCoverageReductionStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageReductionStateCreateInfoNV32 *)in_header;
14556             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV;
14557             out_ext->pNext = NULL;
14558             out_ext->flags = in_ext->flags;
14559             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
14560             out_header->pNext = (void *)out_ext;
14561             out_header = (void *)out_ext;
14562             break;
14563         }
14564         default:
14565             FIXME("Unhandled sType %u.\n", in_header->sType);
14566             break;
14567         }
14568     }
14569 }
14570
14571 static inline const VkPipelineMultisampleStateCreateInfo *convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, uint32_t count)
14572 {
14573     VkPipelineMultisampleStateCreateInfo *out;
14574     unsigned int i;
14575
14576     if (!in || !count) return NULL;
14577
14578     out = conversion_context_alloc(ctx, count * sizeof(*out));
14579     for (i = 0; i < count; i++)
14580     {
14581         convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14582     }
14583
14584     return out;
14585 }
14586
14587 static inline void convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(const VkPipelineDepthStencilStateCreateInfo32 *in, VkPipelineDepthStencilStateCreateInfo *out)
14588 {
14589     if (!in) return;
14590
14591     out->sType = in->sType;
14592     out->pNext = NULL;
14593     out->flags = in->flags;
14594     out->depthTestEnable = in->depthTestEnable;
14595     out->depthWriteEnable = in->depthWriteEnable;
14596     out->depthCompareOp = in->depthCompareOp;
14597     out->depthBoundsTestEnable = in->depthBoundsTestEnable;
14598     out->stencilTestEnable = in->stencilTestEnable;
14599     out->front = in->front;
14600     out->back = in->back;
14601     out->minDepthBounds = in->minDepthBounds;
14602     out->maxDepthBounds = in->maxDepthBounds;
14603     if (in->pNext)
14604         FIXME("Unexpected pNext\n");
14605 }
14606
14607 static inline const VkPipelineDepthStencilStateCreateInfo *convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDepthStencilStateCreateInfo32 *in, uint32_t count)
14608 {
14609     VkPipelineDepthStencilStateCreateInfo *out;
14610     unsigned int i;
14611
14612     if (!in || !count) return NULL;
14613
14614     out = conversion_context_alloc(ctx, count * sizeof(*out));
14615     for (i = 0; i < count; i++)
14616     {
14617         convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(&in[i], &out[i]);
14618     }
14619
14620     return out;
14621 }
14622
14623 static inline void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, VkPipelineColorBlendStateCreateInfo *out)
14624 {
14625     const VkBaseInStructure32 *in_header;
14626     VkBaseOutStructure *out_header = (void *)out;
14627
14628     if (!in) return;
14629
14630     out->sType = in->sType;
14631     out->pNext = NULL;
14632     out->flags = in->flags;
14633     out->logicOpEnable = in->logicOpEnable;
14634     out->logicOp = in->logicOp;
14635     out->attachmentCount = in->attachmentCount;
14636     out->pAttachments = (const VkPipelineColorBlendAttachmentState *)UlongToPtr(in->pAttachments);
14637     memcpy(out->blendConstants, in->blendConstants, 4 * sizeof(float));
14638
14639     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14640     {
14641         switch (in_header->sType)
14642         {
14643         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
14644         {
14645             VkPipelineColorBlendAdvancedStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14646             const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *in_ext = (const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *)in_header;
14647             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT;
14648             out_ext->pNext = NULL;
14649             out_ext->srcPremultiplied = in_ext->srcPremultiplied;
14650             out_ext->dstPremultiplied = in_ext->dstPremultiplied;
14651             out_ext->blendOverlap = in_ext->blendOverlap;
14652             out_header->pNext = (void *)out_ext;
14653             out_header = (void *)out_ext;
14654             break;
14655         }
14656         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
14657         {
14658             VkPipelineColorWriteCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14659             const VkPipelineColorWriteCreateInfoEXT32 *in_ext = (const VkPipelineColorWriteCreateInfoEXT32 *)in_header;
14660             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT;
14661             out_ext->pNext = NULL;
14662             out_ext->attachmentCount = in_ext->attachmentCount;
14663             out_ext->pColorWriteEnables = (const VkBool32 *)UlongToPtr(in_ext->pColorWriteEnables);
14664             out_header->pNext = (void *)out_ext;
14665             out_header = (void *)out_ext;
14666             break;
14667         }
14668         default:
14669             FIXME("Unhandled sType %u.\n", in_header->sType);
14670             break;
14671         }
14672     }
14673 }
14674
14675 static inline const VkPipelineColorBlendStateCreateInfo *convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, uint32_t count)
14676 {
14677     VkPipelineColorBlendStateCreateInfo *out;
14678     unsigned int i;
14679
14680     if (!in || !count) return NULL;
14681
14682     out = conversion_context_alloc(ctx, count * sizeof(*out));
14683     for (i = 0; i < count; i++)
14684     {
14685         convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14686     }
14687
14688     return out;
14689 }
14690
14691 static inline void convert_VkPipelineDynamicStateCreateInfo_win32_to_host(const VkPipelineDynamicStateCreateInfo32 *in, VkPipelineDynamicStateCreateInfo *out)
14692 {
14693     if (!in) return;
14694
14695     out->sType = in->sType;
14696     out->pNext = NULL;
14697     out->flags = in->flags;
14698     out->dynamicStateCount = in->dynamicStateCount;
14699     out->pDynamicStates = (const VkDynamicState *)UlongToPtr(in->pDynamicStates);
14700     if (in->pNext)
14701         FIXME("Unexpected pNext\n");
14702 }
14703
14704 static inline const VkPipelineDynamicStateCreateInfo *convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDynamicStateCreateInfo32 *in, uint32_t count)
14705 {
14706     VkPipelineDynamicStateCreateInfo *out;
14707     unsigned int i;
14708
14709     if (!in || !count) return NULL;
14710
14711     out = conversion_context_alloc(ctx, count * sizeof(*out));
14712     for (i = 0; i < count; i++)
14713     {
14714         convert_VkPipelineDynamicStateCreateInfo_win32_to_host(&in[i], &out[i]);
14715     }
14716
14717     return out;
14718 }
14719
14720 #ifdef _WIN64
14721 static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, VkGraphicsPipelineCreateInfo *out)
14722 {
14723     const VkBaseInStructure *in_header;
14724     VkBaseOutStructure *out_header = (void *)out;
14725
14726     if (!in) return;
14727
14728     out->sType = in->sType;
14729     out->pNext = NULL;
14730     out->flags = in->flags;
14731     out->stageCount = in->stageCount;
14732     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
14733     out->pVertexInputState = in->pVertexInputState;
14734     out->pInputAssemblyState = in->pInputAssemblyState;
14735     out->pTessellationState = in->pTessellationState;
14736     out->pViewportState = in->pViewportState;
14737     out->pRasterizationState = in->pRasterizationState;
14738     out->pMultisampleState = in->pMultisampleState;
14739     out->pDepthStencilState = in->pDepthStencilState;
14740     out->pColorBlendState = in->pColorBlendState;
14741     out->pDynamicState = in->pDynamicState;
14742     out->layout = in->layout;
14743     out->renderPass = in->renderPass;
14744     out->subpass = in->subpass;
14745     out->basePipelineHandle = in->basePipelineHandle;
14746     out->basePipelineIndex = in->basePipelineIndex;
14747
14748     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
14749     {
14750         switch (in_header->sType)
14751         {
14752         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
14753         {
14754             VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14755             const VkGraphicsPipelineShaderGroupsCreateInfoNV *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV *)in_header;
14756             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
14757             out_ext->pNext = NULL;
14758             out_ext->groupCount = in_ext->groupCount;
14759             out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(ctx, in_ext->pGroups, in_ext->groupCount);
14760             out_ext->pipelineCount = in_ext->pipelineCount;
14761             out_ext->pPipelines = in_ext->pPipelines;
14762             out_header->pNext = (void *)out_ext;
14763             out_header = (void *)out_ext;
14764             break;
14765         }
14766         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
14767         {
14768             VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14769             const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header;
14770             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
14771             out_ext->pNext = NULL;
14772             out_ext->flags = in_ext->flags;
14773             out_ext->discardRectangleMode = in_ext->discardRectangleMode;
14774             out_ext->discardRectangleCount = in_ext->discardRectangleCount;
14775             out_ext->pDiscardRectangles = in_ext->pDiscardRectangles;
14776             out_header->pNext = (void *)out_ext;
14777             out_header = (void *)out_ext;
14778             break;
14779         }
14780         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
14781         {
14782             VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14783             const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header;
14784             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
14785             out_ext->pNext = NULL;
14786             out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
14787             out_header->pNext = (void *)out_ext;
14788             out_header = (void *)out_ext;
14789             break;
14790         }
14791         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
14792         {
14793             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14794             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
14795             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
14796             out_ext->pNext = NULL;
14797             out_ext->pPipelineCreationFeedback = in_ext->pPipelineCreationFeedback;
14798             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
14799             out_ext->pPipelineStageCreationFeedbacks = in_ext->pPipelineStageCreationFeedbacks;
14800             out_header->pNext = (void *)out_ext;
14801             out_header = (void *)out_ext;
14802             break;
14803         }
14804         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
14805         {
14806             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14807             const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header;
14808             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
14809             out_ext->pNext = NULL;
14810             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
14811             out_header->pNext = (void *)out_ext;
14812             out_header = (void *)out_ext;
14813             break;
14814         }
14815         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
14816         {
14817             VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14818             const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header;
14819             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
14820             out_ext->pNext = NULL;
14821             out_ext->libraryCount = in_ext->libraryCount;
14822             out_ext->pLibraries = in_ext->pLibraries;
14823             out_header->pNext = (void *)out_ext;
14824             out_header = (void *)out_ext;
14825             break;
14826         }
14827         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
14828         {
14829             VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14830             const VkPipelineFragmentShadingRateStateCreateInfoKHR *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR *)in_header;
14831             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
14832             out_ext->pNext = NULL;
14833             out_ext->fragmentSize = in_ext->fragmentSize;
14834             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
14835             out_header->pNext = (void *)out_ext;
14836             out_header = (void *)out_ext;
14837             break;
14838         }
14839         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
14840         {
14841             VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14842             const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header;
14843             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
14844             out_ext->pNext = NULL;
14845             out_ext->shadingRateType = in_ext->shadingRateType;
14846             out_ext->shadingRate = in_ext->shadingRate;
14847             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
14848             out_header->pNext = (void *)out_ext;
14849             out_header = (void *)out_ext;
14850             break;
14851         }
14852         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
14853         {
14854             VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14855             const VkPipelineRenderingCreateInfo *in_ext = (const VkPipelineRenderingCreateInfo *)in_header;
14856             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
14857             out_ext->pNext = NULL;
14858             out_ext->viewMask = in_ext->viewMask;
14859             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
14860             out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats;
14861             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
14862             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
14863             out_header->pNext = (void *)out_ext;
14864             out_header = (void *)out_ext;
14865             break;
14866         }
14867         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
14868         {
14869             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14870             const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header;
14871             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
14872             out_ext->pNext = NULL;
14873             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
14874             out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
14875             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
14876             out_header->pNext = (void *)out_ext;
14877             out_header = (void *)out_ext;
14878             break;
14879         }
14880         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
14881         {
14882             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14883             const VkMultiviewPerViewAttributesInfoNVX *in_ext = (const VkMultiviewPerViewAttributesInfoNVX *)in_header;
14884             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
14885             out_ext->pNext = NULL;
14886             out_ext->perViewAttributes = in_ext->perViewAttributes;
14887             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
14888             out_header->pNext = (void *)out_ext;
14889             out_header = (void *)out_ext;
14890             break;
14891         }
14892         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
14893         {
14894             VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14895             const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header;
14896             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
14897             out_ext->pNext = NULL;
14898             out_ext->flags = in_ext->flags;
14899             out_header->pNext = (void *)out_ext;
14900             out_header = (void *)out_ext;
14901             break;
14902         }
14903         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
14904         {
14905             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14906             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
14907             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
14908             out_ext->pNext = NULL;
14909             out_ext->storageBuffers = in_ext->storageBuffers;
14910             out_ext->uniformBuffers = in_ext->uniformBuffers;
14911             out_ext->vertexInputs = in_ext->vertexInputs;
14912             out_ext->images = in_ext->images;
14913             out_header->pNext = (void *)out_ext;
14914             out_header = (void *)out_ext;
14915             break;
14916         }
14917         default:
14918             FIXME("Unhandled sType %u.\n", in_header->sType);
14919             break;
14920         }
14921     }
14922 }
14923 #endif /* _WIN64 */
14924
14925 static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, VkGraphicsPipelineCreateInfo *out)
14926 {
14927     const VkBaseInStructure32 *in_header;
14928     VkBaseOutStructure *out_header = (void *)out;
14929
14930     if (!in) return;
14931
14932     out->sType = in->sType;
14933     out->pNext = NULL;
14934     out->flags = in->flags;
14935     out->stageCount = in->stageCount;
14936     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
14937     out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineVertexInputStateCreateInfo32 *)UlongToPtr(in->pVertexInputState), 1);
14938     out->pInputAssemblyState = convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineInputAssemblyStateCreateInfo32 *)UlongToPtr(in->pInputAssemblyState), 1);
14939     out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineTessellationStateCreateInfo32 *)UlongToPtr(in->pTessellationState), 1);
14940     out->pViewportState = convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineViewportStateCreateInfo32 *)UlongToPtr(in->pViewportState), 1);
14941     out->pRasterizationState = convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineRasterizationStateCreateInfo32 *)UlongToPtr(in->pRasterizationState), 1);
14942     out->pMultisampleState = convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineMultisampleStateCreateInfo32 *)UlongToPtr(in->pMultisampleState), 1);
14943     out->pDepthStencilState = convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDepthStencilStateCreateInfo32 *)UlongToPtr(in->pDepthStencilState), 1);
14944     out->pColorBlendState = convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineColorBlendStateCreateInfo32 *)UlongToPtr(in->pColorBlendState), 1);
14945     out->pDynamicState = convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDynamicStateCreateInfo32 *)UlongToPtr(in->pDynamicState), 1);
14946     out->layout = in->layout;
14947     out->renderPass = in->renderPass;
14948     out->subpass = in->subpass;
14949     out->basePipelineHandle = in->basePipelineHandle;
14950     out->basePipelineIndex = in->basePipelineIndex;
14951
14952     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14953     {
14954         switch (in_header->sType)
14955         {
14956         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
14957         {
14958             VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14959             const VkGraphicsPipelineShaderGroupsCreateInfoNV32 *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV32 *)in_header;
14960             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
14961             out_ext->pNext = NULL;
14962             out_ext->groupCount = in_ext->groupCount;
14963             out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(ctx, (const VkGraphicsShaderGroupCreateInfoNV32 *)UlongToPtr(in_ext->pGroups), in_ext->groupCount);
14964             out_ext->pipelineCount = in_ext->pipelineCount;
14965             out_ext->pPipelines = (const VkPipeline *)UlongToPtr(in_ext->pPipelines);
14966             out_header->pNext = (void *)out_ext;
14967             out_header = (void *)out_ext;
14968             break;
14969         }
14970         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
14971         {
14972             VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14973             const VkPipelineDiscardRectangleStateCreateInfoEXT32 *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT32 *)in_header;
14974             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
14975             out_ext->pNext = NULL;
14976             out_ext->flags = in_ext->flags;
14977             out_ext->discardRectangleMode = in_ext->discardRectangleMode;
14978             out_ext->discardRectangleCount = in_ext->discardRectangleCount;
14979             out_ext->pDiscardRectangles = (const VkRect2D *)UlongToPtr(in_ext->pDiscardRectangles);
14980             out_header->pNext = (void *)out_ext;
14981             out_header = (void *)out_ext;
14982             break;
14983         }
14984         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
14985         {
14986             VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14987             const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *)in_header;
14988             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
14989             out_ext->pNext = NULL;
14990             out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
14991             out_header->pNext = (void *)out_ext;
14992             out_header = (void *)out_ext;
14993             break;
14994         }
14995         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
14996         {
14997             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14998             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
14999             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
15000             out_ext->pNext = NULL;
15001             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
15002             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
15003             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
15004             out_header->pNext = (void *)out_ext;
15005             out_header = (void *)out_ext;
15006             break;
15007         }
15008         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
15009         {
15010             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15011             const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header;
15012             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
15013             out_ext->pNext = NULL;
15014             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
15015             out_header->pNext = (void *)out_ext;
15016             out_header = (void *)out_ext;
15017             break;
15018         }
15019         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
15020         {
15021             VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15022             const VkPipelineLibraryCreateInfoKHR32 *in_ext = (const VkPipelineLibraryCreateInfoKHR32 *)in_header;
15023             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
15024             out_ext->pNext = NULL;
15025             out_ext->libraryCount = in_ext->libraryCount;
15026             out_ext->pLibraries = (const VkPipeline *)UlongToPtr(in_ext->pLibraries);
15027             out_header->pNext = (void *)out_ext;
15028             out_header = (void *)out_ext;
15029             break;
15030         }
15031         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
15032         {
15033             VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15034             const VkPipelineFragmentShadingRateStateCreateInfoKHR32 *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR32 *)in_header;
15035             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
15036             out_ext->pNext = NULL;
15037             out_ext->fragmentSize = in_ext->fragmentSize;
15038             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
15039             out_header->pNext = (void *)out_ext;
15040             out_header = (void *)out_ext;
15041             break;
15042         }
15043         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
15044         {
15045             VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15046             const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *)in_header;
15047             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
15048             out_ext->pNext = NULL;
15049             out_ext->shadingRateType = in_ext->shadingRateType;
15050             out_ext->shadingRate = in_ext->shadingRate;
15051             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
15052             out_header->pNext = (void *)out_ext;
15053             out_header = (void *)out_ext;
15054             break;
15055         }
15056         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
15057         {
15058             VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15059             const VkPipelineRenderingCreateInfo32 *in_ext = (const VkPipelineRenderingCreateInfo32 *)in_header;
15060             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
15061             out_ext->pNext = NULL;
15062             out_ext->viewMask = in_ext->viewMask;
15063             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
15064             out_ext->pColorAttachmentFormats = (const VkFormat *)UlongToPtr(in_ext->pColorAttachmentFormats);
15065             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
15066             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
15067             out_header->pNext = (void *)out_ext;
15068             out_header = (void *)out_ext;
15069             break;
15070         }
15071         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
15072         {
15073             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15074             const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header;
15075             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
15076             out_ext->pNext = NULL;
15077             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
15078             out_ext->pColorAttachmentSamples = (const VkSampleCountFlagBits *)UlongToPtr(in_ext->pColorAttachmentSamples);
15079             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
15080             out_header->pNext = (void *)out_ext;
15081             out_header = (void *)out_ext;
15082             break;
15083         }
15084         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
15085         {
15086             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15087             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
15088             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
15089             out_ext->pNext = NULL;
15090             out_ext->perViewAttributes = in_ext->perViewAttributes;
15091             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
15092             out_header->pNext = (void *)out_ext;
15093             out_header = (void *)out_ext;
15094             break;
15095         }
15096         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
15097         {
15098             VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15099             const VkGraphicsPipelineLibraryCreateInfoEXT32 *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT32 *)in_header;
15100             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
15101             out_ext->pNext = NULL;
15102             out_ext->flags = in_ext->flags;
15103             out_header->pNext = (void *)out_ext;
15104             out_header = (void *)out_ext;
15105             break;
15106         }
15107         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
15108         {
15109             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15110             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
15111             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
15112             out_ext->pNext = NULL;
15113             out_ext->storageBuffers = in_ext->storageBuffers;
15114             out_ext->uniformBuffers = in_ext->uniformBuffers;
15115             out_ext->vertexInputs = in_ext->vertexInputs;
15116             out_ext->images = in_ext->images;
15117             out_header->pNext = (void *)out_ext;
15118             out_header = (void *)out_ext;
15119             break;
15120         }
15121         default:
15122             FIXME("Unhandled sType %u.\n", in_header->sType);
15123             break;
15124         }
15125     }
15126 }
15127
15128 static inline void convert_VkGraphicsPipelineCreateInfo_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out)
15129 {
15130     const VkBaseInStructure *in_header;
15131     VkBaseOutStructure32 *out_header = (void *)out;
15132
15133     if (!in) return;
15134
15135
15136     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
15137     {
15138         switch (in_header->sType)
15139         {
15140         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
15141         {
15142             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
15143             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
15144             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
15145             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
15146             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
15147             out_header = (void *)out_ext;
15148             break;
15149         }
15150         default:
15151             break;
15152         }
15153     }
15154 }
15155
15156 #ifdef _WIN64
15157 static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, uint32_t count)
15158 {
15159     VkGraphicsPipelineCreateInfo *out;
15160     unsigned int i;
15161
15162     if (!in || !count) return NULL;
15163
15164     out = conversion_context_alloc(ctx, count * sizeof(*out));
15165     for (i = 0; i < count; i++)
15166     {
15167         convert_VkGraphicsPipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
15168     }
15169
15170     return out;
15171 }
15172 #endif /* _WIN64 */
15173
15174 static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, uint32_t count)
15175 {
15176     VkGraphicsPipelineCreateInfo *out;
15177     unsigned int i;
15178
15179     if (!in || !count) return NULL;
15180
15181     out = conversion_context_alloc(ctx, count * sizeof(*out));
15182     for (i = 0; i < count; i++)
15183     {
15184         convert_VkGraphicsPipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
15185     }
15186
15187     return out;
15188 }
15189
15190 static inline void convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out, uint32_t count)
15191 {
15192     unsigned int i;
15193
15194     if (!in) return;
15195
15196     for (i = 0; i < count; i++)
15197     {
15198         convert_VkGraphicsPipelineCreateInfo_host_to_win32(&in[i], &out[i]);
15199     }
15200 }
15201
15202 static inline void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, VkImageCreateInfo *out)
15203 {
15204     const VkBaseInStructure32 *in_header;
15205     VkBaseOutStructure *out_header = (void *)out;
15206
15207     if (!in) return;
15208
15209     out->sType = in->sType;
15210     out->pNext = NULL;
15211     out->flags = in->flags;
15212     out->imageType = in->imageType;
15213     out->format = in->format;
15214     out->extent = in->extent;
15215     out->mipLevels = in->mipLevels;
15216     out->arrayLayers = in->arrayLayers;
15217     out->samples = in->samples;
15218     out->tiling = in->tiling;
15219     out->usage = in->usage;
15220     out->sharingMode = in->sharingMode;
15221     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
15222     out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);
15223     out->initialLayout = in->initialLayout;
15224
15225     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15226     {
15227         switch (in_header->sType)
15228         {
15229         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
15230         {
15231             VkDedicatedAllocationImageCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15232             const VkDedicatedAllocationImageCreateInfoNV32 *in_ext = (const VkDedicatedAllocationImageCreateInfoNV32 *)in_header;
15233             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV;
15234             out_ext->pNext = NULL;
15235             out_ext->dedicatedAllocation = in_ext->dedicatedAllocation;
15236             out_header->pNext = (void *)out_ext;
15237             out_header = (void *)out_ext;
15238             break;
15239         }
15240         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
15241         {
15242             VkExternalMemoryImageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15243             const VkExternalMemoryImageCreateInfo32 *in_ext = (const VkExternalMemoryImageCreateInfo32 *)in_header;
15244             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
15245             out_ext->pNext = NULL;
15246             out_ext->handleTypes = in_ext->handleTypes;
15247             out_header->pNext = (void *)out_ext;
15248             out_header = (void *)out_ext;
15249             break;
15250         }
15251         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
15252         {
15253             VkImageSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15254             const VkImageSwapchainCreateInfoKHR32 *in_ext = (const VkImageSwapchainCreateInfoKHR32 *)in_header;
15255             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR;
15256             out_ext->pNext = NULL;
15257             out_ext->swapchain = in_ext->swapchain;
15258             out_header->pNext = (void *)out_ext;
15259             out_header = (void *)out_ext;
15260             break;
15261         }
15262         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
15263         {
15264             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15265             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
15266             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
15267             out_ext->pNext = NULL;
15268             out_ext->viewFormatCount = in_ext->viewFormatCount;
15269             out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
15270             out_header->pNext = (void *)out_ext;
15271             out_header = (void *)out_ext;
15272             break;
15273         }
15274         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
15275         {
15276             VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15277             const VkImageStencilUsageCreateInfo32 *in_ext = (const VkImageStencilUsageCreateInfo32 *)in_header;
15278             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
15279             out_ext->pNext = NULL;
15280             out_ext->stencilUsage = in_ext->stencilUsage;
15281             out_header->pNext = (void *)out_ext;
15282             out_header = (void *)out_ext;
15283             break;
15284         }
15285         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
15286         {
15287             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15288             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
15289             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
15290             out_ext->pNext = NULL;
15291             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
15292             out_header->pNext = (void *)out_ext;
15293             out_header = (void *)out_ext;
15294             break;
15295         }
15296         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
15297         {
15298             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15299             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
15300             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
15301             out_ext->pNext = NULL;
15302             out_ext->flags = in_ext->flags;
15303             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
15304             out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
15305             out_header->pNext = (void *)out_ext;
15306             out_header = (void *)out_ext;
15307             break;
15308         }
15309         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
15310         {
15311             VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15312             const VkOpticalFlowImageFormatInfoNV32 *in_ext = (const VkOpticalFlowImageFormatInfoNV32 *)in_header;
15313             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
15314             out_ext->pNext = NULL;
15315             out_ext->usage = in_ext->usage;
15316             out_header->pNext = (void *)out_ext;
15317             out_header = (void *)out_ext;
15318             break;
15319         }
15320         default:
15321             FIXME("Unhandled sType %u.\n", in_header->sType);
15322             break;
15323         }
15324     }
15325 }
15326
15327 static inline void convert_VkImageViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageViewCreateInfo32 *in, VkImageViewCreateInfo *out)
15328 {
15329     const VkBaseInStructure32 *in_header;
15330     VkBaseOutStructure *out_header = (void *)out;
15331
15332     if (!in) return;
15333
15334     out->sType = in->sType;
15335     out->pNext = NULL;
15336     out->flags = in->flags;
15337     out->image = in->image;
15338     out->viewType = in->viewType;
15339     out->format = in->format;
15340     out->components = in->components;
15341     out->subresourceRange = in->subresourceRange;
15342
15343     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15344     {
15345         switch (in_header->sType)
15346         {
15347         case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
15348         {
15349             VkImageViewUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15350             const VkImageViewUsageCreateInfo32 *in_ext = (const VkImageViewUsageCreateInfo32 *)in_header;
15351             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
15352             out_ext->pNext = NULL;
15353             out_ext->usage = in_ext->usage;
15354             out_header->pNext = (void *)out_ext;
15355             out_header = (void *)out_ext;
15356             break;
15357         }
15358         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
15359         {
15360             VkImageViewSlicedCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15361             const VkImageViewSlicedCreateInfoEXT32 *in_ext = (const VkImageViewSlicedCreateInfoEXT32 *)in_header;
15362             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT;
15363             out_ext->pNext = NULL;
15364             out_ext->sliceOffset = in_ext->sliceOffset;
15365             out_ext->sliceCount = in_ext->sliceCount;
15366             out_header->pNext = (void *)out_ext;
15367             out_header = (void *)out_ext;
15368             break;
15369         }
15370         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
15371         {
15372             VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15373             const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
15374             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
15375             out_ext->pNext = NULL;
15376             out_ext->conversion = in_ext->conversion;
15377             out_header->pNext = (void *)out_ext;
15378             out_header = (void *)out_ext;
15379             break;
15380         }
15381         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
15382         {
15383             VkImageViewASTCDecodeModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15384             const VkImageViewASTCDecodeModeEXT32 *in_ext = (const VkImageViewASTCDecodeModeEXT32 *)in_header;
15385             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT;
15386             out_ext->pNext = NULL;
15387             out_ext->decodeMode = in_ext->decodeMode;
15388             out_header->pNext = (void *)out_ext;
15389             out_header = (void *)out_ext;
15390             break;
15391         }
15392         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
15393         {
15394             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15395             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
15396             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
15397             out_ext->pNext = NULL;
15398             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
15399             out_header->pNext = (void *)out_ext;
15400             out_header = (void *)out_ext;
15401             break;
15402         }
15403         case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
15404         {
15405             VkImageViewMinLodCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15406             const VkImageViewMinLodCreateInfoEXT32 *in_ext = (const VkImageViewMinLodCreateInfoEXT32 *)in_header;
15407             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT;
15408             out_ext->pNext = NULL;
15409             out_ext->minLod = in_ext->minLod;
15410             out_header->pNext = (void *)out_ext;
15411             out_header = (void *)out_ext;
15412             break;
15413         }
15414         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
15415         {
15416             VkImageViewSampleWeightCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15417             const VkImageViewSampleWeightCreateInfoQCOM32 *in_ext = (const VkImageViewSampleWeightCreateInfoQCOM32 *)in_header;
15418             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM;
15419             out_ext->pNext = NULL;
15420             out_ext->filterCenter = in_ext->filterCenter;
15421             out_ext->filterSize = in_ext->filterSize;
15422             out_ext->numPhases = in_ext->numPhases;
15423             out_header->pNext = (void *)out_ext;
15424             out_header = (void *)out_ext;
15425             break;
15426         }
15427         default:
15428             FIXME("Unhandled sType %u.\n", in_header->sType);
15429             break;
15430         }
15431     }
15432 }
15433
15434 static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const VkIndirectCommandsLayoutTokenNV32 *in, VkIndirectCommandsLayoutTokenNV *out)
15435 {
15436     if (!in) return;
15437
15438     out->sType = in->sType;
15439     out->pNext = NULL;
15440     out->tokenType = in->tokenType;
15441     out->stream = in->stream;
15442     out->offset = in->offset;
15443     out->vertexBindingUnit = in->vertexBindingUnit;
15444     out->vertexDynamicStride = in->vertexDynamicStride;
15445     out->pushconstantPipelineLayout = in->pushconstantPipelineLayout;
15446     out->pushconstantShaderStageFlags = in->pushconstantShaderStageFlags;
15447     out->pushconstantOffset = in->pushconstantOffset;
15448     out->pushconstantSize = in->pushconstantSize;
15449     out->indirectStateFlags = in->indirectStateFlags;
15450     out->indexTypeCount = in->indexTypeCount;
15451     out->pIndexTypes = (const VkIndexType *)UlongToPtr(in->pIndexTypes);
15452     out->pIndexTypeValues = (const uint32_t *)UlongToPtr(in->pIndexTypeValues);
15453     if (in->pNext)
15454         FIXME("Unexpected pNext\n");
15455 }
15456
15457 static inline const VkIndirectCommandsLayoutTokenNV *convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenNV32 *in, uint32_t count)
15458 {
15459     VkIndirectCommandsLayoutTokenNV *out;
15460     unsigned int i;
15461
15462     if (!in || !count) return NULL;
15463
15464     out = conversion_context_alloc(ctx, count * sizeof(*out));
15465     for (i = 0; i < count; i++)
15466     {
15467         convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(&in[i], &out[i]);
15468     }
15469
15470     return out;
15471 }
15472
15473 static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoNV32 *in, VkIndirectCommandsLayoutCreateInfoNV *out)
15474 {
15475     if (!in) return;
15476
15477     out->sType = in->sType;
15478     out->pNext = NULL;
15479     out->flags = in->flags;
15480     out->pipelineBindPoint = in->pipelineBindPoint;
15481     out->tokenCount = in->tokenCount;
15482     out->pTokens = convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(ctx, (const VkIndirectCommandsLayoutTokenNV32 *)UlongToPtr(in->pTokens), in->tokenCount);
15483     out->streamCount = in->streamCount;
15484     out->pStreamStrides = (const uint32_t *)UlongToPtr(in->pStreamStrides);
15485     if (in->pNext)
15486         FIXME("Unexpected pNext\n");
15487 }
15488
15489 static inline void convert_VkApplicationInfo_win32_to_host(const VkApplicationInfo32 *in, VkApplicationInfo *out)
15490 {
15491     if (!in) return;
15492
15493     out->sType = in->sType;
15494     out->pNext = NULL;
15495     out->pApplicationName = (const char *)UlongToPtr(in->pApplicationName);
15496     out->applicationVersion = in->applicationVersion;
15497     out->pEngineName = (const char *)UlongToPtr(in->pEngineName);
15498     out->engineVersion = in->engineVersion;
15499     out->apiVersion = in->apiVersion;
15500     if (in->pNext)
15501         FIXME("Unexpected pNext\n");
15502 }
15503
15504 static inline const VkApplicationInfo *convert_VkApplicationInfo_array_win32_to_host(struct conversion_context *ctx, const VkApplicationInfo32 *in, uint32_t count)
15505 {
15506     VkApplicationInfo *out;
15507     unsigned int i;
15508
15509     if (!in || !count) return NULL;
15510
15511     out = conversion_context_alloc(ctx, count * sizeof(*out));
15512     for (i = 0; i < count; i++)
15513     {
15514         convert_VkApplicationInfo_win32_to_host(&in[i], &out[i]);
15515     }
15516
15517     return out;
15518 }
15519
15520 #ifdef _WIN64
15521 static inline void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo *in, VkInstanceCreateInfo *out)
15522 {
15523     const VkBaseInStructure *in_header;
15524     VkBaseOutStructure *out_header = (void *)out;
15525
15526     if (!in) return;
15527
15528     out->sType = in->sType;
15529     out->pNext = NULL;
15530     out->flags = in->flags;
15531     out->pApplicationInfo = in->pApplicationInfo;
15532     out->enabledLayerCount = in->enabledLayerCount;
15533     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
15534     out->enabledExtensionCount = in->enabledExtensionCount;
15535     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
15536
15537     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
15538     {
15539         switch (in_header->sType)
15540         {
15541         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
15542             break;
15543         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
15544         {
15545             VkDebugReportCallbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15546             const VkDebugReportCallbackCreateInfoEXT *in_ext = (const VkDebugReportCallbackCreateInfoEXT *)in_header;
15547             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
15548             out_ext->pNext = NULL;
15549             out_ext->flags = in_ext->flags;
15550             out_ext->pfnCallback = in_ext->pfnCallback;
15551             out_ext->pUserData = in_ext->pUserData;
15552             out_header->pNext = (void *)out_ext;
15553             out_header = (void *)out_ext;
15554             break;
15555         }
15556         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
15557         {
15558             VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15559             const VkValidationFlagsEXT *in_ext = (const VkValidationFlagsEXT *)in_header;
15560             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
15561             out_ext->pNext = NULL;
15562             out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
15563             out_ext->pDisabledValidationChecks = in_ext->pDisabledValidationChecks;
15564             out_header->pNext = (void *)out_ext;
15565             out_header = (void *)out_ext;
15566             break;
15567         }
15568         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
15569         {
15570             VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15571             const VkValidationFeaturesEXT *in_ext = (const VkValidationFeaturesEXT *)in_header;
15572             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
15573             out_ext->pNext = NULL;
15574             out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount;
15575             out_ext->pEnabledValidationFeatures = in_ext->pEnabledValidationFeatures;
15576             out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount;
15577             out_ext->pDisabledValidationFeatures = in_ext->pDisabledValidationFeatures;
15578             out_header->pNext = (void *)out_ext;
15579             out_header = (void *)out_ext;
15580             break;
15581         }
15582         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
15583         {
15584             VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15585             const VkDebugUtilsMessengerCreateInfoEXT *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT *)in_header;
15586             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
15587             out_ext->pNext = NULL;
15588             out_ext->flags = in_ext->flags;
15589             out_ext->messageSeverity = in_ext->messageSeverity;
15590             out_ext->messageType = in_ext->messageType;
15591             out_ext->pfnUserCallback = in_ext->pfnUserCallback;
15592             out_ext->pUserData = in_ext->pUserData;
15593             out_header->pNext = (void *)out_ext;
15594             out_header = (void *)out_ext;
15595             break;
15596         }
15597         default:
15598             FIXME("Unhandled sType %u.\n", in_header->sType);
15599             break;
15600         }
15601     }
15602 }
15603 #endif /* _WIN64 */
15604
15605 static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo32 *in, VkInstanceCreateInfo *out)
15606 {
15607     const VkBaseInStructure32 *in_header;
15608     VkBaseOutStructure *out_header = (void *)out;
15609
15610     if (!in) return;
15611
15612     out->sType = in->sType;
15613     out->pNext = NULL;
15614     out->flags = in->flags;
15615     out->pApplicationInfo = convert_VkApplicationInfo_array_win32_to_host(ctx, (const VkApplicationInfo32 *)UlongToPtr(in->pApplicationInfo), 1);
15616     out->enabledLayerCount = in->enabledLayerCount;
15617     out->ppEnabledLayerNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledLayerNames), in->enabledLayerCount);
15618     out->enabledExtensionCount = in->enabledExtensionCount;
15619     out->ppEnabledExtensionNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledExtensionNames), in->enabledExtensionCount);
15620
15621     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15622     {
15623         switch (in_header->sType)
15624         {
15625         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
15626             break;
15627         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
15628         {
15629             VkDebugReportCallbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15630             const VkDebugReportCallbackCreateInfoEXT32 *in_ext = (const VkDebugReportCallbackCreateInfoEXT32 *)in_header;
15631             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
15632             out_ext->pNext = NULL;
15633             out_ext->flags = in_ext->flags;
15634             out_ext->pfnCallback = in_ext->pfnCallback;
15635             out_ext->pUserData = (void *)UlongToPtr(in_ext->pUserData);
15636             out_header->pNext = (void *)out_ext;
15637             out_header = (void *)out_ext;
15638             break;
15639         }
15640         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
15641         {
15642             VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15643             const VkValidationFlagsEXT32 *in_ext = (const VkValidationFlagsEXT32 *)in_header;
15644             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
15645             out_ext->pNext = NULL;
15646             out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
15647             out_ext->pDisabledValidationChecks = (const VkValidationCheckEXT *)UlongToPtr(in_ext->pDisabledValidationChecks);
15648             out_header->pNext = (void *)out_ext;
15649             out_header = (void *)out_ext;
15650             break;
15651         }
15652         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
15653         {
15654             VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15655             const VkValidationFeaturesEXT32 *in_ext = (const VkValidationFeaturesEXT32 *)in_header;
15656             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
15657             out_ext->pNext = NULL;
15658             out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount;
15659             out_ext->pEnabledValidationFeatures = (const VkValidationFeatureEnableEXT *)UlongToPtr(in_ext->pEnabledValidationFeatures);
15660             out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount;
15661             out_ext->pDisabledValidationFeatures = (const VkValidationFeatureDisableEXT *)UlongToPtr(in_ext->pDisabledValidationFeatures);
15662             out_header->pNext = (void *)out_ext;
15663             out_header = (void *)out_ext;
15664             break;
15665         }
15666         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
15667         {
15668             VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15669             const VkDebugUtilsMessengerCreateInfoEXT32 *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT32 *)in_header;
15670             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
15671             out_ext->pNext = NULL;
15672             out_ext->flags = in_ext->flags;
15673             out_ext->messageSeverity = in_ext->messageSeverity;
15674             out_ext->messageType = in_ext->messageType;
15675             out_ext->pfnUserCallback = in_ext->pfnUserCallback;
15676             out_ext->pUserData = (void *)UlongToPtr(in_ext->pUserData);
15677             out_header->pNext = (void *)out_ext;
15678             out_header = (void *)out_ext;
15679             break;
15680         }
15681         default:
15682             FIXME("Unhandled sType %u.\n", in_header->sType);
15683             break;
15684         }
15685     }
15686 }
15687
15688 static inline void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicromapCreateInfoEXT32 *in, VkMicromapCreateInfoEXT *out)
15689 {
15690     if (!in) return;
15691
15692     out->sType = in->sType;
15693     out->pNext = NULL;
15694     out->createFlags = in->createFlags;
15695     out->buffer = in->buffer;
15696     out->offset = in->offset;
15697     out->size = in->size;
15698     out->type = in->type;
15699     out->deviceAddress = in->deviceAddress;
15700     if (in->pNext)
15701         FIXME("Unexpected pNext\n");
15702 }
15703
15704 static inline void convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowSessionCreateInfoNV32 *in, VkOpticalFlowSessionCreateInfoNV *out)
15705 {
15706     const VkBaseInStructure32 *in_header;
15707     VkBaseOutStructure *out_header = (void *)out;
15708
15709     if (!in) return;
15710
15711     out->sType = in->sType;
15712     out->pNext = NULL;
15713     out->width = in->width;
15714     out->height = in->height;
15715     out->imageFormat = in->imageFormat;
15716     out->flowVectorFormat = in->flowVectorFormat;
15717     out->costFormat = in->costFormat;
15718     out->outputGridSize = in->outputGridSize;
15719     out->hintGridSize = in->hintGridSize;
15720     out->performanceLevel = in->performanceLevel;
15721     out->flags = in->flags;
15722
15723     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15724     {
15725         switch (in_header->sType)
15726         {
15727         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
15728         {
15729             VkOpticalFlowSessionCreatePrivateDataInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15730             const VkOpticalFlowSessionCreatePrivateDataInfoNV32 *in_ext = (const VkOpticalFlowSessionCreatePrivateDataInfoNV32 *)in_header;
15731             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV;
15732             out_ext->pNext = NULL;
15733             out_ext->id = in_ext->id;
15734             out_ext->size = in_ext->size;
15735             out_ext->pPrivateData = (const void *)UlongToPtr(in_ext->pPrivateData);
15736             out_header->pNext = (void *)out_ext;
15737             out_header = (void *)out_ext;
15738             break;
15739         }
15740         default:
15741             FIXME("Unhandled sType %u.\n", in_header->sType);
15742             break;
15743         }
15744     }
15745 }
15746
15747 static inline void convert_VkPipelineCacheCreateInfo_win32_to_host(const VkPipelineCacheCreateInfo32 *in, VkPipelineCacheCreateInfo *out)
15748 {
15749     if (!in) return;
15750
15751     out->sType = in->sType;
15752     out->pNext = NULL;
15753     out->flags = in->flags;
15754     out->initialDataSize = in->initialDataSize;
15755     out->pInitialData = (const void *)UlongToPtr(in->pInitialData);
15756     if (in->pNext)
15757         FIXME("Unexpected pNext\n");
15758 }
15759
15760 static inline void convert_VkPipelineLayoutCreateInfo_win32_to_host(const VkPipelineLayoutCreateInfo32 *in, VkPipelineLayoutCreateInfo *out)
15761 {
15762     if (!in) return;
15763
15764     out->sType = in->sType;
15765     out->pNext = NULL;
15766     out->flags = in->flags;
15767     out->setLayoutCount = in->setLayoutCount;
15768     out->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in->pSetLayouts);
15769     out->pushConstantRangeCount = in->pushConstantRangeCount;
15770     out->pPushConstantRanges = (const VkPushConstantRange *)UlongToPtr(in->pPushConstantRanges);
15771     if (in->pNext)
15772         FIXME("Unexpected pNext\n");
15773 }
15774
15775 static inline void convert_VkPrivateDataSlotCreateInfo_win32_to_host(const VkPrivateDataSlotCreateInfo32 *in, VkPrivateDataSlotCreateInfo *out)
15776 {
15777     if (!in) return;
15778
15779     out->sType = in->sType;
15780     out->pNext = NULL;
15781     out->flags = in->flags;
15782     if (in->pNext)
15783         FIXME("Unexpected pNext\n");
15784 }
15785
15786 static inline void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkQueryPoolCreateInfo32 *in, VkQueryPoolCreateInfo *out)
15787 {
15788     const VkBaseInStructure32 *in_header;
15789     VkBaseOutStructure *out_header = (void *)out;
15790
15791     if (!in) return;
15792
15793     out->sType = in->sType;
15794     out->pNext = NULL;
15795     out->flags = in->flags;
15796     out->queryType = in->queryType;
15797     out->queryCount = in->queryCount;
15798     out->pipelineStatistics = in->pipelineStatistics;
15799
15800     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15801     {
15802         switch (in_header->sType)
15803         {
15804         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
15805         {
15806             VkQueryPoolPerformanceCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15807             const VkQueryPoolPerformanceCreateInfoKHR32 *in_ext = (const VkQueryPoolPerformanceCreateInfoKHR32 *)in_header;
15808             out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR;
15809             out_ext->pNext = NULL;
15810             out_ext->queueFamilyIndex = in_ext->queueFamilyIndex;
15811             out_ext->counterIndexCount = in_ext->counterIndexCount;
15812             out_ext->pCounterIndices = (const uint32_t *)UlongToPtr(in_ext->pCounterIndices);
15813             out_header->pNext = (void *)out_ext;
15814             out_header = (void *)out_ext;
15815             break;
15816         }
15817         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
15818         {
15819             VkQueryPoolPerformanceQueryCreateInfoINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15820             const VkQueryPoolPerformanceQueryCreateInfoINTEL32 *in_ext = (const VkQueryPoolPerformanceQueryCreateInfoINTEL32 *)in_header;
15821             out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL;
15822             out_ext->pNext = NULL;
15823             out_ext->performanceCountersSampling = in_ext->performanceCountersSampling;
15824             out_header->pNext = (void *)out_ext;
15825             out_header = (void *)out_ext;
15826             break;
15827         }
15828         default:
15829             FIXME("Unhandled sType %u.\n", in_header->sType);
15830             break;
15831         }
15832     }
15833 }
15834
15835 static inline void convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(const VkRayTracingShaderGroupCreateInfoKHR32 *in, VkRayTracingShaderGroupCreateInfoKHR *out)
15836 {
15837     if (!in) return;
15838
15839     out->sType = in->sType;
15840     out->pNext = NULL;
15841     out->type = in->type;
15842     out->generalShader = in->generalShader;
15843     out->closestHitShader = in->closestHitShader;
15844     out->anyHitShader = in->anyHitShader;
15845     out->intersectionShader = in->intersectionShader;
15846     out->pShaderGroupCaptureReplayHandle = (const void *)UlongToPtr(in->pShaderGroupCaptureReplayHandle);
15847     if (in->pNext)
15848         FIXME("Unexpected pNext\n");
15849 }
15850
15851 static inline const VkRayTracingShaderGroupCreateInfoKHR *convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoKHR32 *in, uint32_t count)
15852 {
15853     VkRayTracingShaderGroupCreateInfoKHR *out;
15854     unsigned int i;
15855
15856     if (!in || !count) return NULL;
15857
15858     out = conversion_context_alloc(ctx, count * sizeof(*out));
15859     for (i = 0; i < count; i++)
15860     {
15861         convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(&in[i], &out[i]);
15862     }
15863
15864     return out;
15865 }
15866
15867 static inline void convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(const VkPipelineLibraryCreateInfoKHR32 *in, VkPipelineLibraryCreateInfoKHR *out)
15868 {
15869     if (!in) return;
15870
15871     out->sType = in->sType;
15872     out->pNext = NULL;
15873     out->libraryCount = in->libraryCount;
15874     out->pLibraries = (const VkPipeline *)UlongToPtr(in->pLibraries);
15875     if (in->pNext)
15876         FIXME("Unexpected pNext\n");
15877 }
15878
15879 static inline const VkPipelineLibraryCreateInfoKHR *convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineLibraryCreateInfoKHR32 *in, uint32_t count)
15880 {
15881     VkPipelineLibraryCreateInfoKHR *out;
15882     unsigned int i;
15883
15884     if (!in || !count) return NULL;
15885
15886     out = conversion_context_alloc(ctx, count * sizeof(*out));
15887     for (i = 0; i < count; i++)
15888     {
15889         convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(&in[i], &out[i]);
15890     }
15891
15892     return out;
15893 }
15894
15895 static inline void convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_host(const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, VkRayTracingPipelineInterfaceCreateInfoKHR *out)
15896 {
15897     if (!in) return;
15898
15899     out->sType = in->sType;
15900     out->pNext = NULL;
15901     out->maxPipelineRayPayloadSize = in->maxPipelineRayPayloadSize;
15902     out->maxPipelineRayHitAttributeSize = in->maxPipelineRayHitAttributeSize;
15903     if (in->pNext)
15904         FIXME("Unexpected pNext\n");
15905 }
15906
15907 static inline const VkRayTracingPipelineInterfaceCreateInfoKHR *convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, uint32_t count)
15908 {
15909     VkRayTracingPipelineInterfaceCreateInfoKHR *out;
15910     unsigned int i;
15911
15912     if (!in || !count) return NULL;
15913
15914     out = conversion_context_alloc(ctx, count * sizeof(*out));
15915     for (i = 0; i < count; i++)
15916     {
15917         convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_host(&in[i], &out[i]);
15918     }
15919
15920     return out;
15921 }
15922
15923 #ifdef _WIN64
15924 static inline void convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, VkRayTracingPipelineCreateInfoKHR *out)
15925 {
15926     if (!in) return;
15927
15928     out->sType = in->sType;
15929     out->pNext = in->pNext;
15930     out->flags = in->flags;
15931     out->stageCount = in->stageCount;
15932     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
15933     out->groupCount = in->groupCount;
15934     out->pGroups = in->pGroups;
15935     out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
15936     out->pLibraryInfo = in->pLibraryInfo;
15937     out->pLibraryInterface = in->pLibraryInterface;
15938     out->pDynamicState = in->pDynamicState;
15939     out->layout = in->layout;
15940     out->basePipelineHandle = in->basePipelineHandle;
15941     out->basePipelineIndex = in->basePipelineIndex;
15942 }
15943 #endif /* _WIN64 */
15944
15945 static inline void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, VkRayTracingPipelineCreateInfoKHR *out)
15946 {
15947     const VkBaseInStructure32 *in_header;
15948     VkBaseOutStructure *out_header = (void *)out;
15949
15950     if (!in) return;
15951
15952     out->sType = in->sType;
15953     out->pNext = NULL;
15954     out->flags = in->flags;
15955     out->stageCount = in->stageCount;
15956     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
15957     out->groupCount = in->groupCount;
15958     out->pGroups = convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(ctx, (const VkRayTracingShaderGroupCreateInfoKHR32 *)UlongToPtr(in->pGroups), in->groupCount);
15959     out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
15960     out->pLibraryInfo = convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(ctx, (const VkPipelineLibraryCreateInfoKHR32 *)UlongToPtr(in->pLibraryInfo), 1);
15961     out->pLibraryInterface = convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(ctx, (const VkRayTracingPipelineInterfaceCreateInfoKHR32 *)UlongToPtr(in->pLibraryInterface), 1);
15962     out->pDynamicState = convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDynamicStateCreateInfo32 *)UlongToPtr(in->pDynamicState), 1);
15963     out->layout = in->layout;
15964     out->basePipelineHandle = in->basePipelineHandle;
15965     out->basePipelineIndex = in->basePipelineIndex;
15966
15967     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15968     {
15969         switch (in_header->sType)
15970         {
15971         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
15972         {
15973             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15974             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
15975             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
15976             out_ext->pNext = NULL;
15977             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
15978             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
15979             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
15980             out_header->pNext = (void *)out_ext;
15981             out_header = (void *)out_ext;
15982             break;
15983         }
15984         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
15985         {
15986             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15987             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
15988             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
15989             out_ext->pNext = NULL;
15990             out_ext->storageBuffers = in_ext->storageBuffers;
15991             out_ext->uniformBuffers = in_ext->uniformBuffers;
15992             out_ext->vertexInputs = in_ext->vertexInputs;
15993             out_ext->images = in_ext->images;
15994             out_header->pNext = (void *)out_ext;
15995             out_header = (void *)out_ext;
15996             break;
15997         }
15998         default:
15999             FIXME("Unhandled sType %u.\n", in_header->sType);
16000             break;
16001         }
16002     }
16003 }
16004
16005 static inline void convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out)
16006 {
16007     const VkBaseInStructure *in_header;
16008     VkBaseOutStructure32 *out_header = (void *)out;
16009
16010     if (!in) return;
16011
16012
16013     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
16014     {
16015         switch (in_header->sType)
16016         {
16017         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
16018         {
16019             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
16020             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
16021             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
16022             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
16023             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
16024             out_header = (void *)out_ext;
16025             break;
16026         }
16027         default:
16028             break;
16029         }
16030     }
16031 }
16032
16033 #ifdef _WIN64
16034 static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, uint32_t count)
16035 {
16036     VkRayTracingPipelineCreateInfoKHR *out;
16037     unsigned int i;
16038
16039     if (!in || !count) return NULL;
16040
16041     out = conversion_context_alloc(ctx, count * sizeof(*out));
16042     for (i = 0; i < count; i++)
16043     {
16044         convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(ctx, &in[i], &out[i]);
16045     }
16046
16047     return out;
16048 }
16049 #endif /* _WIN64 */
16050
16051 static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, uint32_t count)
16052 {
16053     VkRayTracingPipelineCreateInfoKHR *out;
16054     unsigned int i;
16055
16056     if (!in || !count) return NULL;
16057
16058     out = conversion_context_alloc(ctx, count * sizeof(*out));
16059     for (i = 0; i < count; i++)
16060     {
16061         convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
16062     }
16063
16064     return out;
16065 }
16066
16067 static inline void convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out, uint32_t count)
16068 {
16069     unsigned int i;
16070
16071     if (!in) return;
16072
16073     for (i = 0; i < count; i++)
16074     {
16075         convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(&in[i], &out[i]);
16076     }
16077 }
16078
16079 static inline void convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(const VkRayTracingShaderGroupCreateInfoNV32 *in, VkRayTracingShaderGroupCreateInfoNV *out)
16080 {
16081     if (!in) return;
16082
16083     out->sType = in->sType;
16084     out->pNext = NULL;
16085     out->type = in->type;
16086     out->generalShader = in->generalShader;
16087     out->closestHitShader = in->closestHitShader;
16088     out->anyHitShader = in->anyHitShader;
16089     out->intersectionShader = in->intersectionShader;
16090     if (in->pNext)
16091         FIXME("Unexpected pNext\n");
16092 }
16093
16094 static inline const VkRayTracingShaderGroupCreateInfoNV *convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoNV32 *in, uint32_t count)
16095 {
16096     VkRayTracingShaderGroupCreateInfoNV *out;
16097     unsigned int i;
16098
16099     if (!in || !count) return NULL;
16100
16101     out = conversion_context_alloc(ctx, count * sizeof(*out));
16102     for (i = 0; i < count; i++)
16103     {
16104         convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(&in[i], &out[i]);
16105     }
16106
16107     return out;
16108 }
16109
16110 #ifdef _WIN64
16111 static inline void convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, VkRayTracingPipelineCreateInfoNV *out)
16112 {
16113     if (!in) return;
16114
16115     out->sType = in->sType;
16116     out->pNext = in->pNext;
16117     out->flags = in->flags;
16118     out->stageCount = in->stageCount;
16119     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
16120     out->groupCount = in->groupCount;
16121     out->pGroups = in->pGroups;
16122     out->maxRecursionDepth = in->maxRecursionDepth;
16123     out->layout = in->layout;
16124     out->basePipelineHandle = in->basePipelineHandle;
16125     out->basePipelineIndex = in->basePipelineIndex;
16126 }
16127 #endif /* _WIN64 */
16128
16129 static inline void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, VkRayTracingPipelineCreateInfoNV *out)
16130 {
16131     const VkBaseInStructure32 *in_header;
16132     VkBaseOutStructure *out_header = (void *)out;
16133
16134     if (!in) return;
16135
16136     out->sType = in->sType;
16137     out->pNext = NULL;
16138     out->flags = in->flags;
16139     out->stageCount = in->stageCount;
16140     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
16141     out->groupCount = in->groupCount;
16142     out->pGroups = convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(ctx, (const VkRayTracingShaderGroupCreateInfoNV32 *)UlongToPtr(in->pGroups), in->groupCount);
16143     out->maxRecursionDepth = in->maxRecursionDepth;
16144     out->layout = in->layout;
16145     out->basePipelineHandle = in->basePipelineHandle;
16146     out->basePipelineIndex = in->basePipelineIndex;
16147
16148     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16149     {
16150         switch (in_header->sType)
16151         {
16152         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
16153         {
16154             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16155             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
16156             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
16157             out_ext->pNext = NULL;
16158             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
16159             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
16160             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
16161             out_header->pNext = (void *)out_ext;
16162             out_header = (void *)out_ext;
16163             break;
16164         }
16165         default:
16166             FIXME("Unhandled sType %u.\n", in_header->sType);
16167             break;
16168         }
16169     }
16170 }
16171
16172 static inline void convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out)
16173 {
16174     const VkBaseInStructure *in_header;
16175     VkBaseOutStructure32 *out_header = (void *)out;
16176
16177     if (!in) return;
16178
16179
16180     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
16181     {
16182         switch (in_header->sType)
16183         {
16184         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
16185         {
16186             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
16187             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
16188             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
16189             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
16190             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
16191             out_header = (void *)out_ext;
16192             break;
16193         }
16194         default:
16195             break;
16196         }
16197     }
16198 }
16199
16200 #ifdef _WIN64
16201 static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, uint32_t count)
16202 {
16203     VkRayTracingPipelineCreateInfoNV *out;
16204     unsigned int i;
16205
16206     if (!in || !count) return NULL;
16207
16208     out = conversion_context_alloc(ctx, count * sizeof(*out));
16209     for (i = 0; i < count; i++)
16210     {
16211         convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
16212     }
16213
16214     return out;
16215 }
16216 #endif /* _WIN64 */
16217
16218 static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, uint32_t count)
16219 {
16220     VkRayTracingPipelineCreateInfoNV *out;
16221     unsigned int i;
16222
16223     if (!in || !count) return NULL;
16224
16225     out = conversion_context_alloc(ctx, count * sizeof(*out));
16226     for (i = 0; i < count; i++)
16227     {
16228         convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
16229     }
16230
16231     return out;
16232 }
16233
16234 static inline void convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out, uint32_t count)
16235 {
16236     unsigned int i;
16237
16238     if (!in) return;
16239
16240     for (i = 0; i < count; i++)
16241     {
16242         convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(&in[i], &out[i]);
16243     }
16244 }
16245
16246 static inline void convert_VkSubpassDescription_win32_to_host(const VkSubpassDescription32 *in, VkSubpassDescription *out)
16247 {
16248     if (!in) return;
16249
16250     out->flags = in->flags;
16251     out->pipelineBindPoint = in->pipelineBindPoint;
16252     out->inputAttachmentCount = in->inputAttachmentCount;
16253     out->pInputAttachments = (const VkAttachmentReference *)UlongToPtr(in->pInputAttachments);
16254     out->colorAttachmentCount = in->colorAttachmentCount;
16255     out->pColorAttachments = (const VkAttachmentReference *)UlongToPtr(in->pColorAttachments);
16256     out->pResolveAttachments = (const VkAttachmentReference *)UlongToPtr(in->pResolveAttachments);
16257     out->pDepthStencilAttachment = (const VkAttachmentReference *)UlongToPtr(in->pDepthStencilAttachment);
16258     out->preserveAttachmentCount = in->preserveAttachmentCount;
16259     out->pPreserveAttachments = (const uint32_t *)UlongToPtr(in->pPreserveAttachments);
16260 }
16261
16262 static inline const VkSubpassDescription *convert_VkSubpassDescription_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription32 *in, uint32_t count)
16263 {
16264     VkSubpassDescription *out;
16265     unsigned int i;
16266
16267     if (!in || !count) return NULL;
16268
16269     out = conversion_context_alloc(ctx, count * sizeof(*out));
16270     for (i = 0; i < count; i++)
16271     {
16272         convert_VkSubpassDescription_win32_to_host(&in[i], &out[i]);
16273     }
16274
16275     return out;
16276 }
16277
16278 static inline void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo32 *in, VkRenderPassCreateInfo *out)
16279 {
16280     const VkBaseInStructure32 *in_header;
16281     VkBaseOutStructure *out_header = (void *)out;
16282
16283     if (!in) return;
16284
16285     out->sType = in->sType;
16286     out->pNext = NULL;
16287     out->flags = in->flags;
16288     out->attachmentCount = in->attachmentCount;
16289     out->pAttachments = (const VkAttachmentDescription *)UlongToPtr(in->pAttachments);
16290     out->subpassCount = in->subpassCount;
16291     out->pSubpasses = convert_VkSubpassDescription_array_win32_to_host(ctx, (const VkSubpassDescription32 *)UlongToPtr(in->pSubpasses), in->subpassCount);
16292     out->dependencyCount = in->dependencyCount;
16293     out->pDependencies = (const VkSubpassDependency *)UlongToPtr(in->pDependencies);
16294
16295     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16296     {
16297         switch (in_header->sType)
16298         {
16299         case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
16300         {
16301             VkRenderPassMultiviewCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16302             const VkRenderPassMultiviewCreateInfo32 *in_ext = (const VkRenderPassMultiviewCreateInfo32 *)in_header;
16303             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
16304             out_ext->pNext = NULL;
16305             out_ext->subpassCount = in_ext->subpassCount;
16306             out_ext->pViewMasks = (const uint32_t *)UlongToPtr(in_ext->pViewMasks);
16307             out_ext->dependencyCount = in_ext->dependencyCount;
16308             out_ext->pViewOffsets = (const int32_t *)UlongToPtr(in_ext->pViewOffsets);
16309             out_ext->correlationMaskCount = in_ext->correlationMaskCount;
16310             out_ext->pCorrelationMasks = (const uint32_t *)UlongToPtr(in_ext->pCorrelationMasks);
16311             out_header->pNext = (void *)out_ext;
16312             out_header = (void *)out_ext;
16313             break;
16314         }
16315         case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
16316         {
16317             VkRenderPassInputAttachmentAspectCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16318             const VkRenderPassInputAttachmentAspectCreateInfo32 *in_ext = (const VkRenderPassInputAttachmentAspectCreateInfo32 *)in_header;
16319             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
16320             out_ext->pNext = NULL;
16321             out_ext->aspectReferenceCount = in_ext->aspectReferenceCount;
16322             out_ext->pAspectReferences = (const VkInputAttachmentAspectReference *)UlongToPtr(in_ext->pAspectReferences);
16323             out_header->pNext = (void *)out_ext;
16324             out_header = (void *)out_ext;
16325             break;
16326         }
16327         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
16328         {
16329             VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16330             const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header;
16331             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
16332             out_ext->pNext = NULL;
16333             out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment;
16334             out_header->pNext = (void *)out_ext;
16335             out_header = (void *)out_ext;
16336             break;
16337         }
16338         default:
16339             FIXME("Unhandled sType %u.\n", in_header->sType);
16340             break;
16341         }
16342     }
16343 }
16344
16345 static inline void convert_VkAttachmentDescription2_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, VkAttachmentDescription2 *out)
16346 {
16347     const VkBaseInStructure32 *in_header;
16348     VkBaseOutStructure *out_header = (void *)out;
16349
16350     if (!in) return;
16351
16352     out->sType = in->sType;
16353     out->pNext = NULL;
16354     out->flags = in->flags;
16355     out->format = in->format;
16356     out->samples = in->samples;
16357     out->loadOp = in->loadOp;
16358     out->storeOp = in->storeOp;
16359     out->stencilLoadOp = in->stencilLoadOp;
16360     out->stencilStoreOp = in->stencilStoreOp;
16361     out->initialLayout = in->initialLayout;
16362     out->finalLayout = in->finalLayout;
16363
16364     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16365     {
16366         switch (in_header->sType)
16367         {
16368         case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
16369         {
16370             VkAttachmentDescriptionStencilLayout *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16371             const VkAttachmentDescriptionStencilLayout32 *in_ext = (const VkAttachmentDescriptionStencilLayout32 *)in_header;
16372             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
16373             out_ext->pNext = NULL;
16374             out_ext->stencilInitialLayout = in_ext->stencilInitialLayout;
16375             out_ext->stencilFinalLayout = in_ext->stencilFinalLayout;
16376             out_header->pNext = (void *)out_ext;
16377             out_header = (void *)out_ext;
16378             break;
16379         }
16380         default:
16381             FIXME("Unhandled sType %u.\n", in_header->sType);
16382             break;
16383         }
16384     }
16385 }
16386
16387 static inline const VkAttachmentDescription2 *convert_VkAttachmentDescription2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, uint32_t count)
16388 {
16389     VkAttachmentDescription2 *out;
16390     unsigned int i;
16391
16392     if (!in || !count) return NULL;
16393
16394     out = conversion_context_alloc(ctx, count * sizeof(*out));
16395     for (i = 0; i < count; i++)
16396     {
16397         convert_VkAttachmentDescription2_win32_to_host(ctx, &in[i], &out[i]);
16398     }
16399
16400     return out;
16401 }
16402
16403 static inline void convert_VkAttachmentReference2_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, VkAttachmentReference2 *out)
16404 {
16405     const VkBaseInStructure32 *in_header;
16406     VkBaseOutStructure *out_header = (void *)out;
16407
16408     if (!in) return;
16409
16410     out->sType = in->sType;
16411     out->pNext = NULL;
16412     out->attachment = in->attachment;
16413     out->layout = in->layout;
16414     out->aspectMask = in->aspectMask;
16415
16416     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16417     {
16418         switch (in_header->sType)
16419         {
16420         case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
16421         {
16422             VkAttachmentReferenceStencilLayout *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16423             const VkAttachmentReferenceStencilLayout32 *in_ext = (const VkAttachmentReferenceStencilLayout32 *)in_header;
16424             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
16425             out_ext->pNext = NULL;
16426             out_ext->stencilLayout = in_ext->stencilLayout;
16427             out_header->pNext = (void *)out_ext;
16428             out_header = (void *)out_ext;
16429             break;
16430         }
16431         default:
16432             FIXME("Unhandled sType %u.\n", in_header->sType);
16433             break;
16434         }
16435     }
16436 }
16437
16438 static inline const VkAttachmentReference2 *convert_VkAttachmentReference2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, uint32_t count)
16439 {
16440     VkAttachmentReference2 *out;
16441     unsigned int i;
16442
16443     if (!in || !count) return NULL;
16444
16445     out = conversion_context_alloc(ctx, count * sizeof(*out));
16446     for (i = 0; i < count; i++)
16447     {
16448         convert_VkAttachmentReference2_win32_to_host(ctx, &in[i], &out[i]);
16449     }
16450
16451     return out;
16452 }
16453
16454 static inline void convert_VkSubpassDescription2_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, VkSubpassDescription2 *out)
16455 {
16456     const VkBaseInStructure32 *in_header;
16457     VkBaseOutStructure *out_header = (void *)out;
16458
16459     if (!in) return;
16460
16461     out->sType = in->sType;
16462     out->pNext = NULL;
16463     out->flags = in->flags;
16464     out->pipelineBindPoint = in->pipelineBindPoint;
16465     out->viewMask = in->viewMask;
16466     out->inputAttachmentCount = in->inputAttachmentCount;
16467     out->pInputAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pInputAttachments), in->inputAttachmentCount);
16468     out->colorAttachmentCount = in->colorAttachmentCount;
16469     out->pColorAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pColorAttachments), in->colorAttachmentCount);
16470     out->pResolveAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pResolveAttachments), in->colorAttachmentCount);
16471     out->pDepthStencilAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pDepthStencilAttachment), 1);
16472     out->preserveAttachmentCount = in->preserveAttachmentCount;
16473     out->pPreserveAttachments = (const uint32_t *)UlongToPtr(in->pPreserveAttachments);
16474
16475     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16476     {
16477         switch (in_header->sType)
16478         {
16479         case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
16480         {
16481             VkSubpassDescriptionDepthStencilResolve *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16482             const VkSubpassDescriptionDepthStencilResolve32 *in_ext = (const VkSubpassDescriptionDepthStencilResolve32 *)in_header;
16483             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
16484             out_ext->pNext = NULL;
16485             out_ext->depthResolveMode = in_ext->depthResolveMode;
16486             out_ext->stencilResolveMode = in_ext->stencilResolveMode;
16487             out_ext->pDepthStencilResolveAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in_ext->pDepthStencilResolveAttachment), 1);
16488             out_header->pNext = (void *)out_ext;
16489             out_header = (void *)out_ext;
16490             break;
16491         }
16492         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
16493         {
16494             VkFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16495             const VkFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkFragmentShadingRateAttachmentInfoKHR32 *)in_header;
16496             out_ext->sType = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
16497             out_ext->pNext = NULL;
16498             out_ext->pFragmentShadingRateAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in_ext->pFragmentShadingRateAttachment), 1);
16499             out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize;
16500             out_header->pNext = (void *)out_ext;
16501             out_header = (void *)out_ext;
16502             break;
16503         }
16504         case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
16505         {
16506             VkMultisampledRenderToSingleSampledInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16507             const VkMultisampledRenderToSingleSampledInfoEXT32 *in_ext = (const VkMultisampledRenderToSingleSampledInfoEXT32 *)in_header;
16508             out_ext->sType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
16509             out_ext->pNext = NULL;
16510             out_ext->multisampledRenderToSingleSampledEnable = in_ext->multisampledRenderToSingleSampledEnable;
16511             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
16512             out_header->pNext = (void *)out_ext;
16513             out_header = (void *)out_ext;
16514             break;
16515         }
16516         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
16517         {
16518             VkRenderPassCreationControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16519             const VkRenderPassCreationControlEXT32 *in_ext = (const VkRenderPassCreationControlEXT32 *)in_header;
16520             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT;
16521             out_ext->pNext = NULL;
16522             out_ext->disallowMerging = in_ext->disallowMerging;
16523             out_header->pNext = (void *)out_ext;
16524             out_header = (void *)out_ext;
16525             break;
16526         }
16527         case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
16528         {
16529             VkRenderPassSubpassFeedbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16530             const VkRenderPassSubpassFeedbackCreateInfoEXT32 *in_ext = (const VkRenderPassSubpassFeedbackCreateInfoEXT32 *)in_header;
16531             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT;
16532             out_ext->pNext = NULL;
16533             out_ext->pSubpassFeedback = (VkRenderPassSubpassFeedbackInfoEXT *)UlongToPtr(in_ext->pSubpassFeedback);
16534             out_header->pNext = (void *)out_ext;
16535             out_header = (void *)out_ext;
16536             break;
16537         }
16538         default:
16539             FIXME("Unhandled sType %u.\n", in_header->sType);
16540             break;
16541         }
16542     }
16543 }
16544
16545 static inline const VkSubpassDescription2 *convert_VkSubpassDescription2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, uint32_t count)
16546 {
16547     VkSubpassDescription2 *out;
16548     unsigned int i;
16549
16550     if (!in || !count) return NULL;
16551
16552     out = conversion_context_alloc(ctx, count * sizeof(*out));
16553     for (i = 0; i < count; i++)
16554     {
16555         convert_VkSubpassDescription2_win32_to_host(ctx, &in[i], &out[i]);
16556     }
16557
16558     return out;
16559 }
16560
16561 static inline void convert_VkSubpassDependency2_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, VkSubpassDependency2 *out)
16562 {
16563     const VkBaseInStructure32 *in_header;
16564     VkBaseOutStructure *out_header = (void *)out;
16565
16566     if (!in) return;
16567
16568     out->sType = in->sType;
16569     out->pNext = NULL;
16570     out->srcSubpass = in->srcSubpass;
16571     out->dstSubpass = in->dstSubpass;
16572     out->srcStageMask = in->srcStageMask;
16573     out->dstStageMask = in->dstStageMask;
16574     out->srcAccessMask = in->srcAccessMask;
16575     out->dstAccessMask = in->dstAccessMask;
16576     out->dependencyFlags = in->dependencyFlags;
16577     out->viewOffset = in->viewOffset;
16578
16579     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16580     {
16581         switch (in_header->sType)
16582         {
16583         case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
16584         {
16585             VkMemoryBarrier2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16586             const VkMemoryBarrier232 *in_ext = (const VkMemoryBarrier232 *)in_header;
16587             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2;
16588             out_ext->pNext = NULL;
16589             out_ext->srcStageMask = in_ext->srcStageMask;
16590             out_ext->srcAccessMask = in_ext->srcAccessMask;
16591             out_ext->dstStageMask = in_ext->dstStageMask;
16592             out_ext->dstAccessMask = in_ext->dstAccessMask;
16593             out_header->pNext = (void *)out_ext;
16594             out_header = (void *)out_ext;
16595             break;
16596         }
16597         default:
16598             FIXME("Unhandled sType %u.\n", in_header->sType);
16599             break;
16600         }
16601     }
16602 }
16603
16604 static inline const VkSubpassDependency2 *convert_VkSubpassDependency2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, uint32_t count)
16605 {
16606     VkSubpassDependency2 *out;
16607     unsigned int i;
16608
16609     if (!in || !count) return NULL;
16610
16611     out = conversion_context_alloc(ctx, count * sizeof(*out));
16612     for (i = 0; i < count; i++)
16613     {
16614         convert_VkSubpassDependency2_win32_to_host(ctx, &in[i], &out[i]);
16615     }
16616
16617     return out;
16618 }
16619
16620 static inline void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo232 *in, VkRenderPassCreateInfo2 *out)
16621 {
16622     const VkBaseInStructure32 *in_header;
16623     VkBaseOutStructure *out_header = (void *)out;
16624
16625     if (!in) return;
16626
16627     out->sType = in->sType;
16628     out->pNext = NULL;
16629     out->flags = in->flags;
16630     out->attachmentCount = in->attachmentCount;
16631     out->pAttachments = convert_VkAttachmentDescription2_array_win32_to_host(ctx, (const VkAttachmentDescription232 *)UlongToPtr(in->pAttachments), in->attachmentCount);
16632     out->subpassCount = in->subpassCount;
16633     out->pSubpasses = convert_VkSubpassDescription2_array_win32_to_host(ctx, (const VkSubpassDescription232 *)UlongToPtr(in->pSubpasses), in->subpassCount);
16634     out->dependencyCount = in->dependencyCount;
16635     out->pDependencies = convert_VkSubpassDependency2_array_win32_to_host(ctx, (const VkSubpassDependency232 *)UlongToPtr(in->pDependencies), in->dependencyCount);
16636     out->correlatedViewMaskCount = in->correlatedViewMaskCount;
16637     out->pCorrelatedViewMasks = (const uint32_t *)UlongToPtr(in->pCorrelatedViewMasks);
16638
16639     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16640     {
16641         switch (in_header->sType)
16642         {
16643         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
16644         {
16645             VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16646             const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header;
16647             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
16648             out_ext->pNext = NULL;
16649             out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment;
16650             out_header->pNext = (void *)out_ext;
16651             out_header = (void *)out_ext;
16652             break;
16653         }
16654         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
16655         {
16656             VkRenderPassCreationControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16657             const VkRenderPassCreationControlEXT32 *in_ext = (const VkRenderPassCreationControlEXT32 *)in_header;
16658             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT;
16659             out_ext->pNext = NULL;
16660             out_ext->disallowMerging = in_ext->disallowMerging;
16661             out_header->pNext = (void *)out_ext;
16662             out_header = (void *)out_ext;
16663             break;
16664         }
16665         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
16666         {
16667             VkRenderPassCreationFeedbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16668             const VkRenderPassCreationFeedbackCreateInfoEXT32 *in_ext = (const VkRenderPassCreationFeedbackCreateInfoEXT32 *)in_header;
16669             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT;
16670             out_ext->pNext = NULL;
16671             out_ext->pRenderPassFeedback = (VkRenderPassCreationFeedbackInfoEXT *)UlongToPtr(in_ext->pRenderPassFeedback);
16672             out_header->pNext = (void *)out_ext;
16673             out_header = (void *)out_ext;
16674             break;
16675         }
16676         default:
16677             FIXME("Unhandled sType %u.\n", in_header->sType);
16678             break;
16679         }
16680     }
16681 }
16682
16683 static inline void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSamplerCreateInfo32 *in, VkSamplerCreateInfo *out)
16684 {
16685     const VkBaseInStructure32 *in_header;
16686     VkBaseOutStructure *out_header = (void *)out;
16687
16688     if (!in) return;
16689
16690     out->sType = in->sType;
16691     out->pNext = NULL;
16692     out->flags = in->flags;
16693     out->magFilter = in->magFilter;
16694     out->minFilter = in->minFilter;
16695     out->mipmapMode = in->mipmapMode;
16696     out->addressModeU = in->addressModeU;
16697     out->addressModeV = in->addressModeV;
16698     out->addressModeW = in->addressModeW;
16699     out->mipLodBias = in->mipLodBias;
16700     out->anisotropyEnable = in->anisotropyEnable;
16701     out->maxAnisotropy = in->maxAnisotropy;
16702     out->compareEnable = in->compareEnable;
16703     out->compareOp = in->compareOp;
16704     out->minLod = in->minLod;
16705     out->maxLod = in->maxLod;
16706     out->borderColor = in->borderColor;
16707     out->unnormalizedCoordinates = in->unnormalizedCoordinates;
16708
16709     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16710     {
16711         switch (in_header->sType)
16712         {
16713         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
16714         {
16715             VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16716             const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
16717             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
16718             out_ext->pNext = NULL;
16719             out_ext->conversion = in_ext->conversion;
16720             out_header->pNext = (void *)out_ext;
16721             out_header = (void *)out_ext;
16722             break;
16723         }
16724         case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
16725         {
16726             VkSamplerReductionModeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16727             const VkSamplerReductionModeCreateInfo32 *in_ext = (const VkSamplerReductionModeCreateInfo32 *)in_header;
16728             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO;
16729             out_ext->pNext = NULL;
16730             out_ext->reductionMode = in_ext->reductionMode;
16731             out_header->pNext = (void *)out_ext;
16732             out_header = (void *)out_ext;
16733             break;
16734         }
16735         case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
16736         {
16737             VkSamplerCustomBorderColorCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16738             const VkSamplerCustomBorderColorCreateInfoEXT32 *in_ext = (const VkSamplerCustomBorderColorCreateInfoEXT32 *)in_header;
16739             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT;
16740             out_ext->pNext = NULL;
16741             out_ext->customBorderColor = in_ext->customBorderColor;
16742             out_ext->format = in_ext->format;
16743             out_header->pNext = (void *)out_ext;
16744             out_header = (void *)out_ext;
16745             break;
16746         }
16747         case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
16748         {
16749             VkSamplerBorderColorComponentMappingCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16750             const VkSamplerBorderColorComponentMappingCreateInfoEXT32 *in_ext = (const VkSamplerBorderColorComponentMappingCreateInfoEXT32 *)in_header;
16751             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT;
16752             out_ext->pNext = NULL;
16753             out_ext->components = in_ext->components;
16754             out_ext->srgb = in_ext->srgb;
16755             out_header->pNext = (void *)out_ext;
16756             out_header = (void *)out_ext;
16757             break;
16758         }
16759         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
16760         {
16761             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16762             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
16763             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
16764             out_ext->pNext = NULL;
16765             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
16766             out_header->pNext = (void *)out_ext;
16767             out_header = (void *)out_ext;
16768             break;
16769         }
16770         default:
16771             FIXME("Unhandled sType %u.\n", in_header->sType);
16772             break;
16773         }
16774     }
16775 }
16776
16777 static inline void convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(const VkSamplerYcbcrConversionCreateInfo32 *in, VkSamplerYcbcrConversionCreateInfo *out)
16778 {
16779     if (!in) return;
16780
16781     out->sType = in->sType;
16782     out->pNext = NULL;
16783     out->format = in->format;
16784     out->ycbcrModel = in->ycbcrModel;
16785     out->ycbcrRange = in->ycbcrRange;
16786     out->components = in->components;
16787     out->xChromaOffset = in->xChromaOffset;
16788     out->yChromaOffset = in->yChromaOffset;
16789     out->chromaFilter = in->chromaFilter;
16790     out->forceExplicitReconstruction = in->forceExplicitReconstruction;
16791     if (in->pNext)
16792         FIXME("Unexpected pNext\n");
16793 }
16794
16795 static inline void convert_VkSemaphoreCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSemaphoreCreateInfo32 *in, VkSemaphoreCreateInfo *out)
16796 {
16797     const VkBaseInStructure32 *in_header;
16798     VkBaseOutStructure *out_header = (void *)out;
16799
16800     if (!in) return;
16801
16802     out->sType = in->sType;
16803     out->pNext = NULL;
16804     out->flags = in->flags;
16805
16806     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16807     {
16808         switch (in_header->sType)
16809         {
16810         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
16811         {
16812             VkExportSemaphoreCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16813             const VkExportSemaphoreCreateInfo32 *in_ext = (const VkExportSemaphoreCreateInfo32 *)in_header;
16814             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO;
16815             out_ext->pNext = NULL;
16816             out_ext->handleTypes = in_ext->handleTypes;
16817             out_header->pNext = (void *)out_ext;
16818             out_header = (void *)out_ext;
16819             break;
16820         }
16821         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
16822         {
16823             VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16824             const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header;
16825             out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
16826             out_ext->pNext = NULL;
16827             out_ext->semaphoreType = in_ext->semaphoreType;
16828             out_ext->initialValue = in_ext->initialValue;
16829             out_header->pNext = (void *)out_ext;
16830             out_header = (void *)out_ext;
16831             break;
16832         }
16833         case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
16834         {
16835             VkQueryLowLatencySupportNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16836             const VkQueryLowLatencySupportNV32 *in_ext = (const VkQueryLowLatencySupportNV32 *)in_header;
16837             out_ext->sType = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV;
16838             out_ext->pNext = NULL;
16839             out_ext->pQueriedLowLatencyData = (void *)UlongToPtr(in_ext->pQueriedLowLatencyData);
16840             out_header->pNext = (void *)out_ext;
16841             out_header = (void *)out_ext;
16842             break;
16843         }
16844         default:
16845             FIXME("Unhandled sType %u.\n", in_header->sType);
16846             break;
16847         }
16848     }
16849 }
16850
16851 static inline void convert_VkShaderModuleCreateInfo_win32_to_host(struct conversion_context *ctx, const VkShaderModuleCreateInfo32 *in, VkShaderModuleCreateInfo *out)
16852 {
16853     const VkBaseInStructure32 *in_header;
16854     VkBaseOutStructure *out_header = (void *)out;
16855
16856     if (!in) return;
16857
16858     out->sType = in->sType;
16859     out->pNext = NULL;
16860     out->flags = in->flags;
16861     out->codeSize = in->codeSize;
16862     out->pCode = (const uint32_t *)UlongToPtr(in->pCode);
16863
16864     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16865     {
16866         switch (in_header->sType)
16867         {
16868         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
16869         {
16870             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16871             const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
16872             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
16873             out_ext->pNext = NULL;
16874             out_ext->validationCache = in_ext->validationCache;
16875             out_header->pNext = (void *)out_ext;
16876             out_header = (void *)out_ext;
16877             break;
16878         }
16879         default:
16880             FIXME("Unhandled sType %u.\n", in_header->sType);
16881             break;
16882         }
16883     }
16884 }
16885
16886 static inline void convert_VkShaderCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkShaderCreateInfoEXT32 *in, VkShaderCreateInfoEXT *out)
16887 {
16888     const VkBaseInStructure32 *in_header;
16889     VkBaseOutStructure *out_header = (void *)out;
16890
16891     if (!in) return;
16892
16893     out->sType = in->sType;
16894     out->pNext = NULL;
16895     out->flags = in->flags;
16896     out->stage = in->stage;
16897     out->nextStage = in->nextStage;
16898     out->codeType = in->codeType;
16899     out->codeSize = in->codeSize;
16900     out->pCode = (const void *)UlongToPtr(in->pCode);
16901     out->pName = (const char *)UlongToPtr(in->pName);
16902     out->setLayoutCount = in->setLayoutCount;
16903     out->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in->pSetLayouts);
16904     out->pushConstantRangeCount = in->pushConstantRangeCount;
16905     out->pPushConstantRanges = (const VkPushConstantRange *)UlongToPtr(in->pPushConstantRanges);
16906     out->pSpecializationInfo = convert_VkSpecializationInfo_array_win32_to_host(ctx, (const VkSpecializationInfo32 *)UlongToPtr(in->pSpecializationInfo), 1);
16907
16908     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16909     {
16910         switch (in_header->sType)
16911         {
16912         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
16913         {
16914             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16915             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *)in_header;
16916             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
16917             out_ext->pNext = NULL;
16918             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
16919             out_header->pNext = (void *)out_ext;
16920             out_header = (void *)out_ext;
16921             break;
16922         }
16923         default:
16924             FIXME("Unhandled sType %u.\n", in_header->sType);
16925             break;
16926         }
16927     }
16928 }
16929
16930 static inline const VkShaderCreateInfoEXT *convert_VkShaderCreateInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkShaderCreateInfoEXT32 *in, uint32_t count)
16931 {
16932     VkShaderCreateInfoEXT *out;
16933     unsigned int i;
16934
16935     if (!in || !count) return NULL;
16936
16937     out = conversion_context_alloc(ctx, count * sizeof(*out));
16938     for (i = 0; i < count; i++)
16939     {
16940         convert_VkShaderCreateInfoEXT_win32_to_host(ctx, &in[i], &out[i]);
16941     }
16942
16943     return out;
16944 }
16945
16946 #ifdef _WIN64
16947 static inline void convert_VkSwapchainCreateInfoKHR_win64_to_host(const VkSwapchainCreateInfoKHR *in, VkSwapchainCreateInfoKHR *out)
16948 {
16949     if (!in) return;
16950
16951     out->sType = in->sType;
16952     out->pNext = in->pNext;
16953     out->flags = in->flags;
16954     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
16955     out->minImageCount = in->minImageCount;
16956     out->imageFormat = in->imageFormat;
16957     out->imageColorSpace = in->imageColorSpace;
16958     out->imageExtent = in->imageExtent;
16959     out->imageArrayLayers = in->imageArrayLayers;
16960     out->imageUsage = in->imageUsage;
16961     out->imageSharingMode = in->imageSharingMode;
16962     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
16963     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
16964     out->preTransform = in->preTransform;
16965     out->compositeAlpha = in->compositeAlpha;
16966     out->presentMode = in->presentMode;
16967     out->clipped = in->clipped;
16968     out->oldSwapchain = in->oldSwapchain;
16969 }
16970 #endif /* _WIN64 */
16971
16972 static inline void convert_VkSwapchainCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkSwapchainCreateInfoKHR32 *in, VkSwapchainCreateInfoKHR *out)
16973 {
16974     const VkBaseInStructure32 *in_header;
16975     VkBaseOutStructure *out_header = (void *)out;
16976
16977     if (!in) return;
16978
16979     out->sType = in->sType;
16980     out->pNext = NULL;
16981     out->flags = in->flags;
16982     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
16983     out->minImageCount = in->minImageCount;
16984     out->imageFormat = in->imageFormat;
16985     out->imageColorSpace = in->imageColorSpace;
16986     out->imageExtent = in->imageExtent;
16987     out->imageArrayLayers = in->imageArrayLayers;
16988     out->imageUsage = in->imageUsage;
16989     out->imageSharingMode = in->imageSharingMode;
16990     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
16991     out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);
16992     out->preTransform = in->preTransform;
16993     out->compositeAlpha = in->compositeAlpha;
16994     out->presentMode = in->presentMode;
16995     out->clipped = in->clipped;
16996     out->oldSwapchain = in->oldSwapchain;
16997
16998     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16999     {
17000         switch (in_header->sType)
17001         {
17002         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
17003         {
17004             VkDeviceGroupSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17005             const VkDeviceGroupSwapchainCreateInfoKHR32 *in_ext = (const VkDeviceGroupSwapchainCreateInfoKHR32 *)in_header;
17006             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR;
17007             out_ext->pNext = NULL;
17008             out_ext->modes = in_ext->modes;
17009             out_header->pNext = (void *)out_ext;
17010             out_header = (void *)out_ext;
17011             break;
17012         }
17013         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
17014         {
17015             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17016             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
17017             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
17018             out_ext->pNext = NULL;
17019             out_ext->viewFormatCount = in_ext->viewFormatCount;
17020             out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
17021             out_header->pNext = (void *)out_ext;
17022             out_header = (void *)out_ext;
17023             break;
17024         }
17025         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
17026         {
17027             VkSwapchainPresentBarrierCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17028             const VkSwapchainPresentBarrierCreateInfoNV32 *in_ext = (const VkSwapchainPresentBarrierCreateInfoNV32 *)in_header;
17029             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV;
17030             out_ext->pNext = NULL;
17031             out_ext->presentBarrierEnable = in_ext->presentBarrierEnable;
17032             out_header->pNext = (void *)out_ext;
17033             out_header = (void *)out_ext;
17034             break;
17035         }
17036         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
17037         {
17038             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17039             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
17040             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
17041             out_ext->pNext = NULL;
17042             out_ext->flags = in_ext->flags;
17043             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
17044             out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
17045             out_header->pNext = (void *)out_ext;
17046             out_header = (void *)out_ext;
17047             break;
17048         }
17049         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT:
17050         {
17051             VkSwapchainPresentModesCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17052             const VkSwapchainPresentModesCreateInfoEXT32 *in_ext = (const VkSwapchainPresentModesCreateInfoEXT32 *)in_header;
17053             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT;
17054             out_ext->pNext = NULL;
17055             out_ext->presentModeCount = in_ext->presentModeCount;
17056             out_ext->pPresentModes = (const VkPresentModeKHR *)UlongToPtr(in_ext->pPresentModes);
17057             out_header->pNext = (void *)out_ext;
17058             out_header = (void *)out_ext;
17059             break;
17060         }
17061         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT:
17062         {
17063             VkSwapchainPresentScalingCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17064             const VkSwapchainPresentScalingCreateInfoEXT32 *in_ext = (const VkSwapchainPresentScalingCreateInfoEXT32 *)in_header;
17065             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT;
17066             out_ext->pNext = NULL;
17067             out_ext->scalingBehavior = in_ext->scalingBehavior;
17068             out_ext->presentGravityX = in_ext->presentGravityX;
17069             out_ext->presentGravityY = in_ext->presentGravityY;
17070             out_header->pNext = (void *)out_ext;
17071             out_header = (void *)out_ext;
17072             break;
17073         }
17074         default:
17075             FIXME("Unhandled sType %u.\n", in_header->sType);
17076             break;
17077         }
17078     }
17079 }
17080
17081 static inline void convert_VkValidationCacheCreateInfoEXT_win32_to_host(const VkValidationCacheCreateInfoEXT32 *in, VkValidationCacheCreateInfoEXT *out)
17082 {
17083     if (!in) return;
17084
17085     out->sType = in->sType;
17086     out->pNext = NULL;
17087     out->flags = in->flags;
17088     out->initialDataSize = in->initialDataSize;
17089     out->pInitialData = (const void *)UlongToPtr(in->pInitialData);
17090     if (in->pNext)
17091         FIXME("Unexpected pNext\n");
17092 }
17093
17094 static inline void convert_VkWin32SurfaceCreateInfoKHR_win32_to_host(const VkWin32SurfaceCreateInfoKHR32 *in, VkWin32SurfaceCreateInfoKHR *out)
17095 {
17096     if (!in) return;
17097
17098     out->sType = in->sType;
17099     out->pNext = NULL;
17100     out->flags = in->flags;
17101     out->hinstance = (HINSTANCE)UlongToPtr(in->hinstance);
17102     out->hwnd = (HWND)UlongToPtr(in->hwnd);
17103     if (in->pNext)
17104         FIXME("Unexpected pNext\n");
17105 }
17106
17107 #ifdef _WIN64
17108 static inline void convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(const VkDebugMarkerObjectNameInfoEXT *in, VkDebugMarkerObjectNameInfoEXT *out)
17109 {
17110     if (!in) return;
17111
17112     out->sType = in->sType;
17113     out->pNext = in->pNext;
17114     out->objectType = in->objectType;
17115     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
17116     out->pObjectName = in->pObjectName;
17117 }
17118 #endif /* _WIN64 */
17119
17120 static inline void convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(const VkDebugMarkerObjectNameInfoEXT32 *in, VkDebugMarkerObjectNameInfoEXT *out)
17121 {
17122     if (!in) return;
17123
17124     out->sType = in->sType;
17125     out->pNext = NULL;
17126     out->objectType = in->objectType;
17127     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
17128     out->pObjectName = (const char *)UlongToPtr(in->pObjectName);
17129     if (in->pNext)
17130         FIXME("Unexpected pNext\n");
17131 }
17132
17133 #ifdef _WIN64
17134 static inline void convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(const VkDebugMarkerObjectTagInfoEXT *in, VkDebugMarkerObjectTagInfoEXT *out)
17135 {
17136     if (!in) return;
17137
17138     out->sType = in->sType;
17139     out->pNext = in->pNext;
17140     out->objectType = in->objectType;
17141     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
17142     out->tagName = in->tagName;
17143     out->tagSize = in->tagSize;
17144     out->pTag = in->pTag;
17145 }
17146 #endif /* _WIN64 */
17147
17148 static inline void convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(const VkDebugMarkerObjectTagInfoEXT32 *in, VkDebugMarkerObjectTagInfoEXT *out)
17149 {
17150     if (!in) return;
17151
17152     out->sType = in->sType;
17153     out->pNext = NULL;
17154     out->objectType = in->objectType;
17155     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
17156     out->tagName = in->tagName;
17157     out->tagSize = in->tagSize;
17158     out->pTag = (const void *)UlongToPtr(in->pTag);
17159     if (in->pNext)
17160         FIXME("Unexpected pNext\n");
17161 }
17162
17163 static inline void convert_VkPhysicalDevice_array_unwrapped_host_to_win32(const VkPhysicalDevice *in, PTR32 *out, uint32_t count)
17164 {
17165     unsigned int i;
17166
17167     if (!in) return;
17168
17169     for (i = 0; i < count; i++)
17170     {
17171         out[i] = PtrToUlong(in[i]);
17172     }
17173 }
17174
17175 static inline void convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_host(const VkPhysicalDeviceGroupProperties32 *in, VkPhysicalDeviceGroupProperties *out)
17176 {
17177     if (!in) return;
17178
17179     out->sType = in->sType;
17180     out->pNext = NULL;
17181     if (in->pNext)
17182         FIXME("Unexpected pNext\n");
17183 }
17184
17185 static inline void convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out)
17186 {
17187     if (!in) return;
17188
17189     out->physicalDeviceCount = in->physicalDeviceCount;
17190     convert_VkPhysicalDevice_array_unwrapped_host_to_win32(in->physicalDevices, out->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE);
17191     out->subsetAllocation = in->subsetAllocation;
17192 }
17193
17194 static inline VkPhysicalDeviceGroupProperties *convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceGroupProperties32 *in, uint32_t count)
17195 {
17196     VkPhysicalDeviceGroupProperties *out;
17197     unsigned int i;
17198
17199     if (!in || !count) return NULL;
17200
17201     out = conversion_context_alloc(ctx, count * sizeof(*out));
17202     for (i = 0; i < count; i++)
17203     {
17204         convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_host(&in[i], &out[i]);
17205     }
17206
17207     return out;
17208 }
17209
17210 static inline void convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out, uint32_t count)
17211 {
17212     unsigned int i;
17213
17214     if (!in) return;
17215
17216     for (i = 0; i < count; i++)
17217     {
17218         convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(&in[i], &out[i]);
17219     }
17220 }
17221
17222 static inline void convert_VkPerformanceCounterKHR_win32_to_host(const VkPerformanceCounterKHR32 *in, VkPerformanceCounterKHR *out)
17223 {
17224     if (!in) return;
17225
17226     out->sType = in->sType;
17227     out->pNext = NULL;
17228     if (in->pNext)
17229         FIXME("Unexpected pNext\n");
17230 }
17231
17232 static inline void convert_VkPerformanceCounterKHR_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out)
17233 {
17234     if (!in) return;
17235
17236     out->unit = in->unit;
17237     out->scope = in->scope;
17238     out->storage = in->storage;
17239     memcpy(out->uuid, in->uuid, VK_UUID_SIZE * sizeof(uint8_t));
17240 }
17241
17242 static inline VkPerformanceCounterKHR *convert_VkPerformanceCounterKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterKHR32 *in, uint32_t count)
17243 {
17244     VkPerformanceCounterKHR *out;
17245     unsigned int i;
17246
17247     if (!in || !count) return NULL;
17248
17249     out = conversion_context_alloc(ctx, count * sizeof(*out));
17250     for (i = 0; i < count; i++)
17251     {
17252         convert_VkPerformanceCounterKHR_win32_to_host(&in[i], &out[i]);
17253     }
17254
17255     return out;
17256 }
17257
17258 static inline void convert_VkPerformanceCounterKHR_array_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out, uint32_t count)
17259 {
17260     unsigned int i;
17261
17262     if (!in) return;
17263
17264     for (i = 0; i < count; i++)
17265     {
17266         convert_VkPerformanceCounterKHR_host_to_win32(&in[i], &out[i]);
17267     }
17268 }
17269
17270 static inline void convert_VkPerformanceCounterDescriptionKHR_win32_to_host(const VkPerformanceCounterDescriptionKHR32 *in, VkPerformanceCounterDescriptionKHR *out)
17271 {
17272     if (!in) return;
17273
17274     out->sType = in->sType;
17275     out->pNext = NULL;
17276     if (in->pNext)
17277         FIXME("Unexpected pNext\n");
17278 }
17279
17280 static inline void convert_VkPerformanceCounterDescriptionKHR_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out)
17281 {
17282     if (!in) return;
17283
17284     out->flags = in->flags;
17285     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17286     memcpy(out->category, in->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17287     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17288 }
17289
17290 static inline VkPerformanceCounterDescriptionKHR *convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterDescriptionKHR32 *in, uint32_t count)
17291 {
17292     VkPerformanceCounterDescriptionKHR *out;
17293     unsigned int i;
17294
17295     if (!in || !count) return NULL;
17296
17297     out = conversion_context_alloc(ctx, count * sizeof(*out));
17298     for (i = 0; i < count; i++)
17299     {
17300         convert_VkPerformanceCounterDescriptionKHR_win32_to_host(&in[i], &out[i]);
17301     }
17302
17303     return out;
17304 }
17305
17306 static inline void convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out, uint32_t count)
17307 {
17308     unsigned int i;
17309
17310     if (!in) return;
17311
17312     for (i = 0; i < count; i++)
17313     {
17314         convert_VkPerformanceCounterDescriptionKHR_host_to_win32(&in[i], &out[i]);
17315     }
17316 }
17317
17318 #ifdef _WIN64
17319 static inline void convert_VkMappedMemoryRange_win64_to_host(const VkMappedMemoryRange *in, VkMappedMemoryRange *out)
17320 {
17321     if (!in) return;
17322
17323     out->sType = in->sType;
17324     out->pNext = in->pNext;
17325     out->memory = wine_device_memory_from_handle(in->memory)->memory;
17326     out->offset = in->offset;
17327     out->size = in->size;
17328 }
17329 #endif /* _WIN64 */
17330
17331 static inline void convert_VkMappedMemoryRange_win32_to_host(const VkMappedMemoryRange32 *in, VkMappedMemoryRange *out)
17332 {
17333     if (!in) return;
17334
17335     out->sType = in->sType;
17336     out->pNext = NULL;
17337     out->memory = wine_device_memory_from_handle(in->memory)->memory;
17338     out->offset = in->offset;
17339     out->size = in->size;
17340     if (in->pNext)
17341         FIXME("Unexpected pNext\n");
17342 }
17343
17344 #ifdef _WIN64
17345 static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win64_to_host(struct conversion_context *ctx, const VkMappedMemoryRange *in, uint32_t count)
17346 {
17347     VkMappedMemoryRange *out;
17348     unsigned int i;
17349
17350     if (!in || !count) return NULL;
17351
17352     out = conversion_context_alloc(ctx, count * sizeof(*out));
17353     for (i = 0; i < count; i++)
17354     {
17355         convert_VkMappedMemoryRange_win64_to_host(&in[i], &out[i]);
17356     }
17357
17358     return out;
17359 }
17360 #endif /* _WIN64 */
17361
17362 static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win32_to_host(struct conversion_context *ctx, const VkMappedMemoryRange32 *in, uint32_t count)
17363 {
17364     VkMappedMemoryRange *out;
17365     unsigned int i;
17366
17367     if (!in || !count) return NULL;
17368
17369     out = conversion_context_alloc(ctx, count * sizeof(*out));
17370     for (i = 0; i < count; i++)
17371     {
17372         convert_VkMappedMemoryRange_win32_to_host(&in[i], &out[i]);
17373     }
17374
17375     return out;
17376 }
17377
17378 static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host(const VkAccelerationStructureBuildSizesInfoKHR32 *in, VkAccelerationStructureBuildSizesInfoKHR *out)
17379 {
17380     if (!in) return;
17381
17382     out->sType = in->sType;
17383     out->pNext = NULL;
17384     out->accelerationStructureSize = in->accelerationStructureSize;
17385     out->updateScratchSize = in->updateScratchSize;
17386     out->buildScratchSize = in->buildScratchSize;
17387     if (in->pNext)
17388         FIXME("Unexpected pNext\n");
17389 }
17390
17391 static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(const VkAccelerationStructureBuildSizesInfoKHR *in, VkAccelerationStructureBuildSizesInfoKHR32 *out)
17392 {
17393     if (!in) return;
17394
17395     out->accelerationStructureSize = in->accelerationStructureSize;
17396     out->updateScratchSize = in->updateScratchSize;
17397     out->buildScratchSize = in->buildScratchSize;
17398 }
17399
17400 static inline void convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host(const VkAccelerationStructureDeviceAddressInfoKHR32 *in, VkAccelerationStructureDeviceAddressInfoKHR *out)
17401 {
17402     if (!in) return;
17403
17404     out->sType = in->sType;
17405     out->pNext = NULL;
17406     out->accelerationStructure = in->accelerationStructure;
17407     if (in->pNext)
17408         FIXME("Unexpected pNext\n");
17409 }
17410
17411 static inline void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host(const VkAccelerationStructureMemoryRequirementsInfoNV32 *in, VkAccelerationStructureMemoryRequirementsInfoNV *out)
17412 {
17413     if (!in) return;
17414
17415     out->sType = in->sType;
17416     out->pNext = NULL;
17417     out->type = in->type;
17418     out->accelerationStructure = in->accelerationStructure;
17419     if (in->pNext)
17420         FIXME("Unexpected pNext\n");
17421 }
17422
17423 static inline void convert_VkMemoryRequirements_host_to_win32(const VkMemoryRequirements *in, VkMemoryRequirements32 *out)
17424 {
17425     if (!in) return;
17426
17427     out->size = in->size;
17428     out->alignment = in->alignment;
17429     out->memoryTypeBits = in->memoryTypeBits;
17430 }
17431
17432 static inline void convert_VkMemoryRequirements2KHR_win32_to_host(const VkMemoryRequirements2KHR32 *in, VkMemoryRequirements2KHR *out)
17433 {
17434     if (!in) return;
17435
17436     out->sType = in->sType;
17437     out->pNext = NULL;
17438     if (in->pNext)
17439         FIXME("Unexpected pNext\n");
17440 }
17441
17442 static inline void convert_VkMemoryRequirements2KHR_host_to_win32(const VkMemoryRequirements2KHR *in, VkMemoryRequirements2KHR32 *out)
17443 {
17444     if (!in) return;
17445
17446     convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
17447 }
17448
17449 static inline void convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_win32_to_host(const VkAccelerationStructureCaptureDescriptorDataInfoEXT32 *in, VkAccelerationStructureCaptureDescriptorDataInfoEXT *out)
17450 {
17451     if (!in) return;
17452
17453     out->sType = in->sType;
17454     out->pNext = NULL;
17455     out->accelerationStructure = in->accelerationStructure;
17456     out->accelerationStructureNV = in->accelerationStructureNV;
17457     if (in->pNext)
17458         FIXME("Unexpected pNext\n");
17459 }
17460
17461 static inline void convert_VkBufferDeviceAddressInfo_win32_to_host(const VkBufferDeviceAddressInfo32 *in, VkBufferDeviceAddressInfo *out)
17462 {
17463     if (!in) return;
17464
17465     out->sType = in->sType;
17466     out->pNext = NULL;
17467     out->buffer = in->buffer;
17468     if (in->pNext)
17469         FIXME("Unexpected pNext\n");
17470 }
17471
17472 static inline void convert_VkBufferMemoryRequirementsInfo2_win32_to_host(const VkBufferMemoryRequirementsInfo232 *in, VkBufferMemoryRequirementsInfo2 *out)
17473 {
17474     if (!in) return;
17475
17476     out->sType = in->sType;
17477     out->pNext = NULL;
17478     out->buffer = in->buffer;
17479     if (in->pNext)
17480         FIXME("Unexpected pNext\n");
17481 }
17482
17483 static inline void convert_VkMemoryRequirements2_win32_to_host(struct conversion_context *ctx, const VkMemoryRequirements232 *in, VkMemoryRequirements2 *out)
17484 {
17485     const VkBaseInStructure32 *in_header;
17486     VkBaseOutStructure *out_header = (void *)out;
17487
17488     if (!in) return;
17489
17490     out->sType = in->sType;
17491     out->pNext = NULL;
17492
17493     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17494     {
17495         switch (in_header->sType)
17496         {
17497         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
17498         {
17499             VkMemoryDedicatedRequirements *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17500             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
17501             out_ext->pNext = NULL;
17502             out_header->pNext = (void *)out_ext;
17503             out_header = (void *)out_ext;
17504             break;
17505         }
17506         default:
17507             FIXME("Unhandled sType %u.\n", in_header->sType);
17508             break;
17509         }
17510     }
17511 }
17512
17513 static inline void convert_VkMemoryRequirements2_host_to_win32(const VkMemoryRequirements2 *in, VkMemoryRequirements232 *out)
17514 {
17515     const VkBaseInStructure *in_header;
17516     VkBaseOutStructure32 *out_header = (void *)out;
17517
17518     if (!in) return;
17519
17520     convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
17521
17522     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
17523     {
17524         switch (in_header->sType)
17525         {
17526         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
17527         {
17528             VkMemoryDedicatedRequirements32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
17529             const VkMemoryDedicatedRequirements *in_ext = (const VkMemoryDedicatedRequirements *)in_header;
17530             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
17531             out_ext->prefersDedicatedAllocation = in_ext->prefersDedicatedAllocation;
17532             out_ext->requiresDedicatedAllocation = in_ext->requiresDedicatedAllocation;
17533             out_header = (void *)out_ext;
17534             break;
17535         }
17536         default:
17537             break;
17538         }
17539     }
17540 }
17541
17542 static inline void convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host(const VkBufferCaptureDescriptorDataInfoEXT32 *in, VkBufferCaptureDescriptorDataInfoEXT *out)
17543 {
17544     if (!in) return;
17545
17546     out->sType = in->sType;
17547     out->pNext = NULL;
17548     out->buffer = in->buffer;
17549     if (in->pNext)
17550         FIXME("Unexpected pNext\n");
17551 }
17552
17553 static inline void convert_VkCalibratedTimestampInfoEXT_win32_to_host(const VkCalibratedTimestampInfoEXT32 *in, VkCalibratedTimestampInfoEXT *out)
17554 {
17555     if (!in) return;
17556
17557     out->sType = in->sType;
17558     out->pNext = NULL;
17559     out->timeDomain = in->timeDomain;
17560     if (in->pNext)
17561         FIXME("Unexpected pNext\n");
17562 }
17563
17564 static inline const VkCalibratedTimestampInfoEXT *convert_VkCalibratedTimestampInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoEXT32 *in, uint32_t count)
17565 {
17566     VkCalibratedTimestampInfoEXT *out;
17567     unsigned int i;
17568
17569     if (!in || !count) return NULL;
17570
17571     out = conversion_context_alloc(ctx, count * sizeof(*out));
17572     for (i = 0; i < count; i++)
17573     {
17574         convert_VkCalibratedTimestampInfoEXT_win32_to_host(&in[i], &out[i]);
17575     }
17576
17577     return out;
17578 }
17579
17580 static inline void convert_VkDescriptorAddressInfoEXT_win32_to_host(const VkDescriptorAddressInfoEXT32 *in, VkDescriptorAddressInfoEXT *out)
17581 {
17582     if (!in) return;
17583
17584     out->sType = in->sType;
17585     out->pNext = NULL;
17586     out->address = in->address;
17587     out->range = in->range;
17588     out->format = in->format;
17589     if (in->pNext)
17590         FIXME("Unexpected pNext\n");
17591 }
17592
17593 static inline const VkDescriptorAddressInfoEXT *convert_VkDescriptorAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorAddressInfoEXT32 *in, uint32_t count)
17594 {
17595     VkDescriptorAddressInfoEXT *out;
17596     unsigned int i;
17597
17598     if (!in || !count) return NULL;
17599
17600     out = conversion_context_alloc(ctx, count * sizeof(*out));
17601     for (i = 0; i < count; i++)
17602     {
17603         convert_VkDescriptorAddressInfoEXT_win32_to_host(&in[i], &out[i]);
17604     }
17605
17606     return out;
17607 }
17608
17609 static inline void convert_VkDescriptorDataEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorDataEXT32 *in, VkDescriptorDataEXT *out, VkFlags selector)
17610 {
17611     if (!in) return;
17612
17613     if (selector == VK_DESCRIPTOR_TYPE_SAMPLER)
17614         out->pSampler = (const VkSampler *)UlongToPtr(in->pSampler);
17615     if (selector == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
17616         out->pCombinedImageSampler = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pCombinedImageSampler), 1);
17617     if (selector == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
17618         out->pInputAttachmentImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pInputAttachmentImage), 1);
17619     if (selector == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE)
17620         out->pSampledImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pSampledImage), 1);
17621     if (selector == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
17622         out->pStorageImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pStorageImage), 1);
17623     if (selector == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER)
17624         out->pUniformTexelBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pUniformTexelBuffer), 1);
17625     if (selector == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)
17626         out->pStorageTexelBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pStorageTexelBuffer), 1);
17627     if (selector == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER)
17628         out->pUniformBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pUniformBuffer), 1);
17629     if (selector == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
17630         out->pStorageBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pStorageBuffer), 1);
17631     if (selector == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR || selector == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV)
17632         out->accelerationStructure = in->accelerationStructure;
17633 }
17634
17635 static inline void convert_VkDescriptorGetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorGetInfoEXT32 *in, VkDescriptorGetInfoEXT *out)
17636 {
17637     if (!in) return;
17638
17639     out->sType = in->sType;
17640     out->pNext = NULL;
17641     out->type = in->type;
17642     convert_VkDescriptorDataEXT_win32_to_host(ctx, &in->data, &out->data, in->type);
17643     if (in->pNext)
17644         FIXME("Unexpected pNext\n");
17645 }
17646
17647 static inline void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(const VkDescriptorSetBindingReferenceVALVE32 *in, VkDescriptorSetBindingReferenceVALVE *out)
17648 {
17649     if (!in) return;
17650
17651     out->sType = in->sType;
17652     out->pNext = NULL;
17653     out->descriptorSetLayout = in->descriptorSetLayout;
17654     out->binding = in->binding;
17655     if (in->pNext)
17656         FIXME("Unexpected pNext\n");
17657 }
17658
17659 static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host(const VkDescriptorSetLayoutHostMappingInfoVALVE32 *in, VkDescriptorSetLayoutHostMappingInfoVALVE *out)
17660 {
17661     if (!in) return;
17662
17663     out->sType = in->sType;
17664     out->pNext = NULL;
17665     out->descriptorOffset = in->descriptorOffset;
17666     out->descriptorSize = in->descriptorSize;
17667     if (in->pNext)
17668         FIXME("Unexpected pNext\n");
17669 }
17670
17671 static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(const VkDescriptorSetLayoutHostMappingInfoVALVE *in, VkDescriptorSetLayoutHostMappingInfoVALVE32 *out)
17672 {
17673     if (!in) return;
17674
17675     out->descriptorOffset = in->descriptorOffset;
17676     out->descriptorSize = in->descriptorSize;
17677 }
17678
17679 static inline void convert_VkDescriptorSetLayoutSupport_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutSupport32 *in, VkDescriptorSetLayoutSupport *out)
17680 {
17681     const VkBaseInStructure32 *in_header;
17682     VkBaseOutStructure *out_header = (void *)out;
17683
17684     if (!in) return;
17685
17686     out->sType = in->sType;
17687     out->pNext = NULL;
17688
17689     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17690     {
17691         switch (in_header->sType)
17692         {
17693         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
17694         {
17695             VkDescriptorSetVariableDescriptorCountLayoutSupport *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17696             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
17697             out_ext->pNext = NULL;
17698             out_header->pNext = (void *)out_ext;
17699             out_header = (void *)out_ext;
17700             break;
17701         }
17702         default:
17703             FIXME("Unhandled sType %u.\n", in_header->sType);
17704             break;
17705         }
17706     }
17707 }
17708
17709 static inline void convert_VkDescriptorSetLayoutSupport_host_to_win32(const VkDescriptorSetLayoutSupport *in, VkDescriptorSetLayoutSupport32 *out)
17710 {
17711     const VkBaseInStructure *in_header;
17712     VkBaseOutStructure32 *out_header = (void *)out;
17713
17714     if (!in) return;
17715
17716     out->supported = in->supported;
17717
17718     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
17719     {
17720         switch (in_header->sType)
17721         {
17722         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
17723         {
17724             VkDescriptorSetVariableDescriptorCountLayoutSupport32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT);
17725             const VkDescriptorSetVariableDescriptorCountLayoutSupport *in_ext = (const VkDescriptorSetVariableDescriptorCountLayoutSupport *)in_header;
17726             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
17727             out_ext->maxVariableDescriptorCount = in_ext->maxVariableDescriptorCount;
17728             out_header = (void *)out_ext;
17729             break;
17730         }
17731         default:
17732             break;
17733         }
17734     }
17735 }
17736
17737 static inline void convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(const VkAccelerationStructureVersionInfoKHR32 *in, VkAccelerationStructureVersionInfoKHR *out)
17738 {
17739     if (!in) return;
17740
17741     out->sType = in->sType;
17742     out->pNext = NULL;
17743     out->pVersionData = (const uint8_t *)UlongToPtr(in->pVersionData);
17744     if (in->pNext)
17745         FIXME("Unexpected pNext\n");
17746 }
17747
17748 static inline const VkBufferCreateInfo *convert_VkBufferCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, uint32_t count)
17749 {
17750     VkBufferCreateInfo *out;
17751     unsigned int i;
17752
17753     if (!in || !count) return NULL;
17754
17755     out = conversion_context_alloc(ctx, count * sizeof(*out));
17756     for (i = 0; i < count; i++)
17757     {
17758         convert_VkBufferCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
17759     }
17760
17761     return out;
17762 }
17763
17764 static inline void convert_VkDeviceBufferMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceBufferMemoryRequirements32 *in, VkDeviceBufferMemoryRequirements *out)
17765 {
17766     if (!in) return;
17767
17768     out->sType = in->sType;
17769     out->pNext = NULL;
17770     out->pCreateInfo = convert_VkBufferCreateInfo_array_win32_to_host(ctx, (const VkBufferCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1);
17771     if (in->pNext)
17772         FIXME("Unexpected pNext\n");
17773 }
17774
17775 static inline void convert_VkDeviceFaultCountsEXT_win32_to_host(const VkDeviceFaultCountsEXT32 *in, VkDeviceFaultCountsEXT *out)
17776 {
17777     if (!in) return;
17778
17779     out->sType = in->sType;
17780     out->pNext = NULL;
17781     out->addressInfoCount = in->addressInfoCount;
17782     out->vendorInfoCount = in->vendorInfoCount;
17783     out->vendorBinarySize = in->vendorBinarySize;
17784     if (in->pNext)
17785         FIXME("Unexpected pNext\n");
17786 }
17787
17788 static inline void convert_VkDeviceFaultCountsEXT_host_to_win32(const VkDeviceFaultCountsEXT *in, VkDeviceFaultCountsEXT32 *out)
17789 {
17790     if (!in) return;
17791
17792     out->addressInfoCount = in->addressInfoCount;
17793     out->vendorInfoCount = in->vendorInfoCount;
17794     out->vendorBinarySize = in->vendorBinarySize;
17795 }
17796
17797 static inline void convert_VkDeviceFaultAddressInfoEXT_win32_to_host(const VkDeviceFaultAddressInfoEXT32 *in, VkDeviceFaultAddressInfoEXT *out)
17798 {
17799     if (!in) return;
17800
17801     out->addressType = in->addressType;
17802     out->reportedAddress = in->reportedAddress;
17803     out->addressPrecision = in->addressPrecision;
17804 }
17805
17806 static inline void convert_VkDeviceFaultAddressInfoEXT_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out)
17807 {
17808     if (!in) return;
17809
17810     out->addressType = in->addressType;
17811     out->reportedAddress = in->reportedAddress;
17812     out->addressPrecision = in->addressPrecision;
17813 }
17814
17815 static inline VkDeviceFaultAddressInfoEXT *convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultAddressInfoEXT32 *in, uint32_t count)
17816 {
17817     VkDeviceFaultAddressInfoEXT *out;
17818     unsigned int i;
17819
17820     if (!in || !count) return NULL;
17821
17822     out = conversion_context_alloc(ctx, count * sizeof(*out));
17823     for (i = 0; i < count; i++)
17824     {
17825         convert_VkDeviceFaultAddressInfoEXT_win32_to_host(&in[i], &out[i]);
17826     }
17827
17828     return out;
17829 }
17830
17831 static inline void convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out, uint32_t count)
17832 {
17833     unsigned int i;
17834
17835     if (!in) return;
17836
17837     for (i = 0; i < count; i++)
17838     {
17839         convert_VkDeviceFaultAddressInfoEXT_host_to_win32(&in[i], &out[i]);
17840     }
17841 }
17842
17843 static inline void convert_VkDeviceFaultVendorInfoEXT_win32_to_host(const VkDeviceFaultVendorInfoEXT32 *in, VkDeviceFaultVendorInfoEXT *out)
17844 {
17845     if (!in) return;
17846
17847     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17848     out->vendorFaultCode = in->vendorFaultCode;
17849     out->vendorFaultData = in->vendorFaultData;
17850 }
17851
17852 static inline void convert_VkDeviceFaultVendorInfoEXT_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out)
17853 {
17854     if (!in) return;
17855
17856     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17857     out->vendorFaultCode = in->vendorFaultCode;
17858     out->vendorFaultData = in->vendorFaultData;
17859 }
17860
17861 static inline VkDeviceFaultVendorInfoEXT *convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultVendorInfoEXT32 *in, uint32_t count)
17862 {
17863     VkDeviceFaultVendorInfoEXT *out;
17864     unsigned int i;
17865
17866     if (!in || !count) return NULL;
17867
17868     out = conversion_context_alloc(ctx, count * sizeof(*out));
17869     for (i = 0; i < count; i++)
17870     {
17871         convert_VkDeviceFaultVendorInfoEXT_win32_to_host(&in[i], &out[i]);
17872     }
17873
17874     return out;
17875 }
17876
17877 static inline void convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out, uint32_t count)
17878 {
17879     unsigned int i;
17880
17881     if (!in) return;
17882
17883     for (i = 0; i < count; i++)
17884     {
17885         convert_VkDeviceFaultVendorInfoEXT_host_to_win32(&in[i], &out[i]);
17886     }
17887 }
17888
17889 static inline void convert_VkDeviceFaultInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultInfoEXT32 *in, VkDeviceFaultInfoEXT *out)
17890 {
17891     if (!in) return;
17892
17893     out->sType = in->sType;
17894     out->pNext = NULL;
17895     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17896     out->pAddressInfos = convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(in->pAddressInfos), 1);
17897     out->pVendorInfos = convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(in->pVendorInfos), 1);
17898     out->pVendorBinaryData = (void *)UlongToPtr(in->pVendorBinaryData);
17899     if (in->pNext)
17900         FIXME("Unexpected pNext\n");
17901 }
17902
17903 static inline void convert_VkDeviceFaultInfoEXT_host_to_win32(const VkDeviceFaultInfoEXT *in, VkDeviceFaultInfoEXT32 *out)
17904 {
17905     if (!in) return;
17906
17907     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
17908     convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(in->pAddressInfos, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(out->pAddressInfos), 1);
17909     convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(in->pVendorInfos, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(out->pVendorInfos), 1);
17910     out->pVendorBinaryData = PtrToUlong(in->pVendorBinaryData);
17911 }
17912
17913 static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host(const VkDeviceGroupPresentCapabilitiesKHR32 *in, VkDeviceGroupPresentCapabilitiesKHR *out)
17914 {
17915     if (!in) return;
17916
17917     out->sType = in->sType;
17918     out->pNext = NULL;
17919     if (in->pNext)
17920         FIXME("Unexpected pNext\n");
17921 }
17922
17923 static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(const VkDeviceGroupPresentCapabilitiesKHR *in, VkDeviceGroupPresentCapabilitiesKHR32 *out)
17924 {
17925     if (!in) return;
17926
17927     memcpy(out->presentMask, in->presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
17928     out->modes = in->modes;
17929 }
17930
17931 static inline const VkImageCreateInfo *convert_VkImageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, uint32_t count)
17932 {
17933     VkImageCreateInfo *out;
17934     unsigned int i;
17935
17936     if (!in || !count) return NULL;
17937
17938     out = conversion_context_alloc(ctx, count * sizeof(*out));
17939     for (i = 0; i < count; i++)
17940     {
17941         convert_VkImageCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
17942     }
17943
17944     return out;
17945 }
17946
17947 static inline void convert_VkDeviceImageMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceImageMemoryRequirements32 *in, VkDeviceImageMemoryRequirements *out)
17948 {
17949     if (!in) return;
17950
17951     out->sType = in->sType;
17952     out->pNext = NULL;
17953     out->pCreateInfo = convert_VkImageCreateInfo_array_win32_to_host(ctx, (const VkImageCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1);
17954     out->planeAspect = in->planeAspect;
17955     if (in->pNext)
17956         FIXME("Unexpected pNext\n");
17957 }
17958
17959 static inline void convert_VkSparseImageMemoryRequirements_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out)
17960 {
17961     if (!in) return;
17962
17963     out->formatProperties = in->formatProperties;
17964     out->imageMipTailFirstLod = in->imageMipTailFirstLod;
17965     out->imageMipTailSize = in->imageMipTailSize;
17966     out->imageMipTailOffset = in->imageMipTailOffset;
17967     out->imageMipTailStride = in->imageMipTailStride;
17968 }
17969
17970 static inline void convert_VkSparseImageMemoryRequirements2_win32_to_host(const VkSparseImageMemoryRequirements232 *in, VkSparseImageMemoryRequirements2 *out)
17971 {
17972     if (!in) return;
17973
17974     out->sType = in->sType;
17975     out->pNext = NULL;
17976     if (in->pNext)
17977         FIXME("Unexpected pNext\n");
17978 }
17979
17980 static inline void convert_VkSparseImageMemoryRequirements2_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out)
17981 {
17982     if (!in) return;
17983
17984     convert_VkSparseImageMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
17985 }
17986
17987 static inline VkSparseImageMemoryRequirements2 *convert_VkSparseImageMemoryRequirements2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryRequirements232 *in, uint32_t count)
17988 {
17989     VkSparseImageMemoryRequirements2 *out;
17990     unsigned int i;
17991
17992     if (!in || !count) return NULL;
17993
17994     out = conversion_context_alloc(ctx, count * sizeof(*out));
17995     for (i = 0; i < count; i++)
17996     {
17997         convert_VkSparseImageMemoryRequirements2_win32_to_host(&in[i], &out[i]);
17998     }
17999
18000     return out;
18001 }
18002
18003 static inline void convert_VkSparseImageMemoryRequirements2_array_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out, uint32_t count)
18004 {
18005     unsigned int i;
18006
18007     if (!in) return;
18008
18009     for (i = 0; i < count; i++)
18010     {
18011         convert_VkSparseImageMemoryRequirements2_host_to_win32(&in[i], &out[i]);
18012     }
18013 }
18014
18015 #ifdef _WIN64
18016 static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out)
18017 {
18018     if (!in) return;
18019
18020     out->sType = in->sType;
18021     out->pNext = in->pNext;
18022     out->memory = wine_device_memory_from_handle(in->memory)->memory;
18023 }
18024 #endif /* _WIN64 */
18025
18026 static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo32 *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out)
18027 {
18028     if (!in) return;
18029
18030     out->sType = in->sType;
18031     out->pNext = NULL;
18032     out->memory = wine_device_memory_from_handle(in->memory)->memory;
18033     if (in->pNext)
18034         FIXME("Unexpected pNext\n");
18035 }
18036
18037 static inline void convert_VkMicromapVersionInfoEXT_win32_to_host(const VkMicromapVersionInfoEXT32 *in, VkMicromapVersionInfoEXT *out)
18038 {
18039     if (!in) return;
18040
18041     out->sType = in->sType;
18042     out->pNext = NULL;
18043     out->pVersionData = (const uint8_t *)UlongToPtr(in->pVersionData);
18044     if (in->pNext)
18045         FIXME("Unexpected pNext\n");
18046 }
18047
18048 static inline void convert_VkDeviceQueueInfo2_win32_to_host(const VkDeviceQueueInfo232 *in, VkDeviceQueueInfo2 *out)
18049 {
18050     if (!in) return;
18051
18052     out->sType = in->sType;
18053     out->pNext = NULL;
18054     out->flags = in->flags;
18055     out->queueFamilyIndex = in->queueFamilyIndex;
18056     out->queueIndex = in->queueIndex;
18057     if (in->pNext)
18058         FIXME("Unexpected pNext\n");
18059 }
18060
18061 static inline void convert_VkTilePropertiesQCOM_win32_to_host(const VkTilePropertiesQCOM32 *in, VkTilePropertiesQCOM *out)
18062 {
18063     if (!in) return;
18064
18065     out->sType = in->sType;
18066     out->pNext = NULL;
18067     out->tileSize = in->tileSize;
18068     out->apronSize = in->apronSize;
18069     out->origin = in->origin;
18070     if (in->pNext)
18071         FIXME("Unexpected pNext\n");
18072 }
18073
18074 static inline void convert_VkTilePropertiesQCOM_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out)
18075 {
18076     if (!in) return;
18077
18078     out->tileSize = in->tileSize;
18079     out->apronSize = in->apronSize;
18080     out->origin = in->origin;
18081 }
18082
18083 static inline VkTilePropertiesQCOM *convert_VkTilePropertiesQCOM_array_win32_to_host(struct conversion_context *ctx, const VkTilePropertiesQCOM32 *in, uint32_t count)
18084 {
18085     VkTilePropertiesQCOM *out;
18086     unsigned int i;
18087
18088     if (!in || !count) return NULL;
18089
18090     out = conversion_context_alloc(ctx, count * sizeof(*out));
18091     for (i = 0; i < count; i++)
18092     {
18093         convert_VkTilePropertiesQCOM_win32_to_host(&in[i], &out[i]);
18094     }
18095
18096     return out;
18097 }
18098
18099 static inline void convert_VkTilePropertiesQCOM_array_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out, uint32_t count)
18100 {
18101     unsigned int i;
18102
18103     if (!in) return;
18104
18105     for (i = 0; i < count; i++)
18106     {
18107         convert_VkTilePropertiesQCOM_host_to_win32(&in[i], &out[i]);
18108     }
18109 }
18110
18111 static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV32 *in, VkGeneratedCommandsMemoryRequirementsInfoNV *out)
18112 {
18113     if (!in) return;
18114
18115     out->sType = in->sType;
18116     out->pNext = NULL;
18117     out->pipelineBindPoint = in->pipelineBindPoint;
18118     out->pipeline = in->pipeline;
18119     out->indirectCommandsLayout = in->indirectCommandsLayout;
18120     out->maxSequencesCount = in->maxSequencesCount;
18121     if (in->pNext)
18122         FIXME("Unexpected pNext\n");
18123 }
18124
18125 static inline void convert_VkImageMemoryRequirementsInfo2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryRequirementsInfo232 *in, VkImageMemoryRequirementsInfo2 *out)
18126 {
18127     const VkBaseInStructure32 *in_header;
18128     VkBaseOutStructure *out_header = (void *)out;
18129
18130     if (!in) return;
18131
18132     out->sType = in->sType;
18133     out->pNext = NULL;
18134     out->image = in->image;
18135
18136     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
18137     {
18138         switch (in_header->sType)
18139         {
18140         case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
18141         {
18142             VkImagePlaneMemoryRequirementsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18143             const VkImagePlaneMemoryRequirementsInfo32 *in_ext = (const VkImagePlaneMemoryRequirementsInfo32 *)in_header;
18144             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
18145             out_ext->pNext = NULL;
18146             out_ext->planeAspect = in_ext->planeAspect;
18147             out_header->pNext = (void *)out_ext;
18148             out_header = (void *)out_ext;
18149             break;
18150         }
18151         default:
18152             FIXME("Unhandled sType %u.\n", in_header->sType);
18153             break;
18154         }
18155     }
18156 }
18157
18158 static inline void convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageCaptureDescriptorDataInfoEXT32 *in, VkImageCaptureDescriptorDataInfoEXT *out)
18159 {
18160     if (!in) return;
18161
18162     out->sType = in->sType;
18163     out->pNext = NULL;
18164     out->image = in->image;
18165     if (in->pNext)
18166         FIXME("Unexpected pNext\n");
18167 }
18168
18169 static inline void convert_VkSparseImageMemoryRequirements_array_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out, uint32_t count)
18170 {
18171     unsigned int i;
18172
18173     if (!in) return;
18174
18175     for (i = 0; i < count; i++)
18176     {
18177         convert_VkSparseImageMemoryRequirements_host_to_win32(&in[i], &out[i]);
18178     }
18179 }
18180
18181 static inline void convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(const VkImageSparseMemoryRequirementsInfo232 *in, VkImageSparseMemoryRequirementsInfo2 *out)
18182 {
18183     if (!in) return;
18184
18185     out->sType = in->sType;
18186     out->pNext = NULL;
18187     out->image = in->image;
18188     if (in->pNext)
18189         FIXME("Unexpected pNext\n");
18190 }
18191
18192 static inline void convert_VkSubresourceLayout_win32_to_host(const VkSubresourceLayout32 *in, VkSubresourceLayout *out)
18193 {
18194     if (!in) return;
18195
18196     out->offset = in->offset;
18197     out->size = in->size;
18198     out->rowPitch = in->rowPitch;
18199     out->arrayPitch = in->arrayPitch;
18200     out->depthPitch = in->depthPitch;
18201 }
18202
18203 static inline void convert_VkSubresourceLayout_host_to_win32(const VkSubresourceLayout *in, VkSubresourceLayout32 *out)
18204 {
18205     if (!in) return;
18206
18207     out->offset = in->offset;
18208     out->size = in->size;
18209     out->rowPitch = in->rowPitch;
18210     out->arrayPitch = in->arrayPitch;
18211     out->depthPitch = in->depthPitch;
18212 }
18213
18214 static inline void convert_VkImageSubresource2EXT_win32_to_host(const VkImageSubresource2EXT32 *in, VkImageSubresource2EXT *out)
18215 {
18216     if (!in) return;
18217
18218     out->sType = in->sType;
18219     out->pNext = NULL;
18220     out->imageSubresource = in->imageSubresource;
18221     if (in->pNext)
18222         FIXME("Unexpected pNext\n");
18223 }
18224
18225 static inline void convert_VkSubresourceLayout2EXT_win32_to_host(struct conversion_context *ctx, const VkSubresourceLayout2EXT32 *in, VkSubresourceLayout2EXT *out)
18226 {
18227     const VkBaseInStructure32 *in_header;
18228     VkBaseOutStructure *out_header = (void *)out;
18229
18230     if (!in) return;
18231
18232     out->sType = in->sType;
18233     out->pNext = NULL;
18234
18235     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
18236     {
18237         switch (in_header->sType)
18238         {
18239         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
18240         {
18241             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18242             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
18243             out_ext->pNext = NULL;
18244             out_header->pNext = (void *)out_ext;
18245             out_header = (void *)out_ext;
18246             break;
18247         }
18248         default:
18249             FIXME("Unhandled sType %u.\n", in_header->sType);
18250             break;
18251         }
18252     }
18253 }
18254
18255 static inline void convert_VkSubresourceLayout2EXT_host_to_win32(const VkSubresourceLayout2EXT *in, VkSubresourceLayout2EXT32 *out)
18256 {
18257     const VkBaseInStructure *in_header;
18258     VkBaseOutStructure32 *out_header = (void *)out;
18259
18260     if (!in) return;
18261
18262     convert_VkSubresourceLayout_host_to_win32(&in->subresourceLayout, &out->subresourceLayout);
18263
18264     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
18265     {
18266         switch (in_header->sType)
18267         {
18268         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
18269         {
18270             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
18271             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
18272             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
18273             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
18274             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
18275             out_header = (void *)out_ext;
18276             break;
18277         }
18278         default:
18279             break;
18280         }
18281     }
18282 }
18283
18284 static inline void convert_VkImageViewAddressPropertiesNVX_win32_to_host(const VkImageViewAddressPropertiesNVX32 *in, VkImageViewAddressPropertiesNVX *out)
18285 {
18286     if (!in) return;
18287
18288     out->sType = in->sType;
18289     out->pNext = NULL;
18290     if (in->pNext)
18291         FIXME("Unexpected pNext\n");
18292 }
18293
18294 static inline void convert_VkImageViewAddressPropertiesNVX_host_to_win32(const VkImageViewAddressPropertiesNVX *in, VkImageViewAddressPropertiesNVX32 *out)
18295 {
18296     if (!in) return;
18297
18298     out->deviceAddress = in->deviceAddress;
18299     out->size = in->size;
18300 }
18301
18302 static inline void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageViewHandleInfoNVX32 *in, VkImageViewHandleInfoNVX *out)
18303 {
18304     if (!in) return;
18305
18306     out->sType = in->sType;
18307     out->pNext = NULL;
18308     out->imageView = in->imageView;
18309     out->descriptorType = in->descriptorType;
18310     out->sampler = in->sampler;
18311     if (in->pNext)
18312         FIXME("Unexpected pNext\n");
18313 }
18314
18315 static inline void convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageViewCaptureDescriptorDataInfoEXT32 *in, VkImageViewCaptureDescriptorDataInfoEXT *out)
18316 {
18317     if (!in) return;
18318
18319     out->sType = in->sType;
18320     out->pNext = NULL;
18321     out->imageView = in->imageView;
18322     if (in->pNext)
18323         FIXME("Unexpected pNext\n");
18324 }
18325
18326 static inline void convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(const VkMemoryHostPointerPropertiesEXT32 *in, VkMemoryHostPointerPropertiesEXT *out)
18327 {
18328     if (!in) return;
18329
18330     out->sType = in->sType;
18331     out->pNext = NULL;
18332     if (in->pNext)
18333         FIXME("Unexpected pNext\n");
18334 }
18335
18336 static inline void convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(const VkMemoryHostPointerPropertiesEXT *in, VkMemoryHostPointerPropertiesEXT32 *out)
18337 {
18338     if (!in) return;
18339
18340     out->memoryTypeBits = in->memoryTypeBits;
18341 }
18342
18343 static inline void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMicromapBuildSizesInfoEXT32 *in, VkMicromapBuildSizesInfoEXT *out)
18344 {
18345     if (!in) return;
18346
18347     out->sType = in->sType;
18348     out->pNext = NULL;
18349     out->micromapSize = in->micromapSize;
18350     out->buildScratchSize = in->buildScratchSize;
18351     out->discardable = in->discardable;
18352     if (in->pNext)
18353         FIXME("Unexpected pNext\n");
18354 }
18355
18356 static inline void convert_VkMicromapBuildSizesInfoEXT_host_to_win32(const VkMicromapBuildSizesInfoEXT *in, VkMicromapBuildSizesInfoEXT32 *out)
18357 {
18358     if (!in) return;
18359
18360     out->micromapSize = in->micromapSize;
18361     out->buildScratchSize = in->buildScratchSize;
18362     out->discardable = in->discardable;
18363 }
18364
18365 static inline void convert_VkPerformanceValueDataINTEL_win32_to_host(const VkPerformanceValueDataINTEL32 *in, VkPerformanceValueDataINTEL *out, VkFlags selector)
18366 {
18367     if (!in) return;
18368
18369     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL)
18370         out->value32 = in->value32;
18371     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL)
18372         out->value64 = in->value64;
18373     if (selector == VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL)
18374         out->valueFloat = in->valueFloat;
18375     if (selector == VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL)
18376         out->valueBool = in->valueBool;
18377     if (selector == VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL)
18378         out->valueString = (const char *)UlongToPtr(in->valueString);
18379 }
18380
18381 static inline void convert_VkPerformanceValueDataINTEL_host_to_win32(const VkPerformanceValueDataINTEL *in, VkPerformanceValueDataINTEL32 *out, VkFlags selector)
18382 {
18383     if (!in) return;
18384
18385     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL)
18386         out->value32 = in->value32;
18387     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL)
18388         out->value64 = in->value64;
18389     if (selector == VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL)
18390         out->valueFloat = in->valueFloat;
18391     if (selector == VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL)
18392         out->valueBool = in->valueBool;
18393 }
18394
18395 static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerformanceValueINTEL *in, VkPerformanceValueINTEL32 *out)
18396 {
18397     if (!in) return;
18398
18399     out->type = in->type;
18400     convert_VkPerformanceValueDataINTEL_host_to_win32(&in->data, &out->data, in->type);
18401 }
18402
18403 static inline void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const VkCooperativeMatrixPropertiesNV32 *in, VkCooperativeMatrixPropertiesNV *out)
18404 {
18405     if (!in) return;
18406
18407     out->sType = in->sType;
18408     out->pNext = NULL;
18409     if (in->pNext)
18410         FIXME("Unexpected pNext\n");
18411 }
18412
18413 static inline void convert_VkCooperativeMatrixPropertiesNV_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out)
18414 {
18415     if (!in) return;
18416
18417     out->MSize = in->MSize;
18418     out->NSize = in->NSize;
18419     out->KSize = in->KSize;
18420     out->AType = in->AType;
18421     out->BType = in->BType;
18422     out->CType = in->CType;
18423     out->DType = in->DType;
18424     out->scope = in->scope;
18425 }
18426
18427 static inline VkCooperativeMatrixPropertiesNV *convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesNV32 *in, uint32_t count)
18428 {
18429     VkCooperativeMatrixPropertiesNV *out;
18430     unsigned int i;
18431
18432     if (!in || !count) return NULL;
18433
18434     out = conversion_context_alloc(ctx, count * sizeof(*out));
18435     for (i = 0; i < count; i++)
18436     {
18437         convert_VkCooperativeMatrixPropertiesNV_win32_to_host(&in[i], &out[i]);
18438     }
18439
18440     return out;
18441 }
18442
18443 static inline void convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out, uint32_t count)
18444 {
18445     unsigned int i;
18446
18447     if (!in) return;
18448
18449     for (i = 0; i < count; i++)
18450     {
18451         convert_VkCooperativeMatrixPropertiesNV_host_to_win32(&in[i], &out[i]);
18452     }
18453 }
18454
18455 static inline void convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(const VkPhysicalDeviceExternalBufferInfo32 *in, VkPhysicalDeviceExternalBufferInfo *out)
18456 {
18457     if (!in) return;
18458
18459     out->sType = in->sType;
18460     out->pNext = NULL;
18461     out->flags = in->flags;
18462     out->usage = in->usage;
18463     out->handleType = in->handleType;
18464     if (in->pNext)
18465         FIXME("Unexpected pNext\n");
18466 }
18467
18468 static inline void convert_VkExternalBufferProperties_win32_to_host(const VkExternalBufferProperties32 *in, VkExternalBufferProperties *out)
18469 {
18470     if (!in) return;
18471
18472     out->sType = in->sType;
18473     out->pNext = NULL;
18474     if (in->pNext)
18475         FIXME("Unexpected pNext\n");
18476 }
18477
18478 static inline void convert_VkExternalBufferProperties_host_to_win32(const VkExternalBufferProperties *in, VkExternalBufferProperties32 *out)
18479 {
18480     if (!in) return;
18481
18482     out->externalMemoryProperties = in->externalMemoryProperties;
18483 }
18484
18485 static inline void convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(const VkPhysicalDeviceExternalFenceInfo32 *in, VkPhysicalDeviceExternalFenceInfo *out)
18486 {
18487     if (!in) return;
18488
18489     out->sType = in->sType;
18490     out->pNext = NULL;
18491     out->handleType = in->handleType;
18492     if (in->pNext)
18493         FIXME("Unexpected pNext\n");
18494 }
18495
18496 static inline void convert_VkExternalFenceProperties_win32_to_host(const VkExternalFenceProperties32 *in, VkExternalFenceProperties *out)
18497 {
18498     if (!in) return;
18499
18500     out->sType = in->sType;
18501     out->pNext = NULL;
18502     if (in->pNext)
18503         FIXME("Unexpected pNext\n");
18504 }
18505
18506 static inline void convert_VkExternalFenceProperties_host_to_win32(const VkExternalFenceProperties *in, VkExternalFenceProperties32 *out)
18507 {
18508     if (!in) return;
18509
18510     out->exportFromImportedHandleTypes = in->exportFromImportedHandleTypes;
18511     out->compatibleHandleTypes = in->compatibleHandleTypes;
18512     out->externalFenceFeatures = in->externalFenceFeatures;
18513 }
18514
18515 static inline void convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalSemaphoreInfo32 *in, VkPhysicalDeviceExternalSemaphoreInfo *out)
18516 {
18517     const VkBaseInStructure32 *in_header;
18518     VkBaseOutStructure *out_header = (void *)out;
18519
18520     if (!in) return;
18521
18522     out->sType = in->sType;
18523     out->pNext = NULL;
18524     out->handleType = in->handleType;
18525
18526     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
18527     {
18528         switch (in_header->sType)
18529         {
18530         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
18531         {
18532             VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18533             const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header;
18534             out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
18535             out_ext->pNext = NULL;
18536             out_ext->semaphoreType = in_ext->semaphoreType;
18537             out_ext->initialValue = in_ext->initialValue;
18538             out_header->pNext = (void *)out_ext;
18539             out_header = (void *)out_ext;
18540             break;
18541         }
18542         default:
18543             FIXME("Unhandled sType %u.\n", in_header->sType);
18544             break;
18545         }
18546     }
18547 }
18548
18549 static inline void convert_VkExternalSemaphoreProperties_win32_to_host(const VkExternalSemaphoreProperties32 *in, VkExternalSemaphoreProperties *out)
18550 {
18551     if (!in) return;
18552
18553     out->sType = in->sType;
18554     out->pNext = NULL;
18555     if (in->pNext)
18556         FIXME("Unexpected pNext\n");
18557 }
18558
18559 static inline void convert_VkExternalSemaphoreProperties_host_to_win32(const VkExternalSemaphoreProperties *in, VkExternalSemaphoreProperties32 *out)
18560 {
18561     if (!in) return;
18562
18563     out->exportFromImportedHandleTypes = in->exportFromImportedHandleTypes;
18564     out->compatibleHandleTypes = in->compatibleHandleTypes;
18565     out->externalSemaphoreFeatures = in->externalSemaphoreFeatures;
18566 }
18567
18568 static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFeatures232 *in, VkPhysicalDeviceFeatures2 *out)
18569 {
18570     const VkBaseInStructure32 *in_header;
18571     VkBaseOutStructure *out_header = (void *)out;
18572
18573     if (!in) return;
18574
18575     out->sType = in->sType;
18576     out->pNext = NULL;
18577     out->features = in->features;
18578
18579     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
18580     {
18581         switch (in_header->sType)
18582         {
18583         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
18584         {
18585             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18586             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header;
18587             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
18588             out_ext->pNext = NULL;
18589             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
18590             out_header->pNext = (void *)out_ext;
18591             out_header = (void *)out_ext;
18592             break;
18593         }
18594         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
18595         {
18596             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18597             const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header;
18598             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
18599             out_ext->pNext = NULL;
18600             out_ext->privateData = in_ext->privateData;
18601             out_header->pNext = (void *)out_ext;
18602             out_header = (void *)out_ext;
18603             break;
18604         }
18605         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
18606         {
18607             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18608             const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header;
18609             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
18610             out_ext->pNext = NULL;
18611             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
18612             out_ext->variablePointers = in_ext->variablePointers;
18613             out_header->pNext = (void *)out_ext;
18614             out_header = (void *)out_ext;
18615             break;
18616         }
18617         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
18618         {
18619             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18620             const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header;
18621             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
18622             out_ext->pNext = NULL;
18623             out_ext->multiview = in_ext->multiview;
18624             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
18625             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
18626             out_header->pNext = (void *)out_ext;
18627             out_header = (void *)out_ext;
18628             break;
18629         }
18630         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
18631         {
18632             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18633             const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header;
18634             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
18635             out_ext->pNext = NULL;
18636             out_ext->presentId = in_ext->presentId;
18637             out_header->pNext = (void *)out_ext;
18638             out_header = (void *)out_ext;
18639             break;
18640         }
18641         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
18642         {
18643             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18644             const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header;
18645             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
18646             out_ext->pNext = NULL;
18647             out_ext->presentWait = in_ext->presentWait;
18648             out_header->pNext = (void *)out_ext;
18649             out_header = (void *)out_ext;
18650             break;
18651         }
18652         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
18653         {
18654             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18655             const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header;
18656             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
18657             out_ext->pNext = NULL;
18658             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
18659             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
18660             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
18661             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
18662             out_header->pNext = (void *)out_ext;
18663             out_header = (void *)out_ext;
18664             break;
18665         }
18666         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
18667         {
18668             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18669             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header;
18670             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
18671             out_ext->pNext = NULL;
18672             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
18673             out_header->pNext = (void *)out_ext;
18674             out_header = (void *)out_ext;
18675             break;
18676         }
18677         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
18678         {
18679             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18680             const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header;
18681             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
18682             out_ext->pNext = NULL;
18683             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
18684             out_header->pNext = (void *)out_ext;
18685             out_header = (void *)out_ext;
18686             break;
18687         }
18688         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
18689         {
18690             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18691             const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header;
18692             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
18693             out_ext->pNext = NULL;
18694             out_ext->protectedMemory = in_ext->protectedMemory;
18695             out_header->pNext = (void *)out_ext;
18696             out_header = (void *)out_ext;
18697             break;
18698         }
18699         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
18700         {
18701             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18702             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *)in_header;
18703             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
18704             out_ext->pNext = NULL;
18705             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
18706             out_header->pNext = (void *)out_ext;
18707             out_header = (void *)out_ext;
18708             break;
18709         }
18710         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
18711         {
18712             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18713             const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header;
18714             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
18715             out_ext->pNext = NULL;
18716             out_ext->multiDraw = in_ext->multiDraw;
18717             out_header->pNext = (void *)out_ext;
18718             out_header = (void *)out_ext;
18719             break;
18720         }
18721         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
18722         {
18723             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18724             const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header;
18725             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
18726             out_ext->pNext = NULL;
18727             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
18728             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
18729             out_header->pNext = (void *)out_ext;
18730             out_header = (void *)out_ext;
18731             break;
18732         }
18733         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
18734         {
18735             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18736             const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header;
18737             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
18738             out_ext->pNext = NULL;
18739             out_ext->maintenance4 = in_ext->maintenance4;
18740             out_header->pNext = (void *)out_ext;
18741             out_header = (void *)out_ext;
18742             break;
18743         }
18744         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
18745         {
18746             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18747             const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header;
18748             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
18749             out_ext->pNext = NULL;
18750             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
18751             out_header->pNext = (void *)out_ext;
18752             out_header = (void *)out_ext;
18753             break;
18754         }
18755         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
18756         {
18757             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18758             const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header;
18759             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
18760             out_ext->pNext = NULL;
18761             out_ext->shaderFloat16 = in_ext->shaderFloat16;
18762             out_ext->shaderInt8 = in_ext->shaderInt8;
18763             out_header->pNext = (void *)out_ext;
18764             out_header = (void *)out_ext;
18765             break;
18766         }
18767         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
18768         {
18769             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18770             const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header;
18771             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
18772             out_ext->pNext = NULL;
18773             out_ext->hostQueryReset = in_ext->hostQueryReset;
18774             out_header->pNext = (void *)out_ext;
18775             out_header = (void *)out_ext;
18776             break;
18777         }
18778         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
18779         {
18780             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18781             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *)in_header;
18782             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
18783             out_ext->pNext = NULL;
18784             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
18785             out_header->pNext = (void *)out_ext;
18786             out_header = (void *)out_ext;
18787             break;
18788         }
18789         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
18790         {
18791             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18792             const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header;
18793             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
18794             out_ext->pNext = NULL;
18795             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
18796             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
18797             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
18798             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
18799             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
18800             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
18801             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
18802             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
18803             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
18804             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
18805             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
18806             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
18807             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
18808             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
18809             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
18810             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
18811             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
18812             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
18813             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
18814             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
18815             out_header->pNext = (void *)out_ext;
18816             out_header = (void *)out_ext;
18817             break;
18818         }
18819         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
18820         {
18821             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18822             const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header;
18823             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
18824             out_ext->pNext = NULL;
18825             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
18826             out_header->pNext = (void *)out_ext;
18827             out_header = (void *)out_ext;
18828             break;
18829         }
18830         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
18831         {
18832             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18833             const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header;
18834             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
18835             out_ext->pNext = NULL;
18836             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
18837             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
18838             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
18839             out_header->pNext = (void *)out_ext;
18840             out_header = (void *)out_ext;
18841             break;
18842         }
18843         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
18844         {
18845             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18846             const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header;
18847             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
18848             out_ext->pNext = NULL;
18849             out_ext->conditionalRendering = in_ext->conditionalRendering;
18850             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
18851             out_header->pNext = (void *)out_ext;
18852             out_header = (void *)out_ext;
18853             break;
18854         }
18855         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
18856         {
18857             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18858             const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header;
18859             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
18860             out_ext->pNext = NULL;
18861             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
18862             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
18863             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
18864             out_header->pNext = (void *)out_ext;
18865             out_header = (void *)out_ext;
18866             break;
18867         }
18868         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
18869         {
18870             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18871             const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header;
18872             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
18873             out_ext->pNext = NULL;
18874             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
18875             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
18876             out_header->pNext = (void *)out_ext;
18877             out_header = (void *)out_ext;
18878             break;
18879         }
18880         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
18881         {
18882             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18883             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header;
18884             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
18885             out_ext->pNext = NULL;
18886             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
18887             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
18888             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
18889             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
18890             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
18891             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
18892             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
18893             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
18894             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
18895             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
18896             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
18897             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
18898             out_header->pNext = (void *)out_ext;
18899             out_header = (void *)out_ext;
18900             break;
18901         }
18902         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
18903         {
18904             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18905             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header;
18906             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
18907             out_ext->pNext = NULL;
18908             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
18909             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
18910             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
18911             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
18912             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
18913             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
18914             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
18915             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
18916             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
18917             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
18918             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
18919             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
18920             out_header->pNext = (void *)out_ext;
18921             out_header = (void *)out_ext;
18922             break;
18923         }
18924         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
18925         {
18926             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18927             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *)in_header;
18928             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
18929             out_ext->pNext = NULL;
18930             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
18931             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
18932             out_header->pNext = (void *)out_ext;
18933             out_header = (void *)out_ext;
18934             break;
18935         }
18936         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
18937         {
18938             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18939             const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header;
18940             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
18941             out_ext->pNext = NULL;
18942             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
18943             out_header->pNext = (void *)out_ext;
18944             out_header = (void *)out_ext;
18945             break;
18946         }
18947         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
18948         {
18949             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18950             const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header;
18951             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
18952             out_ext->pNext = NULL;
18953             out_ext->transformFeedback = in_ext->transformFeedback;
18954             out_ext->geometryStreams = in_ext->geometryStreams;
18955             out_header->pNext = (void *)out_ext;
18956             out_header = (void *)out_ext;
18957             break;
18958         }
18959         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
18960         {
18961             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18962             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header;
18963             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
18964             out_ext->pNext = NULL;
18965             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
18966             out_header->pNext = (void *)out_ext;
18967             out_header = (void *)out_ext;
18968             break;
18969         }
18970         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
18971         {
18972             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18973             const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header;
18974             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
18975             out_ext->pNext = NULL;
18976             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
18977             out_header->pNext = (void *)out_ext;
18978             out_header = (void *)out_ext;
18979             break;
18980         }
18981         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
18982         {
18983             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18984             const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header;
18985             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
18986             out_ext->pNext = NULL;
18987             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
18988             out_header->pNext = (void *)out_ext;
18989             out_header = (void *)out_ext;
18990             break;
18991         }
18992         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
18993         {
18994             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18995             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *)in_header;
18996             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
18997             out_ext->pNext = NULL;
18998             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
18999             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
19000             out_header->pNext = (void *)out_ext;
19001             out_header = (void *)out_ext;
19002             break;
19003         }
19004         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
19005         {
19006             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19007             const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header;
19008             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
19009             out_ext->pNext = NULL;
19010             out_ext->imageFootprint = in_ext->imageFootprint;
19011             out_header->pNext = (void *)out_ext;
19012             out_header = (void *)out_ext;
19013             break;
19014         }
19015         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
19016         {
19017             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19018             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header;
19019             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
19020             out_ext->pNext = NULL;
19021             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
19022             out_header->pNext = (void *)out_ext;
19023             out_header = (void *)out_ext;
19024             break;
19025         }
19026         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
19027         {
19028             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19029             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header;
19030             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
19031             out_ext->pNext = NULL;
19032             out_ext->indirectCopy = in_ext->indirectCopy;
19033             out_header->pNext = (void *)out_ext;
19034             out_header = (void *)out_ext;
19035             break;
19036         }
19037         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
19038         {
19039             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19040             const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header;
19041             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
19042             out_ext->pNext = NULL;
19043             out_ext->memoryDecompression = in_ext->memoryDecompression;
19044             out_header->pNext = (void *)out_ext;
19045             out_header = (void *)out_ext;
19046             break;
19047         }
19048         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
19049         {
19050             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19051             const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header;
19052             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
19053             out_ext->pNext = NULL;
19054             out_ext->shadingRateImage = in_ext->shadingRateImage;
19055             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
19056             out_header->pNext = (void *)out_ext;
19057             out_header = (void *)out_ext;
19058             break;
19059         }
19060         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
19061         {
19062             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19063             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header;
19064             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
19065             out_ext->pNext = NULL;
19066             out_ext->invocationMask = in_ext->invocationMask;
19067             out_header->pNext = (void *)out_ext;
19068             out_header = (void *)out_ext;
19069             break;
19070         }
19071         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
19072         {
19073             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19074             const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header;
19075             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
19076             out_ext->pNext = NULL;
19077             out_ext->taskShader = in_ext->taskShader;
19078             out_ext->meshShader = in_ext->meshShader;
19079             out_header->pNext = (void *)out_ext;
19080             out_header = (void *)out_ext;
19081             break;
19082         }
19083         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
19084         {
19085             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19086             const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header;
19087             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
19088             out_ext->pNext = NULL;
19089             out_ext->taskShader = in_ext->taskShader;
19090             out_ext->meshShader = in_ext->meshShader;
19091             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
19092             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
19093             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
19094             out_header->pNext = (void *)out_ext;
19095             out_header = (void *)out_ext;
19096             break;
19097         }
19098         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
19099         {
19100             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19101             const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header;
19102             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
19103             out_ext->pNext = NULL;
19104             out_ext->accelerationStructure = in_ext->accelerationStructure;
19105             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
19106             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
19107             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
19108             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
19109             out_header->pNext = (void *)out_ext;
19110             out_header = (void *)out_ext;
19111             break;
19112         }
19113         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
19114         {
19115             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19116             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header;
19117             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
19118             out_ext->pNext = NULL;
19119             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
19120             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
19121             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
19122             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
19123             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
19124             out_header->pNext = (void *)out_ext;
19125             out_header = (void *)out_ext;
19126             break;
19127         }
19128         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
19129         {
19130             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19131             const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header;
19132             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
19133             out_ext->pNext = NULL;
19134             out_ext->rayQuery = in_ext->rayQuery;
19135             out_header->pNext = (void *)out_ext;
19136             out_header = (void *)out_ext;
19137             break;
19138         }
19139         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
19140         {
19141             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19142             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header;
19143             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
19144             out_ext->pNext = NULL;
19145             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
19146             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
19147             out_header->pNext = (void *)out_ext;
19148             out_header = (void *)out_ext;
19149             break;
19150         }
19151         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
19152         {
19153             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19154             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header;
19155             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
19156             out_ext->pNext = NULL;
19157             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
19158             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
19159             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
19160             out_header->pNext = (void *)out_ext;
19161             out_header = (void *)out_ext;
19162             break;
19163         }
19164         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
19165         {
19166             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19167             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header;
19168             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
19169             out_ext->pNext = NULL;
19170             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
19171             out_header->pNext = (void *)out_ext;
19172             out_header = (void *)out_ext;
19173             break;
19174         }
19175         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
19176         {
19177             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19178             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *)in_header;
19179             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
19180             out_ext->pNext = NULL;
19181             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
19182             out_header->pNext = (void *)out_ext;
19183             out_header = (void *)out_ext;
19184             break;
19185         }
19186         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
19187         {
19188             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19189             const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header;
19190             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
19191             out_ext->pNext = NULL;
19192             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
19193             out_header->pNext = (void *)out_ext;
19194             out_header = (void *)out_ext;
19195             break;
19196         }
19197         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
19198         {
19199             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19200             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header;
19201             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
19202             out_ext->pNext = NULL;
19203             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
19204             out_header->pNext = (void *)out_ext;
19205             out_header = (void *)out_ext;
19206             break;
19207         }
19208         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
19209         {
19210             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19211             const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header;
19212             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
19213             out_ext->pNext = NULL;
19214             out_ext->depthClipEnable = in_ext->depthClipEnable;
19215             out_header->pNext = (void *)out_ext;
19216             out_header = (void *)out_ext;
19217             break;
19218         }
19219         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
19220         {
19221             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19222             const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header;
19223             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
19224             out_ext->pNext = NULL;
19225             out_ext->memoryPriority = in_ext->memoryPriority;
19226             out_header->pNext = (void *)out_ext;
19227             out_header = (void *)out_ext;
19228             break;
19229         }
19230         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
19231         {
19232             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19233             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header;
19234             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
19235             out_ext->pNext = NULL;
19236             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
19237             out_header->pNext = (void *)out_ext;
19238             out_header = (void *)out_ext;
19239             break;
19240         }
19241         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
19242         {
19243             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19244             const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header;
19245             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
19246             out_ext->pNext = NULL;
19247             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
19248             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
19249             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
19250             out_header->pNext = (void *)out_ext;
19251             out_header = (void *)out_ext;
19252             break;
19253         }
19254         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
19255         {
19256             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19257             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header;
19258             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
19259             out_ext->pNext = NULL;
19260             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
19261             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
19262             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
19263             out_header->pNext = (void *)out_ext;
19264             out_header = (void *)out_ext;
19265             break;
19266         }
19267         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
19268         {
19269             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19270             const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header;
19271             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
19272             out_ext->pNext = NULL;
19273             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
19274             out_header->pNext = (void *)out_ext;
19275             out_header = (void *)out_ext;
19276             break;
19277         }
19278         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
19279         {
19280             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19281             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header;
19282             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
19283             out_ext->pNext = NULL;
19284             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
19285             out_header->pNext = (void *)out_ext;
19286             out_header = (void *)out_ext;
19287             break;
19288         }
19289         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
19290         {
19291             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19292             const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header;
19293             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
19294             out_ext->pNext = NULL;
19295             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
19296             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
19297             out_header->pNext = (void *)out_ext;
19298             out_header = (void *)out_ext;
19299             break;
19300         }
19301         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
19302         {
19303             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19304             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header;
19305             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
19306             out_ext->pNext = NULL;
19307             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
19308             out_header->pNext = (void *)out_ext;
19309             out_header = (void *)out_ext;
19310             break;
19311         }
19312         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
19313         {
19314             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19315             const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header;
19316             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
19317             out_ext->pNext = NULL;
19318             out_ext->presentBarrier = in_ext->presentBarrier;
19319             out_header->pNext = (void *)out_ext;
19320             out_header = (void *)out_ext;
19321             break;
19322         }
19323         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
19324         {
19325             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19326             const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header;
19327             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
19328             out_ext->pNext = NULL;
19329             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
19330             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
19331             out_header->pNext = (void *)out_ext;
19332             out_header = (void *)out_ext;
19333             break;
19334         }
19335         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
19336         {
19337             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19338             const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header;
19339             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
19340             out_ext->pNext = NULL;
19341             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
19342             out_header->pNext = (void *)out_ext;
19343             out_header = (void *)out_ext;
19344             break;
19345         }
19346         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
19347         {
19348             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19349             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header;
19350             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
19351             out_ext->pNext = NULL;
19352             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
19353             out_header->pNext = (void *)out_ext;
19354             out_header = (void *)out_ext;
19355             break;
19356         }
19357         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
19358         {
19359             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19360             const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header;
19361             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
19362             out_ext->pNext = NULL;
19363             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
19364             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
19365             out_header->pNext = (void *)out_ext;
19366             out_header = (void *)out_ext;
19367             break;
19368         }
19369         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
19370         {
19371             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19372             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *)in_header;
19373             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
19374             out_ext->pNext = NULL;
19375             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
19376             out_header->pNext = (void *)out_ext;
19377             out_header = (void *)out_ext;
19378             break;
19379         }
19380         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
19381         {
19382             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19383             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header;
19384             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
19385             out_ext->pNext = NULL;
19386             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
19387             out_header->pNext = (void *)out_ext;
19388             out_header = (void *)out_ext;
19389             break;
19390         }
19391         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
19392         {
19393             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19394             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header;
19395             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
19396             out_ext->pNext = NULL;
19397             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
19398             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
19399             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
19400             out_header->pNext = (void *)out_ext;
19401             out_header = (void *)out_ext;
19402             break;
19403         }
19404         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
19405         {
19406             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19407             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header;
19408             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
19409             out_ext->pNext = NULL;
19410             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
19411             out_header->pNext = (void *)out_ext;
19412             out_header = (void *)out_ext;
19413             break;
19414         }
19415         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
19416         {
19417             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19418             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header;
19419             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
19420             out_ext->pNext = NULL;
19421             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
19422             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
19423             out_header->pNext = (void *)out_ext;
19424             out_header = (void *)out_ext;
19425             break;
19426         }
19427         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
19428         {
19429             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19430             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header;
19431             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
19432             out_ext->pNext = NULL;
19433             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
19434             out_header->pNext = (void *)out_ext;
19435             out_header = (void *)out_ext;
19436             break;
19437         }
19438         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
19439         {
19440             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19441             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header;
19442             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
19443             out_ext->pNext = NULL;
19444             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
19445             out_header->pNext = (void *)out_ext;
19446             out_header = (void *)out_ext;
19447             break;
19448         }
19449         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
19450         {
19451             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19452             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header;
19453             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
19454             out_ext->pNext = NULL;
19455             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
19456             out_header->pNext = (void *)out_ext;
19457             out_header = (void *)out_ext;
19458             break;
19459         }
19460         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
19461         {
19462             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19463             const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header;
19464             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
19465             out_ext->pNext = NULL;
19466             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
19467             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
19468             out_header->pNext = (void *)out_ext;
19469             out_header = (void *)out_ext;
19470             break;
19471         }
19472         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
19473         {
19474             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19475             const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *)in_header;
19476             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
19477             out_ext->pNext = NULL;
19478             out_ext->rectangularLines = in_ext->rectangularLines;
19479             out_ext->bresenhamLines = in_ext->bresenhamLines;
19480             out_ext->smoothLines = in_ext->smoothLines;
19481             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
19482             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
19483             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
19484             out_header->pNext = (void *)out_ext;
19485             out_header = (void *)out_ext;
19486             break;
19487         }
19488         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
19489         {
19490             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19491             const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header;
19492             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
19493             out_ext->pNext = NULL;
19494             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
19495             out_header->pNext = (void *)out_ext;
19496             out_header = (void *)out_ext;
19497             break;
19498         }
19499         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
19500         {
19501             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19502             const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header;
19503             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
19504             out_ext->pNext = NULL;
19505             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
19506             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
19507             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
19508             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
19509             out_ext->multiview = in_ext->multiview;
19510             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
19511             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
19512             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
19513             out_ext->variablePointers = in_ext->variablePointers;
19514             out_ext->protectedMemory = in_ext->protectedMemory;
19515             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
19516             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
19517             out_header->pNext = (void *)out_ext;
19518             out_header = (void *)out_ext;
19519             break;
19520         }
19521         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
19522         {
19523             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19524             const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header;
19525             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
19526             out_ext->pNext = NULL;
19527             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
19528             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
19529             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
19530             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
19531             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
19532             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
19533             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
19534             out_ext->shaderFloat16 = in_ext->shaderFloat16;
19535             out_ext->shaderInt8 = in_ext->shaderInt8;
19536             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
19537             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
19538             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
19539             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
19540             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
19541             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
19542             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
19543             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
19544             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
19545             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
19546             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
19547             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
19548             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
19549             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
19550             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
19551             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
19552             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
19553             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
19554             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
19555             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
19556             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
19557             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
19558             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
19559             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
19560             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
19561             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
19562             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
19563             out_ext->hostQueryReset = in_ext->hostQueryReset;
19564             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
19565             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
19566             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
19567             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
19568             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
19569             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
19570             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
19571             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
19572             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
19573             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
19574             out_header->pNext = (void *)out_ext;
19575             out_header = (void *)out_ext;
19576             break;
19577         }
19578         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
19579         {
19580             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19581             const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header;
19582             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
19583             out_ext->pNext = NULL;
19584             out_ext->robustImageAccess = in_ext->robustImageAccess;
19585             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
19586             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
19587             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
19588             out_ext->privateData = in_ext->privateData;
19589             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
19590             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
19591             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
19592             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
19593             out_ext->synchronization2 = in_ext->synchronization2;
19594             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
19595             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
19596             out_ext->dynamicRendering = in_ext->dynamicRendering;
19597             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
19598             out_ext->maintenance4 = in_ext->maintenance4;
19599             out_header->pNext = (void *)out_ext;
19600             out_header = (void *)out_ext;
19601             break;
19602         }
19603         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
19604         {
19605             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19606             const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header;
19607             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
19608             out_ext->pNext = NULL;
19609             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
19610             out_header->pNext = (void *)out_ext;
19611             out_header = (void *)out_ext;
19612             break;
19613         }
19614         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
19615         {
19616             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19617             const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header;
19618             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
19619             out_ext->pNext = NULL;
19620             out_ext->customBorderColors = in_ext->customBorderColors;
19621             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
19622             out_header->pNext = (void *)out_ext;
19623             out_header = (void *)out_ext;
19624             break;
19625         }
19626         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
19627         {
19628             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19629             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header;
19630             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
19631             out_ext->pNext = NULL;
19632             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
19633             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
19634             out_header->pNext = (void *)out_ext;
19635             out_header = (void *)out_ext;
19636             break;
19637         }
19638         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
19639         {
19640             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19641             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header;
19642             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
19643             out_ext->pNext = NULL;
19644             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
19645             out_header->pNext = (void *)out_ext;
19646             out_header = (void *)out_ext;
19647             break;
19648         }
19649         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
19650         {
19651             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19652             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header;
19653             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
19654             out_ext->pNext = NULL;
19655             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
19656             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
19657             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
19658             out_header->pNext = (void *)out_ext;
19659             out_header = (void *)out_ext;
19660             break;
19661         }
19662         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
19663         {
19664             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19665             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header;
19666             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
19667             out_ext->pNext = NULL;
19668             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
19669             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
19670             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
19671             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
19672             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
19673             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
19674             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
19675             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
19676             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
19677             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
19678             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
19679             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
19680             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
19681             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
19682             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
19683             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
19684             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
19685             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
19686             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
19687             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
19688             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
19689             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
19690             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
19691             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
19692             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
19693             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
19694             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
19695             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
19696             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
19697             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
19698             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
19699             out_header->pNext = (void *)out_ext;
19700             out_header = (void *)out_ext;
19701             break;
19702         }
19703         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
19704         {
19705             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19706             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header;
19707             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
19708             out_ext->pNext = NULL;
19709             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
19710             out_header->pNext = (void *)out_ext;
19711             out_header = (void *)out_ext;
19712             break;
19713         }
19714         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
19715         {
19716             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19717             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header;
19718             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
19719             out_ext->pNext = NULL;
19720             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
19721             out_header->pNext = (void *)out_ext;
19722             out_header = (void *)out_ext;
19723             break;
19724         }
19725         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
19726         {
19727             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19728             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header;
19729             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
19730             out_ext->pNext = NULL;
19731             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
19732             out_header->pNext = (void *)out_ext;
19733             out_header = (void *)out_ext;
19734             break;
19735         }
19736         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
19737         {
19738             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19739             const VkPhysicalDeviceRobustness2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT32 *)in_header;
19740             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
19741             out_ext->pNext = NULL;
19742             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
19743             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
19744             out_ext->nullDescriptor = in_ext->nullDescriptor;
19745             out_header->pNext = (void *)out_ext;
19746             out_header = (void *)out_ext;
19747             break;
19748         }
19749         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
19750         {
19751             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19752             const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header;
19753             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
19754             out_ext->pNext = NULL;
19755             out_ext->robustImageAccess = in_ext->robustImageAccess;
19756             out_header->pNext = (void *)out_ext;
19757             out_header = (void *)out_ext;
19758             break;
19759         }
19760         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
19761         {
19762             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19763             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header;
19764             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
19765             out_ext->pNext = NULL;
19766             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
19767             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
19768             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
19769             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
19770             out_header->pNext = (void *)out_ext;
19771             out_header = (void *)out_ext;
19772             break;
19773         }
19774         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
19775         {
19776             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19777             const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header;
19778             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
19779             out_ext->pNext = NULL;
19780             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
19781             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
19782             out_header->pNext = (void *)out_ext;
19783             out_header = (void *)out_ext;
19784             break;
19785         }
19786         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
19787         {
19788             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19789             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header;
19790             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
19791             out_ext->pNext = NULL;
19792             out_ext->subpassShading = in_ext->subpassShading;
19793             out_header->pNext = (void *)out_ext;
19794             out_header = (void *)out_ext;
19795             break;
19796         }
19797         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
19798         {
19799             VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19800             const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *)in_header;
19801             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
19802             out_ext->pNext = NULL;
19803             out_ext->clustercullingShader = in_ext->clustercullingShader;
19804             out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
19805             out_header->pNext = (void *)out_ext;
19806             out_header = (void *)out_ext;
19807             break;
19808         }
19809         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
19810         {
19811             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19812             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header;
19813             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
19814             out_ext->pNext = NULL;
19815             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
19816             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
19817             out_header->pNext = (void *)out_ext;
19818             out_header = (void *)out_ext;
19819             break;
19820         }
19821         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
19822         {
19823             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19824             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header;
19825             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
19826             out_ext->pNext = NULL;
19827             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
19828             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
19829             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
19830             out_header->pNext = (void *)out_ext;
19831             out_header = (void *)out_ext;
19832             break;
19833         }
19834         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
19835         {
19836             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19837             const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header;
19838             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
19839             out_ext->pNext = NULL;
19840             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
19841             out_header->pNext = (void *)out_ext;
19842             out_header = (void *)out_ext;
19843             break;
19844         }
19845         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
19846         {
19847             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19848             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header;
19849             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
19850             out_ext->pNext = NULL;
19851             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
19852             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
19853             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
19854             out_header->pNext = (void *)out_ext;
19855             out_header = (void *)out_ext;
19856             break;
19857         }
19858         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
19859         {
19860             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19861             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header;
19862             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
19863             out_ext->pNext = NULL;
19864             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
19865             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
19866             out_header->pNext = (void *)out_ext;
19867             out_header = (void *)out_ext;
19868             break;
19869         }
19870         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
19871         {
19872             VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19873             const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *)in_header;
19874             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
19875             out_ext->pNext = NULL;
19876             out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
19877             out_header->pNext = (void *)out_ext;
19878             out_header = (void *)out_ext;
19879             break;
19880         }
19881         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
19882         {
19883             VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19884             const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *)in_header;
19885             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
19886             out_ext->pNext = NULL;
19887             out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
19888             out_header->pNext = (void *)out_ext;
19889             out_header = (void *)out_ext;
19890             break;
19891         }
19892         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
19893         {
19894             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19895             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header;
19896             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
19897             out_ext->pNext = NULL;
19898             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
19899             out_header->pNext = (void *)out_ext;
19900             out_header = (void *)out_ext;
19901             break;
19902         }
19903         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
19904         {
19905             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19906             const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header;
19907             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
19908             out_ext->pNext = NULL;
19909             out_ext->depthClipControl = in_ext->depthClipControl;
19910             out_header->pNext = (void *)out_ext;
19911             out_header = (void *)out_ext;
19912             break;
19913         }
19914         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
19915         {
19916             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19917             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header;
19918             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
19919             out_ext->pNext = NULL;
19920             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
19921             out_header->pNext = (void *)out_ext;
19922             out_header = (void *)out_ext;
19923             break;
19924         }
19925         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
19926         {
19927             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19928             const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header;
19929             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
19930             out_ext->pNext = NULL;
19931             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
19932             out_header->pNext = (void *)out_ext;
19933             out_header = (void *)out_ext;
19934             break;
19935         }
19936         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
19937         {
19938             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19939             const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header;
19940             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
19941             out_ext->pNext = NULL;
19942             out_ext->synchronization2 = in_ext->synchronization2;
19943             out_header->pNext = (void *)out_ext;
19944             out_header = (void *)out_ext;
19945             break;
19946         }
19947         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
19948         {
19949             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19950             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header;
19951             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
19952             out_ext->pNext = NULL;
19953             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
19954             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
19955             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
19956             out_header->pNext = (void *)out_ext;
19957             out_header = (void *)out_ext;
19958             break;
19959         }
19960         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
19961         {
19962             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19963             const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header;
19964             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
19965             out_ext->pNext = NULL;
19966             out_ext->legacyDithering = in_ext->legacyDithering;
19967             out_header->pNext = (void *)out_ext;
19968             out_header = (void *)out_ext;
19969             break;
19970         }
19971         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
19972         {
19973             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19974             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header;
19975             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
19976             out_ext->pNext = NULL;
19977             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
19978             out_header->pNext = (void *)out_ext;
19979             out_header = (void *)out_ext;
19980             break;
19981         }
19982         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
19983         {
19984             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19985             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *)in_header;
19986             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
19987             out_ext->pNext = NULL;
19988             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
19989             out_header->pNext = (void *)out_ext;
19990             out_header = (void *)out_ext;
19991             break;
19992         }
19993         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
19994         {
19995             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19996             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header;
19997             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
19998             out_ext->pNext = NULL;
19999             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
20000             out_header->pNext = (void *)out_ext;
20001             out_header = (void *)out_ext;
20002             break;
20003         }
20004         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
20005         {
20006             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20007             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header;
20008             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
20009             out_ext->pNext = NULL;
20010             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
20011             out_header->pNext = (void *)out_ext;
20012             out_header = (void *)out_ext;
20013             break;
20014         }
20015         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
20016         {
20017             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20018             const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *)in_header;
20019             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
20020             out_ext->pNext = NULL;
20021             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
20022             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
20023             out_header->pNext = (void *)out_ext;
20024             out_header = (void *)out_ext;
20025             break;
20026         }
20027         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
20028         {
20029             VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20030             const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header;
20031             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
20032             out_ext->pNext = NULL;
20033             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
20034             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
20035             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
20036             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
20037             out_header->pNext = (void *)out_ext;
20038             out_header = (void *)out_ext;
20039             break;
20040         }
20041         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
20042         {
20043             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20044             const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header;
20045             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
20046             out_ext->pNext = NULL;
20047             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
20048             out_header->pNext = (void *)out_ext;
20049             out_header = (void *)out_ext;
20050             break;
20051         }
20052         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
20053         {
20054             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20055             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header;
20056             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
20057             out_ext->pNext = NULL;
20058             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
20059             out_header->pNext = (void *)out_ext;
20060             out_header = (void *)out_ext;
20061             break;
20062         }
20063         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
20064         {
20065             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20066             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header;
20067             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
20068             out_ext->pNext = NULL;
20069             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
20070             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
20071             out_header->pNext = (void *)out_ext;
20072             out_header = (void *)out_ext;
20073             break;
20074         }
20075         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
20076         {
20077             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20078             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header;
20079             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
20080             out_ext->pNext = NULL;
20081             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
20082             out_header->pNext = (void *)out_ext;
20083             out_header = (void *)out_ext;
20084             break;
20085         }
20086         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
20087         {
20088             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20089             const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header;
20090             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
20091             out_ext->pNext = NULL;
20092             out_ext->dynamicRendering = in_ext->dynamicRendering;
20093             out_header->pNext = (void *)out_ext;
20094             out_header = (void *)out_ext;
20095             break;
20096         }
20097         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
20098         {
20099             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20100             const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header;
20101             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
20102             out_ext->pNext = NULL;
20103             out_ext->minLod = in_ext->minLod;
20104             out_header->pNext = (void *)out_ext;
20105             out_header = (void *)out_ext;
20106             break;
20107         }
20108         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
20109         {
20110             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20111             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header;
20112             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
20113             out_ext->pNext = NULL;
20114             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
20115             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
20116             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
20117             out_header->pNext = (void *)out_ext;
20118             out_header = (void *)out_ext;
20119             break;
20120         }
20121         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
20122         {
20123             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20124             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header;
20125             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
20126             out_ext->pNext = NULL;
20127             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
20128             out_header->pNext = (void *)out_ext;
20129             out_header = (void *)out_ext;
20130             break;
20131         }
20132         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
20133         {
20134             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20135             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header;
20136             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
20137             out_ext->pNext = NULL;
20138             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
20139             out_header->pNext = (void *)out_ext;
20140             out_header = (void *)out_ext;
20141             break;
20142         }
20143         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
20144         {
20145             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20146             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header;
20147             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
20148             out_ext->pNext = NULL;
20149             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
20150             out_header->pNext = (void *)out_ext;
20151             out_header = (void *)out_ext;
20152             break;
20153         }
20154         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
20155         {
20156             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20157             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header;
20158             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
20159             out_ext->pNext = NULL;
20160             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
20161             out_header->pNext = (void *)out_ext;
20162             out_header = (void *)out_ext;
20163             break;
20164         }
20165         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
20166         {
20167             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20168             const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header;
20169             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
20170             out_ext->pNext = NULL;
20171             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
20172             out_header->pNext = (void *)out_ext;
20173             out_header = (void *)out_ext;
20174             break;
20175         }
20176         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
20177         {
20178             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20179             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header;
20180             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
20181             out_ext->pNext = NULL;
20182             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
20183             out_header->pNext = (void *)out_ext;
20184             out_header = (void *)out_ext;
20185             break;
20186         }
20187         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
20188         {
20189             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20190             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header;
20191             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
20192             out_ext->pNext = NULL;
20193             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
20194             out_header->pNext = (void *)out_ext;
20195             out_header = (void *)out_ext;
20196             break;
20197         }
20198         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
20199         {
20200             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20201             const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header;
20202             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
20203             out_ext->pNext = NULL;
20204             out_ext->micromap = in_ext->micromap;
20205             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
20206             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
20207             out_header->pNext = (void *)out_ext;
20208             out_header = (void *)out_ext;
20209             break;
20210         }
20211         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
20212         {
20213             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20214             const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header;
20215             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
20216             out_ext->pNext = NULL;
20217             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
20218             out_header->pNext = (void *)out_ext;
20219             out_header = (void *)out_ext;
20220             break;
20221         }
20222         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
20223         {
20224             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20225             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header;
20226             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
20227             out_ext->pNext = NULL;
20228             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
20229             out_header->pNext = (void *)out_ext;
20230             out_header = (void *)out_ext;
20231             break;
20232         }
20233         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
20234         {
20235             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20236             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header;
20237             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
20238             out_ext->pNext = NULL;
20239             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
20240             out_header->pNext = (void *)out_ext;
20241             out_header = (void *)out_ext;
20242             break;
20243         }
20244         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
20245         {
20246             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20247             const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *)in_header;
20248             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
20249             out_ext->pNext = NULL;
20250             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
20251             out_header->pNext = (void *)out_ext;
20252             out_header = (void *)out_ext;
20253             break;
20254         }
20255         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
20256         {
20257             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20258             const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header;
20259             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
20260             out_ext->pNext = NULL;
20261             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
20262             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
20263             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
20264             out_header->pNext = (void *)out_ext;
20265             out_header = (void *)out_ext;
20266             break;
20267         }
20268         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
20269         {
20270             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20271             const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header;
20272             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
20273             out_ext->pNext = NULL;
20274             out_ext->tileProperties = in_ext->tileProperties;
20275             out_header->pNext = (void *)out_ext;
20276             out_header = (void *)out_ext;
20277             break;
20278         }
20279         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
20280         {
20281             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20282             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header;
20283             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
20284             out_ext->pNext = NULL;
20285             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
20286             out_header->pNext = (void *)out_ext;
20287             out_header = (void *)out_ext;
20288             break;
20289         }
20290         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
20291         {
20292             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20293             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *)in_header;
20294             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
20295             out_ext->pNext = NULL;
20296             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
20297             out_header->pNext = (void *)out_ext;
20298             out_header = (void *)out_ext;
20299             break;
20300         }
20301         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
20302         {
20303             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20304             const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header;
20305             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
20306             out_ext->pNext = NULL;
20307             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
20308             out_header->pNext = (void *)out_ext;
20309             out_header = (void *)out_ext;
20310             break;
20311         }
20312         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
20313         {
20314             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20315             const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header;
20316             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
20317             out_ext->pNext = NULL;
20318             out_ext->opticalFlow = in_ext->opticalFlow;
20319             out_header->pNext = (void *)out_ext;
20320             out_header = (void *)out_ext;
20321             break;
20322         }
20323         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
20324         {
20325             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20326             const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header;
20327             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
20328             out_ext->pNext = NULL;
20329             out_ext->deviceFault = in_ext->deviceFault;
20330             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
20331             out_header->pNext = (void *)out_ext;
20332             out_header = (void *)out_ext;
20333             break;
20334         }
20335         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
20336         {
20337             VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20338             const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *)in_header;
20339             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
20340             out_ext->pNext = NULL;
20341             out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
20342             out_header->pNext = (void *)out_ext;
20343             out_header = (void *)out_ext;
20344             break;
20345         }
20346         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
20347         {
20348             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20349             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header;
20350             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
20351             out_ext->pNext = NULL;
20352             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
20353             out_header->pNext = (void *)out_ext;
20354             out_header = (void *)out_ext;
20355             break;
20356         }
20357         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
20358         {
20359             VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20360             const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *)in_header;
20361             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
20362             out_ext->pNext = NULL;
20363             out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
20364             out_header->pNext = (void *)out_ext;
20365             out_header = (void *)out_ext;
20366             break;
20367         }
20368         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
20369         {
20370             VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20371             const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *)in_header;
20372             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT;
20373             out_ext->pNext = NULL;
20374             out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
20375             out_header->pNext = (void *)out_ext;
20376             out_header = (void *)out_ext;
20377             break;
20378         }
20379         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
20380         {
20381             VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20382             const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *)in_header;
20383             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
20384             out_ext->pNext = NULL;
20385             out_ext->depthBiasControl = in_ext->depthBiasControl;
20386             out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
20387             out_ext->floatRepresentation = in_ext->floatRepresentation;
20388             out_ext->depthBiasExact = in_ext->depthBiasExact;
20389             out_header->pNext = (void *)out_ext;
20390             out_header = (void *)out_ext;
20391             break;
20392         }
20393         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
20394         {
20395             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20396             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header;
20397             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
20398             out_ext->pNext = NULL;
20399             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
20400             out_header->pNext = (void *)out_ext;
20401             out_header = (void *)out_ext;
20402             break;
20403         }
20404         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
20405         {
20406             VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20407             const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *)in_header;
20408             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
20409             out_ext->pNext = NULL;
20410             out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
20411             out_header->pNext = (void *)out_ext;
20412             out_header = (void *)out_ext;
20413             break;
20414         }
20415         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
20416         {
20417             VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20418             const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *)in_header;
20419             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
20420             out_ext->pNext = NULL;
20421             out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
20422             out_header->pNext = (void *)out_ext;
20423             out_header = (void *)out_ext;
20424             break;
20425         }
20426         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
20427         {
20428             VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20429             const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *)in_header;
20430             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
20431             out_ext->pNext = NULL;
20432             out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
20433             out_header->pNext = (void *)out_ext;
20434             out_header = (void *)out_ext;
20435             break;
20436         }
20437         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
20438         {
20439             VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20440             const VkPhysicalDeviceShaderObjectFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT32 *)in_header;
20441             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
20442             out_ext->pNext = NULL;
20443             out_ext->shaderObject = in_ext->shaderObject;
20444             out_header->pNext = (void *)out_ext;
20445             out_header = (void *)out_ext;
20446             break;
20447         }
20448         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
20449         {
20450             VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20451             const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *)in_header;
20452             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
20453             out_ext->pNext = NULL;
20454             out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
20455             out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
20456             out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
20457             out_header->pNext = (void *)out_ext;
20458             out_header = (void *)out_ext;
20459             break;
20460         }
20461         default:
20462             FIXME("Unhandled sType %u.\n", in_header->sType);
20463             break;
20464         }
20465     }
20466 }
20467
20468 static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDeviceFeatures2 *in, VkPhysicalDeviceFeatures232 *out)
20469 {
20470     const VkBaseInStructure *in_header;
20471     VkBaseOutStructure32 *out_header = (void *)out;
20472
20473     if (!in) return;
20474
20475     out->features = in->features;
20476
20477     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
20478     {
20479         switch (in_header->sType)
20480         {
20481         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
20482         {
20483             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV);
20484             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
20485             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
20486             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
20487             out_header = (void *)out_ext;
20488             break;
20489         }
20490         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
20491         {
20492             VkPhysicalDevicePrivateDataFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES);
20493             const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
20494             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
20495             out_ext->privateData = in_ext->privateData;
20496             out_header = (void *)out_ext;
20497             break;
20498         }
20499         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
20500         {
20501             VkPhysicalDeviceVariablePointersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
20502             const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
20503             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
20504             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
20505             out_ext->variablePointers = in_ext->variablePointers;
20506             out_header = (void *)out_ext;
20507             break;
20508         }
20509         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
20510         {
20511             VkPhysicalDeviceMultiviewFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
20512             const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
20513             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
20514             out_ext->multiview = in_ext->multiview;
20515             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
20516             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
20517             out_header = (void *)out_ext;
20518             break;
20519         }
20520         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
20521         {
20522             VkPhysicalDevicePresentIdFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR);
20523             const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
20524             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
20525             out_ext->presentId = in_ext->presentId;
20526             out_header = (void *)out_ext;
20527             break;
20528         }
20529         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
20530         {
20531             VkPhysicalDevicePresentWaitFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR);
20532             const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
20533             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
20534             out_ext->presentWait = in_ext->presentWait;
20535             out_header = (void *)out_ext;
20536             break;
20537         }
20538         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
20539         {
20540             VkPhysicalDevice16BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
20541             const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
20542             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
20543             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
20544             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
20545             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
20546             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
20547             out_header = (void *)out_ext;
20548             break;
20549         }
20550         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
20551         {
20552             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
20553             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
20554             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
20555             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
20556             out_header = (void *)out_ext;
20557             break;
20558         }
20559         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
20560         {
20561             VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
20562             const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
20563             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
20564             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
20565             out_header = (void *)out_ext;
20566             break;
20567         }
20568         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
20569         {
20570             VkPhysicalDeviceProtectedMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
20571             const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
20572             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
20573             out_ext->protectedMemory = in_ext->protectedMemory;
20574             out_header = (void *)out_ext;
20575             break;
20576         }
20577         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
20578         {
20579             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT);
20580             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
20581             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
20582             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
20583             out_header = (void *)out_ext;
20584             break;
20585         }
20586         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
20587         {
20588             VkPhysicalDeviceMultiDrawFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT);
20589             const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
20590             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
20591             out_ext->multiDraw = in_ext->multiDraw;
20592             out_header = (void *)out_ext;
20593             break;
20594         }
20595         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
20596         {
20597             VkPhysicalDeviceInlineUniformBlockFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES);
20598             const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
20599             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
20600             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
20601             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
20602             out_header = (void *)out_ext;
20603             break;
20604         }
20605         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
20606         {
20607             VkPhysicalDeviceMaintenance4Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES);
20608             const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
20609             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
20610             out_ext->maintenance4 = in_ext->maintenance4;
20611             out_header = (void *)out_ext;
20612             break;
20613         }
20614         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
20615         {
20616             VkPhysicalDeviceShaderDrawParametersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
20617             const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
20618             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
20619             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
20620             out_header = (void *)out_ext;
20621             break;
20622         }
20623         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
20624         {
20625             VkPhysicalDeviceShaderFloat16Int8Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
20626             const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
20627             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
20628             out_ext->shaderFloat16 = in_ext->shaderFloat16;
20629             out_ext->shaderInt8 = in_ext->shaderInt8;
20630             out_header = (void *)out_ext;
20631             break;
20632         }
20633         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
20634         {
20635             VkPhysicalDeviceHostQueryResetFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
20636             const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
20637             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
20638             out_ext->hostQueryReset = in_ext->hostQueryReset;
20639             out_header = (void *)out_ext;
20640             break;
20641         }
20642         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
20643         {
20644             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR);
20645             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *)in_header;
20646             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
20647             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
20648             out_header = (void *)out_ext;
20649             break;
20650         }
20651         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
20652         {
20653             VkPhysicalDeviceDescriptorIndexingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
20654             const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
20655             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
20656             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
20657             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
20658             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
20659             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
20660             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
20661             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
20662             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
20663             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
20664             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
20665             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
20666             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
20667             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
20668             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
20669             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
20670             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
20671             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
20672             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
20673             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
20674             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
20675             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
20676             out_header = (void *)out_ext;
20677             break;
20678         }
20679         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
20680         {
20681             VkPhysicalDeviceTimelineSemaphoreFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
20682             const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
20683             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
20684             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
20685             out_header = (void *)out_ext;
20686             break;
20687         }
20688         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
20689         {
20690             VkPhysicalDevice8BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
20691             const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
20692             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
20693             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
20694             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
20695             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
20696             out_header = (void *)out_ext;
20697             break;
20698         }
20699         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
20700         {
20701             VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT);
20702             const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
20703             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
20704             out_ext->conditionalRendering = in_ext->conditionalRendering;
20705             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
20706             out_header = (void *)out_ext;
20707             break;
20708         }
20709         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
20710         {
20711             VkPhysicalDeviceVulkanMemoryModelFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
20712             const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
20713             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
20714             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
20715             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
20716             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
20717             out_header = (void *)out_ext;
20718             break;
20719         }
20720         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
20721         {
20722             VkPhysicalDeviceShaderAtomicInt64Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
20723             const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
20724             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
20725             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
20726             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
20727             out_header = (void *)out_ext;
20728             break;
20729         }
20730         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
20731         {
20732             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT);
20733             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
20734             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
20735             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
20736             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
20737             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
20738             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
20739             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
20740             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
20741             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
20742             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
20743             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
20744             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
20745             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
20746             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
20747             out_header = (void *)out_ext;
20748             break;
20749         }
20750         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
20751         {
20752             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT);
20753             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
20754             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
20755             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
20756             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
20757             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
20758             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
20759             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
20760             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
20761             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
20762             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
20763             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
20764             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
20765             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
20766             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
20767             out_header = (void *)out_ext;
20768             break;
20769         }
20770         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
20771         {
20772             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT);
20773             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header;
20774             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
20775             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
20776             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
20777             out_header = (void *)out_ext;
20778             break;
20779         }
20780         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
20781         {
20782             VkPhysicalDeviceASTCDecodeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT);
20783             const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
20784             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
20785             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
20786             out_header = (void *)out_ext;
20787             break;
20788         }
20789         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
20790         {
20791             VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
20792             const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
20793             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
20794             out_ext->transformFeedback = in_ext->transformFeedback;
20795             out_ext->geometryStreams = in_ext->geometryStreams;
20796             out_header = (void *)out_ext;
20797             break;
20798         }
20799         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
20800         {
20801             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV);
20802             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
20803             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
20804             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
20805             out_header = (void *)out_ext;
20806             break;
20807         }
20808         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
20809         {
20810             VkPhysicalDeviceExclusiveScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV);
20811             const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
20812             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
20813             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
20814             out_header = (void *)out_ext;
20815             break;
20816         }
20817         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
20818         {
20819             VkPhysicalDeviceCornerSampledImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV);
20820             const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
20821             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
20822             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
20823             out_header = (void *)out_ext;
20824             break;
20825         }
20826         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
20827         {
20828             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV);
20829             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header;
20830             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
20831             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
20832             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
20833             out_header = (void *)out_ext;
20834             break;
20835         }
20836         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
20837         {
20838             VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV);
20839             const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
20840             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
20841             out_ext->imageFootprint = in_ext->imageFootprint;
20842             out_header = (void *)out_ext;
20843             break;
20844         }
20845         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
20846         {
20847             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV);
20848             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
20849             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
20850             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
20851             out_header = (void *)out_ext;
20852             break;
20853         }
20854         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
20855         {
20856             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV);
20857             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
20858             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
20859             out_ext->indirectCopy = in_ext->indirectCopy;
20860             out_header = (void *)out_ext;
20861             break;
20862         }
20863         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
20864         {
20865             VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV);
20866             const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
20867             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
20868             out_ext->memoryDecompression = in_ext->memoryDecompression;
20869             out_header = (void *)out_ext;
20870             break;
20871         }
20872         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
20873         {
20874             VkPhysicalDeviceShadingRateImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV);
20875             const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
20876             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
20877             out_ext->shadingRateImage = in_ext->shadingRateImage;
20878             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
20879             out_header = (void *)out_ext;
20880             break;
20881         }
20882         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
20883         {
20884             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI);
20885             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
20886             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
20887             out_ext->invocationMask = in_ext->invocationMask;
20888             out_header = (void *)out_ext;
20889             break;
20890         }
20891         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
20892         {
20893             VkPhysicalDeviceMeshShaderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV);
20894             const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
20895             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
20896             out_ext->taskShader = in_ext->taskShader;
20897             out_ext->meshShader = in_ext->meshShader;
20898             out_header = (void *)out_ext;
20899             break;
20900         }
20901         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
20902         {
20903             VkPhysicalDeviceMeshShaderFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT);
20904             const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
20905             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
20906             out_ext->taskShader = in_ext->taskShader;
20907             out_ext->meshShader = in_ext->meshShader;
20908             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
20909             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
20910             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
20911             out_header = (void *)out_ext;
20912             break;
20913         }
20914         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
20915         {
20916             VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR);
20917             const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
20918             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
20919             out_ext->accelerationStructure = in_ext->accelerationStructure;
20920             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
20921             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
20922             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
20923             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
20924             out_header = (void *)out_ext;
20925             break;
20926         }
20927         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
20928         {
20929             VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR);
20930             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
20931             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
20932             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
20933             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
20934             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
20935             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
20936             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
20937             out_header = (void *)out_ext;
20938             break;
20939         }
20940         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
20941         {
20942             VkPhysicalDeviceRayQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR);
20943             const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
20944             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
20945             out_ext->rayQuery = in_ext->rayQuery;
20946             out_header = (void *)out_ext;
20947             break;
20948         }
20949         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
20950         {
20951             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR);
20952             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
20953             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
20954             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
20955             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
20956             out_header = (void *)out_ext;
20957             break;
20958         }
20959         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
20960         {
20961             VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT);
20962             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
20963             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
20964             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
20965             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
20966             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
20967             out_header = (void *)out_ext;
20968             break;
20969         }
20970         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
20971         {
20972             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT);
20973             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
20974             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
20975             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
20976             out_header = (void *)out_ext;
20977             break;
20978         }
20979         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
20980         {
20981             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM);
20982             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *)in_header;
20983             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
20984             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
20985             out_header = (void *)out_ext;
20986             break;
20987         }
20988         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
20989         {
20990             VkPhysicalDeviceScalarBlockLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
20991             const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
20992             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
20993             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
20994             out_header = (void *)out_ext;
20995             break;
20996         }
20997         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
20998         {
20999             VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
21000             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
21001             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
21002             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
21003             out_header = (void *)out_ext;
21004             break;
21005         }
21006         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
21007         {
21008             VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
21009             const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
21010             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
21011             out_ext->depthClipEnable = in_ext->depthClipEnable;
21012             out_header = (void *)out_ext;
21013             break;
21014         }
21015         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
21016         {
21017             VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT);
21018             const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
21019             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
21020             out_ext->memoryPriority = in_ext->memoryPriority;
21021             out_header = (void *)out_ext;
21022             break;
21023         }
21024         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
21025         {
21026             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT);
21027             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
21028             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
21029             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
21030             out_header = (void *)out_ext;
21031             break;
21032         }
21033         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
21034         {
21035             VkPhysicalDeviceBufferDeviceAddressFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
21036             const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
21037             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
21038             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
21039             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
21040             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
21041             out_header = (void *)out_ext;
21042             break;
21043         }
21044         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
21045         {
21046             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT);
21047             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
21048             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
21049             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
21050             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
21051             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
21052             out_header = (void *)out_ext;
21053             break;
21054         }
21055         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
21056         {
21057             VkPhysicalDeviceImagelessFramebufferFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
21058             const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
21059             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
21060             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
21061             out_header = (void *)out_ext;
21062             break;
21063         }
21064         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
21065         {
21066             VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES);
21067             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
21068             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
21069             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
21070             out_header = (void *)out_ext;
21071             break;
21072         }
21073         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
21074         {
21075             VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV);
21076             const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
21077             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
21078             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
21079             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
21080             out_header = (void *)out_ext;
21081             break;
21082         }
21083         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
21084         {
21085             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT);
21086             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
21087             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
21088             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
21089             out_header = (void *)out_ext;
21090             break;
21091         }
21092         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
21093         {
21094             VkPhysicalDevicePresentBarrierFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV);
21095             const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
21096             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
21097             out_ext->presentBarrier = in_ext->presentBarrier;
21098             out_header = (void *)out_ext;
21099             break;
21100         }
21101         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
21102         {
21103             VkPhysicalDevicePerformanceQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR);
21104             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
21105             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
21106             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
21107             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
21108             out_header = (void *)out_ext;
21109             break;
21110         }
21111         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
21112         {
21113             VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV);
21114             const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
21115             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
21116             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
21117             out_header = (void *)out_ext;
21118             break;
21119         }
21120         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
21121         {
21122             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL);
21123             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
21124             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
21125             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
21126             out_header = (void *)out_ext;
21127             break;
21128         }
21129         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
21130         {
21131             VkPhysicalDeviceShaderClockFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR);
21132             const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
21133             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
21134             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
21135             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
21136             out_header = (void *)out_ext;
21137             break;
21138         }
21139         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
21140         {
21141             VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT);
21142             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header;
21143             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
21144             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
21145             out_header = (void *)out_ext;
21146             break;
21147         }
21148         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
21149         {
21150             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV);
21151             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
21152             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
21153             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
21154             out_header = (void *)out_ext;
21155             break;
21156         }
21157         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
21158         {
21159             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT);
21160             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
21161             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
21162             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
21163             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
21164             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
21165             out_header = (void *)out_ext;
21166             break;
21167         }
21168         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
21169         {
21170             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
21171             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
21172             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
21173             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
21174             out_header = (void *)out_ext;
21175             break;
21176         }
21177         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
21178         {
21179             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT);
21180             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
21181             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
21182             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
21183             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
21184             out_header = (void *)out_ext;
21185             break;
21186         }
21187         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
21188         {
21189             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR);
21190             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
21191             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
21192             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
21193             out_header = (void *)out_ext;
21194             break;
21195         }
21196         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
21197         {
21198             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES);
21199             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
21200             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
21201             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
21202             out_header = (void *)out_ext;
21203             break;
21204         }
21205         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
21206         {
21207             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT);
21208             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
21209             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
21210             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
21211             out_header = (void *)out_ext;
21212             break;
21213         }
21214         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
21215         {
21216             VkPhysicalDeviceSubgroupSizeControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES);
21217             const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
21218             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
21219             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
21220             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
21221             out_header = (void *)out_ext;
21222             break;
21223         }
21224         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
21225         {
21226             VkPhysicalDeviceLineRasterizationFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT);
21227             const VkPhysicalDeviceLineRasterizationFeaturesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header;
21228             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
21229             out_ext->rectangularLines = in_ext->rectangularLines;
21230             out_ext->bresenhamLines = in_ext->bresenhamLines;
21231             out_ext->smoothLines = in_ext->smoothLines;
21232             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
21233             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
21234             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
21235             out_header = (void *)out_ext;
21236             break;
21237         }
21238         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
21239         {
21240             VkPhysicalDevicePipelineCreationCacheControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES);
21241             const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
21242             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
21243             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
21244             out_header = (void *)out_ext;
21245             break;
21246         }
21247         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
21248         {
21249             VkPhysicalDeviceVulkan11Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
21250             const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
21251             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
21252             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
21253             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
21254             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
21255             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
21256             out_ext->multiview = in_ext->multiview;
21257             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
21258             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
21259             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
21260             out_ext->variablePointers = in_ext->variablePointers;
21261             out_ext->protectedMemory = in_ext->protectedMemory;
21262             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
21263             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
21264             out_header = (void *)out_ext;
21265             break;
21266         }
21267         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
21268         {
21269             VkPhysicalDeviceVulkan12Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
21270             const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
21271             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
21272             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
21273             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
21274             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
21275             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
21276             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
21277             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
21278             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
21279             out_ext->shaderFloat16 = in_ext->shaderFloat16;
21280             out_ext->shaderInt8 = in_ext->shaderInt8;
21281             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
21282             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
21283             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
21284             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
21285             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
21286             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
21287             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
21288             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
21289             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
21290             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
21291             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
21292             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
21293             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
21294             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
21295             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
21296             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
21297             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
21298             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
21299             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
21300             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
21301             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
21302             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
21303             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
21304             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
21305             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
21306             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
21307             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
21308             out_ext->hostQueryReset = in_ext->hostQueryReset;
21309             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
21310             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
21311             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
21312             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
21313             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
21314             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
21315             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
21316             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
21317             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
21318             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
21319             out_header = (void *)out_ext;
21320             break;
21321         }
21322         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
21323         {
21324             VkPhysicalDeviceVulkan13Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
21325             const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
21326             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
21327             out_ext->robustImageAccess = in_ext->robustImageAccess;
21328             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
21329             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
21330             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
21331             out_ext->privateData = in_ext->privateData;
21332             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
21333             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
21334             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
21335             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
21336             out_ext->synchronization2 = in_ext->synchronization2;
21337             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
21338             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
21339             out_ext->dynamicRendering = in_ext->dynamicRendering;
21340             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
21341             out_ext->maintenance4 = in_ext->maintenance4;
21342             out_header = (void *)out_ext;
21343             break;
21344         }
21345         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
21346         {
21347             VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD);
21348             const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
21349             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
21350             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
21351             out_header = (void *)out_ext;
21352             break;
21353         }
21354         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
21355         {
21356             VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT);
21357             const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
21358             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
21359             out_ext->customBorderColors = in_ext->customBorderColors;
21360             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
21361             out_header = (void *)out_ext;
21362             break;
21363         }
21364         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
21365         {
21366             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT);
21367             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
21368             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
21369             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
21370             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
21371             out_header = (void *)out_ext;
21372             break;
21373         }
21374         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
21375         {
21376             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT);
21377             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
21378             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
21379             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
21380             out_header = (void *)out_ext;
21381             break;
21382         }
21383         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
21384         {
21385             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT);
21386             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
21387             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
21388             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
21389             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
21390             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
21391             out_header = (void *)out_ext;
21392             break;
21393         }
21394         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
21395         {
21396             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT);
21397             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
21398             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
21399             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
21400             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
21401             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
21402             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
21403             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
21404             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
21405             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
21406             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
21407             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
21408             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
21409             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
21410             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
21411             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
21412             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
21413             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
21414             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
21415             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
21416             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
21417             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
21418             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
21419             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
21420             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
21421             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
21422             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
21423             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
21424             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
21425             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
21426             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
21427             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
21428             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
21429             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
21430             out_header = (void *)out_ext;
21431             break;
21432         }
21433         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
21434         {
21435             VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV);
21436             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
21437             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
21438             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
21439             out_header = (void *)out_ext;
21440             break;
21441         }
21442         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
21443         {
21444             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES);
21445             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
21446             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
21447             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
21448             out_header = (void *)out_ext;
21449             break;
21450         }
21451         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
21452         {
21453             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR);
21454             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
21455             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
21456             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
21457             out_header = (void *)out_ext;
21458             break;
21459         }
21460         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
21461         {
21462             VkPhysicalDeviceRobustness2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT);
21463             const VkPhysicalDeviceRobustness2FeaturesEXT *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT *)in_header;
21464             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
21465             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
21466             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
21467             out_ext->nullDescriptor = in_ext->nullDescriptor;
21468             out_header = (void *)out_ext;
21469             break;
21470         }
21471         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
21472         {
21473             VkPhysicalDeviceImageRobustnessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES);
21474             const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
21475             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
21476             out_ext->robustImageAccess = in_ext->robustImageAccess;
21477             out_header = (void *)out_ext;
21478             break;
21479         }
21480         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
21481         {
21482             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR);
21483             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
21484             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
21485             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
21486             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
21487             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
21488             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
21489             out_header = (void *)out_ext;
21490             break;
21491         }
21492         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
21493         {
21494             VkPhysicalDevice4444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT);
21495             const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
21496             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
21497             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
21498             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
21499             out_header = (void *)out_ext;
21500             break;
21501         }
21502         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
21503         {
21504             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI);
21505             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
21506             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
21507             out_ext->subpassShading = in_ext->subpassShading;
21508             out_header = (void *)out_ext;
21509             break;
21510         }
21511         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
21512         {
21513             VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI);
21514             const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *)in_header;
21515             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
21516             out_ext->clustercullingShader = in_ext->clustercullingShader;
21517             out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader;
21518             out_header = (void *)out_ext;
21519             break;
21520         }
21521         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
21522         {
21523             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT);
21524             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
21525             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
21526             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
21527             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
21528             out_header = (void *)out_ext;
21529             break;
21530         }
21531         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
21532         {
21533             VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR);
21534             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
21535             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
21536             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
21537             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
21538             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
21539             out_header = (void *)out_ext;
21540             break;
21541         }
21542         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
21543         {
21544             VkPhysicalDeviceShaderTerminateInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES);
21545             const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
21546             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
21547             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
21548             out_header = (void *)out_ext;
21549             break;
21550         }
21551         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
21552         {
21553             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV);
21554             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
21555             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
21556             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
21557             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
21558             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
21559             out_header = (void *)out_ext;
21560             break;
21561         }
21562         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
21563         {
21564             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT);
21565             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
21566             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
21567             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
21568             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
21569             out_header = (void *)out_ext;
21570             break;
21571         }
21572         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
21573         {
21574             VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT);
21575             const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)in_header;
21576             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
21577             out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D;
21578             out_header = (void *)out_ext;
21579             break;
21580         }
21581         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
21582         {
21583             VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT);
21584             const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)in_header;
21585             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
21586             out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState;
21587             out_header = (void *)out_ext;
21588             break;
21589         }
21590         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
21591         {
21592             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT);
21593             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
21594             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
21595             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
21596             out_header = (void *)out_ext;
21597             break;
21598         }
21599         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
21600         {
21601             VkPhysicalDeviceDepthClipControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT);
21602             const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
21603             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
21604             out_ext->depthClipControl = in_ext->depthClipControl;
21605             out_header = (void *)out_ext;
21606             break;
21607         }
21608         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
21609         {
21610             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT);
21611             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
21612             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
21613             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
21614             out_header = (void *)out_ext;
21615             break;
21616         }
21617         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
21618         {
21619             VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT);
21620             const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
21621             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
21622             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
21623             out_header = (void *)out_ext;
21624             break;
21625         }
21626         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
21627         {
21628             VkPhysicalDeviceSynchronization2Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES);
21629             const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
21630             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
21631             out_ext->synchronization2 = in_ext->synchronization2;
21632             out_header = (void *)out_ext;
21633             break;
21634         }
21635         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
21636         {
21637             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT);
21638             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
21639             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
21640             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
21641             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
21642             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
21643             out_header = (void *)out_ext;
21644             break;
21645         }
21646         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
21647         {
21648             VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT);
21649             const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
21650             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
21651             out_ext->legacyDithering = in_ext->legacyDithering;
21652             out_header = (void *)out_ext;
21653             break;
21654         }
21655         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
21656         {
21657             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT);
21658             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
21659             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
21660             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
21661             out_header = (void *)out_ext;
21662             break;
21663         }
21664         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
21665         {
21666             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT);
21667             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)in_header;
21668             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
21669             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
21670             out_header = (void *)out_ext;
21671             break;
21672         }
21673         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
21674         {
21675             VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV);
21676             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
21677             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
21678             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
21679             out_header = (void *)out_ext;
21680             break;
21681         }
21682         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
21683         {
21684             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT);
21685             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
21686             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
21687             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
21688             out_header = (void *)out_ext;
21689             break;
21690         }
21691         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
21692         {
21693             VkPhysicalDeviceProvokingVertexFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT);
21694             const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
21695             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
21696             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
21697             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
21698             out_header = (void *)out_ext;
21699             break;
21700         }
21701         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
21702         {
21703             VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT);
21704             const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header;
21705             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
21706             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
21707             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
21708             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
21709             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
21710             out_header = (void *)out_ext;
21711             break;
21712         }
21713         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
21714         {
21715             VkPhysicalDeviceShaderIntegerDotProductFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES);
21716             const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
21717             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
21718             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
21719             out_header = (void *)out_ext;
21720             break;
21721         }
21722         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
21723         {
21724             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR);
21725             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
21726             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
21727             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
21728             out_header = (void *)out_ext;
21729             break;
21730         }
21731         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
21732         {
21733             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV);
21734             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
21735             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
21736             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
21737             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
21738             out_header = (void *)out_ext;
21739             break;
21740         }
21741         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
21742         {
21743             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT);
21744             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
21745             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
21746             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
21747             out_header = (void *)out_ext;
21748             break;
21749         }
21750         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
21751         {
21752             VkPhysicalDeviceDynamicRenderingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES);
21753             const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
21754             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
21755             out_ext->dynamicRendering = in_ext->dynamicRendering;
21756             out_header = (void *)out_ext;
21757             break;
21758         }
21759         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
21760         {
21761             VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT);
21762             const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
21763             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
21764             out_ext->minLod = in_ext->minLod;
21765             out_header = (void *)out_ext;
21766             break;
21767         }
21768         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
21769         {
21770             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT);
21771             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
21772             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
21773             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
21774             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
21775             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
21776             out_header = (void *)out_ext;
21777             break;
21778         }
21779         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
21780         {
21781             VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV);
21782             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
21783             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
21784             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
21785             out_header = (void *)out_ext;
21786             break;
21787         }
21788         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
21789         {
21790             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT);
21791             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
21792             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
21793             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
21794             out_header = (void *)out_ext;
21795             break;
21796         }
21797         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
21798         {
21799             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE);
21800             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
21801             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
21802             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
21803             out_header = (void *)out_ext;
21804             break;
21805         }
21806         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
21807         {
21808             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT);
21809             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
21810             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
21811             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
21812             out_header = (void *)out_ext;
21813             break;
21814         }
21815         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
21816         {
21817             VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT);
21818             const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
21819             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
21820             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
21821             out_header = (void *)out_ext;
21822             break;
21823         }
21824         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
21825         {
21826             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT);
21827             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
21828             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
21829             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
21830             out_header = (void *)out_ext;
21831             break;
21832         }
21833         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
21834         {
21835             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT);
21836             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
21837             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
21838             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
21839             out_header = (void *)out_ext;
21840             break;
21841         }
21842         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
21843         {
21844             VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT);
21845             const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
21846             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
21847             out_ext->micromap = in_ext->micromap;
21848             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
21849             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
21850             out_header = (void *)out_ext;
21851             break;
21852         }
21853         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
21854         {
21855             VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT);
21856             const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
21857             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
21858             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
21859             out_header = (void *)out_ext;
21860             break;
21861         }
21862         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
21863         {
21864             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD);
21865             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header;
21866             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
21867             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
21868             out_header = (void *)out_ext;
21869             break;
21870         }
21871         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
21872         {
21873             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT);
21874             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
21875             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
21876             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
21877             out_header = (void *)out_ext;
21878             break;
21879         }
21880         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
21881         {
21882             VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT);
21883             const VkPhysicalDevicePipelineRobustnessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT *)in_header;
21884             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
21885             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
21886             out_header = (void *)out_ext;
21887             break;
21888         }
21889         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
21890         {
21891             VkPhysicalDeviceImageProcessingFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM);
21892             const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
21893             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
21894             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
21895             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
21896             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
21897             out_header = (void *)out_ext;
21898             break;
21899         }
21900         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
21901         {
21902             VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM);
21903             const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
21904             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
21905             out_ext->tileProperties = in_ext->tileProperties;
21906             out_header = (void *)out_ext;
21907             break;
21908         }
21909         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
21910         {
21911             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT);
21912             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
21913             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
21914             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
21915             out_header = (void *)out_ext;
21916             break;
21917         }
21918         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
21919         {
21920             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT);
21921             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *)in_header;
21922             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
21923             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
21924             out_header = (void *)out_ext;
21925             break;
21926         }
21927         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
21928         {
21929             VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT);
21930             const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
21931             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
21932             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
21933             out_header = (void *)out_ext;
21934             break;
21935         }
21936         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
21937         {
21938             VkPhysicalDeviceOpticalFlowFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV);
21939             const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
21940             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
21941             out_ext->opticalFlow = in_ext->opticalFlow;
21942             out_header = (void *)out_ext;
21943             break;
21944         }
21945         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
21946         {
21947             VkPhysicalDeviceFaultFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT);
21948             const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
21949             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
21950             out_ext->deviceFault = in_ext->deviceFault;
21951             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
21952             out_header = (void *)out_ext;
21953             break;
21954         }
21955         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
21956         {
21957             VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT);
21958             const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)in_header;
21959             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
21960             out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles;
21961             out_header = (void *)out_ext;
21962             break;
21963         }
21964         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
21965         {
21966             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM);
21967             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
21968             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
21969             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
21970             out_header = (void *)out_ext;
21971             break;
21972         }
21973         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
21974         {
21975             VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT);
21976             const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)in_header;
21977             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
21978             out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments;
21979             out_header = (void *)out_ext;
21980             break;
21981         }
21982         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
21983         {
21984             VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT);
21985             const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *)in_header;
21986             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT;
21987             out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1;
21988             out_header = (void *)out_ext;
21989             break;
21990         }
21991         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
21992         {
21993             VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT);
21994             const VkPhysicalDeviceDepthBiasControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT *)in_header;
21995             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT;
21996             out_ext->depthBiasControl = in_ext->depthBiasControl;
21997             out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation;
21998             out_ext->floatRepresentation = in_ext->floatRepresentation;
21999             out_ext->depthBiasExact = in_ext->depthBiasExact;
22000             out_header = (void *)out_ext;
22001             break;
22002         }
22003         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
22004         {
22005             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV);
22006             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
22007             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
22008             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
22009             out_header = (void *)out_ext;
22010             break;
22011         }
22012         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
22013         {
22014             VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM);
22015             const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *)in_header;
22016             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
22017             out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports;
22018             out_header = (void *)out_ext;
22019             break;
22020         }
22021         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
22022         {
22023             VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR);
22024             const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)in_header;
22025             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
22026             out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch;
22027             out_header = (void *)out_ext;
22028             break;
22029         }
22030         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
22031         {
22032             VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM);
22033             const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *)in_header;
22034             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
22035             out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas;
22036             out_header = (void *)out_ext;
22037             break;
22038         }
22039         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
22040         {
22041             VkPhysicalDeviceShaderObjectFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT);
22042             const VkPhysicalDeviceShaderObjectFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)in_header;
22043             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
22044             out_ext->shaderObject = in_ext->shaderObject;
22045             out_header = (void *)out_ext;
22046             break;
22047         }
22048         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
22049         {
22050             VkPhysicalDeviceShaderTileImageFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT);
22051             const VkPhysicalDeviceShaderTileImageFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT *)in_header;
22052             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
22053             out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess;
22054             out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess;
22055             out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess;
22056             out_header = (void *)out_ext;
22057             break;
22058         }
22059         default:
22060             break;
22061         }
22062     }
22063 }
22064
22065 static inline void convert_VkFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkFormatProperties232 *in, VkFormatProperties2 *out)
22066 {
22067     const VkBaseInStructure32 *in_header;
22068     VkBaseOutStructure *out_header = (void *)out;
22069
22070     if (!in) return;
22071
22072     out->sType = in->sType;
22073     out->pNext = NULL;
22074
22075     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
22076     {
22077         switch (in_header->sType)
22078         {
22079         case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
22080         {
22081             VkSubpassResolvePerformanceQueryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22082             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
22083             out_ext->pNext = NULL;
22084             out_header->pNext = (void *)out_ext;
22085             out_header = (void *)out_ext;
22086             break;
22087         }
22088         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
22089         {
22090             VkFormatProperties3 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22091             out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
22092             out_ext->pNext = NULL;
22093             out_header->pNext = (void *)out_ext;
22094             out_header = (void *)out_ext;
22095             break;
22096         }
22097         default:
22098             FIXME("Unhandled sType %u.\n", in_header->sType);
22099             break;
22100         }
22101     }
22102 }
22103
22104 static inline void convert_VkFormatProperties2_host_to_win32(const VkFormatProperties2 *in, VkFormatProperties232 *out)
22105 {
22106     const VkBaseInStructure *in_header;
22107     VkBaseOutStructure32 *out_header = (void *)out;
22108
22109     if (!in) return;
22110
22111     out->formatProperties = in->formatProperties;
22112
22113     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
22114     {
22115         switch (in_header->sType)
22116         {
22117         case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
22118         {
22119             VkSubpassResolvePerformanceQueryEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT);
22120             const VkSubpassResolvePerformanceQueryEXT *in_ext = (const VkSubpassResolvePerformanceQueryEXT *)in_header;
22121             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
22122             out_ext->optimal = in_ext->optimal;
22123             out_header = (void *)out_ext;
22124             break;
22125         }
22126         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
22127         {
22128             VkFormatProperties332 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3);
22129             const VkFormatProperties3 *in_ext = (const VkFormatProperties3 *)in_header;
22130             out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
22131             out_ext->linearTilingFeatures = in_ext->linearTilingFeatures;
22132             out_ext->optimalTilingFeatures = in_ext->optimalTilingFeatures;
22133             out_ext->bufferFeatures = in_ext->bufferFeatures;
22134             out_header = (void *)out_ext;
22135             break;
22136         }
22137         default:
22138             break;
22139         }
22140     }
22141 }
22142
22143 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(const VkPhysicalDeviceFragmentShadingRateKHR32 *in, VkPhysicalDeviceFragmentShadingRateKHR *out)
22144 {
22145     if (!in) return;
22146
22147     out->sType = in->sType;
22148     out->pNext = NULL;
22149     if (in->pNext)
22150         FIXME("Unexpected pNext\n");
22151 }
22152
22153 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out)
22154 {
22155     if (!in) return;
22156
22157     out->sampleCounts = in->sampleCounts;
22158     out->fragmentSize = in->fragmentSize;
22159 }
22160
22161 static inline VkPhysicalDeviceFragmentShadingRateKHR *convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFragmentShadingRateKHR32 *in, uint32_t count)
22162 {
22163     VkPhysicalDeviceFragmentShadingRateKHR *out;
22164     unsigned int i;
22165
22166     if (!in || !count) return NULL;
22167
22168     out = conversion_context_alloc(ctx, count * sizeof(*out));
22169     for (i = 0; i < count; i++)
22170     {
22171         convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(&in[i], &out[i]);
22172     }
22173
22174     return out;
22175 }
22176
22177 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out, uint32_t count)
22178 {
22179     unsigned int i;
22180
22181     if (!in) return;
22182
22183     for (i = 0; i < count; i++)
22184     {
22185         convert_VkPhysicalDeviceFragmentShadingRateKHR_host_to_win32(&in[i], &out[i]);
22186     }
22187 }
22188
22189 static inline void convert_VkImageFormatProperties_host_to_win32(const VkImageFormatProperties *in, VkImageFormatProperties32 *out)
22190 {
22191     if (!in) return;
22192
22193     out->maxExtent = in->maxExtent;
22194     out->maxMipLevels = in->maxMipLevels;
22195     out->maxArrayLayers = in->maxArrayLayers;
22196     out->sampleCounts = in->sampleCounts;
22197     out->maxResourceSize = in->maxResourceSize;
22198 }
22199
22200 static inline void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceImageFormatInfo232 *in, VkPhysicalDeviceImageFormatInfo2 *out)
22201 {
22202     const VkBaseInStructure32 *in_header;
22203     VkBaseOutStructure *out_header = (void *)out;
22204
22205     if (!in) return;
22206
22207     out->sType = in->sType;
22208     out->pNext = NULL;
22209     out->format = in->format;
22210     out->type = in->type;
22211     out->tiling = in->tiling;
22212     out->usage = in->usage;
22213     out->flags = in->flags;
22214
22215     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
22216     {
22217         switch (in_header->sType)
22218         {
22219         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
22220         {
22221             VkPhysicalDeviceExternalImageFormatInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22222             const VkPhysicalDeviceExternalImageFormatInfo32 *in_ext = (const VkPhysicalDeviceExternalImageFormatInfo32 *)in_header;
22223             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
22224             out_ext->pNext = NULL;
22225             out_ext->handleType = in_ext->handleType;
22226             out_header->pNext = (void *)out_ext;
22227             out_header = (void *)out_ext;
22228             break;
22229         }
22230         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
22231         {
22232             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22233             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
22234             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
22235             out_ext->pNext = NULL;
22236             out_ext->viewFormatCount = in_ext->viewFormatCount;
22237             out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
22238             out_header->pNext = (void *)out_ext;
22239             out_header = (void *)out_ext;
22240             break;
22241         }
22242         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
22243         {
22244             VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22245             const VkImageStencilUsageCreateInfo32 *in_ext = (const VkImageStencilUsageCreateInfo32 *)in_header;
22246             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
22247             out_ext->pNext = NULL;
22248             out_ext->stencilUsage = in_ext->stencilUsage;
22249             out_header->pNext = (void *)out_ext;
22250             out_header = (void *)out_ext;
22251             break;
22252         }
22253         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
22254         {
22255             VkPhysicalDeviceImageViewImageFormatInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22256             const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *in_ext = (const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *)in_header;
22257             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT;
22258             out_ext->pNext = NULL;
22259             out_ext->imageViewType = in_ext->imageViewType;
22260             out_header->pNext = (void *)out_ext;
22261             out_header = (void *)out_ext;
22262             break;
22263         }
22264         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
22265         {
22266             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22267             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
22268             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
22269             out_ext->pNext = NULL;
22270             out_ext->flags = in_ext->flags;
22271             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
22272             out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
22273             out_header->pNext = (void *)out_ext;
22274             out_header = (void *)out_ext;
22275             break;
22276         }
22277         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
22278         {
22279             VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22280             const VkOpticalFlowImageFormatInfoNV32 *in_ext = (const VkOpticalFlowImageFormatInfoNV32 *)in_header;
22281             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
22282             out_ext->pNext = NULL;
22283             out_ext->usage = in_ext->usage;
22284             out_header->pNext = (void *)out_ext;
22285             out_header = (void *)out_ext;
22286             break;
22287         }
22288         default:
22289             FIXME("Unhandled sType %u.\n", in_header->sType);
22290             break;
22291         }
22292     }
22293 }
22294
22295 static inline void convert_VkImageFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkImageFormatProperties232 *in, VkImageFormatProperties2 *out)
22296 {
22297     const VkBaseInStructure32 *in_header;
22298     VkBaseOutStructure *out_header = (void *)out;
22299
22300     if (!in) return;
22301
22302     out->sType = in->sType;
22303     out->pNext = NULL;
22304
22305     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
22306     {
22307         switch (in_header->sType)
22308         {
22309         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
22310         {
22311             VkExternalImageFormatProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22312             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
22313             out_ext->pNext = NULL;
22314             out_header->pNext = (void *)out_ext;
22315             out_header = (void *)out_ext;
22316             break;
22317         }
22318         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
22319         {
22320             VkSamplerYcbcrConversionImageFormatProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22321             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
22322             out_ext->pNext = NULL;
22323             out_header->pNext = (void *)out_ext;
22324             out_header = (void *)out_ext;
22325             break;
22326         }
22327         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
22328         {
22329             VkTextureLODGatherFormatPropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22330             out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
22331             out_ext->pNext = NULL;
22332             out_header->pNext = (void *)out_ext;
22333             out_header = (void *)out_ext;
22334             break;
22335         }
22336         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
22337         {
22338             VkFilterCubicImageViewImageFormatPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22339             out_ext->sType = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT;
22340             out_ext->pNext = NULL;
22341             out_header->pNext = (void *)out_ext;
22342             out_header = (void *)out_ext;
22343             break;
22344         }
22345         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
22346         {
22347             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22348             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
22349             out_ext->pNext = NULL;
22350             out_header->pNext = (void *)out_ext;
22351             out_header = (void *)out_ext;
22352             break;
22353         }
22354         default:
22355             FIXME("Unhandled sType %u.\n", in_header->sType);
22356             break;
22357         }
22358     }
22359 }
22360
22361 static inline void convert_VkImageFormatProperties2_host_to_win32(const VkImageFormatProperties2 *in, VkImageFormatProperties232 *out)
22362 {
22363     const VkBaseInStructure *in_header;
22364     VkBaseOutStructure32 *out_header = (void *)out;
22365
22366     if (!in) return;
22367
22368     convert_VkImageFormatProperties_host_to_win32(&in->imageFormatProperties, &out->imageFormatProperties);
22369
22370     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
22371     {
22372         switch (in_header->sType)
22373         {
22374         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
22375         {
22376             VkExternalImageFormatProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
22377             const VkExternalImageFormatProperties *in_ext = (const VkExternalImageFormatProperties *)in_header;
22378             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
22379             out_ext->externalMemoryProperties = in_ext->externalMemoryProperties;
22380             out_header = (void *)out_ext;
22381             break;
22382         }
22383         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
22384         {
22385             VkSamplerYcbcrConversionImageFormatProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
22386             const VkSamplerYcbcrConversionImageFormatProperties *in_ext = (const VkSamplerYcbcrConversionImageFormatProperties *)in_header;
22387             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
22388             out_ext->combinedImageSamplerDescriptorCount = in_ext->combinedImageSamplerDescriptorCount;
22389             out_header = (void *)out_ext;
22390             break;
22391         }
22392         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
22393         {
22394             VkTextureLODGatherFormatPropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD);
22395             const VkTextureLODGatherFormatPropertiesAMD *in_ext = (const VkTextureLODGatherFormatPropertiesAMD *)in_header;
22396             out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
22397             out_ext->supportsTextureGatherLODBiasAMD = in_ext->supportsTextureGatherLODBiasAMD;
22398             out_header = (void *)out_ext;
22399             break;
22400         }
22401         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
22402         {
22403             VkFilterCubicImageViewImageFormatPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT);
22404             const VkFilterCubicImageViewImageFormatPropertiesEXT *in_ext = (const VkFilterCubicImageViewImageFormatPropertiesEXT *)in_header;
22405             out_ext->sType = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT;
22406             out_ext->filterCubic = in_ext->filterCubic;
22407             out_ext->filterCubicMinmax = in_ext->filterCubicMinmax;
22408             out_header = (void *)out_ext;
22409             break;
22410         }
22411         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
22412         {
22413             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
22414             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
22415             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
22416             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
22417             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
22418             out_header = (void *)out_ext;
22419             break;
22420         }
22421         default:
22422             break;
22423         }
22424     }
22425 }
22426
22427 static inline void convert_VkMemoryHeap_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out)
22428 {
22429     if (!in) return;
22430
22431     out->size = in->size;
22432     out->flags = in->flags;
22433 }
22434
22435 static inline void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out, uint32_t count)
22436 {
22437     unsigned int i;
22438
22439     if (!in) return;
22440
22441     for (i = 0; i < count; i++)
22442     {
22443         convert_VkMemoryHeap_host_to_win32(&in[i], &out[i]);
22444     }
22445 }
22446
22447 static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win32(const VkPhysicalDeviceMemoryProperties *in, VkPhysicalDeviceMemoryProperties32 *out)
22448 {
22449     if (!in) return;
22450
22451     out->memoryTypeCount = in->memoryTypeCount;
22452     memcpy(out->memoryTypes, in->memoryTypes, VK_MAX_MEMORY_TYPES * sizeof(VkMemoryType));
22453     out->memoryHeapCount = in->memoryHeapCount;
22454     convert_VkMemoryHeap_array_host_to_win32(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
22455 }
22456
22457 static inline void convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceMemoryProperties232 *in, VkPhysicalDeviceMemoryProperties2 *out)
22458 {
22459     const VkBaseInStructure32 *in_header;
22460     VkBaseOutStructure *out_header = (void *)out;
22461
22462     if (!in) return;
22463
22464     out->sType = in->sType;
22465     out->pNext = NULL;
22466
22467     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
22468     {
22469         switch (in_header->sType)
22470         {
22471         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
22472         {
22473             VkPhysicalDeviceMemoryBudgetPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22474             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
22475             out_ext->pNext = NULL;
22476             out_header->pNext = (void *)out_ext;
22477             out_header = (void *)out_ext;
22478             break;
22479         }
22480         default:
22481             FIXME("Unhandled sType %u.\n", in_header->sType);
22482             break;
22483         }
22484     }
22485 }
22486
22487 static inline void convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(const VkPhysicalDeviceMemoryProperties2 *in, VkPhysicalDeviceMemoryProperties232 *out)
22488 {
22489     const VkBaseInStructure *in_header;
22490     VkBaseOutStructure32 *out_header = (void *)out;
22491
22492     if (!in) return;
22493
22494     convert_VkPhysicalDeviceMemoryProperties_host_to_win32(&in->memoryProperties, &out->memoryProperties);
22495
22496     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
22497     {
22498         switch (in_header->sType)
22499         {
22500         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
22501         {
22502             VkPhysicalDeviceMemoryBudgetPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT);
22503             const VkPhysicalDeviceMemoryBudgetPropertiesEXT *in_ext = (const VkPhysicalDeviceMemoryBudgetPropertiesEXT *)in_header;
22504             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
22505             memcpy(out_ext->heapBudget, in_ext->heapBudget, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
22506             memcpy(out_ext->heapUsage, in_ext->heapUsage, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
22507             out_header = (void *)out_ext;
22508             break;
22509         }
22510         default:
22511             break;
22512         }
22513     }
22514 }
22515
22516 static inline void convert_VkMultisamplePropertiesEXT_win32_to_host(const VkMultisamplePropertiesEXT32 *in, VkMultisamplePropertiesEXT *out)
22517 {
22518     if (!in) return;
22519
22520     out->sType = in->sType;
22521     out->pNext = NULL;
22522     if (in->pNext)
22523         FIXME("Unexpected pNext\n");
22524 }
22525
22526 static inline void convert_VkMultisamplePropertiesEXT_host_to_win32(const VkMultisamplePropertiesEXT *in, VkMultisamplePropertiesEXT32 *out)
22527 {
22528     if (!in) return;
22529
22530     out->maxSampleLocationGridSize = in->maxSampleLocationGridSize;
22531 }
22532
22533 static inline void convert_VkOpticalFlowImageFormatInfoNV_win32_to_host(const VkOpticalFlowImageFormatInfoNV32 *in, VkOpticalFlowImageFormatInfoNV *out)
22534 {
22535     if (!in) return;
22536
22537     out->sType = in->sType;
22538     out->pNext = NULL;
22539     out->usage = in->usage;
22540     if (in->pNext)
22541         FIXME("Unexpected pNext\n");
22542 }
22543
22544 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(const VkOpticalFlowImageFormatPropertiesNV32 *in, VkOpticalFlowImageFormatPropertiesNV *out)
22545 {
22546     if (!in) return;
22547
22548     out->sType = in->sType;
22549     out->pNext = NULL;
22550     if (in->pNext)
22551         FIXME("Unexpected pNext\n");
22552 }
22553
22554 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out)
22555 {
22556     if (!in) return;
22557
22558     out->format = in->format;
22559 }
22560
22561 static inline VkOpticalFlowImageFormatPropertiesNV *convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowImageFormatPropertiesNV32 *in, uint32_t count)
22562 {
22563     VkOpticalFlowImageFormatPropertiesNV *out;
22564     unsigned int i;
22565
22566     if (!in || !count) return NULL;
22567
22568     out = conversion_context_alloc(ctx, count * sizeof(*out));
22569     for (i = 0; i < count; i++)
22570     {
22571         convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(&in[i], &out[i]);
22572     }
22573
22574     return out;
22575 }
22576
22577 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out, uint32_t count)
22578 {
22579     unsigned int i;
22580
22581     if (!in) return;
22582
22583     for (i = 0; i < count; i++)
22584     {
22585         convert_VkOpticalFlowImageFormatPropertiesNV_host_to_win32(&in[i], &out[i]);
22586     }
22587 }
22588
22589 static inline void convert_VkPhysicalDeviceLimits_host_to_win32(const VkPhysicalDeviceLimits *in, VkPhysicalDeviceLimits32 *out)
22590 {
22591     if (!in) return;
22592
22593     out->maxImageDimension1D = in->maxImageDimension1D;
22594     out->maxImageDimension2D = in->maxImageDimension2D;
22595     out->maxImageDimension3D = in->maxImageDimension3D;
22596     out->maxImageDimensionCube = in->maxImageDimensionCube;
22597     out->maxImageArrayLayers = in->maxImageArrayLayers;
22598     out->maxTexelBufferElements = in->maxTexelBufferElements;
22599     out->maxUniformBufferRange = in->maxUniformBufferRange;
22600     out->maxStorageBufferRange = in->maxStorageBufferRange;
22601     out->maxPushConstantsSize = in->maxPushConstantsSize;
22602     out->maxMemoryAllocationCount = in->maxMemoryAllocationCount;
22603     out->maxSamplerAllocationCount = in->maxSamplerAllocationCount;
22604     out->bufferImageGranularity = in->bufferImageGranularity;
22605     out->sparseAddressSpaceSize = in->sparseAddressSpaceSize;
22606     out->maxBoundDescriptorSets = in->maxBoundDescriptorSets;
22607     out->maxPerStageDescriptorSamplers = in->maxPerStageDescriptorSamplers;
22608     out->maxPerStageDescriptorUniformBuffers = in->maxPerStageDescriptorUniformBuffers;
22609     out->maxPerStageDescriptorStorageBuffers = in->maxPerStageDescriptorStorageBuffers;
22610     out->maxPerStageDescriptorSampledImages = in->maxPerStageDescriptorSampledImages;
22611     out->maxPerStageDescriptorStorageImages = in->maxPerStageDescriptorStorageImages;
22612     out->maxPerStageDescriptorInputAttachments = in->maxPerStageDescriptorInputAttachments;
22613     out->maxPerStageResources = in->maxPerStageResources;
22614     out->maxDescriptorSetSamplers = in->maxDescriptorSetSamplers;
22615     out->maxDescriptorSetUniformBuffers = in->maxDescriptorSetUniformBuffers;
22616     out->maxDescriptorSetUniformBuffersDynamic = in->maxDescriptorSetUniformBuffersDynamic;
22617     out->maxDescriptorSetStorageBuffers = in->maxDescriptorSetStorageBuffers;
22618     out->maxDescriptorSetStorageBuffersDynamic = in->maxDescriptorSetStorageBuffersDynamic;
22619     out->maxDescriptorSetSampledImages = in->maxDescriptorSetSampledImages;
22620     out->maxDescriptorSetStorageImages = in->maxDescriptorSetStorageImages;
22621     out->maxDescriptorSetInputAttachments = in->maxDescriptorSetInputAttachments;
22622     out->maxVertexInputAttributes = in->maxVertexInputAttributes;
22623     out->maxVertexInputBindings = in->maxVertexInputBindings;
22624     out->maxVertexInputAttributeOffset = in->maxVertexInputAttributeOffset;
22625     out->maxVertexInputBindingStride = in->maxVertexInputBindingStride;
22626     out->maxVertexOutputComponents = in->maxVertexOutputComponents;
22627     out->maxTessellationGenerationLevel = in->maxTessellationGenerationLevel;
22628     out->maxTessellationPatchSize = in->maxTessellationPatchSize;
22629     out->maxTessellationControlPerVertexInputComponents = in->maxTessellationControlPerVertexInputComponents;
22630     out->maxTessellationControlPerVertexOutputComponents = in->maxTessellationControlPerVertexOutputComponents;
22631     out->maxTessellationControlPerPatchOutputComponents = in->maxTessellationControlPerPatchOutputComponents;
22632     out->maxTessellationControlTotalOutputComponents = in->maxTessellationControlTotalOutputComponents;
22633     out->maxTessellationEvaluationInputComponents = in->maxTessellationEvaluationInputComponents;
22634     out->maxTessellationEvaluationOutputComponents = in->maxTessellationEvaluationOutputComponents;
22635     out->maxGeometryShaderInvocations = in->maxGeometryShaderInvocations;
22636     out->maxGeometryInputComponents = in->maxGeometryInputComponents;
22637     out->maxGeometryOutputComponents = in->maxGeometryOutputComponents;
22638     out->maxGeometryOutputVertices = in->maxGeometryOutputVertices;
22639     out->maxGeometryTotalOutputComponents = in->maxGeometryTotalOutputComponents;
22640     out->maxFragmentInputComponents = in->maxFragmentInputComponents;
22641     out->maxFragmentOutputAttachments = in->maxFragmentOutputAttachments;
22642     out->maxFragmentDualSrcAttachments = in->maxFragmentDualSrcAttachments;
22643     out->maxFragmentCombinedOutputResources = in->maxFragmentCombinedOutputResources;
22644     out->maxComputeSharedMemorySize = in->maxComputeSharedMemorySize;
22645     memcpy(out->maxComputeWorkGroupCount, in->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
22646     out->maxComputeWorkGroupInvocations = in->maxComputeWorkGroupInvocations;
22647     memcpy(out->maxComputeWorkGroupSize, in->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
22648     out->subPixelPrecisionBits = in->subPixelPrecisionBits;
22649     out->subTexelPrecisionBits = in->subTexelPrecisionBits;
22650     out->mipmapPrecisionBits = in->mipmapPrecisionBits;
22651     out->maxDrawIndexedIndexValue = in->maxDrawIndexedIndexValue;
22652     out->maxDrawIndirectCount = in->maxDrawIndirectCount;
22653     out->maxSamplerLodBias = in->maxSamplerLodBias;
22654     out->maxSamplerAnisotropy = in->maxSamplerAnisotropy;
22655     out->maxViewports = in->maxViewports;
22656     memcpy(out->maxViewportDimensions, in->maxViewportDimensions, 2 * sizeof(uint32_t));
22657     memcpy(out->viewportBoundsRange, in->viewportBoundsRange, 2 * sizeof(float));
22658     out->viewportSubPixelBits = in->viewportSubPixelBits;
22659     out->minMemoryMapAlignment = in->minMemoryMapAlignment;
22660     out->minTexelBufferOffsetAlignment = in->minTexelBufferOffsetAlignment;
22661     out->minUniformBufferOffsetAlignment = in->minUniformBufferOffsetAlignment;
22662     out->minStorageBufferOffsetAlignment = in->minStorageBufferOffsetAlignment;
22663     out->minTexelOffset = in->minTexelOffset;
22664     out->maxTexelOffset = in->maxTexelOffset;
22665     out->minTexelGatherOffset = in->minTexelGatherOffset;
22666     out->maxTexelGatherOffset = in->maxTexelGatherOffset;
22667     out->minInterpolationOffset = in->minInterpolationOffset;
22668     out->maxInterpolationOffset = in->maxInterpolationOffset;
22669     out->subPixelInterpolationOffsetBits = in->subPixelInterpolationOffsetBits;
22670     out->maxFramebufferWidth = in->maxFramebufferWidth;
22671     out->maxFramebufferHeight = in->maxFramebufferHeight;
22672     out->maxFramebufferLayers = in->maxFramebufferLayers;
22673     out->framebufferColorSampleCounts = in->framebufferColorSampleCounts;
22674     out->framebufferDepthSampleCounts = in->framebufferDepthSampleCounts;
22675     out->framebufferStencilSampleCounts = in->framebufferStencilSampleCounts;
22676     out->framebufferNoAttachmentsSampleCounts = in->framebufferNoAttachmentsSampleCounts;
22677     out->maxColorAttachments = in->maxColorAttachments;
22678     out->sampledImageColorSampleCounts = in->sampledImageColorSampleCounts;
22679     out->sampledImageIntegerSampleCounts = in->sampledImageIntegerSampleCounts;
22680     out->sampledImageDepthSampleCounts = in->sampledImageDepthSampleCounts;
22681     out->sampledImageStencilSampleCounts = in->sampledImageStencilSampleCounts;
22682     out->storageImageSampleCounts = in->storageImageSampleCounts;
22683     out->maxSampleMaskWords = in->maxSampleMaskWords;
22684     out->timestampComputeAndGraphics = in->timestampComputeAndGraphics;
22685     out->timestampPeriod = in->timestampPeriod;
22686     out->maxClipDistances = in->maxClipDistances;
22687     out->maxCullDistances = in->maxCullDistances;
22688     out->maxCombinedClipAndCullDistances = in->maxCombinedClipAndCullDistances;
22689     out->discreteQueuePriorities = in->discreteQueuePriorities;
22690     memcpy(out->pointSizeRange, in->pointSizeRange, 2 * sizeof(float));
22691     memcpy(out->lineWidthRange, in->lineWidthRange, 2 * sizeof(float));
22692     out->pointSizeGranularity = in->pointSizeGranularity;
22693     out->lineWidthGranularity = in->lineWidthGranularity;
22694     out->strictLines = in->strictLines;
22695     out->standardSampleLocations = in->standardSampleLocations;
22696     out->optimalBufferCopyOffsetAlignment = in->optimalBufferCopyOffsetAlignment;
22697     out->optimalBufferCopyRowPitchAlignment = in->optimalBufferCopyRowPitchAlignment;
22698     out->nonCoherentAtomSize = in->nonCoherentAtomSize;
22699 }
22700
22701 static inline void convert_VkPhysicalDeviceProperties_host_to_win32(const VkPhysicalDeviceProperties *in, VkPhysicalDeviceProperties32 *out)
22702 {
22703     if (!in) return;
22704
22705     out->apiVersion = in->apiVersion;
22706     out->driverVersion = in->driverVersion;
22707     out->vendorID = in->vendorID;
22708     out->deviceID = in->deviceID;
22709     out->deviceType = in->deviceType;
22710     memcpy(out->deviceName, in->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
22711     memcpy(out->pipelineCacheUUID, in->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
22712     convert_VkPhysicalDeviceLimits_host_to_win32(&in->limits, &out->limits);
22713     out->sparseProperties = in->sparseProperties;
22714 }
22715
22716 static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceProperties232 *in, VkPhysicalDeviceProperties2 *out)
22717 {
22718     const VkBaseInStructure32 *in_header;
22719     VkBaseOutStructure *out_header = (void *)out;
22720
22721     if (!in) return;
22722
22723     out->sType = in->sType;
22724     out->pNext = NULL;
22725
22726     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
22727     {
22728         switch (in_header->sType)
22729         {
22730         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
22731         {
22732             VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22733             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
22734             out_ext->pNext = NULL;
22735             out_header->pNext = (void *)out_ext;
22736             out_header = (void *)out_ext;
22737             break;
22738         }
22739         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
22740         {
22741             VkPhysicalDeviceMultiDrawPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22742             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
22743             out_ext->pNext = NULL;
22744             out_header->pNext = (void *)out_ext;
22745             out_header = (void *)out_ext;
22746             break;
22747         }
22748         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
22749         {
22750             VkPhysicalDevicePushDescriptorPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22751             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
22752             out_ext->pNext = NULL;
22753             out_header->pNext = (void *)out_ext;
22754             out_header = (void *)out_ext;
22755             break;
22756         }
22757         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
22758         {
22759             VkPhysicalDeviceDriverProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22760             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
22761             out_ext->pNext = NULL;
22762             out_header->pNext = (void *)out_ext;
22763             out_header = (void *)out_ext;
22764             break;
22765         }
22766         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
22767         {
22768             VkPhysicalDeviceIDProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22769             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
22770             out_ext->pNext = NULL;
22771             out_header->pNext = (void *)out_ext;
22772             out_header = (void *)out_ext;
22773             break;
22774         }
22775         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
22776         {
22777             VkPhysicalDeviceMultiviewProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22778             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
22779             out_ext->pNext = NULL;
22780             out_header->pNext = (void *)out_ext;
22781             out_header = (void *)out_ext;
22782             break;
22783         }
22784         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
22785         {
22786             VkPhysicalDeviceDiscardRectanglePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22787             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
22788             out_ext->pNext = NULL;
22789             out_header->pNext = (void *)out_ext;
22790             out_header = (void *)out_ext;
22791             break;
22792         }
22793         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
22794         {
22795             VkPhysicalDeviceSubgroupProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22796             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
22797             out_ext->pNext = NULL;
22798             out_header->pNext = (void *)out_ext;
22799             out_header = (void *)out_ext;
22800             break;
22801         }
22802         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
22803         {
22804             VkPhysicalDevicePointClippingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22805             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
22806             out_ext->pNext = NULL;
22807             out_header->pNext = (void *)out_ext;
22808             out_header = (void *)out_ext;
22809             break;
22810         }
22811         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
22812         {
22813             VkPhysicalDeviceProtectedMemoryProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22814             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
22815             out_ext->pNext = NULL;
22816             out_header->pNext = (void *)out_ext;
22817             out_header = (void *)out_ext;
22818             break;
22819         }
22820         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
22821         {
22822             VkPhysicalDeviceSamplerFilterMinmaxProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22823             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
22824             out_ext->pNext = NULL;
22825             out_header->pNext = (void *)out_ext;
22826             out_header = (void *)out_ext;
22827             break;
22828         }
22829         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
22830         {
22831             VkPhysicalDeviceSampleLocationsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22832             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
22833             out_ext->pNext = NULL;
22834             out_header->pNext = (void *)out_ext;
22835             out_header = (void *)out_ext;
22836             break;
22837         }
22838         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
22839         {
22840             VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22841             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
22842             out_ext->pNext = NULL;
22843             out_header->pNext = (void *)out_ext;
22844             out_header = (void *)out_ext;
22845             break;
22846         }
22847         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
22848         {
22849             VkPhysicalDeviceInlineUniformBlockProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22850             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
22851             out_ext->pNext = NULL;
22852             out_header->pNext = (void *)out_ext;
22853             out_header = (void *)out_ext;
22854             break;
22855         }
22856         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
22857         {
22858             VkPhysicalDeviceMaintenance3Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22859             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
22860             out_ext->pNext = NULL;
22861             out_header->pNext = (void *)out_ext;
22862             out_header = (void *)out_ext;
22863             break;
22864         }
22865         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
22866         {
22867             VkPhysicalDeviceMaintenance4Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22868             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
22869             out_ext->pNext = NULL;
22870             out_header->pNext = (void *)out_ext;
22871             out_header = (void *)out_ext;
22872             break;
22873         }
22874         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
22875         {
22876             VkPhysicalDeviceFloatControlsProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22877             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
22878             out_ext->pNext = NULL;
22879             out_header->pNext = (void *)out_ext;
22880             out_header = (void *)out_ext;
22881             break;
22882         }
22883         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
22884         {
22885             VkPhysicalDeviceExternalMemoryHostPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22886             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
22887             out_ext->pNext = NULL;
22888             out_header->pNext = (void *)out_ext;
22889             out_header = (void *)out_ext;
22890             break;
22891         }
22892         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
22893         {
22894             VkPhysicalDeviceConservativeRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22895             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
22896             out_ext->pNext = NULL;
22897             out_header->pNext = (void *)out_ext;
22898             out_header = (void *)out_ext;
22899             break;
22900         }
22901         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
22902         {
22903             VkPhysicalDeviceShaderCorePropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22904             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
22905             out_ext->pNext = NULL;
22906             out_header->pNext = (void *)out_ext;
22907             out_header = (void *)out_ext;
22908             break;
22909         }
22910         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
22911         {
22912             VkPhysicalDeviceShaderCoreProperties2AMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22913             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
22914             out_ext->pNext = NULL;
22915             out_header->pNext = (void *)out_ext;
22916             out_header = (void *)out_ext;
22917             break;
22918         }
22919         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
22920         {
22921             VkPhysicalDeviceDescriptorIndexingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22922             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
22923             out_ext->pNext = NULL;
22924             out_header->pNext = (void *)out_ext;
22925             out_header = (void *)out_ext;
22926             break;
22927         }
22928         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
22929         {
22930             VkPhysicalDeviceTimelineSemaphoreProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22931             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
22932             out_ext->pNext = NULL;
22933             out_header->pNext = (void *)out_ext;
22934             out_header = (void *)out_ext;
22935             break;
22936         }
22937         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
22938         {
22939             VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22940             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
22941             out_ext->pNext = NULL;
22942             out_header->pNext = (void *)out_ext;
22943             out_header = (void *)out_ext;
22944             break;
22945         }
22946         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
22947         {
22948             VkPhysicalDevicePCIBusInfoPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22949             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
22950             out_ext->pNext = NULL;
22951             out_header->pNext = (void *)out_ext;
22952             out_header = (void *)out_ext;
22953             break;
22954         }
22955         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
22956         {
22957             VkPhysicalDeviceDepthStencilResolveProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22958             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
22959             out_ext->pNext = NULL;
22960             out_header->pNext = (void *)out_ext;
22961             out_header = (void *)out_ext;
22962             break;
22963         }
22964         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
22965         {
22966             VkPhysicalDeviceTransformFeedbackPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22967             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
22968             out_ext->pNext = NULL;
22969             out_header->pNext = (void *)out_ext;
22970             out_header = (void *)out_ext;
22971             break;
22972         }
22973         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
22974         {
22975             VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22976             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
22977             out_ext->pNext = NULL;
22978             out_header->pNext = (void *)out_ext;
22979             out_header = (void *)out_ext;
22980             break;
22981         }
22982         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
22983         {
22984             VkPhysicalDeviceMemoryDecompressionPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22985             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
22986             out_ext->pNext = NULL;
22987             out_header->pNext = (void *)out_ext;
22988             out_header = (void *)out_ext;
22989             break;
22990         }
22991         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
22992         {
22993             VkPhysicalDeviceShadingRateImagePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22994             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
22995             out_ext->pNext = NULL;
22996             out_header->pNext = (void *)out_ext;
22997             out_header = (void *)out_ext;
22998             break;
22999         }
23000         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
23001         {
23002             VkPhysicalDeviceMeshShaderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23003             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
23004             out_ext->pNext = NULL;
23005             out_header->pNext = (void *)out_ext;
23006             out_header = (void *)out_ext;
23007             break;
23008         }
23009         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
23010         {
23011             VkPhysicalDeviceMeshShaderPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23012             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
23013             out_ext->pNext = NULL;
23014             out_header->pNext = (void *)out_ext;
23015             out_header = (void *)out_ext;
23016             break;
23017         }
23018         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
23019         {
23020             VkPhysicalDeviceAccelerationStructurePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23021             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
23022             out_ext->pNext = NULL;
23023             out_header->pNext = (void *)out_ext;
23024             out_header = (void *)out_ext;
23025             break;
23026         }
23027         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
23028         {
23029             VkPhysicalDeviceRayTracingPipelinePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23030             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
23031             out_ext->pNext = NULL;
23032             out_header->pNext = (void *)out_ext;
23033             out_header = (void *)out_ext;
23034             break;
23035         }
23036         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
23037         {
23038             VkPhysicalDeviceRayTracingPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23039             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
23040             out_ext->pNext = NULL;
23041             out_header->pNext = (void *)out_ext;
23042             out_header = (void *)out_ext;
23043             break;
23044         }
23045         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
23046         {
23047             VkPhysicalDeviceFragmentDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23048             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
23049             out_ext->pNext = NULL;
23050             out_header->pNext = (void *)out_ext;
23051             out_header = (void *)out_ext;
23052             break;
23053         }
23054         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
23055         {
23056             VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23057             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
23058             out_ext->pNext = NULL;
23059             out_header->pNext = (void *)out_ext;
23060             out_header = (void *)out_ext;
23061             break;
23062         }
23063         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
23064         {
23065             VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23066             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM;
23067             out_ext->pNext = NULL;
23068             out_header->pNext = (void *)out_ext;
23069             out_header = (void *)out_ext;
23070             break;
23071         }
23072         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
23073         {
23074             VkPhysicalDeviceCooperativeMatrixPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23075             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
23076             out_ext->pNext = NULL;
23077             out_header->pNext = (void *)out_ext;
23078             out_header = (void *)out_ext;
23079             break;
23080         }
23081         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
23082         {
23083             VkPhysicalDevicePerformanceQueryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23084             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
23085             out_ext->pNext = NULL;
23086             out_header->pNext = (void *)out_ext;
23087             out_header = (void *)out_ext;
23088             break;
23089         }
23090         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
23091         {
23092             VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23093             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
23094             out_ext->pNext = NULL;
23095             out_header->pNext = (void *)out_ext;
23096             out_header = (void *)out_ext;
23097             break;
23098         }
23099         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
23100         {
23101             VkPhysicalDeviceTexelBufferAlignmentProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23102             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
23103             out_ext->pNext = NULL;
23104             out_header->pNext = (void *)out_ext;
23105             out_header = (void *)out_ext;
23106             break;
23107         }
23108         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
23109         {
23110             VkPhysicalDeviceSubgroupSizeControlProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23111             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
23112             out_ext->pNext = NULL;
23113             out_header->pNext = (void *)out_ext;
23114             out_header = (void *)out_ext;
23115             break;
23116         }
23117         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
23118         {
23119             VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23120             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
23121             out_ext->pNext = NULL;
23122             out_header->pNext = (void *)out_ext;
23123             out_header = (void *)out_ext;
23124             break;
23125         }
23126         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
23127         {
23128             VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23129             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI;
23130             out_ext->pNext = NULL;
23131             out_header->pNext = (void *)out_ext;
23132             out_header = (void *)out_ext;
23133             break;
23134         }
23135         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
23136         {
23137             VkPhysicalDeviceLineRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23138             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
23139             out_ext->pNext = NULL;
23140             out_header->pNext = (void *)out_ext;
23141             out_header = (void *)out_ext;
23142             break;
23143         }
23144         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
23145         {
23146             VkPhysicalDeviceVulkan11Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23147             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
23148             out_ext->pNext = NULL;
23149             out_header->pNext = (void *)out_ext;
23150             out_header = (void *)out_ext;
23151             break;
23152         }
23153         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
23154         {
23155             VkPhysicalDeviceVulkan12Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23156             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
23157             out_ext->pNext = NULL;
23158             out_header->pNext = (void *)out_ext;
23159             out_header = (void *)out_ext;
23160             break;
23161         }
23162         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
23163         {
23164             VkPhysicalDeviceVulkan13Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23165             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
23166             out_ext->pNext = NULL;
23167             out_header->pNext = (void *)out_ext;
23168             out_header = (void *)out_ext;
23169             break;
23170         }
23171         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
23172         {
23173             VkPhysicalDeviceCustomBorderColorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23174             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
23175             out_ext->pNext = NULL;
23176             out_header->pNext = (void *)out_ext;
23177             out_header = (void *)out_ext;
23178             break;
23179         }
23180         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
23181         {
23182             VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23183             const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *)in_header;
23184             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
23185             out_ext->pNext = NULL;
23186             out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted;
23187             out_header->pNext = (void *)out_ext;
23188             out_header = (void *)out_ext;
23189             break;
23190         }
23191         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
23192         {
23193             VkPhysicalDeviceRobustness2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23194             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
23195             out_ext->pNext = NULL;
23196             out_header->pNext = (void *)out_ext;
23197             out_header = (void *)out_ext;
23198             break;
23199         }
23200         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
23201         {
23202             VkPhysicalDeviceFragmentShadingRatePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23203             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
23204             out_ext->pNext = NULL;
23205             out_header->pNext = (void *)out_ext;
23206             out_header = (void *)out_ext;
23207             break;
23208         }
23209         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
23210         {
23211             VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23212             const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *)in_header;
23213             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
23214             out_ext->pNext = NULL;
23215             out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount;
23216             out_header->pNext = (void *)out_ext;
23217             out_header = (void *)out_ext;
23218             break;
23219         }
23220         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
23221         {
23222             VkPhysicalDeviceProvokingVertexPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23223             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
23224             out_ext->pNext = NULL;
23225             out_header->pNext = (void *)out_ext;
23226             out_header = (void *)out_ext;
23227             break;
23228         }
23229         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
23230         {
23231             VkPhysicalDeviceDescriptorBufferPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23232             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
23233             out_ext->pNext = NULL;
23234             out_header->pNext = (void *)out_ext;
23235             out_header = (void *)out_ext;
23236             break;
23237         }
23238         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
23239         {
23240             VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23241             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
23242             out_ext->pNext = NULL;
23243             out_header->pNext = (void *)out_ext;
23244             out_header = (void *)out_ext;
23245             break;
23246         }
23247         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
23248         {
23249             VkPhysicalDeviceShaderIntegerDotProductProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23250             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
23251             out_ext->pNext = NULL;
23252             out_header->pNext = (void *)out_ext;
23253             out_header = (void *)out_ext;
23254             break;
23255         }
23256         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
23257         {
23258             VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23259             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
23260             out_ext->pNext = NULL;
23261             out_header->pNext = (void *)out_ext;
23262             out_header = (void *)out_ext;
23263             break;
23264         }
23265         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
23266         {
23267             VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23268             const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *)in_header;
23269             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
23270             out_ext->pNext = NULL;
23271             out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking;
23272             out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration;
23273             out_header->pNext = (void *)out_ext;
23274             out_header = (void *)out_ext;
23275             break;
23276         }
23277         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
23278         {
23279             VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23280             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
23281             out_ext->pNext = NULL;
23282             out_header->pNext = (void *)out_ext;
23283             out_header = (void *)out_ext;
23284             break;
23285         }
23286         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
23287         {
23288             VkPhysicalDeviceOpacityMicromapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23289             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
23290             out_ext->pNext = NULL;
23291             out_header->pNext = (void *)out_ext;
23292             out_header = (void *)out_ext;
23293             break;
23294         }
23295         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
23296         {
23297             VkPhysicalDevicePipelineRobustnessPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23298             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT;
23299             out_ext->pNext = NULL;
23300             out_header->pNext = (void *)out_ext;
23301             out_header = (void *)out_ext;
23302             break;
23303         }
23304         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
23305         {
23306             VkPhysicalDeviceImageProcessingPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23307             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
23308             out_ext->pNext = NULL;
23309             out_header->pNext = (void *)out_ext;
23310             out_header = (void *)out_ext;
23311             break;
23312         }
23313         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
23314         {
23315             VkPhysicalDeviceOpticalFlowPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23316             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
23317             out_ext->pNext = NULL;
23318             out_header->pNext = (void *)out_ext;
23319             out_header = (void *)out_ext;
23320             break;
23321         }
23322         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
23323         {
23324             VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23325             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
23326             out_ext->pNext = NULL;
23327             out_header->pNext = (void *)out_ext;
23328             out_header = (void *)out_ext;
23329             break;
23330         }
23331         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
23332         {
23333             VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23334             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
23335             out_ext->pNext = NULL;
23336             out_header->pNext = (void *)out_ext;
23337             out_header = (void *)out_ext;
23338             break;
23339         }
23340         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
23341         {
23342             VkPhysicalDeviceShaderCorePropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23343             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM;
23344             out_ext->pNext = NULL;
23345             out_header->pNext = (void *)out_ext;
23346             out_header = (void *)out_ext;
23347             break;
23348         }
23349         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
23350         {
23351             VkPhysicalDeviceShaderObjectPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23352             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
23353             out_ext->pNext = NULL;
23354             out_header->pNext = (void *)out_ext;
23355             out_header = (void *)out_ext;
23356             break;
23357         }
23358         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
23359         {
23360             VkPhysicalDeviceShaderTileImagePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23361             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
23362             out_ext->pNext = NULL;
23363             out_header->pNext = (void *)out_ext;
23364             out_header = (void *)out_ext;
23365             break;
23366         }
23367         default:
23368             FIXME("Unhandled sType %u.\n", in_header->sType);
23369             break;
23370         }
23371     }
23372 }
23373
23374 static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDeviceProperties2 *in, VkPhysicalDeviceProperties232 *out)
23375 {
23376     const VkBaseInStructure *in_header;
23377     VkBaseOutStructure32 *out_header = (void *)out;
23378
23379     if (!in) return;
23380
23381     convert_VkPhysicalDeviceProperties_host_to_win32(&in->properties, &out->properties);
23382
23383     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
23384     {
23385         switch (in_header->sType)
23386         {
23387         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
23388         {
23389             VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV);
23390             const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *)in_header;
23391             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
23392             out_ext->maxGraphicsShaderGroupCount = in_ext->maxGraphicsShaderGroupCount;
23393             out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount;
23394             out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount;
23395             out_ext->maxIndirectCommandsStreamCount = in_ext->maxIndirectCommandsStreamCount;
23396             out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset;
23397             out_ext->maxIndirectCommandsStreamStride = in_ext->maxIndirectCommandsStreamStride;
23398             out_ext->minSequencesCountBufferOffsetAlignment = in_ext->minSequencesCountBufferOffsetAlignment;
23399             out_ext->minSequencesIndexBufferOffsetAlignment = in_ext->minSequencesIndexBufferOffsetAlignment;
23400             out_ext->minIndirectCommandsBufferOffsetAlignment = in_ext->minIndirectCommandsBufferOffsetAlignment;
23401             out_header = (void *)out_ext;
23402             break;
23403         }
23404         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
23405         {
23406             VkPhysicalDeviceMultiDrawPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT);
23407             const VkPhysicalDeviceMultiDrawPropertiesEXT *in_ext = (const VkPhysicalDeviceMultiDrawPropertiesEXT *)in_header;
23408             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
23409             out_ext->maxMultiDrawCount = in_ext->maxMultiDrawCount;
23410             out_header = (void *)out_ext;
23411             break;
23412         }
23413         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
23414         {
23415             VkPhysicalDevicePushDescriptorPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR);
23416             const VkPhysicalDevicePushDescriptorPropertiesKHR *in_ext = (const VkPhysicalDevicePushDescriptorPropertiesKHR *)in_header;
23417             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
23418             out_ext->maxPushDescriptors = in_ext->maxPushDescriptors;
23419             out_header = (void *)out_ext;
23420             break;
23421         }
23422         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
23423         {
23424             VkPhysicalDeviceDriverProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
23425             const VkPhysicalDeviceDriverProperties *in_ext = (const VkPhysicalDeviceDriverProperties *)in_header;
23426             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
23427             out_ext->driverID = in_ext->driverID;
23428             memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
23429             memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
23430             out_ext->conformanceVersion = in_ext->conformanceVersion;
23431             out_header = (void *)out_ext;
23432             break;
23433         }
23434         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
23435         {
23436             VkPhysicalDeviceIDProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
23437             const VkPhysicalDeviceIDProperties *in_ext = (const VkPhysicalDeviceIDProperties *)in_header;
23438             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
23439             memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
23440             memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
23441             memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
23442             out_ext->deviceNodeMask = in_ext->deviceNodeMask;
23443             out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
23444             out_header = (void *)out_ext;
23445             break;
23446         }
23447         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
23448         {
23449             VkPhysicalDeviceMultiviewProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
23450             const VkPhysicalDeviceMultiviewProperties *in_ext = (const VkPhysicalDeviceMultiviewProperties *)in_header;
23451             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
23452             out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
23453             out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
23454             out_header = (void *)out_ext;
23455             break;
23456         }
23457         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
23458         {
23459             VkPhysicalDeviceDiscardRectanglePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT);
23460             const VkPhysicalDeviceDiscardRectanglePropertiesEXT *in_ext = (const VkPhysicalDeviceDiscardRectanglePropertiesEXT *)in_header;
23461             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
23462             out_ext->maxDiscardRectangles = in_ext->maxDiscardRectangles;
23463             out_header = (void *)out_ext;
23464             break;
23465         }
23466         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
23467         {
23468             VkPhysicalDeviceSubgroupProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
23469             const VkPhysicalDeviceSubgroupProperties *in_ext = (const VkPhysicalDeviceSubgroupProperties *)in_header;
23470             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
23471             out_ext->subgroupSize = in_ext->subgroupSize;
23472             out_ext->supportedStages = in_ext->supportedStages;
23473             out_ext->supportedOperations = in_ext->supportedOperations;
23474             out_ext->quadOperationsInAllStages = in_ext->quadOperationsInAllStages;
23475             out_header = (void *)out_ext;
23476             break;
23477         }
23478         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
23479         {
23480             VkPhysicalDevicePointClippingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
23481             const VkPhysicalDevicePointClippingProperties *in_ext = (const VkPhysicalDevicePointClippingProperties *)in_header;
23482             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
23483             out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
23484             out_header = (void *)out_ext;
23485             break;
23486         }
23487         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
23488         {
23489             VkPhysicalDeviceProtectedMemoryProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
23490             const VkPhysicalDeviceProtectedMemoryProperties *in_ext = (const VkPhysicalDeviceProtectedMemoryProperties *)in_header;
23491             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
23492             out_ext->protectedNoFault = in_ext->protectedNoFault;
23493             out_header = (void *)out_ext;
23494             break;
23495         }
23496         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
23497         {
23498             VkPhysicalDeviceSamplerFilterMinmaxProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
23499             const VkPhysicalDeviceSamplerFilterMinmaxProperties *in_ext = (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)in_header;
23500             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
23501             out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
23502             out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
23503             out_header = (void *)out_ext;
23504             break;
23505         }
23506         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
23507         {
23508             VkPhysicalDeviceSampleLocationsPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT);
23509             const VkPhysicalDeviceSampleLocationsPropertiesEXT *in_ext = (const VkPhysicalDeviceSampleLocationsPropertiesEXT *)in_header;
23510             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
23511             out_ext->sampleLocationSampleCounts = in_ext->sampleLocationSampleCounts;
23512             out_ext->maxSampleLocationGridSize = in_ext->maxSampleLocationGridSize;
23513             memcpy(out_ext->sampleLocationCoordinateRange, in_ext->sampleLocationCoordinateRange, 2 * sizeof(float));
23514             out_ext->sampleLocationSubPixelBits = in_ext->sampleLocationSubPixelBits;
23515             out_ext->variableSampleLocations = in_ext->variableSampleLocations;
23516             out_header = (void *)out_ext;
23517             break;
23518         }
23519         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
23520         {
23521             VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT);
23522             const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)in_header;
23523             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
23524             out_ext->advancedBlendMaxColorAttachments = in_ext->advancedBlendMaxColorAttachments;
23525             out_ext->advancedBlendIndependentBlend = in_ext->advancedBlendIndependentBlend;
23526             out_ext->advancedBlendNonPremultipliedSrcColor = in_ext->advancedBlendNonPremultipliedSrcColor;
23527             out_ext->advancedBlendNonPremultipliedDstColor = in_ext->advancedBlendNonPremultipliedDstColor;
23528             out_ext->advancedBlendCorrelatedOverlap = in_ext->advancedBlendCorrelatedOverlap;
23529             out_ext->advancedBlendAllOperations = in_ext->advancedBlendAllOperations;
23530             out_header = (void *)out_ext;
23531             break;
23532         }
23533         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
23534         {
23535             VkPhysicalDeviceInlineUniformBlockProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES);
23536             const VkPhysicalDeviceInlineUniformBlockProperties *in_ext = (const VkPhysicalDeviceInlineUniformBlockProperties *)in_header;
23537             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
23538             out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
23539             out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
23540             out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
23541             out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
23542             out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
23543             out_header = (void *)out_ext;
23544             break;
23545         }
23546         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
23547         {
23548             VkPhysicalDeviceMaintenance3Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
23549             const VkPhysicalDeviceMaintenance3Properties *in_ext = (const VkPhysicalDeviceMaintenance3Properties *)in_header;
23550             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
23551             out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
23552             out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
23553             out_header = (void *)out_ext;
23554             break;
23555         }
23556         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
23557         {
23558             VkPhysicalDeviceMaintenance4Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES);
23559             const VkPhysicalDeviceMaintenance4Properties *in_ext = (const VkPhysicalDeviceMaintenance4Properties *)in_header;
23560             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
23561             out_ext->maxBufferSize = in_ext->maxBufferSize;
23562             out_header = (void *)out_ext;
23563             break;
23564         }
23565         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
23566         {
23567             VkPhysicalDeviceFloatControlsProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
23568             const VkPhysicalDeviceFloatControlsProperties *in_ext = (const VkPhysicalDeviceFloatControlsProperties *)in_header;
23569             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
23570             out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence;
23571             out_ext->roundingModeIndependence = in_ext->roundingModeIndependence;
23572             out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16;
23573             out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32;
23574             out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64;
23575             out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16;
23576             out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32;
23577             out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64;
23578             out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16;
23579             out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32;
23580             out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64;
23581             out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16;
23582             out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32;
23583             out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64;
23584             out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16;
23585             out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32;
23586             out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64;
23587             out_header = (void *)out_ext;
23588             break;
23589         }
23590         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
23591         {
23592             VkPhysicalDeviceExternalMemoryHostPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT);
23593             const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *in_ext = (const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *)in_header;
23594             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
23595             out_ext->minImportedHostPointerAlignment = in_ext->minImportedHostPointerAlignment;
23596             out_header = (void *)out_ext;
23597             break;
23598         }
23599         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
23600         {
23601             VkPhysicalDeviceConservativeRasterizationPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT);
23602             const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)in_header;
23603             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
23604             out_ext->primitiveOverestimationSize = in_ext->primitiveOverestimationSize;
23605             out_ext->maxExtraPrimitiveOverestimationSize = in_ext->maxExtraPrimitiveOverestimationSize;
23606             out_ext->extraPrimitiveOverestimationSizeGranularity = in_ext->extraPrimitiveOverestimationSizeGranularity;
23607             out_ext->primitiveUnderestimation = in_ext->primitiveUnderestimation;
23608             out_ext->conservativePointAndLineRasterization = in_ext->conservativePointAndLineRasterization;
23609             out_ext->degenerateTrianglesRasterized = in_ext->degenerateTrianglesRasterized;
23610             out_ext->degenerateLinesRasterized = in_ext->degenerateLinesRasterized;
23611             out_ext->fullyCoveredFragmentShaderInputVariable = in_ext->fullyCoveredFragmentShaderInputVariable;
23612             out_ext->conservativeRasterizationPostDepthCoverage = in_ext->conservativeRasterizationPostDepthCoverage;
23613             out_header = (void *)out_ext;
23614             break;
23615         }
23616         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
23617         {
23618             VkPhysicalDeviceShaderCorePropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD);
23619             const VkPhysicalDeviceShaderCorePropertiesAMD *in_ext = (const VkPhysicalDeviceShaderCorePropertiesAMD *)in_header;
23620             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
23621             out_ext->shaderEngineCount = in_ext->shaderEngineCount;
23622             out_ext->shaderArraysPerEngineCount = in_ext->shaderArraysPerEngineCount;
23623             out_ext->computeUnitsPerShaderArray = in_ext->computeUnitsPerShaderArray;
23624             out_ext->simdPerComputeUnit = in_ext->simdPerComputeUnit;
23625             out_ext->wavefrontsPerSimd = in_ext->wavefrontsPerSimd;
23626             out_ext->wavefrontSize = in_ext->wavefrontSize;
23627             out_ext->sgprsPerSimd = in_ext->sgprsPerSimd;
23628             out_ext->minSgprAllocation = in_ext->minSgprAllocation;
23629             out_ext->maxSgprAllocation = in_ext->maxSgprAllocation;
23630             out_ext->sgprAllocationGranularity = in_ext->sgprAllocationGranularity;
23631             out_ext->vgprsPerSimd = in_ext->vgprsPerSimd;
23632             out_ext->minVgprAllocation = in_ext->minVgprAllocation;
23633             out_ext->maxVgprAllocation = in_ext->maxVgprAllocation;
23634             out_ext->vgprAllocationGranularity = in_ext->vgprAllocationGranularity;
23635             out_header = (void *)out_ext;
23636             break;
23637         }
23638         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
23639         {
23640             VkPhysicalDeviceShaderCoreProperties2AMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD);
23641             const VkPhysicalDeviceShaderCoreProperties2AMD *in_ext = (const VkPhysicalDeviceShaderCoreProperties2AMD *)in_header;
23642             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
23643             out_ext->shaderCoreFeatures = in_ext->shaderCoreFeatures;
23644             out_ext->activeComputeUnitCount = in_ext->activeComputeUnitCount;
23645             out_header = (void *)out_ext;
23646             break;
23647         }
23648         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
23649         {
23650             VkPhysicalDeviceDescriptorIndexingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
23651             const VkPhysicalDeviceDescriptorIndexingProperties *in_ext = (const VkPhysicalDeviceDescriptorIndexingProperties *)in_header;
23652             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
23653             out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
23654             out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
23655             out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
23656             out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
23657             out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
23658             out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
23659             out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
23660             out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
23661             out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
23662             out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
23663             out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
23664             out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
23665             out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
23666             out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
23667             out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
23668             out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
23669             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
23670             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
23671             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
23672             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
23673             out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
23674             out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
23675             out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
23676             out_header = (void *)out_ext;
23677             break;
23678         }
23679         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
23680         {
23681             VkPhysicalDeviceTimelineSemaphoreProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
23682             const VkPhysicalDeviceTimelineSemaphoreProperties *in_ext = (const VkPhysicalDeviceTimelineSemaphoreProperties *)in_header;
23683             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
23684             out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
23685             out_header = (void *)out_ext;
23686             break;
23687         }
23688         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
23689         {
23690             VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT);
23691             const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)in_header;
23692             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
23693             out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor;
23694             out_header = (void *)out_ext;
23695             break;
23696         }
23697         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
23698         {
23699             VkPhysicalDevicePCIBusInfoPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT);
23700             const VkPhysicalDevicePCIBusInfoPropertiesEXT *in_ext = (const VkPhysicalDevicePCIBusInfoPropertiesEXT *)in_header;
23701             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
23702             out_ext->pciDomain = in_ext->pciDomain;
23703             out_ext->pciBus = in_ext->pciBus;
23704             out_ext->pciDevice = in_ext->pciDevice;
23705             out_ext->pciFunction = in_ext->pciFunction;
23706             out_header = (void *)out_ext;
23707             break;
23708         }
23709         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
23710         {
23711             VkPhysicalDeviceDepthStencilResolveProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
23712             const VkPhysicalDeviceDepthStencilResolveProperties *in_ext = (const VkPhysicalDeviceDepthStencilResolveProperties *)in_header;
23713             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
23714             out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
23715             out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
23716             out_ext->independentResolveNone = in_ext->independentResolveNone;
23717             out_ext->independentResolve = in_ext->independentResolve;
23718             out_header = (void *)out_ext;
23719             break;
23720         }
23721         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
23722         {
23723             VkPhysicalDeviceTransformFeedbackPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
23724             const VkPhysicalDeviceTransformFeedbackPropertiesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)in_header;
23725             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
23726             out_ext->maxTransformFeedbackStreams = in_ext->maxTransformFeedbackStreams;
23727             out_ext->maxTransformFeedbackBuffers = in_ext->maxTransformFeedbackBuffers;
23728             out_ext->maxTransformFeedbackBufferSize = in_ext->maxTransformFeedbackBufferSize;
23729             out_ext->maxTransformFeedbackStreamDataSize = in_ext->maxTransformFeedbackStreamDataSize;
23730             out_ext->maxTransformFeedbackBufferDataSize = in_ext->maxTransformFeedbackBufferDataSize;
23731             out_ext->maxTransformFeedbackBufferDataStride = in_ext->maxTransformFeedbackBufferDataStride;
23732             out_ext->transformFeedbackQueries = in_ext->transformFeedbackQueries;
23733             out_ext->transformFeedbackStreamsLinesTriangles = in_ext->transformFeedbackStreamsLinesTriangles;
23734             out_ext->transformFeedbackRasterizationStreamSelect = in_ext->transformFeedbackRasterizationStreamSelect;
23735             out_ext->transformFeedbackDraw = in_ext->transformFeedbackDraw;
23736             out_header = (void *)out_ext;
23737             break;
23738         }
23739         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
23740         {
23741             VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV);
23742             const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *)in_header;
23743             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
23744             out_ext->supportedQueues = in_ext->supportedQueues;
23745             out_header = (void *)out_ext;
23746             break;
23747         }
23748         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
23749         {
23750             VkPhysicalDeviceMemoryDecompressionPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV);
23751             const VkPhysicalDeviceMemoryDecompressionPropertiesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionPropertiesNV *)in_header;
23752             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
23753             out_ext->decompressionMethods = in_ext->decompressionMethods;
23754             out_ext->maxDecompressionIndirectCount = in_ext->maxDecompressionIndirectCount;
23755             out_header = (void *)out_ext;
23756             break;
23757         }
23758         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
23759         {
23760             VkPhysicalDeviceShadingRateImagePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV);
23761             const VkPhysicalDeviceShadingRateImagePropertiesNV *in_ext = (const VkPhysicalDeviceShadingRateImagePropertiesNV *)in_header;
23762             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
23763             out_ext->shadingRateTexelSize = in_ext->shadingRateTexelSize;
23764             out_ext->shadingRatePaletteSize = in_ext->shadingRatePaletteSize;
23765             out_ext->shadingRateMaxCoarseSamples = in_ext->shadingRateMaxCoarseSamples;
23766             out_header = (void *)out_ext;
23767             break;
23768         }
23769         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
23770         {
23771             VkPhysicalDeviceMeshShaderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV);
23772             const VkPhysicalDeviceMeshShaderPropertiesNV *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesNV *)in_header;
23773             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
23774             out_ext->maxDrawMeshTasksCount = in_ext->maxDrawMeshTasksCount;
23775             out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations;
23776             memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
23777             out_ext->maxTaskTotalMemorySize = in_ext->maxTaskTotalMemorySize;
23778             out_ext->maxTaskOutputCount = in_ext->maxTaskOutputCount;
23779             out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations;
23780             memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
23781             out_ext->maxMeshTotalMemorySize = in_ext->maxMeshTotalMemorySize;
23782             out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices;
23783             out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives;
23784             out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount;
23785             out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity;
23786             out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity;
23787             out_header = (void *)out_ext;
23788             break;
23789         }
23790         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
23791         {
23792             VkPhysicalDeviceMeshShaderPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT);
23793             const VkPhysicalDeviceMeshShaderPropertiesEXT *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesEXT *)in_header;
23794             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
23795             out_ext->maxTaskWorkGroupTotalCount = in_ext->maxTaskWorkGroupTotalCount;
23796             memcpy(out_ext->maxTaskWorkGroupCount, in_ext->maxTaskWorkGroupCount, 3 * sizeof(uint32_t));
23797             out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations;
23798             memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
23799             out_ext->maxTaskPayloadSize = in_ext->maxTaskPayloadSize;
23800             out_ext->maxTaskSharedMemorySize = in_ext->maxTaskSharedMemorySize;
23801             out_ext->maxTaskPayloadAndSharedMemorySize = in_ext->maxTaskPayloadAndSharedMemorySize;
23802             out_ext->maxMeshWorkGroupTotalCount = in_ext->maxMeshWorkGroupTotalCount;
23803             memcpy(out_ext->maxMeshWorkGroupCount, in_ext->maxMeshWorkGroupCount, 3 * sizeof(uint32_t));
23804             out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations;
23805             memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
23806             out_ext->maxMeshSharedMemorySize = in_ext->maxMeshSharedMemorySize;
23807             out_ext->maxMeshPayloadAndSharedMemorySize = in_ext->maxMeshPayloadAndSharedMemorySize;
23808             out_ext->maxMeshOutputMemorySize = in_ext->maxMeshOutputMemorySize;
23809             out_ext->maxMeshPayloadAndOutputMemorySize = in_ext->maxMeshPayloadAndOutputMemorySize;
23810             out_ext->maxMeshOutputComponents = in_ext->maxMeshOutputComponents;
23811             out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices;
23812             out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives;
23813             out_ext->maxMeshOutputLayers = in_ext->maxMeshOutputLayers;
23814             out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount;
23815             out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity;
23816             out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity;
23817             out_ext->maxPreferredTaskWorkGroupInvocations = in_ext->maxPreferredTaskWorkGroupInvocations;
23818             out_ext->maxPreferredMeshWorkGroupInvocations = in_ext->maxPreferredMeshWorkGroupInvocations;
23819             out_ext->prefersLocalInvocationVertexOutput = in_ext->prefersLocalInvocationVertexOutput;
23820             out_ext->prefersLocalInvocationPrimitiveOutput = in_ext->prefersLocalInvocationPrimitiveOutput;
23821             out_ext->prefersCompactVertexOutput = in_ext->prefersCompactVertexOutput;
23822             out_ext->prefersCompactPrimitiveOutput = in_ext->prefersCompactPrimitiveOutput;
23823             out_header = (void *)out_ext;
23824             break;
23825         }
23826         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
23827         {
23828             VkPhysicalDeviceAccelerationStructurePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR);
23829             const VkPhysicalDeviceAccelerationStructurePropertiesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructurePropertiesKHR *)in_header;
23830             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
23831             out_ext->maxGeometryCount = in_ext->maxGeometryCount;
23832             out_ext->maxInstanceCount = in_ext->maxInstanceCount;
23833             out_ext->maxPrimitiveCount = in_ext->maxPrimitiveCount;
23834             out_ext->maxPerStageDescriptorAccelerationStructures = in_ext->maxPerStageDescriptorAccelerationStructures;
23835             out_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures = in_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
23836             out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
23837             out_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures = in_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures;
23838             out_ext->minAccelerationStructureScratchOffsetAlignment = in_ext->minAccelerationStructureScratchOffsetAlignment;
23839             out_header = (void *)out_ext;
23840             break;
23841         }
23842         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
23843         {
23844             VkPhysicalDeviceRayTracingPipelinePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR);
23845             const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *)in_header;
23846             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
23847             out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
23848             out_ext->maxRayRecursionDepth = in_ext->maxRayRecursionDepth;
23849             out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
23850             out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
23851             out_ext->shaderGroupHandleCaptureReplaySize = in_ext->shaderGroupHandleCaptureReplaySize;
23852             out_ext->maxRayDispatchInvocationCount = in_ext->maxRayDispatchInvocationCount;
23853             out_ext->shaderGroupHandleAlignment = in_ext->shaderGroupHandleAlignment;
23854             out_ext->maxRayHitAttributeSize = in_ext->maxRayHitAttributeSize;
23855             out_header = (void *)out_ext;
23856             break;
23857         }
23858         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
23859         {
23860             VkPhysicalDeviceRayTracingPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV);
23861             const VkPhysicalDeviceRayTracingPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingPropertiesNV *)in_header;
23862             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
23863             out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
23864             out_ext->maxRecursionDepth = in_ext->maxRecursionDepth;
23865             out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
23866             out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
23867             out_ext->maxGeometryCount = in_ext->maxGeometryCount;
23868             out_ext->maxInstanceCount = in_ext->maxInstanceCount;
23869             out_ext->maxTriangleCount = in_ext->maxTriangleCount;
23870             out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
23871             out_header = (void *)out_ext;
23872             break;
23873         }
23874         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
23875         {
23876             VkPhysicalDeviceFragmentDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT);
23877             const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *)in_header;
23878             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
23879             out_ext->minFragmentDensityTexelSize = in_ext->minFragmentDensityTexelSize;
23880             out_ext->maxFragmentDensityTexelSize = in_ext->maxFragmentDensityTexelSize;
23881             out_ext->fragmentDensityInvocations = in_ext->fragmentDensityInvocations;
23882             out_header = (void *)out_ext;
23883             break;
23884         }
23885         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
23886         {
23887             VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT);
23888             const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *)in_header;
23889             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
23890             out_ext->subsampledLoads = in_ext->subsampledLoads;
23891             out_ext->subsampledCoarseReconstructionEarlyAccess = in_ext->subsampledCoarseReconstructionEarlyAccess;
23892             out_ext->maxSubsampledArrayLayers = in_ext->maxSubsampledArrayLayers;
23893             out_ext->maxDescriptorSetSubsampledSamplers = in_ext->maxDescriptorSetSubsampledSamplers;
23894             out_header = (void *)out_ext;
23895             break;
23896         }
23897         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
23898         {
23899             VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM);
23900             const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *)in_header;
23901             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM;
23902             out_ext->fragmentDensityOffsetGranularity = in_ext->fragmentDensityOffsetGranularity;
23903             out_header = (void *)out_ext;
23904             break;
23905         }
23906         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
23907         {
23908             VkPhysicalDeviceCooperativeMatrixPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV);
23909             const VkPhysicalDeviceCooperativeMatrixPropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesNV *)in_header;
23910             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
23911             out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages;
23912             out_header = (void *)out_ext;
23913             break;
23914         }
23915         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
23916         {
23917             VkPhysicalDevicePerformanceQueryPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR);
23918             const VkPhysicalDevicePerformanceQueryPropertiesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryPropertiesKHR *)in_header;
23919             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
23920             out_ext->allowCommandBufferQueryCopies = in_ext->allowCommandBufferQueryCopies;
23921             out_header = (void *)out_ext;
23922             break;
23923         }
23924         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
23925         {
23926             VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV);
23927             const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *)in_header;
23928             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
23929             out_ext->shaderSMCount = in_ext->shaderSMCount;
23930             out_ext->shaderWarpsPerSM = in_ext->shaderWarpsPerSM;
23931             out_header = (void *)out_ext;
23932             break;
23933         }
23934         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
23935         {
23936             VkPhysicalDeviceTexelBufferAlignmentProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES);
23937             const VkPhysicalDeviceTexelBufferAlignmentProperties *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentProperties *)in_header;
23938             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
23939             out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
23940             out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
23941             out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
23942             out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
23943             out_header = (void *)out_ext;
23944             break;
23945         }
23946         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
23947         {
23948             VkPhysicalDeviceSubgroupSizeControlProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
23949             const VkPhysicalDeviceSubgroupSizeControlProperties *in_ext = (const VkPhysicalDeviceSubgroupSizeControlProperties *)in_header;
23950             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
23951             out_ext->minSubgroupSize = in_ext->minSubgroupSize;
23952             out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
23953             out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
23954             out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
23955             out_header = (void *)out_ext;
23956             break;
23957         }
23958         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
23959         {
23960             VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI);
23961             const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *)in_header;
23962             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
23963             out_ext->maxSubpassShadingWorkgroupSizeAspectRatio = in_ext->maxSubpassShadingWorkgroupSizeAspectRatio;
23964             out_header = (void *)out_ext;
23965             break;
23966         }
23967         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
23968         {
23969             VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI);
23970             const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *)in_header;
23971             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI;
23972             memcpy(out_ext->maxWorkGroupCount, in_ext->maxWorkGroupCount, 3 * sizeof(uint32_t));
23973             memcpy(out_ext->maxWorkGroupSize, in_ext->maxWorkGroupSize, 3 * sizeof(uint32_t));
23974             out_ext->maxOutputClusterCount = in_ext->maxOutputClusterCount;
23975             out_ext->indirectBufferOffsetAlignment = in_ext->indirectBufferOffsetAlignment;
23976             out_header = (void *)out_ext;
23977             break;
23978         }
23979         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
23980         {
23981             VkPhysicalDeviceLineRasterizationPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT);
23982             const VkPhysicalDeviceLineRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationPropertiesEXT *)in_header;
23983             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
23984             out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits;
23985             out_header = (void *)out_ext;
23986             break;
23987         }
23988         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
23989         {
23990             VkPhysicalDeviceVulkan11Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
23991             const VkPhysicalDeviceVulkan11Properties *in_ext = (const VkPhysicalDeviceVulkan11Properties *)in_header;
23992             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
23993             memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
23994             memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
23995             memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
23996             out_ext->deviceNodeMask = in_ext->deviceNodeMask;
23997             out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
23998             out_ext->subgroupSize = in_ext->subgroupSize;
23999             out_ext->subgroupSupportedStages = in_ext->subgroupSupportedStages;
24000             out_ext->subgroupSupportedOperations = in_ext->subgroupSupportedOperations;
24001             out_ext->subgroupQuadOperationsInAllStages = in_ext->subgroupQuadOperationsInAllStages;
24002             out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
24003             out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
24004             out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
24005             out_ext->protectedNoFault = in_ext->protectedNoFault;
24006             out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
24007             out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
24008             out_header = (void *)out_ext;
24009             break;
24010         }
24011         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
24012         {
24013             VkPhysicalDeviceVulkan12Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
24014             const VkPhysicalDeviceVulkan12Properties *in_ext = (const VkPhysicalDeviceVulkan12Properties *)in_header;
24015             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
24016             out_ext->driverID = in_ext->driverID;
24017             memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
24018             memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
24019             out_ext->conformanceVersion = in_ext->conformanceVersion;
24020             out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence;
24021             out_ext->roundingModeIndependence = in_ext->roundingModeIndependence;
24022             out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16;
24023             out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32;
24024             out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64;
24025             out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16;
24026             out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32;
24027             out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64;
24028             out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16;
24029             out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32;
24030             out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64;
24031             out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16;
24032             out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32;
24033             out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64;
24034             out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16;
24035             out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32;
24036             out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64;
24037             out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
24038             out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
24039             out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
24040             out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
24041             out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
24042             out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
24043             out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
24044             out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
24045             out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
24046             out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
24047             out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
24048             out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
24049             out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
24050             out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
24051             out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
24052             out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
24053             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
24054             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
24055             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
24056             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
24057             out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
24058             out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
24059             out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
24060             out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
24061             out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
24062             out_ext->independentResolveNone = in_ext->independentResolveNone;
24063             out_ext->independentResolve = in_ext->independentResolve;
24064             out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
24065             out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
24066             out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
24067             out_ext->framebufferIntegerColorSampleCounts = in_ext->framebufferIntegerColorSampleCounts;
24068             out_header = (void *)out_ext;
24069             break;
24070         }
24071         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
24072         {
24073             VkPhysicalDeviceVulkan13Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES);
24074             const VkPhysicalDeviceVulkan13Properties *in_ext = (const VkPhysicalDeviceVulkan13Properties *)in_header;
24075             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
24076             out_ext->minSubgroupSize = in_ext->minSubgroupSize;
24077             out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
24078             out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
24079             out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
24080             out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
24081             out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
24082             out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
24083             out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
24084             out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
24085             out_ext->maxInlineUniformTotalSize = in_ext->maxInlineUniformTotalSize;
24086             out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated;
24087             out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated;
24088             out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated;
24089             out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated;
24090             out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated;
24091             out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
24092             out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated;
24093             out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated;
24094             out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated;
24095             out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated;
24096             out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated;
24097             out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated;
24098             out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated;
24099             out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated;
24100             out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated;
24101             out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
24102             out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
24103             out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
24104             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
24105             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
24106             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
24107             out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
24108             out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
24109             out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
24110             out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
24111             out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
24112             out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
24113             out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
24114             out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
24115             out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
24116             out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
24117             out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
24118             out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
24119             out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
24120             out_ext->maxBufferSize = in_ext->maxBufferSize;
24121             out_header = (void *)out_ext;
24122             break;
24123         }
24124         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
24125         {
24126             VkPhysicalDeviceCustomBorderColorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT);
24127             const VkPhysicalDeviceCustomBorderColorPropertiesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)in_header;
24128             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
24129             out_ext->maxCustomBorderColorSamplers = in_ext->maxCustomBorderColorSamplers;
24130             out_header = (void *)out_ext;
24131             break;
24132         }
24133         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
24134         {
24135             VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT);
24136             const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)in_header;
24137             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
24138             out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted;
24139             out_header = (void *)out_ext;
24140             break;
24141         }
24142         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
24143         {
24144             VkPhysicalDeviceRobustness2PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT);
24145             const VkPhysicalDeviceRobustness2PropertiesEXT *in_ext = (const VkPhysicalDeviceRobustness2PropertiesEXT *)in_header;
24146             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
24147             out_ext->robustStorageBufferAccessSizeAlignment = in_ext->robustStorageBufferAccessSizeAlignment;
24148             out_ext->robustUniformBufferAccessSizeAlignment = in_ext->robustUniformBufferAccessSizeAlignment;
24149             out_header = (void *)out_ext;
24150             break;
24151         }
24152         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
24153         {
24154             VkPhysicalDeviceFragmentShadingRatePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR);
24155             const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)in_header;
24156             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
24157             out_ext->minFragmentShadingRateAttachmentTexelSize = in_ext->minFragmentShadingRateAttachmentTexelSize;
24158             out_ext->maxFragmentShadingRateAttachmentTexelSize = in_ext->maxFragmentShadingRateAttachmentTexelSize;
24159             out_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio = in_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
24160             out_ext->primitiveFragmentShadingRateWithMultipleViewports = in_ext->primitiveFragmentShadingRateWithMultipleViewports;
24161             out_ext->layeredShadingRateAttachments = in_ext->layeredShadingRateAttachments;
24162             out_ext->fragmentShadingRateNonTrivialCombinerOps = in_ext->fragmentShadingRateNonTrivialCombinerOps;
24163             out_ext->maxFragmentSize = in_ext->maxFragmentSize;
24164             out_ext->maxFragmentSizeAspectRatio = in_ext->maxFragmentSizeAspectRatio;
24165             out_ext->maxFragmentShadingRateCoverageSamples = in_ext->maxFragmentShadingRateCoverageSamples;
24166             out_ext->maxFragmentShadingRateRasterizationSamples = in_ext->maxFragmentShadingRateRasterizationSamples;
24167             out_ext->fragmentShadingRateWithShaderDepthStencilWrites = in_ext->fragmentShadingRateWithShaderDepthStencilWrites;
24168             out_ext->fragmentShadingRateWithSampleMask = in_ext->fragmentShadingRateWithSampleMask;
24169             out_ext->fragmentShadingRateWithShaderSampleMask = in_ext->fragmentShadingRateWithShaderSampleMask;
24170             out_ext->fragmentShadingRateWithConservativeRasterization = in_ext->fragmentShadingRateWithConservativeRasterization;
24171             out_ext->fragmentShadingRateWithFragmentShaderInterlock = in_ext->fragmentShadingRateWithFragmentShaderInterlock;
24172             out_ext->fragmentShadingRateWithCustomSampleLocations = in_ext->fragmentShadingRateWithCustomSampleLocations;
24173             out_ext->fragmentShadingRateStrictMultiplyCombiner = in_ext->fragmentShadingRateStrictMultiplyCombiner;
24174             out_header = (void *)out_ext;
24175             break;
24176         }
24177         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
24178         {
24179             VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV);
24180             const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *)in_header;
24181             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
24182             out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount;
24183             out_header = (void *)out_ext;
24184             break;
24185         }
24186         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
24187         {
24188             VkPhysicalDeviceProvokingVertexPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT);
24189             const VkPhysicalDeviceProvokingVertexPropertiesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)in_header;
24190             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
24191             out_ext->provokingVertexModePerPipeline = in_ext->provokingVertexModePerPipeline;
24192             out_ext->transformFeedbackPreservesTriangleFanProvokingVertex = in_ext->transformFeedbackPreservesTriangleFanProvokingVertex;
24193             out_header = (void *)out_ext;
24194             break;
24195         }
24196         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
24197         {
24198             VkPhysicalDeviceDescriptorBufferPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT);
24199             const VkPhysicalDeviceDescriptorBufferPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferPropertiesEXT *)in_header;
24200             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
24201             out_ext->combinedImageSamplerDescriptorSingleArray = in_ext->combinedImageSamplerDescriptorSingleArray;
24202             out_ext->bufferlessPushDescriptors = in_ext->bufferlessPushDescriptors;
24203             out_ext->allowSamplerImageViewPostSubmitCreation = in_ext->allowSamplerImageViewPostSubmitCreation;
24204             out_ext->descriptorBufferOffsetAlignment = in_ext->descriptorBufferOffsetAlignment;
24205             out_ext->maxDescriptorBufferBindings = in_ext->maxDescriptorBufferBindings;
24206             out_ext->maxResourceDescriptorBufferBindings = in_ext->maxResourceDescriptorBufferBindings;
24207             out_ext->maxSamplerDescriptorBufferBindings = in_ext->maxSamplerDescriptorBufferBindings;
24208             out_ext->maxEmbeddedImmutableSamplerBindings = in_ext->maxEmbeddedImmutableSamplerBindings;
24209             out_ext->maxEmbeddedImmutableSamplers = in_ext->maxEmbeddedImmutableSamplers;
24210             out_ext->bufferCaptureReplayDescriptorDataSize = in_ext->bufferCaptureReplayDescriptorDataSize;
24211             out_ext->imageCaptureReplayDescriptorDataSize = in_ext->imageCaptureReplayDescriptorDataSize;
24212             out_ext->imageViewCaptureReplayDescriptorDataSize = in_ext->imageViewCaptureReplayDescriptorDataSize;
24213             out_ext->samplerCaptureReplayDescriptorDataSize = in_ext->samplerCaptureReplayDescriptorDataSize;
24214             out_ext->accelerationStructureCaptureReplayDescriptorDataSize = in_ext->accelerationStructureCaptureReplayDescriptorDataSize;
24215             out_ext->samplerDescriptorSize = in_ext->samplerDescriptorSize;
24216             out_ext->combinedImageSamplerDescriptorSize = in_ext->combinedImageSamplerDescriptorSize;
24217             out_ext->sampledImageDescriptorSize = in_ext->sampledImageDescriptorSize;
24218             out_ext->storageImageDescriptorSize = in_ext->storageImageDescriptorSize;
24219             out_ext->uniformTexelBufferDescriptorSize = in_ext->uniformTexelBufferDescriptorSize;
24220             out_ext->robustUniformTexelBufferDescriptorSize = in_ext->robustUniformTexelBufferDescriptorSize;
24221             out_ext->storageTexelBufferDescriptorSize = in_ext->storageTexelBufferDescriptorSize;
24222             out_ext->robustStorageTexelBufferDescriptorSize = in_ext->robustStorageTexelBufferDescriptorSize;
24223             out_ext->uniformBufferDescriptorSize = in_ext->uniformBufferDescriptorSize;
24224             out_ext->robustUniformBufferDescriptorSize = in_ext->robustUniformBufferDescriptorSize;
24225             out_ext->storageBufferDescriptorSize = in_ext->storageBufferDescriptorSize;
24226             out_ext->robustStorageBufferDescriptorSize = in_ext->robustStorageBufferDescriptorSize;
24227             out_ext->inputAttachmentDescriptorSize = in_ext->inputAttachmentDescriptorSize;
24228             out_ext->accelerationStructureDescriptorSize = in_ext->accelerationStructureDescriptorSize;
24229             out_ext->maxSamplerDescriptorBufferRange = in_ext->maxSamplerDescriptorBufferRange;
24230             out_ext->maxResourceDescriptorBufferRange = in_ext->maxResourceDescriptorBufferRange;
24231             out_ext->samplerDescriptorBufferAddressSpaceSize = in_ext->samplerDescriptorBufferAddressSpaceSize;
24232             out_ext->resourceDescriptorBufferAddressSpaceSize = in_ext->resourceDescriptorBufferAddressSpaceSize;
24233             out_ext->descriptorBufferAddressSpaceSize = in_ext->descriptorBufferAddressSpaceSize;
24234             out_header = (void *)out_ext;
24235             break;
24236         }
24237         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
24238         {
24239             VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT);
24240             const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *)in_header;
24241             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
24242             out_ext->combinedImageSamplerDensityMapDescriptorSize = in_ext->combinedImageSamplerDensityMapDescriptorSize;
24243             out_header = (void *)out_ext;
24244             break;
24245         }
24246         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
24247         {
24248             VkPhysicalDeviceShaderIntegerDotProductProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES);
24249             const VkPhysicalDeviceShaderIntegerDotProductProperties *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductProperties *)in_header;
24250             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
24251             out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated;
24252             out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated;
24253             out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated;
24254             out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated;
24255             out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated;
24256             out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
24257             out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated;
24258             out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated;
24259             out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated;
24260             out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated;
24261             out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated;
24262             out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated;
24263             out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated;
24264             out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated;
24265             out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated;
24266             out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
24267             out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
24268             out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
24269             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
24270             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
24271             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
24272             out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
24273             out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
24274             out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
24275             out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
24276             out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
24277             out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
24278             out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
24279             out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
24280             out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
24281             out_header = (void *)out_ext;
24282             break;
24283         }
24284         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
24285         {
24286             VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR);
24287             const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *)in_header;
24288             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
24289             out_ext->triStripVertexOrderIndependentOfProvokingVertex = in_ext->triStripVertexOrderIndependentOfProvokingVertex;
24290             out_header = (void *)out_ext;
24291             break;
24292         }
24293         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
24294         {
24295             VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT);
24296             const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)in_header;
24297             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
24298             out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking;
24299             out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration;
24300             out_header = (void *)out_ext;
24301             break;
24302         }
24303         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
24304         {
24305             VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT);
24306             const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *)in_header;
24307             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
24308             memcpy(out_ext->shaderModuleIdentifierAlgorithmUUID, in_ext->shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE * sizeof(uint8_t));
24309             out_header = (void *)out_ext;
24310             break;
24311         }
24312         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
24313         {
24314             VkPhysicalDeviceOpacityMicromapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT);
24315             const VkPhysicalDeviceOpacityMicromapPropertiesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapPropertiesEXT *)in_header;
24316             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
24317             out_ext->maxOpacity2StateSubdivisionLevel = in_ext->maxOpacity2StateSubdivisionLevel;
24318             out_ext->maxOpacity4StateSubdivisionLevel = in_ext->maxOpacity4StateSubdivisionLevel;
24319             out_header = (void *)out_ext;
24320             break;
24321         }
24322         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
24323         {
24324             VkPhysicalDevicePipelineRobustnessPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT);
24325             const VkPhysicalDevicePipelineRobustnessPropertiesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessPropertiesEXT *)in_header;
24326             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT;
24327             out_ext->defaultRobustnessStorageBuffers = in_ext->defaultRobustnessStorageBuffers;
24328             out_ext->defaultRobustnessUniformBuffers = in_ext->defaultRobustnessUniformBuffers;
24329             out_ext->defaultRobustnessVertexInputs = in_ext->defaultRobustnessVertexInputs;
24330             out_ext->defaultRobustnessImages = in_ext->defaultRobustnessImages;
24331             out_header = (void *)out_ext;
24332             break;
24333         }
24334         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
24335         {
24336             VkPhysicalDeviceImageProcessingPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM);
24337             const VkPhysicalDeviceImageProcessingPropertiesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingPropertiesQCOM *)in_header;
24338             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
24339             out_ext->maxWeightFilterPhases = in_ext->maxWeightFilterPhases;
24340             out_ext->maxWeightFilterDimension = in_ext->maxWeightFilterDimension;
24341             out_ext->maxBlockMatchRegion = in_ext->maxBlockMatchRegion;
24342             out_ext->maxBoxFilterBlockSize = in_ext->maxBoxFilterBlockSize;
24343             out_header = (void *)out_ext;
24344             break;
24345         }
24346         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
24347         {
24348             VkPhysicalDeviceOpticalFlowPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV);
24349             const VkPhysicalDeviceOpticalFlowPropertiesNV *in_ext = (const VkPhysicalDeviceOpticalFlowPropertiesNV *)in_header;
24350             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
24351             out_ext->supportedOutputGridSizes = in_ext->supportedOutputGridSizes;
24352             out_ext->supportedHintGridSizes = in_ext->supportedHintGridSizes;
24353             out_ext->hintSupported = in_ext->hintSupported;
24354             out_ext->costSupported = in_ext->costSupported;
24355             out_ext->bidirectionalFlowSupported = in_ext->bidirectionalFlowSupported;
24356             out_ext->globalFlowSupported = in_ext->globalFlowSupported;
24357             out_ext->minWidth = in_ext->minWidth;
24358             out_ext->minHeight = in_ext->minHeight;
24359             out_ext->maxWidth = in_ext->maxWidth;
24360             out_ext->maxHeight = in_ext->maxHeight;
24361             out_ext->maxNumRegionsOfInterest = in_ext->maxNumRegionsOfInterest;
24362             out_header = (void *)out_ext;
24363             break;
24364         }
24365         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
24366         {
24367             VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM);
24368             const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *)in_header;
24369             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
24370             out_ext->shaderCoreMask = in_ext->shaderCoreMask;
24371             out_ext->shaderCoreCount = in_ext->shaderCoreCount;
24372             out_ext->shaderWarpsPerCore = in_ext->shaderWarpsPerCore;
24373             out_header = (void *)out_ext;
24374             break;
24375         }
24376         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
24377         {
24378             VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV);
24379             const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *)in_header;
24380             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
24381             out_ext->rayTracingInvocationReorderReorderingHint = in_ext->rayTracingInvocationReorderReorderingHint;
24382             out_header = (void *)out_ext;
24383             break;
24384         }
24385         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
24386         {
24387             VkPhysicalDeviceShaderCorePropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM);
24388             const VkPhysicalDeviceShaderCorePropertiesARM *in_ext = (const VkPhysicalDeviceShaderCorePropertiesARM *)in_header;
24389             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM;
24390             out_ext->pixelRate = in_ext->pixelRate;
24391             out_ext->texelRate = in_ext->texelRate;
24392             out_ext->fmaRate = in_ext->fmaRate;
24393             out_header = (void *)out_ext;
24394             break;
24395         }
24396         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
24397         {
24398             VkPhysicalDeviceShaderObjectPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT);
24399             const VkPhysicalDeviceShaderObjectPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderObjectPropertiesEXT *)in_header;
24400             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
24401             memcpy(out_ext->shaderBinaryUUID, in_ext->shaderBinaryUUID, VK_UUID_SIZE * sizeof(uint8_t));
24402             out_ext->shaderBinaryVersion = in_ext->shaderBinaryVersion;
24403             out_header = (void *)out_ext;
24404             break;
24405         }
24406         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
24407         {
24408             VkPhysicalDeviceShaderTileImagePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT);
24409             const VkPhysicalDeviceShaderTileImagePropertiesEXT *in_ext = (const VkPhysicalDeviceShaderTileImagePropertiesEXT *)in_header;
24410             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
24411             out_ext->shaderTileImageCoherentReadAccelerated = in_ext->shaderTileImageCoherentReadAccelerated;
24412             out_ext->shaderTileImageReadSampleFromPixelRateInvocation = in_ext->shaderTileImageReadSampleFromPixelRateInvocation;
24413             out_ext->shaderTileImageReadFromHelperInvocation = in_ext->shaderTileImageReadFromHelperInvocation;
24414             out_header = (void *)out_ext;
24415             break;
24416         }
24417         default:
24418             break;
24419         }
24420     }
24421 }
24422
24423 static inline void convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(const VkQueryPoolPerformanceCreateInfoKHR32 *in, VkQueryPoolPerformanceCreateInfoKHR *out)
24424 {
24425     if (!in) return;
24426
24427     out->sType = in->sType;
24428     out->pNext = NULL;
24429     out->queueFamilyIndex = in->queueFamilyIndex;
24430     out->counterIndexCount = in->counterIndexCount;
24431     out->pCounterIndices = (const uint32_t *)UlongToPtr(in->pCounterIndices);
24432     if (in->pNext)
24433         FIXME("Unexpected pNext\n");
24434 }
24435
24436 static inline void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, VkQueueFamilyProperties2 *out)
24437 {
24438     const VkBaseInStructure32 *in_header;
24439     VkBaseOutStructure *out_header = (void *)out;
24440
24441     if (!in) return;
24442
24443     out->sType = in->sType;
24444     out->pNext = NULL;
24445
24446     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24447     {
24448         switch (in_header->sType)
24449         {
24450         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
24451         {
24452             VkQueueFamilyGlobalPriorityPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24453             const VkQueueFamilyGlobalPriorityPropertiesKHR32 *in_ext = (const VkQueueFamilyGlobalPriorityPropertiesKHR32 *)in_header;
24454             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
24455             out_ext->pNext = NULL;
24456             out_ext->priorityCount = in_ext->priorityCount;
24457             memcpy(out_ext->priorities, in_ext->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
24458             out_header->pNext = (void *)out_ext;
24459             out_header = (void *)out_ext;
24460             break;
24461         }
24462         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
24463         {
24464             VkQueueFamilyCheckpointPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24465             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
24466             out_ext->pNext = NULL;
24467             out_header->pNext = (void *)out_ext;
24468             out_header = (void *)out_ext;
24469             break;
24470         }
24471         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
24472         {
24473             VkQueueFamilyCheckpointProperties2NV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24474             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
24475             out_ext->pNext = NULL;
24476             out_header->pNext = (void *)out_ext;
24477             out_header = (void *)out_ext;
24478             break;
24479         }
24480         default:
24481             FIXME("Unhandled sType %u.\n", in_header->sType);
24482             break;
24483         }
24484     }
24485 }
24486
24487 static inline void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out)
24488 {
24489     const VkBaseInStructure *in_header;
24490     VkBaseOutStructure32 *out_header = (void *)out;
24491
24492     if (!in) return;
24493
24494     out->queueFamilyProperties = in->queueFamilyProperties;
24495
24496     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
24497     {
24498         switch (in_header->sType)
24499         {
24500         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
24501         {
24502             VkQueueFamilyGlobalPriorityPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR);
24503             const VkQueueFamilyGlobalPriorityPropertiesKHR *in_ext = (const VkQueueFamilyGlobalPriorityPropertiesKHR *)in_header;
24504             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
24505             out_ext->priorityCount = in_ext->priorityCount;
24506             memcpy(out_ext->priorities, in_ext->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
24507             out_header = (void *)out_ext;
24508             break;
24509         }
24510         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
24511         {
24512             VkQueueFamilyCheckpointPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV);
24513             const VkQueueFamilyCheckpointPropertiesNV *in_ext = (const VkQueueFamilyCheckpointPropertiesNV *)in_header;
24514             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
24515             out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask;
24516             out_header = (void *)out_ext;
24517             break;
24518         }
24519         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
24520         {
24521             VkQueueFamilyCheckpointProperties2NV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV);
24522             const VkQueueFamilyCheckpointProperties2NV *in_ext = (const VkQueueFamilyCheckpointProperties2NV *)in_header;
24523             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
24524             out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask;
24525             out_header = (void *)out_ext;
24526             break;
24527         }
24528         default:
24529             break;
24530         }
24531     }
24532 }
24533
24534 static inline VkQueueFamilyProperties2 *convert_VkQueueFamilyProperties2_array_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, uint32_t count)
24535 {
24536     VkQueueFamilyProperties2 *out;
24537     unsigned int i;
24538
24539     if (!in || !count) return NULL;
24540
24541     out = conversion_context_alloc(ctx, count * sizeof(*out));
24542     for (i = 0; i < count; i++)
24543     {
24544         convert_VkQueueFamilyProperties2_win32_to_host(ctx, &in[i], &out[i]);
24545     }
24546
24547     return out;
24548 }
24549
24550 static inline void convert_VkQueueFamilyProperties2_array_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out, uint32_t count)
24551 {
24552     unsigned int i;
24553
24554     if (!in) return;
24555
24556     for (i = 0; i < count; i++)
24557     {
24558         convert_VkQueueFamilyProperties2_host_to_win32(&in[i], &out[i]);
24559     }
24560 }
24561
24562 static inline void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(const VkPhysicalDeviceSparseImageFormatInfo232 *in, VkPhysicalDeviceSparseImageFormatInfo2 *out)
24563 {
24564     if (!in) return;
24565
24566     out->sType = in->sType;
24567     out->pNext = NULL;
24568     out->format = in->format;
24569     out->type = in->type;
24570     out->samples = in->samples;
24571     out->usage = in->usage;
24572     out->tiling = in->tiling;
24573     if (in->pNext)
24574         FIXME("Unexpected pNext\n");
24575 }
24576
24577 static inline void convert_VkSparseImageFormatProperties2_win32_to_host(const VkSparseImageFormatProperties232 *in, VkSparseImageFormatProperties2 *out)
24578 {
24579     if (!in) return;
24580
24581     out->sType = in->sType;
24582     out->pNext = NULL;
24583     if (in->pNext)
24584         FIXME("Unexpected pNext\n");
24585 }
24586
24587 static inline void convert_VkSparseImageFormatProperties2_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out)
24588 {
24589     if (!in) return;
24590
24591     out->properties = in->properties;
24592 }
24593
24594 static inline VkSparseImageFormatProperties2 *convert_VkSparseImageFormatProperties2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageFormatProperties232 *in, uint32_t count)
24595 {
24596     VkSparseImageFormatProperties2 *out;
24597     unsigned int i;
24598
24599     if (!in || !count) return NULL;
24600
24601     out = conversion_context_alloc(ctx, count * sizeof(*out));
24602     for (i = 0; i < count; i++)
24603     {
24604         convert_VkSparseImageFormatProperties2_win32_to_host(&in[i], &out[i]);
24605     }
24606
24607     return out;
24608 }
24609
24610 static inline void convert_VkSparseImageFormatProperties2_array_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out, uint32_t count)
24611 {
24612     unsigned int i;
24613
24614     if (!in) return;
24615
24616     for (i = 0; i < count; i++)
24617     {
24618         convert_VkSparseImageFormatProperties2_host_to_win32(&in[i], &out[i]);
24619     }
24620 }
24621
24622 static inline void convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(const VkFramebufferMixedSamplesCombinationNV32 *in, VkFramebufferMixedSamplesCombinationNV *out)
24623 {
24624     if (!in) return;
24625
24626     out->sType = in->sType;
24627     out->pNext = NULL;
24628     if (in->pNext)
24629         FIXME("Unexpected pNext\n");
24630 }
24631
24632 static inline void convert_VkFramebufferMixedSamplesCombinationNV_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out)
24633 {
24634     if (!in) return;
24635
24636     out->coverageReductionMode = in->coverageReductionMode;
24637     out->rasterizationSamples = in->rasterizationSamples;
24638     out->depthStencilSamples = in->depthStencilSamples;
24639     out->colorSamples = in->colorSamples;
24640 }
24641
24642 static inline VkFramebufferMixedSamplesCombinationNV *convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferMixedSamplesCombinationNV32 *in, uint32_t count)
24643 {
24644     VkFramebufferMixedSamplesCombinationNV *out;
24645     unsigned int i;
24646
24647     if (!in || !count) return NULL;
24648
24649     out = conversion_context_alloc(ctx, count * sizeof(*out));
24650     for (i = 0; i < count; i++)
24651     {
24652         convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(&in[i], &out[i]);
24653     }
24654
24655     return out;
24656 }
24657
24658 static inline void convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out, uint32_t count)
24659 {
24660     unsigned int i;
24661
24662     if (!in) return;
24663
24664     for (i = 0; i < count; i++)
24665     {
24666         convert_VkFramebufferMixedSamplesCombinationNV_host_to_win32(&in[i], &out[i]);
24667     }
24668 }
24669
24670 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
24671 {
24672     const VkBaseInStructure32 *in_header;
24673     VkBaseOutStructure *out_header = (void *)out;
24674
24675     if (!in) return;
24676
24677     out->sType = in->sType;
24678     out->pNext = NULL;
24679     out->surface = in->surface;
24680
24681     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24682     {
24683         switch (in_header->sType)
24684         {
24685         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
24686         {
24687             VkSurfacePresentModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24688             const VkSurfacePresentModeEXT32 *in_ext = (const VkSurfacePresentModeEXT32 *)in_header;
24689             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT;
24690             out_ext->pNext = NULL;
24691             out_ext->presentMode = in_ext->presentMode;
24692             out_header->pNext = (void *)out_ext;
24693             out_header = (void *)out_ext;
24694             break;
24695         }
24696         default:
24697             FIXME("Unhandled sType %u.\n", in_header->sType);
24698             break;
24699         }
24700     }
24701 }
24702
24703 static inline void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceCapabilities2KHR32 *in, VkSurfaceCapabilities2KHR *out)
24704 {
24705     const VkBaseInStructure32 *in_header;
24706     VkBaseOutStructure *out_header = (void *)out;
24707
24708     if (!in) return;
24709
24710     out->sType = in->sType;
24711     out->pNext = NULL;
24712
24713     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24714     {
24715         switch (in_header->sType)
24716         {
24717         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
24718         {
24719             VkSurfaceCapabilitiesPresentBarrierNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24720             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV;
24721             out_ext->pNext = NULL;
24722             out_header->pNext = (void *)out_ext;
24723             out_header = (void *)out_ext;
24724             break;
24725         }
24726         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
24727         {
24728             VkSurfacePresentScalingCapabilitiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24729             const VkSurfacePresentScalingCapabilitiesEXT32 *in_ext = (const VkSurfacePresentScalingCapabilitiesEXT32 *)in_header;
24730             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT;
24731             out_ext->pNext = NULL;
24732             out_ext->supportedPresentScaling = in_ext->supportedPresentScaling;
24733             out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX;
24734             out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY;
24735             out_ext->minScaledImageExtent = in_ext->minScaledImageExtent;
24736             out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent;
24737             out_header->pNext = (void *)out_ext;
24738             out_header = (void *)out_ext;
24739             break;
24740         }
24741         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
24742         {
24743             VkSurfacePresentModeCompatibilityEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24744             const VkSurfacePresentModeCompatibilityEXT32 *in_ext = (const VkSurfacePresentModeCompatibilityEXT32 *)in_header;
24745             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT;
24746             out_ext->pNext = NULL;
24747             out_ext->presentModeCount = in_ext->presentModeCount;
24748             out_ext->pPresentModes = (VkPresentModeKHR *)UlongToPtr(in_ext->pPresentModes);
24749             out_header->pNext = (void *)out_ext;
24750             out_header = (void *)out_ext;
24751             break;
24752         }
24753         default:
24754             FIXME("Unhandled sType %u.\n", in_header->sType);
24755             break;
24756         }
24757     }
24758 }
24759
24760 static inline void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapabilities2KHR *in, VkSurfaceCapabilities2KHR32 *out)
24761 {
24762     const VkBaseInStructure *in_header;
24763     VkBaseOutStructure32 *out_header = (void *)out;
24764
24765     if (!in) return;
24766
24767     out->surfaceCapabilities = in->surfaceCapabilities;
24768
24769     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
24770     {
24771         switch (in_header->sType)
24772         {
24773         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
24774         {
24775             VkSurfaceCapabilitiesPresentBarrierNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV);
24776             const VkSurfaceCapabilitiesPresentBarrierNV *in_ext = (const VkSurfaceCapabilitiesPresentBarrierNV *)in_header;
24777             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV;
24778             out_ext->presentBarrierSupported = in_ext->presentBarrierSupported;
24779             out_header = (void *)out_ext;
24780             break;
24781         }
24782         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
24783         {
24784             VkSurfacePresentScalingCapabilitiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT);
24785             const VkSurfacePresentScalingCapabilitiesEXT *in_ext = (const VkSurfacePresentScalingCapabilitiesEXT *)in_header;
24786             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT;
24787             out_ext->supportedPresentScaling = in_ext->supportedPresentScaling;
24788             out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX;
24789             out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY;
24790             out_ext->minScaledImageExtent = in_ext->minScaledImageExtent;
24791             out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent;
24792             out_header = (void *)out_ext;
24793             break;
24794         }
24795         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
24796         {
24797             VkSurfacePresentModeCompatibilityEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT);
24798             const VkSurfacePresentModeCompatibilityEXT *in_ext = (const VkSurfacePresentModeCompatibilityEXT *)in_header;
24799             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT;
24800             out_ext->presentModeCount = in_ext->presentModeCount;
24801             out_ext->pPresentModes = PtrToUlong(in_ext->pPresentModes);
24802             out_header = (void *)out_ext;
24803             break;
24804         }
24805         default:
24806             break;
24807         }
24808     }
24809 }
24810
24811 #ifdef _WIN64
24812 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win64_to_host(const VkPhysicalDeviceSurfaceInfo2KHR *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
24813 {
24814     if (!in) return;
24815
24816     out->sType = in->sType;
24817     out->pNext = in->pNext;
24818     out->surface = in->surface ? wine_surface_from_handle(in->surface)->driver_surface : 0;
24819 }
24820 #endif /* _WIN64 */
24821
24822 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
24823 {
24824     const VkBaseInStructure32 *in_header;
24825     VkBaseOutStructure *out_header = (void *)out;
24826
24827     if (!in) return;
24828
24829     out->sType = in->sType;
24830     out->pNext = NULL;
24831     out->surface = in->surface ? wine_surface_from_handle(in->surface)->driver_surface : 0;
24832
24833     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24834     {
24835         switch (in_header->sType)
24836         {
24837         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
24838         {
24839             VkSurfacePresentModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24840             const VkSurfacePresentModeEXT32 *in_ext = (const VkSurfacePresentModeEXT32 *)in_header;
24841             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT;
24842             out_ext->pNext = NULL;
24843             out_ext->presentMode = in_ext->presentMode;
24844             out_header->pNext = (void *)out_ext;
24845             out_header = (void *)out_ext;
24846             break;
24847         }
24848         default:
24849             FIXME("Unhandled sType %u.\n", in_header->sType);
24850             break;
24851         }
24852     }
24853 }
24854
24855 static inline void convert_VkSurfaceFormat2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, VkSurfaceFormat2KHR *out)
24856 {
24857     const VkBaseInStructure32 *in_header;
24858     VkBaseOutStructure *out_header = (void *)out;
24859
24860     if (!in) return;
24861
24862     out->sType = in->sType;
24863     out->pNext = NULL;
24864
24865     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24866     {
24867         switch (in_header->sType)
24868         {
24869         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
24870         {
24871             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24872             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
24873             out_ext->pNext = NULL;
24874             out_header->pNext = (void *)out_ext;
24875             out_header = (void *)out_ext;
24876             break;
24877         }
24878         default:
24879             FIXME("Unhandled sType %u.\n", in_header->sType);
24880             break;
24881         }
24882     }
24883 }
24884
24885 static inline void convert_VkSurfaceFormat2KHR_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out)
24886 {
24887     const VkBaseInStructure *in_header;
24888     VkBaseOutStructure32 *out_header = (void *)out;
24889
24890     if (!in) return;
24891
24892     out->surfaceFormat = in->surfaceFormat;
24893
24894     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
24895     {
24896         switch (in_header->sType)
24897         {
24898         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
24899         {
24900             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
24901             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
24902             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
24903             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
24904             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
24905             out_header = (void *)out_ext;
24906             break;
24907         }
24908         default:
24909             break;
24910         }
24911     }
24912 }
24913
24914 static inline VkSurfaceFormat2KHR *convert_VkSurfaceFormat2KHR_array_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, uint32_t count)
24915 {
24916     VkSurfaceFormat2KHR *out;
24917     unsigned int i;
24918
24919     if (!in || !count) return NULL;
24920
24921     out = conversion_context_alloc(ctx, count * sizeof(*out));
24922     for (i = 0; i < count; i++)
24923     {
24924         convert_VkSurfaceFormat2KHR_win32_to_host(ctx, &in[i], &out[i]);
24925     }
24926
24927     return out;
24928 }
24929
24930 static inline void convert_VkSurfaceFormat2KHR_array_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out, uint32_t count)
24931 {
24932     unsigned int i;
24933
24934     if (!in) return;
24935
24936     for (i = 0; i < count; i++)
24937     {
24938         convert_VkSurfaceFormat2KHR_host_to_win32(&in[i], &out[i]);
24939     }
24940 }
24941
24942 static inline void convert_VkPhysicalDeviceToolProperties_win32_to_host(const VkPhysicalDeviceToolProperties32 *in, VkPhysicalDeviceToolProperties *out)
24943 {
24944     if (!in) return;
24945
24946     out->sType = in->sType;
24947     out->pNext = NULL;
24948     if (in->pNext)
24949         FIXME("Unexpected pNext\n");
24950 }
24951
24952 static inline void convert_VkPhysicalDeviceToolProperties_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out)
24953 {
24954     if (!in) return;
24955
24956     memcpy(out->name, in->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
24957     memcpy(out->version, in->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
24958     out->purposes = in->purposes;
24959     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
24960     memcpy(out->layer, in->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
24961 }
24962
24963 static inline VkPhysicalDeviceToolProperties *convert_VkPhysicalDeviceToolProperties_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceToolProperties32 *in, uint32_t count)
24964 {
24965     VkPhysicalDeviceToolProperties *out;
24966     unsigned int i;
24967
24968     if (!in || !count) return NULL;
24969
24970     out = conversion_context_alloc(ctx, count * sizeof(*out));
24971     for (i = 0; i < count; i++)
24972     {
24973         convert_VkPhysicalDeviceToolProperties_win32_to_host(&in[i], &out[i]);
24974     }
24975
24976     return out;
24977 }
24978
24979 static inline void convert_VkPhysicalDeviceToolProperties_array_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out, uint32_t count)
24980 {
24981     unsigned int i;
24982
24983     if (!in) return;
24984
24985     for (i = 0; i < count; i++)
24986     {
24987         convert_VkPhysicalDeviceToolProperties_host_to_win32(&in[i], &out[i]);
24988     }
24989 }
24990
24991 static inline void convert_VkPipelineExecutableInfoKHR_win32_to_host(const VkPipelineExecutableInfoKHR32 *in, VkPipelineExecutableInfoKHR *out)
24992 {
24993     if (!in) return;
24994
24995     out->sType = in->sType;
24996     out->pNext = NULL;
24997     out->pipeline = in->pipeline;
24998     out->executableIndex = in->executableIndex;
24999     if (in->pNext)
25000         FIXME("Unexpected pNext\n");
25001 }
25002
25003 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_win32_to_host(const VkPipelineExecutableInternalRepresentationKHR32 *in, VkPipelineExecutableInternalRepresentationKHR *out)
25004 {
25005     if (!in) return;
25006
25007     out->sType = in->sType;
25008     out->pNext = NULL;
25009     if (in->pNext)
25010         FIXME("Unexpected pNext\n");
25011 }
25012
25013 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out)
25014 {
25015     if (!in) return;
25016
25017     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
25018     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
25019     out->isText = in->isText;
25020     out->dataSize = in->dataSize;
25021     out->pData = PtrToUlong(in->pData);
25022 }
25023
25024 static inline VkPipelineExecutableInternalRepresentationKHR *convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableInternalRepresentationKHR32 *in, uint32_t count)
25025 {
25026     VkPipelineExecutableInternalRepresentationKHR *out;
25027     unsigned int i;
25028
25029     if (!in || !count) return NULL;
25030
25031     out = conversion_context_alloc(ctx, count * sizeof(*out));
25032     for (i = 0; i < count; i++)
25033     {
25034         convert_VkPipelineExecutableInternalRepresentationKHR_win32_to_host(&in[i], &out[i]);
25035     }
25036
25037     return out;
25038 }
25039
25040 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out, uint32_t count)
25041 {
25042     unsigned int i;
25043
25044     if (!in) return;
25045
25046     for (i = 0; i < count; i++)
25047     {
25048         convert_VkPipelineExecutableInternalRepresentationKHR_host_to_win32(&in[i], &out[i]);
25049     }
25050 }
25051
25052 static inline void convert_VkPipelineInfoKHR_win32_to_host(const VkPipelineInfoKHR32 *in, VkPipelineInfoKHR *out)
25053 {
25054     if (!in) return;
25055
25056     out->sType = in->sType;
25057     out->pNext = NULL;
25058     out->pipeline = in->pipeline;
25059     if (in->pNext)
25060         FIXME("Unexpected pNext\n");
25061 }
25062
25063 static inline void convert_VkPipelineExecutablePropertiesKHR_win32_to_host(const VkPipelineExecutablePropertiesKHR32 *in, VkPipelineExecutablePropertiesKHR *out)
25064 {
25065     if (!in) return;
25066
25067     out->sType = in->sType;
25068     out->pNext = NULL;
25069     if (in->pNext)
25070         FIXME("Unexpected pNext\n");
25071 }
25072
25073 static inline void convert_VkPipelineExecutablePropertiesKHR_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out)
25074 {
25075     if (!in) return;
25076
25077     out->stages = in->stages;
25078     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
25079     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
25080     out->subgroupSize = in->subgroupSize;
25081 }
25082
25083 static inline VkPipelineExecutablePropertiesKHR *convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutablePropertiesKHR32 *in, uint32_t count)
25084 {
25085     VkPipelineExecutablePropertiesKHR *out;
25086     unsigned int i;
25087
25088     if (!in || !count) return NULL;
25089
25090     out = conversion_context_alloc(ctx, count * sizeof(*out));
25091     for (i = 0; i < count; i++)
25092     {
25093         convert_VkPipelineExecutablePropertiesKHR_win32_to_host(&in[i], &out[i]);
25094     }
25095
25096     return out;
25097 }
25098
25099 static inline void convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out, uint32_t count)
25100 {
25101     unsigned int i;
25102
25103     if (!in) return;
25104
25105     for (i = 0; i < count; i++)
25106     {
25107         convert_VkPipelineExecutablePropertiesKHR_host_to_win32(&in[i], &out[i]);
25108     }
25109 }
25110
25111 static inline void convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(const VkPipelineExecutableStatisticValueKHR *in, VkPipelineExecutableStatisticValueKHR32 *out, VkFlags selector)
25112 {
25113     if (!in) return;
25114
25115     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR)
25116         out->b32 = in->b32;
25117     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR)
25118         out->i64 = in->i64;
25119     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR)
25120         out->u64 = in->u64;
25121     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR)
25122         out->f64 = in->f64;
25123 }
25124
25125 static inline void convert_VkPipelineExecutableStatisticKHR_win32_to_host(const VkPipelineExecutableStatisticKHR32 *in, VkPipelineExecutableStatisticKHR *out)
25126 {
25127     if (!in) return;
25128
25129     out->sType = in->sType;
25130     out->pNext = NULL;
25131     if (in->pNext)
25132         FIXME("Unexpected pNext\n");
25133 }
25134
25135 static inline void convert_VkPipelineExecutableStatisticKHR_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out)
25136 {
25137     if (!in) return;
25138
25139     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
25140     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
25141     out->format = in->format;
25142     convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(&in->value, &out->value, in->format);
25143 }
25144
25145 static inline VkPipelineExecutableStatisticKHR *convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableStatisticKHR32 *in, uint32_t count)
25146 {
25147     VkPipelineExecutableStatisticKHR *out;
25148     unsigned int i;
25149
25150     if (!in || !count) return NULL;
25151
25152     out = conversion_context_alloc(ctx, count * sizeof(*out));
25153     for (i = 0; i < count; i++)
25154     {
25155         convert_VkPipelineExecutableStatisticKHR_win32_to_host(&in[i], &out[i]);
25156     }
25157
25158     return out;
25159 }
25160
25161 static inline void convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out, uint32_t count)
25162 {
25163     unsigned int i;
25164
25165     if (!in) return;
25166
25167     for (i = 0; i < count; i++)
25168     {
25169         convert_VkPipelineExecutableStatisticKHR_host_to_win32(&in[i], &out[i]);
25170     }
25171 }
25172
25173 static inline void convert_VkPipelineInfoEXT_win32_to_host(const VkPipelineInfoEXT32 *in, VkPipelineInfoEXT *out)
25174 {
25175     if (!in) return;
25176
25177     out->sType = in->sType;
25178     out->pNext = NULL;
25179     out->pipeline = in->pipeline;
25180     if (in->pNext)
25181         FIXME("Unexpected pNext\n");
25182 }
25183
25184 static inline void convert_VkCheckpointData2NV_win32_to_host(const VkCheckpointData2NV32 *in, VkCheckpointData2NV *out)
25185 {
25186     if (!in) return;
25187
25188     out->sType = in->sType;
25189     out->pNext = NULL;
25190     if (in->pNext)
25191         FIXME("Unexpected pNext\n");
25192 }
25193
25194 static inline void convert_VkCheckpointData2NV_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out)
25195 {
25196     if (!in) return;
25197
25198     out->stage = in->stage;
25199     out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker);
25200 }
25201
25202 static inline VkCheckpointData2NV *convert_VkCheckpointData2NV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointData2NV32 *in, uint32_t count)
25203 {
25204     VkCheckpointData2NV *out;
25205     unsigned int i;
25206
25207     if (!in || !count) return NULL;
25208
25209     out = conversion_context_alloc(ctx, count * sizeof(*out));
25210     for (i = 0; i < count; i++)
25211     {
25212         convert_VkCheckpointData2NV_win32_to_host(&in[i], &out[i]);
25213     }
25214
25215     return out;
25216 }
25217
25218 static inline void convert_VkCheckpointData2NV_array_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out, uint32_t count)
25219 {
25220     unsigned int i;
25221
25222     if (!in) return;
25223
25224     for (i = 0; i < count; i++)
25225     {
25226         convert_VkCheckpointData2NV_host_to_win32(&in[i], &out[i]);
25227     }
25228 }
25229
25230 static inline void convert_VkCheckpointDataNV_win32_to_host(const VkCheckpointDataNV32 *in, VkCheckpointDataNV *out)
25231 {
25232     if (!in) return;
25233
25234     out->sType = in->sType;
25235     out->pNext = NULL;
25236     if (in->pNext)
25237         FIXME("Unexpected pNext\n");
25238 }
25239
25240 static inline void convert_VkCheckpointDataNV_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out)
25241 {
25242     if (!in) return;
25243
25244     out->stage = in->stage;
25245     out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker);
25246 }
25247
25248 static inline VkCheckpointDataNV *convert_VkCheckpointDataNV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointDataNV32 *in, uint32_t count)
25249 {
25250     VkCheckpointDataNV *out;
25251     unsigned int i;
25252
25253     if (!in || !count) return NULL;
25254
25255     out = conversion_context_alloc(ctx, count * sizeof(*out));
25256     for (i = 0; i < count; i++)
25257     {
25258         convert_VkCheckpointDataNV_win32_to_host(&in[i], &out[i]);
25259     }
25260
25261     return out;
25262 }
25263
25264 static inline void convert_VkCheckpointDataNV_array_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out, uint32_t count)
25265 {
25266     unsigned int i;
25267
25268     if (!in) return;
25269
25270     for (i = 0; i < count; i++)
25271     {
25272         convert_VkCheckpointDataNV_host_to_win32(&in[i], &out[i]);
25273     }
25274 }
25275
25276 static inline void convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host(const VkSamplerCaptureDescriptorDataInfoEXT32 *in, VkSamplerCaptureDescriptorDataInfoEXT *out)
25277 {
25278     if (!in) return;
25279
25280     out->sType = in->sType;
25281     out->pNext = NULL;
25282     out->sampler = in->sampler;
25283     if (in->pNext)
25284         FIXME("Unexpected pNext\n");
25285 }
25286
25287 static inline void convert_VkShaderModuleIdentifierEXT_win32_to_host(const VkShaderModuleIdentifierEXT32 *in, VkShaderModuleIdentifierEXT *out)
25288 {
25289     if (!in) return;
25290
25291     out->sType = in->sType;
25292     out->pNext = NULL;
25293     if (in->pNext)
25294         FIXME("Unexpected pNext\n");
25295 }
25296
25297 static inline void convert_VkShaderModuleIdentifierEXT_host_to_win32(const VkShaderModuleIdentifierEXT *in, VkShaderModuleIdentifierEXT32 *out)
25298 {
25299     if (!in) return;
25300
25301     out->identifierSize = in->identifierSize;
25302     memcpy(out->identifier, in->identifier, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t));
25303 }
25304
25305 static inline void convert_VkInitializePerformanceApiInfoINTEL_win32_to_host(const VkInitializePerformanceApiInfoINTEL32 *in, VkInitializePerformanceApiInfoINTEL *out)
25306 {
25307     if (!in) return;
25308
25309     out->sType = in->sType;
25310     out->pNext = NULL;
25311     out->pUserData = (void *)UlongToPtr(in->pUserData);
25312     if (in->pNext)
25313         FIXME("Unexpected pNext\n");
25314 }
25315
25316 static inline void convert_VkMemoryMapInfoKHR_win32_to_unwrapped_host(const VkMemoryMapInfoKHR32 *in, VkMemoryMapInfoKHR *out)
25317 {
25318     if (!in) return;
25319
25320     out->sType = in->sType;
25321     out->pNext = NULL;
25322     out->flags = in->flags;
25323     out->memory = in->memory;
25324     out->offset = in->offset;
25325     out->size = in->size;
25326     if (in->pNext)
25327         FIXME("Unexpected pNext\n");
25328 }
25329
25330 #ifdef _WIN64
25331 static inline void convert_VkSparseMemoryBind_win64_to_host(const VkSparseMemoryBind *in, VkSparseMemoryBind *out)
25332 {
25333     if (!in) return;
25334
25335     out->resourceOffset = in->resourceOffset;
25336     out->size = in->size;
25337     out->memory = in->memory ? wine_device_memory_from_handle(in->memory)->memory : 0;
25338     out->memoryOffset = in->memoryOffset;
25339     out->flags = in->flags;
25340 }
25341 #endif /* _WIN64 */
25342
25343 static inline void convert_VkSparseMemoryBind_win32_to_host(const VkSparseMemoryBind32 *in, VkSparseMemoryBind *out)
25344 {
25345     if (!in) return;
25346
25347     out->resourceOffset = in->resourceOffset;
25348     out->size = in->size;
25349     out->memory = in->memory ? wine_device_memory_from_handle(in->memory)->memory : 0;
25350     out->memoryOffset = in->memoryOffset;
25351     out->flags = in->flags;
25352 }
25353
25354 #ifdef _WIN64
25355 static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win64_to_host(struct conversion_context *ctx, const VkSparseMemoryBind *in, uint32_t count)
25356 {
25357     VkSparseMemoryBind *out;
25358     unsigned int i;
25359
25360     if (!in || !count) return NULL;
25361
25362     out = conversion_context_alloc(ctx, count * sizeof(*out));
25363     for (i = 0; i < count; i++)
25364     {
25365         convert_VkSparseMemoryBind_win64_to_host(&in[i], &out[i]);
25366     }
25367
25368     return out;
25369 }
25370 #endif /* _WIN64 */
25371
25372 static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseMemoryBind32 *in, uint32_t count)
25373 {
25374     VkSparseMemoryBind *out;
25375     unsigned int i;
25376
25377     if (!in || !count) return NULL;
25378
25379     out = conversion_context_alloc(ctx, count * sizeof(*out));
25380     for (i = 0; i < count; i++)
25381     {
25382         convert_VkSparseMemoryBind_win32_to_host(&in[i], &out[i]);
25383     }
25384
25385     return out;
25386 }
25387
25388 #ifdef _WIN64
25389 static inline void convert_VkSparseBufferMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, VkSparseBufferMemoryBindInfo *out)
25390 {
25391     if (!in) return;
25392
25393     out->buffer = in->buffer;
25394     out->bindCount = in->bindCount;
25395     out->pBinds = convert_VkSparseMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount);
25396 }
25397 #endif /* _WIN64 */
25398
25399 static inline void convert_VkSparseBufferMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, VkSparseBufferMemoryBindInfo *out)
25400 {
25401     if (!in) return;
25402
25403     out->buffer = in->buffer;
25404     out->bindCount = in->bindCount;
25405     out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
25406 }
25407
25408 #ifdef _WIN64
25409 static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, uint32_t count)
25410 {
25411     VkSparseBufferMemoryBindInfo *out;
25412     unsigned int i;
25413
25414     if (!in || !count) return NULL;
25415
25416     out = conversion_context_alloc(ctx, count * sizeof(*out));
25417     for (i = 0; i < count; i++)
25418     {
25419         convert_VkSparseBufferMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
25420     }
25421
25422     return out;
25423 }
25424 #endif /* _WIN64 */
25425
25426 static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, uint32_t count)
25427 {
25428     VkSparseBufferMemoryBindInfo *out;
25429     unsigned int i;
25430
25431     if (!in || !count) return NULL;
25432
25433     out = conversion_context_alloc(ctx, count * sizeof(*out));
25434     for (i = 0; i < count; i++)
25435     {
25436         convert_VkSparseBufferMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
25437     }
25438
25439     return out;
25440 }
25441
25442 #ifdef _WIN64
25443 static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, VkSparseImageOpaqueMemoryBindInfo *out)
25444 {
25445     if (!in) return;
25446
25447     out->image = in->image;
25448     out->bindCount = in->bindCount;
25449     out->pBinds = convert_VkSparseMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount);
25450 }
25451 #endif /* _WIN64 */
25452
25453 static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, VkSparseImageOpaqueMemoryBindInfo *out)
25454 {
25455     if (!in) return;
25456
25457     out->image = in->image;
25458     out->bindCount = in->bindCount;
25459     out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
25460 }
25461
25462 #ifdef _WIN64
25463 static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, uint32_t count)
25464 {
25465     VkSparseImageOpaqueMemoryBindInfo *out;
25466     unsigned int i;
25467
25468     if (!in || !count) return NULL;
25469
25470     out = conversion_context_alloc(ctx, count * sizeof(*out));
25471     for (i = 0; i < count; i++)
25472     {
25473         convert_VkSparseImageOpaqueMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
25474     }
25475
25476     return out;
25477 }
25478 #endif /* _WIN64 */
25479
25480 static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, uint32_t count)
25481 {
25482     VkSparseImageOpaqueMemoryBindInfo *out;
25483     unsigned int i;
25484
25485     if (!in || !count) return NULL;
25486
25487     out = conversion_context_alloc(ctx, count * sizeof(*out));
25488     for (i = 0; i < count; i++)
25489     {
25490         convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
25491     }
25492
25493     return out;
25494 }
25495
25496 #ifdef _WIN64
25497 static inline void convert_VkSparseImageMemoryBind_win64_to_host(const VkSparseImageMemoryBind *in, VkSparseImageMemoryBind *out)
25498 {
25499     if (!in) return;
25500
25501     out->subresource = in->subresource;
25502     out->offset = in->offset;
25503     out->extent = in->extent;
25504     out->memory = in->memory ? wine_device_memory_from_handle(in->memory)->memory : 0;
25505     out->memoryOffset = in->memoryOffset;
25506     out->flags = in->flags;
25507 }
25508 #endif /* _WIN64 */
25509
25510 static inline void convert_VkSparseImageMemoryBind_win32_to_host(const VkSparseImageMemoryBind32 *in, VkSparseImageMemoryBind *out)
25511 {
25512     if (!in) return;
25513
25514     out->subresource = in->subresource;
25515     out->offset = in->offset;
25516     out->extent = in->extent;
25517     out->memory = in->memory ? wine_device_memory_from_handle(in->memory)->memory : 0;
25518     out->memoryOffset = in->memoryOffset;
25519     out->flags = in->flags;
25520 }
25521
25522 #ifdef _WIN64
25523 static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind *in, uint32_t count)
25524 {
25525     VkSparseImageMemoryBind *out;
25526     unsigned int i;
25527
25528     if (!in || !count) return NULL;
25529
25530     out = conversion_context_alloc(ctx, count * sizeof(*out));
25531     for (i = 0; i < count; i++)
25532     {
25533         convert_VkSparseImageMemoryBind_win64_to_host(&in[i], &out[i]);
25534     }
25535
25536     return out;
25537 }
25538 #endif /* _WIN64 */
25539
25540 static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind32 *in, uint32_t count)
25541 {
25542     VkSparseImageMemoryBind *out;
25543     unsigned int i;
25544
25545     if (!in || !count) return NULL;
25546
25547     out = conversion_context_alloc(ctx, count * sizeof(*out));
25548     for (i = 0; i < count; i++)
25549     {
25550         convert_VkSparseImageMemoryBind_win32_to_host(&in[i], &out[i]);
25551     }
25552
25553     return out;
25554 }
25555
25556 #ifdef _WIN64
25557 static inline void convert_VkSparseImageMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, VkSparseImageMemoryBindInfo *out)
25558 {
25559     if (!in) return;
25560
25561     out->image = in->image;
25562     out->bindCount = in->bindCount;
25563     out->pBinds = convert_VkSparseImageMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount);
25564 }
25565 #endif /* _WIN64 */
25566
25567 static inline void convert_VkSparseImageMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, VkSparseImageMemoryBindInfo *out)
25568 {
25569     if (!in) return;
25570
25571     out->image = in->image;
25572     out->bindCount = in->bindCount;
25573     out->pBinds = convert_VkSparseImageMemoryBind_array_win32_to_host(ctx, (const VkSparseImageMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
25574 }
25575
25576 #ifdef _WIN64
25577 static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, uint32_t count)
25578 {
25579     VkSparseImageMemoryBindInfo *out;
25580     unsigned int i;
25581
25582     if (!in || !count) return NULL;
25583
25584     out = conversion_context_alloc(ctx, count * sizeof(*out));
25585     for (i = 0; i < count; i++)
25586     {
25587         convert_VkSparseImageMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]);
25588     }
25589
25590     return out;
25591 }
25592 #endif /* _WIN64 */
25593
25594 static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, uint32_t count)
25595 {
25596     VkSparseImageMemoryBindInfo *out;
25597     unsigned int i;
25598
25599     if (!in || !count) return NULL;
25600
25601     out = conversion_context_alloc(ctx, count * sizeof(*out));
25602     for (i = 0; i < count; i++)
25603     {
25604         convert_VkSparseImageMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
25605     }
25606
25607     return out;
25608 }
25609
25610 #ifdef _WIN64
25611 static inline void convert_VkBindSparseInfo_win64_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, VkBindSparseInfo *out)
25612 {
25613     if (!in) return;
25614
25615     out->sType = in->sType;
25616     out->pNext = in->pNext;
25617     out->waitSemaphoreCount = in->waitSemaphoreCount;
25618     out->pWaitSemaphores = in->pWaitSemaphores;
25619     out->bufferBindCount = in->bufferBindCount;
25620     out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win64_to_host(ctx, in->pBufferBinds, in->bufferBindCount);
25621     out->imageOpaqueBindCount = in->imageOpaqueBindCount;
25622     out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win64_to_host(ctx, in->pImageOpaqueBinds, in->imageOpaqueBindCount);
25623     out->imageBindCount = in->imageBindCount;
25624     out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win64_to_host(ctx, in->pImageBinds, in->imageBindCount);
25625     out->signalSemaphoreCount = in->signalSemaphoreCount;
25626     out->pSignalSemaphores = in->pSignalSemaphores;
25627 }
25628 #endif /* _WIN64 */
25629
25630 static inline void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, VkBindSparseInfo *out)
25631 {
25632     const VkBaseInStructure32 *in_header;
25633     VkBaseOutStructure *out_header = (void *)out;
25634
25635     if (!in) return;
25636
25637     out->sType = in->sType;
25638     out->pNext = NULL;
25639     out->waitSemaphoreCount = in->waitSemaphoreCount;
25640     out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
25641     out->bufferBindCount = in->bufferBindCount;
25642     out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseBufferMemoryBindInfo32 *)UlongToPtr(in->pBufferBinds), in->bufferBindCount);
25643     out->imageOpaqueBindCount = in->imageOpaqueBindCount;
25644     out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseImageOpaqueMemoryBindInfo32 *)UlongToPtr(in->pImageOpaqueBinds), in->imageOpaqueBindCount);
25645     out->imageBindCount = in->imageBindCount;
25646     out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseImageMemoryBindInfo32 *)UlongToPtr(in->pImageBinds), in->imageBindCount);
25647     out->signalSemaphoreCount = in->signalSemaphoreCount;
25648     out->pSignalSemaphores = (const VkSemaphore *)UlongToPtr(in->pSignalSemaphores);
25649
25650     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
25651     {
25652         switch (in_header->sType)
25653         {
25654         case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
25655         {
25656             VkDeviceGroupBindSparseInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25657             const VkDeviceGroupBindSparseInfo32 *in_ext = (const VkDeviceGroupBindSparseInfo32 *)in_header;
25658             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO;
25659             out_ext->pNext = NULL;
25660             out_ext->resourceDeviceIndex = in_ext->resourceDeviceIndex;
25661             out_ext->memoryDeviceIndex = in_ext->memoryDeviceIndex;
25662             out_header->pNext = (void *)out_ext;
25663             out_header = (void *)out_ext;
25664             break;
25665         }
25666         case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
25667         {
25668             VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25669             const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header;
25670             out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
25671             out_ext->pNext = NULL;
25672             out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
25673             out_ext->pWaitSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pWaitSemaphoreValues);
25674             out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
25675             out_ext->pSignalSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pSignalSemaphoreValues);
25676             out_header->pNext = (void *)out_ext;
25677             out_header = (void *)out_ext;
25678             break;
25679         }
25680         default:
25681             FIXME("Unhandled sType %u.\n", in_header->sType);
25682             break;
25683         }
25684     }
25685 }
25686
25687 #ifdef _WIN64
25688 static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, uint32_t count)
25689 {
25690     VkBindSparseInfo *out;
25691     unsigned int i;
25692
25693     if (!in || !count) return NULL;
25694
25695     out = conversion_context_alloc(ctx, count * sizeof(*out));
25696     for (i = 0; i < count; i++)
25697     {
25698         convert_VkBindSparseInfo_win64_to_host(ctx, &in[i], &out[i]);
25699     }
25700
25701     return out;
25702 }
25703 #endif /* _WIN64 */
25704
25705 static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, uint32_t count)
25706 {
25707     VkBindSparseInfo *out;
25708     unsigned int i;
25709
25710     if (!in || !count) return NULL;
25711
25712     out = conversion_context_alloc(ctx, count * sizeof(*out));
25713     for (i = 0; i < count; i++)
25714     {
25715         convert_VkBindSparseInfo_win32_to_host(ctx, &in[i], &out[i]);
25716     }
25717
25718     return out;
25719 }
25720
25721 static inline void convert_VkPresentRegionKHR_win32_to_host(const VkPresentRegionKHR32 *in, VkPresentRegionKHR *out)
25722 {
25723     if (!in) return;
25724
25725     out->rectangleCount = in->rectangleCount;
25726     out->pRectangles = (const VkRectLayerKHR *)UlongToPtr(in->pRectangles);
25727 }
25728
25729 static inline const VkPresentRegionKHR *convert_VkPresentRegionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPresentRegionKHR32 *in, uint32_t count)
25730 {
25731     VkPresentRegionKHR *out;
25732     unsigned int i;
25733
25734     if (!in || !count) return NULL;
25735
25736     out = conversion_context_alloc(ctx, count * sizeof(*out));
25737     for (i = 0; i < count; i++)
25738     {
25739         convert_VkPresentRegionKHR_win32_to_host(&in[i], &out[i]);
25740     }
25741
25742     return out;
25743 }
25744
25745 static inline void convert_VkPresentInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPresentInfoKHR32 *in, VkPresentInfoKHR *out)
25746 {
25747     const VkBaseInStructure32 *in_header;
25748     VkBaseOutStructure *out_header = (void *)out;
25749
25750     if (!in) return;
25751
25752     out->sType = in->sType;
25753     out->pNext = NULL;
25754     out->waitSemaphoreCount = in->waitSemaphoreCount;
25755     out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
25756     out->swapchainCount = in->swapchainCount;
25757     out->pSwapchains = (const VkSwapchainKHR *)UlongToPtr(in->pSwapchains);
25758     out->pImageIndices = (const uint32_t *)UlongToPtr(in->pImageIndices);
25759     out->pResults = (VkResult *)UlongToPtr(in->pResults);
25760
25761     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
25762     {
25763         switch (in_header->sType)
25764         {
25765         case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
25766         {
25767             VkPresentRegionsKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25768             const VkPresentRegionsKHR32 *in_ext = (const VkPresentRegionsKHR32 *)in_header;
25769             out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR;
25770             out_ext->pNext = NULL;
25771             out_ext->swapchainCount = in_ext->swapchainCount;
25772             out_ext->pRegions = convert_VkPresentRegionKHR_array_win32_to_host(ctx, (const VkPresentRegionKHR32 *)UlongToPtr(in_ext->pRegions), in_ext->swapchainCount);
25773             out_header->pNext = (void *)out_ext;
25774             out_header = (void *)out_ext;
25775             break;
25776         }
25777         case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
25778         {
25779             VkDeviceGroupPresentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25780             const VkDeviceGroupPresentInfoKHR32 *in_ext = (const VkDeviceGroupPresentInfoKHR32 *)in_header;
25781             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR;
25782             out_ext->pNext = NULL;
25783             out_ext->swapchainCount = in_ext->swapchainCount;
25784             out_ext->pDeviceMasks = (const uint32_t *)UlongToPtr(in_ext->pDeviceMasks);
25785             out_ext->mode = in_ext->mode;
25786             out_header->pNext = (void *)out_ext;
25787             out_header = (void *)out_ext;
25788             break;
25789         }
25790         case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
25791         {
25792             VkPresentIdKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25793             const VkPresentIdKHR32 *in_ext = (const VkPresentIdKHR32 *)in_header;
25794             out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR;
25795             out_ext->pNext = NULL;
25796             out_ext->swapchainCount = in_ext->swapchainCount;
25797             out_ext->pPresentIds = (const uint64_t *)UlongToPtr(in_ext->pPresentIds);
25798             out_header->pNext = (void *)out_ext;
25799             out_header = (void *)out_ext;
25800             break;
25801         }
25802         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
25803         {
25804             VkSwapchainPresentFenceInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25805             const VkSwapchainPresentFenceInfoEXT32 *in_ext = (const VkSwapchainPresentFenceInfoEXT32 *)in_header;
25806             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT;
25807             out_ext->pNext = NULL;
25808             out_ext->swapchainCount = in_ext->swapchainCount;
25809             out_ext->pFences = (const VkFence *)UlongToPtr(in_ext->pFences);
25810             out_header->pNext = (void *)out_ext;
25811             out_header = (void *)out_ext;
25812             break;
25813         }
25814         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
25815         {
25816             VkSwapchainPresentModeInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25817             const VkSwapchainPresentModeInfoEXT32 *in_ext = (const VkSwapchainPresentModeInfoEXT32 *)in_header;
25818             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT;
25819             out_ext->pNext = NULL;
25820             out_ext->swapchainCount = in_ext->swapchainCount;
25821             out_ext->pPresentModes = (const VkPresentModeKHR *)UlongToPtr(in_ext->pPresentModes);
25822             out_header->pNext = (void *)out_ext;
25823             out_header = (void *)out_ext;
25824             break;
25825         }
25826         default:
25827             FIXME("Unhandled sType %u.\n", in_header->sType);
25828             break;
25829         }
25830     }
25831 }
25832
25833 #ifdef _WIN64
25834 static inline void convert_VkSubmitInfo_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, VkSubmitInfo *out)
25835 {
25836     if (!in) return;
25837
25838     out->sType = in->sType;
25839     out->pNext = in->pNext;
25840     out->waitSemaphoreCount = in->waitSemaphoreCount;
25841     out->pWaitSemaphores = in->pWaitSemaphores;
25842     out->pWaitDstStageMask = in->pWaitDstStageMask;
25843     out->commandBufferCount = in->commandBufferCount;
25844     out->pCommandBuffers = convert_VkCommandBuffer_array_win64_to_host(ctx, in->pCommandBuffers, in->commandBufferCount);
25845     out->signalSemaphoreCount = in->signalSemaphoreCount;
25846     out->pSignalSemaphores = in->pSignalSemaphores;
25847 }
25848 #endif /* _WIN64 */
25849
25850 static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, VkSubmitInfo *out)
25851 {
25852     const VkBaseInStructure32 *in_header;
25853     VkBaseOutStructure *out_header = (void *)out;
25854
25855     if (!in) return;
25856
25857     out->sType = in->sType;
25858     out->pNext = NULL;
25859     out->waitSemaphoreCount = in->waitSemaphoreCount;
25860     out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
25861     out->pWaitDstStageMask = (const VkPipelineStageFlags *)UlongToPtr(in->pWaitDstStageMask);
25862     out->commandBufferCount = in->commandBufferCount;
25863     out->pCommandBuffers = convert_VkCommandBuffer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->pCommandBuffers), in->commandBufferCount);
25864     out->signalSemaphoreCount = in->signalSemaphoreCount;
25865     out->pSignalSemaphores = (const VkSemaphore *)UlongToPtr(in->pSignalSemaphores);
25866
25867     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
25868     {
25869         switch (in_header->sType)
25870         {
25871         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
25872         {
25873             VkDeviceGroupSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25874             const VkDeviceGroupSubmitInfo32 *in_ext = (const VkDeviceGroupSubmitInfo32 *)in_header;
25875             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO;
25876             out_ext->pNext = NULL;
25877             out_ext->waitSemaphoreCount = in_ext->waitSemaphoreCount;
25878             out_ext->pWaitSemaphoreDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pWaitSemaphoreDeviceIndices);
25879             out_ext->commandBufferCount = in_ext->commandBufferCount;
25880             out_ext->pCommandBufferDeviceMasks = (const uint32_t *)UlongToPtr(in_ext->pCommandBufferDeviceMasks);
25881             out_ext->signalSemaphoreCount = in_ext->signalSemaphoreCount;
25882             out_ext->pSignalSemaphoreDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pSignalSemaphoreDeviceIndices);
25883             out_header->pNext = (void *)out_ext;
25884             out_header = (void *)out_ext;
25885             break;
25886         }
25887         case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
25888         {
25889             VkProtectedSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25890             const VkProtectedSubmitInfo32 *in_ext = (const VkProtectedSubmitInfo32 *)in_header;
25891             out_ext->sType = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO;
25892             out_ext->pNext = NULL;
25893             out_ext->protectedSubmit = in_ext->protectedSubmit;
25894             out_header->pNext = (void *)out_ext;
25895             out_header = (void *)out_ext;
25896             break;
25897         }
25898         case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
25899         {
25900             VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25901             const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header;
25902             out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
25903             out_ext->pNext = NULL;
25904             out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
25905             out_ext->pWaitSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pWaitSemaphoreValues);
25906             out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
25907             out_ext->pSignalSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pSignalSemaphoreValues);
25908             out_header->pNext = (void *)out_ext;
25909             out_header = (void *)out_ext;
25910             break;
25911         }
25912         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
25913         {
25914             VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
25915             const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header;
25916             out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
25917             out_ext->pNext = NULL;
25918             out_ext->counterPassIndex = in_ext->counterPassIndex;
25919             out_header->pNext = (void *)out_ext;
25920             out_header = (void *)out_ext;
25921             break;
25922         }
25923         default:
25924             FIXME("Unhandled sType %u.\n", in_header->sType);
25925             break;
25926         }
25927     }
25928 }
25929
25930 #ifdef _WIN64
25931 static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, uint32_t count)
25932 {
25933     VkSubmitInfo *out;
25934     unsigned int i;
25935
25936     if (!in || !count) return NULL;
25937
25938     out = conversion_context_alloc(ctx, count * sizeof(*out));
25939     for (i = 0; i < count; i++)
25940     {
25941         convert_VkSubmitInfo_win64_to_host(ctx, &in[i], &out[i]);
25942     }
25943
25944     return out;
25945 }
25946 #endif /* _WIN64 */
25947
25948 static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, uint32_t count)
25949 {
25950     VkSubmitInfo *out;
25951     unsigned int i;
25952
25953     if (!in || !count) return NULL;
25954
25955     out = conversion_context_alloc(ctx, count * sizeof(*out));
25956     for (i = 0; i < count; i++)
25957     {
25958         convert_VkSubmitInfo_win32_to_host(ctx, &in[i], &out[i]);
25959     }
25960
25961     return out;
25962 }
25963
25964 static inline void convert_VkSemaphoreSubmitInfo_win32_to_host(const VkSemaphoreSubmitInfo32 *in, VkSemaphoreSubmitInfo *out)
25965 {
25966     if (!in) return;
25967
25968     out->sType = in->sType;
25969     out->pNext = NULL;
25970     out->semaphore = in->semaphore;
25971     out->value = in->value;
25972     out->stageMask = in->stageMask;
25973     out->deviceIndex = in->deviceIndex;
25974     if (in->pNext)
25975         FIXME("Unexpected pNext\n");
25976 }
25977
25978 static inline const VkSemaphoreSubmitInfo *convert_VkSemaphoreSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSemaphoreSubmitInfo32 *in, uint32_t count)
25979 {
25980     VkSemaphoreSubmitInfo *out;
25981     unsigned int i;
25982
25983     if (!in || !count) return NULL;
25984
25985     out = conversion_context_alloc(ctx, count * sizeof(*out));
25986     for (i = 0; i < count; i++)
25987     {
25988         convert_VkSemaphoreSubmitInfo_win32_to_host(&in[i], &out[i]);
25989     }
25990
25991     return out;
25992 }
25993
25994 #ifdef _WIN64
25995 static inline void convert_VkCommandBufferSubmitInfo_win64_to_host(const VkCommandBufferSubmitInfo *in, VkCommandBufferSubmitInfo *out)
25996 {
25997     if (!in) return;
25998
25999     out->sType = in->sType;
26000     out->pNext = in->pNext;
26001     out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->command_buffer;
26002     out->deviceMask = in->deviceMask;
26003 }
26004 #endif /* _WIN64 */
26005
26006 static inline void convert_VkCommandBufferSubmitInfo_win32_to_host(const VkCommandBufferSubmitInfo32 *in, VkCommandBufferSubmitInfo *out)
26007 {
26008     if (!in) return;
26009
26010     out->sType = in->sType;
26011     out->pNext = NULL;
26012     out->commandBuffer = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(in->commandBuffer))->command_buffer;
26013     out->deviceMask = in->deviceMask;
26014     if (in->pNext)
26015         FIXME("Unexpected pNext\n");
26016 }
26017
26018 #ifdef _WIN64
26019 static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo *in, uint32_t count)
26020 {
26021     VkCommandBufferSubmitInfo *out;
26022     unsigned int i;
26023
26024     if (!in || !count) return NULL;
26025
26026     out = conversion_context_alloc(ctx, count * sizeof(*out));
26027     for (i = 0; i < count; i++)
26028     {
26029         convert_VkCommandBufferSubmitInfo_win64_to_host(&in[i], &out[i]);
26030     }
26031
26032     return out;
26033 }
26034 #endif /* _WIN64 */
26035
26036 static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo32 *in, uint32_t count)
26037 {
26038     VkCommandBufferSubmitInfo *out;
26039     unsigned int i;
26040
26041     if (!in || !count) return NULL;
26042
26043     out = conversion_context_alloc(ctx, count * sizeof(*out));
26044     for (i = 0; i < count; i++)
26045     {
26046         convert_VkCommandBufferSubmitInfo_win32_to_host(&in[i], &out[i]);
26047     }
26048
26049     return out;
26050 }
26051
26052 #ifdef _WIN64
26053 static inline void convert_VkSubmitInfo2_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, VkSubmitInfo2 *out)
26054 {
26055     if (!in) return;
26056
26057     out->sType = in->sType;
26058     out->pNext = in->pNext;
26059     out->flags = in->flags;
26060     out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
26061     out->pWaitSemaphoreInfos = in->pWaitSemaphoreInfos;
26062     out->commandBufferInfoCount = in->commandBufferInfoCount;
26063     out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win64_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount);
26064     out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
26065     out->pSignalSemaphoreInfos = in->pSignalSemaphoreInfos;
26066 }
26067 #endif /* _WIN64 */
26068
26069 static inline void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, VkSubmitInfo2 *out)
26070 {
26071     const VkBaseInStructure32 *in_header;
26072     VkBaseOutStructure *out_header = (void *)out;
26073
26074     if (!in) return;
26075
26076     out->sType = in->sType;
26077     out->pNext = NULL;
26078     out->flags = in->flags;
26079     out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
26080     out->pWaitSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, (const VkSemaphoreSubmitInfo32 *)UlongToPtr(in->pWaitSemaphoreInfos), in->waitSemaphoreInfoCount);
26081     out->commandBufferInfoCount = in->commandBufferInfoCount;
26082     out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win32_to_host(ctx, (const VkCommandBufferSubmitInfo32 *)UlongToPtr(in->pCommandBufferInfos), in->commandBufferInfoCount);
26083     out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
26084     out->pSignalSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, (const VkSemaphoreSubmitInfo32 *)UlongToPtr(in->pSignalSemaphoreInfos), in->signalSemaphoreInfoCount);
26085
26086     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
26087     {
26088         switch (in_header->sType)
26089         {
26090         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
26091         {
26092             VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26093             const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header;
26094             out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
26095             out_ext->pNext = NULL;
26096             out_ext->counterPassIndex = in_ext->counterPassIndex;
26097             out_header->pNext = (void *)out_ext;
26098             out_header = (void *)out_ext;
26099             break;
26100         }
26101         default:
26102             FIXME("Unhandled sType %u.\n", in_header->sType);
26103             break;
26104         }
26105     }
26106 }
26107
26108 #ifdef _WIN64
26109 static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, uint32_t count)
26110 {
26111     VkSubmitInfo2 *out;
26112     unsigned int i;
26113
26114     if (!in || !count) return NULL;
26115
26116     out = conversion_context_alloc(ctx, count * sizeof(*out));
26117     for (i = 0; i < count; i++)
26118     {
26119         convert_VkSubmitInfo2_win64_to_host(ctx, &in[i], &out[i]);
26120     }
26121
26122     return out;
26123 }
26124 #endif /* _WIN64 */
26125
26126 static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, uint32_t count)
26127 {
26128     VkSubmitInfo2 *out;
26129     unsigned int i;
26130
26131     if (!in || !count) return NULL;
26132
26133     out = conversion_context_alloc(ctx, count * sizeof(*out));
26134     for (i = 0; i < count; i++)
26135     {
26136         convert_VkSubmitInfo2_win32_to_host(ctx, &in[i], &out[i]);
26137     }
26138
26139     return out;
26140 }
26141
26142 static inline void convert_VkReleaseSwapchainImagesInfoEXT_win32_to_host(const VkReleaseSwapchainImagesInfoEXT32 *in, VkReleaseSwapchainImagesInfoEXT *out)
26143 {
26144     if (!in) return;
26145
26146     out->sType = in->sType;
26147     out->pNext = NULL;
26148     out->swapchain = in->swapchain;
26149     out->imageIndexCount = in->imageIndexCount;
26150     out->pImageIndices = (const uint32_t *)UlongToPtr(in->pImageIndices);
26151     if (in->pNext)
26152         FIXME("Unexpected pNext\n");
26153 }
26154
26155 #ifdef _WIN64
26156 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(const VkDebugUtilsObjectNameInfoEXT *in, VkDebugUtilsObjectNameInfoEXT *out)
26157 {
26158     if (!in) return;
26159
26160     out->sType = in->sType;
26161     out->pNext = in->pNext;
26162     out->objectType = in->objectType;
26163     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
26164     out->pObjectName = in->pObjectName;
26165 }
26166 #endif /* _WIN64 */
26167
26168 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(const VkDebugUtilsObjectNameInfoEXT32 *in, VkDebugUtilsObjectNameInfoEXT *out)
26169 {
26170     if (!in) return;
26171
26172     out->sType = in->sType;
26173     out->pNext = NULL;
26174     out->objectType = in->objectType;
26175     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
26176     out->pObjectName = (const char *)UlongToPtr(in->pObjectName);
26177     if (in->pNext)
26178         FIXME("Unexpected pNext\n");
26179 }
26180
26181 #ifdef _WIN64
26182 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(const VkDebugUtilsObjectTagInfoEXT *in, VkDebugUtilsObjectTagInfoEXT *out)
26183 {
26184     if (!in) return;
26185
26186     out->sType = in->sType;
26187     out->pNext = in->pNext;
26188     out->objectType = in->objectType;
26189     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
26190     out->tagName = in->tagName;
26191     out->tagSize = in->tagSize;
26192     out->pTag = in->pTag;
26193 }
26194 #endif /* _WIN64 */
26195
26196 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(const VkDebugUtilsObjectTagInfoEXT32 *in, VkDebugUtilsObjectTagInfoEXT *out)
26197 {
26198     if (!in) return;
26199
26200     out->sType = in->sType;
26201     out->pNext = NULL;
26202     out->objectType = in->objectType;
26203     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
26204     out->tagName = in->tagName;
26205     out->tagSize = in->tagSize;
26206     out->pTag = (const void *)UlongToPtr(in->pTag);
26207     if (in->pNext)
26208         FIXME("Unexpected pNext\n");
26209 }
26210
26211 static inline void convert_VkHdrMetadataEXT_win32_to_host(const VkHdrMetadataEXT32 *in, VkHdrMetadataEXT *out)
26212 {
26213     if (!in) return;
26214
26215     out->sType = in->sType;
26216     out->pNext = NULL;
26217     out->displayPrimaryRed = in->displayPrimaryRed;
26218     out->displayPrimaryGreen = in->displayPrimaryGreen;
26219     out->displayPrimaryBlue = in->displayPrimaryBlue;
26220     out->whitePoint = in->whitePoint;
26221     out->maxLuminance = in->maxLuminance;
26222     out->minLuminance = in->minLuminance;
26223     out->maxContentLightLevel = in->maxContentLightLevel;
26224     out->maxFrameAverageLightLevel = in->maxFrameAverageLightLevel;
26225     if (in->pNext)
26226         FIXME("Unexpected pNext\n");
26227 }
26228
26229 static inline const VkHdrMetadataEXT *convert_VkHdrMetadataEXT_array_win32_to_host(struct conversion_context *ctx, const VkHdrMetadataEXT32 *in, uint32_t count)
26230 {
26231     VkHdrMetadataEXT *out;
26232     unsigned int i;
26233
26234     if (!in || !count) return NULL;
26235
26236     out = conversion_context_alloc(ctx, count * sizeof(*out));
26237     for (i = 0; i < count; i++)
26238     {
26239         convert_VkHdrMetadataEXT_win32_to_host(&in[i], &out[i]);
26240     }
26241
26242     return out;
26243 }
26244
26245 static inline void convert_VkSemaphoreSignalInfo_win32_to_host(const VkSemaphoreSignalInfo32 *in, VkSemaphoreSignalInfo *out)
26246 {
26247     if (!in) return;
26248
26249     out->sType = in->sType;
26250     out->pNext = NULL;
26251     out->semaphore = in->semaphore;
26252     out->value = in->value;
26253     if (in->pNext)
26254         FIXME("Unexpected pNext\n");
26255 }
26256
26257 static inline const VkDebugUtilsLabelEXT *convert_VkDebugUtilsLabelEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsLabelEXT32 *in, uint32_t count)
26258 {
26259     VkDebugUtilsLabelEXT *out;
26260     unsigned int i;
26261
26262     if (!in || !count) return NULL;
26263
26264     out = conversion_context_alloc(ctx, count * sizeof(*out));
26265     for (i = 0; i < count; i++)
26266     {
26267         convert_VkDebugUtilsLabelEXT_win32_to_host(&in[i], &out[i]);
26268     }
26269
26270     return out;
26271 }
26272
26273 #ifdef _WIN64
26274 static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT *in, uint32_t count)
26275 {
26276     VkDebugUtilsObjectNameInfoEXT *out;
26277     unsigned int i;
26278
26279     if (!in || !count) return NULL;
26280
26281     out = conversion_context_alloc(ctx, count * sizeof(*out));
26282     for (i = 0; i < count; i++)
26283     {
26284         convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(&in[i], &out[i]);
26285     }
26286
26287     return out;
26288 }
26289 #endif /* _WIN64 */
26290
26291 static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT32 *in, uint32_t count)
26292 {
26293     VkDebugUtilsObjectNameInfoEXT *out;
26294     unsigned int i;
26295
26296     if (!in || !count) return NULL;
26297
26298     out = conversion_context_alloc(ctx, count * sizeof(*out));
26299     for (i = 0; i < count; i++)
26300     {
26301         convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(&in[i], &out[i]);
26302     }
26303
26304     return out;
26305 }
26306
26307 #ifdef _WIN64
26308 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT *in, VkDebugUtilsMessengerCallbackDataEXT *out)
26309 {
26310     if (!in) return;
26311
26312     out->sType = in->sType;
26313     out->pNext = in->pNext;
26314     out->flags = in->flags;
26315     out->pMessageIdName = in->pMessageIdName;
26316     out->messageIdNumber = in->messageIdNumber;
26317     out->pMessage = in->pMessage;
26318     out->queueLabelCount = in->queueLabelCount;
26319     out->pQueueLabels = in->pQueueLabels;
26320     out->cmdBufLabelCount = in->cmdBufLabelCount;
26321     out->pCmdBufLabels = in->pCmdBufLabels;
26322     out->objectCount = in->objectCount;
26323     out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(ctx, in->pObjects, in->objectCount);
26324 }
26325 #endif /* _WIN64 */
26326
26327 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT32 *in, VkDebugUtilsMessengerCallbackDataEXT *out)
26328 {
26329     const VkBaseInStructure32 *in_header;
26330     VkBaseOutStructure *out_header = (void *)out;
26331
26332     if (!in) return;
26333
26334     out->sType = in->sType;
26335     out->pNext = NULL;
26336     out->flags = in->flags;
26337     out->pMessageIdName = (const char *)UlongToPtr(in->pMessageIdName);
26338     out->messageIdNumber = in->messageIdNumber;
26339     out->pMessage = (const char *)UlongToPtr(in->pMessage);
26340     out->queueLabelCount = in->queueLabelCount;
26341     out->pQueueLabels = convert_VkDebugUtilsLabelEXT_array_win32_to_host(ctx, (const VkDebugUtilsLabelEXT32 *)UlongToPtr(in->pQueueLabels), in->queueLabelCount);
26342     out->cmdBufLabelCount = in->cmdBufLabelCount;
26343     out->pCmdBufLabels = convert_VkDebugUtilsLabelEXT_array_win32_to_host(ctx, (const VkDebugUtilsLabelEXT32 *)UlongToPtr(in->pCmdBufLabels), in->cmdBufLabelCount);
26344     out->objectCount = in->objectCount;
26345     out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(ctx, (const VkDebugUtilsObjectNameInfoEXT32 *)UlongToPtr(in->pObjects), in->objectCount);
26346
26347     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
26348     {
26349         switch (in_header->sType)
26350         {
26351         case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
26352         {
26353             VkDeviceAddressBindingCallbackDataEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
26354             const VkDeviceAddressBindingCallbackDataEXT32 *in_ext = (const VkDeviceAddressBindingCallbackDataEXT32 *)in_header;
26355             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT;
26356             out_ext->pNext = NULL;
26357             out_ext->flags = in_ext->flags;
26358             out_ext->baseAddress = in_ext->baseAddress;
26359             out_ext->size = in_ext->size;
26360             out_ext->bindingType = in_ext->bindingType;
26361             out_header->pNext = (void *)out_ext;
26362             out_header = (void *)out_ext;
26363             break;
26364         }
26365         default:
26366             FIXME("Unhandled sType %u.\n", in_header->sType);
26367             break;
26368         }
26369     }
26370 }
26371
26372 static inline void convert_VkMemoryUnmapInfoKHR_win32_to_unwrapped_host(const VkMemoryUnmapInfoKHR32 *in, VkMemoryUnmapInfoKHR *out)
26373 {
26374     if (!in) return;
26375
26376     out->sType = in->sType;
26377     out->pNext = NULL;
26378     out->flags = in->flags;
26379     out->memory = in->memory;
26380     if (in->pNext)
26381         FIXME("Unexpected pNext\n");
26382 }
26383
26384 static inline void convert_VkCopyDescriptorSet_win32_to_host(const VkCopyDescriptorSet32 *in, VkCopyDescriptorSet *out)
26385 {
26386     if (!in) return;
26387
26388     out->sType = in->sType;
26389     out->pNext = NULL;
26390     out->srcSet = in->srcSet;
26391     out->srcBinding = in->srcBinding;
26392     out->srcArrayElement = in->srcArrayElement;
26393     out->dstSet = in->dstSet;
26394     out->dstBinding = in->dstBinding;
26395     out->dstArrayElement = in->dstArrayElement;
26396     out->descriptorCount = in->descriptorCount;
26397     if (in->pNext)
26398         FIXME("Unexpected pNext\n");
26399 }
26400
26401 static inline const VkCopyDescriptorSet *convert_VkCopyDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkCopyDescriptorSet32 *in, uint32_t count)
26402 {
26403     VkCopyDescriptorSet *out;
26404     unsigned int i;
26405
26406     if (!in || !count) return NULL;
26407
26408     out = conversion_context_alloc(ctx, count * sizeof(*out));
26409     for (i = 0; i < count; i++)
26410     {
26411         convert_VkCopyDescriptorSet_win32_to_host(&in[i], &out[i]);
26412     }
26413
26414     return out;
26415 }
26416
26417 static inline void convert_VkSemaphoreWaitInfo_win32_to_host(const VkSemaphoreWaitInfo32 *in, VkSemaphoreWaitInfo *out)
26418 {
26419     if (!in) return;
26420
26421     out->sType = in->sType;
26422     out->pNext = NULL;
26423     out->flags = in->flags;
26424     out->semaphoreCount = in->semaphoreCount;
26425     out->pSemaphores = (const VkSemaphore *)UlongToPtr(in->pSemaphores);
26426     out->pValues = (const uint64_t *)UlongToPtr(in->pValues);
26427     if (in->pNext)
26428         FIXME("Unexpected pNext\n");
26429 }
26430
26431 #ifdef _WIN64
26432 static NTSTATUS thunk64_vkAcquireNextImage2KHR(void *args)
26433 {
26434     struct vkAcquireNextImage2KHR_params *params = args;
26435
26436     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pImageIndex);
26437
26438     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pImageIndex);
26439     return STATUS_SUCCESS;
26440 }
26441 #endif /* _WIN64 */
26442
26443 static NTSTATUS thunk32_vkAcquireNextImage2KHR(void *args)
26444 {
26445     struct
26446     {
26447         PTR32 device;
26448         PTR32 pAcquireInfo;
26449         PTR32 pImageIndex;
26450         VkResult result;
26451     } *params = args;
26452     VkAcquireNextImageInfoKHR pAcquireInfo_host;
26453
26454     TRACE("%#x, %#x, %#x\n", params->device, params->pAcquireInfo, params->pImageIndex);
26455
26456     convert_VkAcquireNextImageInfoKHR_win32_to_host((const VkAcquireNextImageInfoKHR32 *)UlongToPtr(params->pAcquireInfo), &pAcquireInfo_host);
26457     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));
26458     return STATUS_SUCCESS;
26459 }
26460
26461 #ifdef _WIN64
26462 static NTSTATUS thunk64_vkAcquireNextImageKHR(void *args)
26463 {
26464     struct vkAcquireNextImageKHR_params *params = args;
26465
26466     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);
26467
26468     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);
26469     return STATUS_SUCCESS;
26470 }
26471 #endif /* _WIN64 */
26472
26473 static NTSTATUS thunk32_vkAcquireNextImageKHR(void *args)
26474 {
26475     struct
26476     {
26477         PTR32 device;
26478         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
26479         uint64_t DECLSPEC_ALIGN(8) timeout;
26480         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
26481         VkFence DECLSPEC_ALIGN(8) fence;
26482         PTR32 pImageIndex;
26483         VkResult result;
26484     } *params = args;
26485
26486     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);
26487
26488     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));
26489     return STATUS_SUCCESS;
26490 }
26491
26492 #ifdef _WIN64
26493 static NTSTATUS thunk64_vkAcquirePerformanceConfigurationINTEL(void *args)
26494 {
26495     struct vkAcquirePerformanceConfigurationINTEL_params *params = args;
26496
26497     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pConfiguration);
26498
26499     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pConfiguration);
26500     return STATUS_SUCCESS;
26501 }
26502 #endif /* _WIN64 */
26503
26504 static NTSTATUS thunk32_vkAcquirePerformanceConfigurationINTEL(void *args)
26505 {
26506     struct
26507     {
26508         PTR32 device;
26509         PTR32 pAcquireInfo;
26510         PTR32 pConfiguration;
26511         VkResult result;
26512     } *params = args;
26513     VkPerformanceConfigurationAcquireInfoINTEL pAcquireInfo_host;
26514
26515     TRACE("%#x, %#x, %#x\n", params->device, params->pAcquireInfo, params->pConfiguration);
26516
26517     convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host((const VkPerformanceConfigurationAcquireInfoINTEL32 *)UlongToPtr(params->pAcquireInfo), &pAcquireInfo_host);
26518     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));
26519     return STATUS_SUCCESS;
26520 }
26521
26522 #ifdef _WIN64
26523 static NTSTATUS thunk64_vkAcquireProfilingLockKHR(void *args)
26524 {
26525     struct vkAcquireProfilingLockKHR_params *params = args;
26526
26527     TRACE("%p, %p\n", params->device, params->pInfo);
26528
26529     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle(params->device)->device, params->pInfo);
26530     return STATUS_SUCCESS;
26531 }
26532 #endif /* _WIN64 */
26533
26534 static NTSTATUS thunk32_vkAcquireProfilingLockKHR(void *args)
26535 {
26536     struct
26537     {
26538         PTR32 device;
26539         PTR32 pInfo;
26540         VkResult result;
26541     } *params = args;
26542     VkAcquireProfilingLockInfoKHR pInfo_host;
26543
26544     TRACE("%#x, %#x\n", params->device, params->pInfo);
26545
26546     convert_VkAcquireProfilingLockInfoKHR_win32_to_host((const VkAcquireProfilingLockInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
26547     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
26548     return STATUS_SUCCESS;
26549 }
26550
26551 #ifdef _WIN64
26552 static NTSTATUS thunk64_vkAllocateCommandBuffers(void *args)
26553 {
26554     struct vkAllocateCommandBuffers_params *params = args;
26555
26556     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pCommandBuffers);
26557
26558     params->result = wine_vkAllocateCommandBuffers(params->device, params->pAllocateInfo, params->pCommandBuffers);
26559     return STATUS_SUCCESS;
26560 }
26561 #endif /* _WIN64 */
26562
26563 static NTSTATUS thunk32_vkAllocateCommandBuffers(void *args)
26564 {
26565     struct
26566     {
26567         PTR32 device;
26568         PTR32 pAllocateInfo;
26569         PTR32 pCommandBuffers;
26570         VkResult result;
26571     } *params = args;
26572     VkCommandBufferAllocateInfo pAllocateInfo_host;
26573     VkCommandBuffer *pCommandBuffers_host;
26574     struct conversion_context local_ctx;
26575     struct conversion_context *ctx = &local_ctx;
26576
26577     TRACE("%#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pCommandBuffers);
26578
26579     init_conversion_context(ctx);
26580     convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host((const VkCommandBufferAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
26581     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_unwrapped_host(ctx, (PTR32 *)UlongToPtr(params->pCommandBuffers), ((const VkCommandBufferAllocateInfo32 *)UlongToPtr(params->pAllocateInfo))->commandBufferCount);
26582     params->result = wine_vkAllocateCommandBuffers((VkDevice)UlongToPtr(params->device), &pAllocateInfo_host, pCommandBuffers_host);
26583     free_conversion_context(ctx);
26584     return STATUS_SUCCESS;
26585 }
26586
26587 #ifdef _WIN64
26588 static NTSTATUS thunk64_vkAllocateDescriptorSets(void *args)
26589 {
26590     struct vkAllocateDescriptorSets_params *params = args;
26591
26592     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pDescriptorSets);
26593
26594     params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle(params->device)->device, params->pAllocateInfo, params->pDescriptorSets);
26595     return STATUS_SUCCESS;
26596 }
26597 #endif /* _WIN64 */
26598
26599 static NTSTATUS thunk32_vkAllocateDescriptorSets(void *args)
26600 {
26601     struct
26602     {
26603         PTR32 device;
26604         PTR32 pAllocateInfo;
26605         PTR32 pDescriptorSets;
26606         VkResult result;
26607     } *params = args;
26608     VkDescriptorSetAllocateInfo pAllocateInfo_host;
26609     struct conversion_context local_ctx;
26610     struct conversion_context *ctx = &local_ctx;
26611
26612     TRACE("%#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pDescriptorSets);
26613
26614     init_conversion_context(ctx);
26615     convert_VkDescriptorSetAllocateInfo_win32_to_host(ctx, (const VkDescriptorSetAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
26616     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));
26617     free_conversion_context(ctx);
26618     return STATUS_SUCCESS;
26619 }
26620
26621 #ifdef _WIN64
26622 static NTSTATUS thunk64_vkAllocateMemory(void *args)
26623 {
26624     struct vkAllocateMemory_params *params = args;
26625
26626     TRACE("%p, %p, %p, %p\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
26627
26628     params->result = wine_vkAllocateMemory(params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
26629     return STATUS_SUCCESS;
26630 }
26631 #endif /* _WIN64 */
26632
26633 static NTSTATUS thunk32_vkAllocateMemory(void *args)
26634 {
26635     struct
26636     {
26637         PTR32 device;
26638         PTR32 pAllocateInfo;
26639         PTR32 pAllocator;
26640         PTR32 pMemory;
26641         VkResult result;
26642     } *params = args;
26643     VkMemoryAllocateInfo pAllocateInfo_host;
26644     struct conversion_context local_ctx;
26645     struct conversion_context *ctx = &local_ctx;
26646
26647     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
26648
26649     init_conversion_context(ctx);
26650     convert_VkMemoryAllocateInfo_win32_to_host(ctx, (const VkMemoryAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
26651     params->result = wine_vkAllocateMemory((VkDevice)UlongToPtr(params->device), &pAllocateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDeviceMemory *)UlongToPtr(params->pMemory));
26652     free_conversion_context(ctx);
26653     return STATUS_SUCCESS;
26654 }
26655
26656 #ifdef _WIN64
26657 static NTSTATUS thunk64_vkBeginCommandBuffer(void *args)
26658 {
26659     struct vkBeginCommandBuffer_params *params = args;
26660
26661     TRACE("%p, %p\n", params->commandBuffer, params->pBeginInfo);
26662
26663     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBeginInfo);
26664     return STATUS_SUCCESS;
26665 }
26666 #endif /* _WIN64 */
26667
26668 static NTSTATUS thunk32_vkBeginCommandBuffer(void *args)
26669 {
26670     struct
26671     {
26672         PTR32 commandBuffer;
26673         PTR32 pBeginInfo;
26674         VkResult result;
26675     } *params = args;
26676     VkCommandBufferBeginInfo pBeginInfo_host;
26677     struct conversion_context local_ctx;
26678     struct conversion_context *ctx = &local_ctx;
26679
26680     TRACE("%#x, %#x\n", params->commandBuffer, params->pBeginInfo);
26681
26682     init_conversion_context(ctx);
26683     convert_VkCommandBufferBeginInfo_win32_to_host(ctx, (const VkCommandBufferBeginInfo32 *)UlongToPtr(params->pBeginInfo), &pBeginInfo_host);
26684     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);
26685     free_conversion_context(ctx);
26686     return STATUS_SUCCESS;
26687 }
26688
26689 #ifdef _WIN64
26690 static NTSTATUS thunk64_vkBindAccelerationStructureMemoryNV(void *args)
26691 {
26692     struct vkBindAccelerationStructureMemoryNV_params *params = args;
26693     const VkBindAccelerationStructureMemoryInfoNV *pBindInfos_host;
26694     struct conversion_context local_ctx;
26695     struct conversion_context *ctx = &local_ctx;
26696
26697     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
26698
26699     init_conversion_context(ctx);
26700     pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoNV_array_win64_to_host(ctx, params->pBindInfos, params->bindInfoCount);
26701     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
26702     free_conversion_context(ctx);
26703     return STATUS_SUCCESS;
26704 }
26705 #endif /* _WIN64 */
26706
26707 static NTSTATUS thunk32_vkBindAccelerationStructureMemoryNV(void *args)
26708 {
26709     struct
26710     {
26711         PTR32 device;
26712         uint32_t bindInfoCount;
26713         PTR32 pBindInfos;
26714         VkResult result;
26715     } *params = args;
26716     const VkBindAccelerationStructureMemoryInfoNV *pBindInfos_host;
26717     struct conversion_context local_ctx;
26718     struct conversion_context *ctx = &local_ctx;
26719
26720     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
26721
26722     init_conversion_context(ctx);
26723     pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(ctx, (const VkBindAccelerationStructureMemoryInfoNV32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
26724     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);
26725     free_conversion_context(ctx);
26726     return STATUS_SUCCESS;
26727 }
26728
26729 #ifdef _WIN64
26730 static NTSTATUS thunk64_vkBindBufferMemory(void *args)
26731 {
26732     struct vkBindBufferMemory_params *params = args;
26733
26734     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));
26735
26736     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);
26737     return STATUS_SUCCESS;
26738 }
26739 #endif /* _WIN64 */
26740
26741 static NTSTATUS thunk32_vkBindBufferMemory(void *args)
26742 {
26743     struct
26744     {
26745         PTR32 device;
26746         VkBuffer DECLSPEC_ALIGN(8) buffer;
26747         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
26748         VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
26749         VkResult result;
26750     } *params = args;
26751
26752     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));
26753
26754     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);
26755     return STATUS_SUCCESS;
26756 }
26757
26758 #ifdef _WIN64
26759 static NTSTATUS thunk64_vkBindBufferMemory2(void *args)
26760 {
26761     struct vkBindBufferMemory2_params *params = args;
26762     const VkBindBufferMemoryInfo *pBindInfos_host;
26763     struct conversion_context local_ctx;
26764     struct conversion_context *ctx = &local_ctx;
26765
26766     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
26767
26768     init_conversion_context(ctx);
26769     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win64_to_host(ctx, params->pBindInfos, params->bindInfoCount);
26770     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
26771     free_conversion_context(ctx);
26772     return STATUS_SUCCESS;
26773 }
26774 #endif /* _WIN64 */
26775
26776 static NTSTATUS thunk32_vkBindBufferMemory2(void *args)
26777 {
26778     struct
26779     {
26780         PTR32 device;
26781         uint32_t bindInfoCount;
26782         PTR32 pBindInfos;
26783         VkResult result;
26784     } *params = args;
26785     const VkBindBufferMemoryInfo *pBindInfos_host;
26786     struct conversion_context local_ctx;
26787     struct conversion_context *ctx = &local_ctx;
26788
26789     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
26790
26791     init_conversion_context(ctx);
26792     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(ctx, (const VkBindBufferMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
26793     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);
26794     free_conversion_context(ctx);
26795     return STATUS_SUCCESS;
26796 }
26797
26798 #ifdef _WIN64
26799 static NTSTATUS thunk64_vkBindBufferMemory2KHR(void *args)
26800 {
26801     struct vkBindBufferMemory2KHR_params *params = args;
26802     const VkBindBufferMemoryInfo *pBindInfos_host;
26803     struct conversion_context local_ctx;
26804     struct conversion_context *ctx = &local_ctx;
26805
26806     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
26807
26808     init_conversion_context(ctx);
26809     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win64_to_host(ctx, params->pBindInfos, params->bindInfoCount);
26810     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
26811     free_conversion_context(ctx);
26812     return STATUS_SUCCESS;
26813 }
26814 #endif /* _WIN64 */
26815
26816 static NTSTATUS thunk32_vkBindBufferMemory2KHR(void *args)
26817 {
26818     struct
26819     {
26820         PTR32 device;
26821         uint32_t bindInfoCount;
26822         PTR32 pBindInfos;
26823         VkResult result;
26824     } *params = args;
26825     const VkBindBufferMemoryInfo *pBindInfos_host;
26826     struct conversion_context local_ctx;
26827     struct conversion_context *ctx = &local_ctx;
26828
26829     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
26830
26831     init_conversion_context(ctx);
26832     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(ctx, (const VkBindBufferMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
26833     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);
26834     free_conversion_context(ctx);
26835     return STATUS_SUCCESS;
26836 }
26837
26838 #ifdef _WIN64
26839 static NTSTATUS thunk64_vkBindImageMemory(void *args)
26840 {
26841     struct vkBindImageMemory_params *params = args;
26842
26843     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));
26844
26845     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);
26846     return STATUS_SUCCESS;
26847 }
26848 #endif /* _WIN64 */
26849
26850 static NTSTATUS thunk32_vkBindImageMemory(void *args)
26851 {
26852     struct
26853     {
26854         PTR32 device;
26855         VkImage DECLSPEC_ALIGN(8) image;
26856         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
26857         VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
26858         VkResult result;
26859     } *params = args;
26860
26861     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));
26862
26863     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);
26864     return STATUS_SUCCESS;
26865 }
26866
26867 #ifdef _WIN64
26868 static NTSTATUS thunk64_vkBindImageMemory2(void *args)
26869 {
26870     struct vkBindImageMemory2_params *params = args;
26871     const VkBindImageMemoryInfo *pBindInfos_host;
26872     struct conversion_context local_ctx;
26873     struct conversion_context *ctx = &local_ctx;
26874
26875     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
26876
26877     init_conversion_context(ctx);
26878     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win64_to_host(ctx, params->pBindInfos, params->bindInfoCount);
26879     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
26880     free_conversion_context(ctx);
26881     return STATUS_SUCCESS;
26882 }
26883 #endif /* _WIN64 */
26884
26885 static NTSTATUS thunk32_vkBindImageMemory2(void *args)
26886 {
26887     struct
26888     {
26889         PTR32 device;
26890         uint32_t bindInfoCount;
26891         PTR32 pBindInfos;
26892         VkResult result;
26893     } *params = args;
26894     const VkBindImageMemoryInfo *pBindInfos_host;
26895     struct conversion_context local_ctx;
26896     struct conversion_context *ctx = &local_ctx;
26897
26898     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
26899
26900     init_conversion_context(ctx);
26901     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(ctx, (const VkBindImageMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
26902     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);
26903     free_conversion_context(ctx);
26904     return STATUS_SUCCESS;
26905 }
26906
26907 #ifdef _WIN64
26908 static NTSTATUS thunk64_vkBindImageMemory2KHR(void *args)
26909 {
26910     struct vkBindImageMemory2KHR_params *params = args;
26911     const VkBindImageMemoryInfo *pBindInfos_host;
26912     struct conversion_context local_ctx;
26913     struct conversion_context *ctx = &local_ctx;
26914
26915     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
26916
26917     init_conversion_context(ctx);
26918     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win64_to_host(ctx, params->pBindInfos, params->bindInfoCount);
26919     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
26920     free_conversion_context(ctx);
26921     return STATUS_SUCCESS;
26922 }
26923 #endif /* _WIN64 */
26924
26925 static NTSTATUS thunk32_vkBindImageMemory2KHR(void *args)
26926 {
26927     struct
26928     {
26929         PTR32 device;
26930         uint32_t bindInfoCount;
26931         PTR32 pBindInfos;
26932         VkResult result;
26933     } *params = args;
26934     const VkBindImageMemoryInfo *pBindInfos_host;
26935     struct conversion_context local_ctx;
26936     struct conversion_context *ctx = &local_ctx;
26937
26938     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
26939
26940     init_conversion_context(ctx);
26941     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(ctx, (const VkBindImageMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
26942     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);
26943     free_conversion_context(ctx);
26944     return STATUS_SUCCESS;
26945 }
26946
26947 #ifdef _WIN64
26948 static NTSTATUS thunk64_vkBindOpticalFlowSessionImageNV(void *args)
26949 {
26950     struct vkBindOpticalFlowSessionImageNV_params *params = args;
26951
26952     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);
26953
26954     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);
26955     return STATUS_SUCCESS;
26956 }
26957 #endif /* _WIN64 */
26958
26959 static NTSTATUS thunk32_vkBindOpticalFlowSessionImageNV(void *args)
26960 {
26961     struct
26962     {
26963         PTR32 device;
26964         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
26965         VkOpticalFlowSessionBindingPointNV bindingPoint;
26966         VkImageView DECLSPEC_ALIGN(8) view;
26967         VkImageLayout layout;
26968         VkResult result;
26969     } *params = args;
26970
26971     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);
26972
26973     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);
26974     return STATUS_SUCCESS;
26975 }
26976
26977 #ifdef _WIN64
26978 static NTSTATUS thunk64_vkBuildAccelerationStructuresKHR(void *args)
26979 {
26980     struct vkBuildAccelerationStructuresKHR_params *params = args;
26981
26982     TRACE("%p, 0x%s, %u, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);
26983
26984     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);
26985     return STATUS_SUCCESS;
26986 }
26987 #endif /* _WIN64 */
26988
26989 static NTSTATUS thunk32_vkBuildAccelerationStructuresKHR(void *args)
26990 {
26991     struct
26992     {
26993         PTR32 device;
26994         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
26995         uint32_t infoCount;
26996         PTR32 pInfos;
26997         PTR32 ppBuildRangeInfos;
26998         VkResult result;
26999     } *params = args;
27000     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
27001     struct conversion_context local_ctx;
27002     struct conversion_context *ctx = &local_ctx;
27003
27004     TRACE("%#x, 0x%s, %u, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);
27005
27006     if (params->deferredOperation == VK_NULL_HANDLE)
27007         init_conversion_context(ctx);
27008     else
27009         ctx = &wine_deferred_operation_from_handle(params->deferredOperation)->ctx;
27010     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
27011     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));
27012     if (params->deferredOperation == VK_NULL_HANDLE)
27013         free_conversion_context(ctx);
27014     return STATUS_SUCCESS;
27015 }
27016
27017 #ifdef _WIN64
27018 static NTSTATUS thunk64_vkBuildMicromapsEXT(void *args)
27019 {
27020     struct vkBuildMicromapsEXT_params *params = args;
27021
27022     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
27023
27024     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);
27025     return STATUS_SUCCESS;
27026 }
27027 #endif /* _WIN64 */
27028
27029 static NTSTATUS thunk32_vkBuildMicromapsEXT(void *args)
27030 {
27031     struct
27032     {
27033         PTR32 device;
27034         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
27035         uint32_t infoCount;
27036         PTR32 pInfos;
27037         VkResult result;
27038     } *params = args;
27039     const VkMicromapBuildInfoEXT *pInfos_host;
27040     struct conversion_context local_ctx;
27041     struct conversion_context *ctx = &local_ctx;
27042
27043     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
27044
27045     if (params->deferredOperation == VK_NULL_HANDLE)
27046         init_conversion_context(ctx);
27047     else
27048         ctx = &wine_deferred_operation_from_handle(params->deferredOperation)->ctx;
27049     pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pInfos), params->infoCount);
27050     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);
27051     if (params->deferredOperation == VK_NULL_HANDLE)
27052         free_conversion_context(ctx);
27053     return STATUS_SUCCESS;
27054 }
27055
27056 #ifdef _WIN64
27057 static void thunk64_vkCmdBeginConditionalRenderingEXT(void *args)
27058 {
27059     struct vkCmdBeginConditionalRenderingEXT_params *params = args;
27060
27061     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pConditionalRenderingBegin);
27062 }
27063 #endif /* _WIN64 */
27064
27065 static void thunk32_vkCmdBeginConditionalRenderingEXT(void *args)
27066 {
27067     struct
27068     {
27069         PTR32 commandBuffer;
27070         PTR32 pConditionalRenderingBegin;
27071     } *params = args;
27072     VkConditionalRenderingBeginInfoEXT pConditionalRenderingBegin_host;
27073
27074     convert_VkConditionalRenderingBeginInfoEXT_win32_to_host((const VkConditionalRenderingBeginInfoEXT32 *)UlongToPtr(params->pConditionalRenderingBegin), &pConditionalRenderingBegin_host);
27075     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);
27076 }
27077
27078 #ifdef _WIN64
27079 static void thunk64_vkCmdBeginDebugUtilsLabelEXT(void *args)
27080 {
27081     struct vkCmdBeginDebugUtilsLabelEXT_params *params = args;
27082
27083     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
27084 }
27085 #endif /* _WIN64 */
27086
27087 static void thunk32_vkCmdBeginDebugUtilsLabelEXT(void *args)
27088 {
27089     struct
27090     {
27091         PTR32 commandBuffer;
27092         PTR32 pLabelInfo;
27093     } *params = args;
27094     VkDebugUtilsLabelEXT pLabelInfo_host;
27095
27096     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
27097     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);
27098 }
27099
27100 #ifdef _WIN64
27101 static void thunk64_vkCmdBeginQuery(void *args)
27102 {
27103     struct vkCmdBeginQuery_params *params = args;
27104
27105     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);
27106 }
27107 #endif /* _WIN64 */
27108
27109 static void thunk32_vkCmdBeginQuery(void *args)
27110 {
27111     struct
27112     {
27113         PTR32 commandBuffer;
27114         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
27115         uint32_t query;
27116         VkQueryControlFlags flags;
27117     } *params = args;
27118
27119     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);
27120 }
27121
27122 #ifdef _WIN64
27123 static void thunk64_vkCmdBeginQueryIndexedEXT(void *args)
27124 {
27125     struct vkCmdBeginQueryIndexedEXT_params *params = args;
27126
27127     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);
27128 }
27129 #endif /* _WIN64 */
27130
27131 static void thunk32_vkCmdBeginQueryIndexedEXT(void *args)
27132 {
27133     struct
27134     {
27135         PTR32 commandBuffer;
27136         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
27137         uint32_t query;
27138         VkQueryControlFlags flags;
27139         uint32_t index;
27140     } *params = args;
27141
27142     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);
27143 }
27144
27145 #ifdef _WIN64
27146 static void thunk64_vkCmdBeginRenderPass(void *args)
27147 {
27148     struct vkCmdBeginRenderPass_params *params = args;
27149
27150     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->contents);
27151 }
27152 #endif /* _WIN64 */
27153
27154 static void thunk32_vkCmdBeginRenderPass(void *args)
27155 {
27156     struct
27157     {
27158         PTR32 commandBuffer;
27159         PTR32 pRenderPassBegin;
27160         VkSubpassContents contents;
27161     } *params = args;
27162     VkRenderPassBeginInfo pRenderPassBegin_host;
27163     struct conversion_context local_ctx;
27164     struct conversion_context *ctx = &local_ctx;
27165
27166     init_conversion_context(ctx);
27167     convert_VkRenderPassBeginInfo_win32_to_host(ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
27168     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);
27169     free_conversion_context(ctx);
27170 }
27171
27172 #ifdef _WIN64
27173 static void thunk64_vkCmdBeginRenderPass2(void *args)
27174 {
27175     struct vkCmdBeginRenderPass2_params *params = args;
27176
27177     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
27178 }
27179 #endif /* _WIN64 */
27180
27181 static void thunk32_vkCmdBeginRenderPass2(void *args)
27182 {
27183     struct
27184     {
27185         PTR32 commandBuffer;
27186         PTR32 pRenderPassBegin;
27187         PTR32 pSubpassBeginInfo;
27188     } *params = args;
27189     VkRenderPassBeginInfo pRenderPassBegin_host;
27190     VkSubpassBeginInfo pSubpassBeginInfo_host;
27191     struct conversion_context local_ctx;
27192     struct conversion_context *ctx = &local_ctx;
27193
27194     init_conversion_context(ctx);
27195     convert_VkRenderPassBeginInfo_win32_to_host(ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
27196     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
27197     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);
27198     free_conversion_context(ctx);
27199 }
27200
27201 #ifdef _WIN64
27202 static void thunk64_vkCmdBeginRenderPass2KHR(void *args)
27203 {
27204     struct vkCmdBeginRenderPass2KHR_params *params = args;
27205
27206     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
27207 }
27208 #endif /* _WIN64 */
27209
27210 static void thunk32_vkCmdBeginRenderPass2KHR(void *args)
27211 {
27212     struct
27213     {
27214         PTR32 commandBuffer;
27215         PTR32 pRenderPassBegin;
27216         PTR32 pSubpassBeginInfo;
27217     } *params = args;
27218     VkRenderPassBeginInfo pRenderPassBegin_host;
27219     VkSubpassBeginInfo pSubpassBeginInfo_host;
27220     struct conversion_context local_ctx;
27221     struct conversion_context *ctx = &local_ctx;
27222
27223     init_conversion_context(ctx);
27224     convert_VkRenderPassBeginInfo_win32_to_host(ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
27225     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
27226     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);
27227     free_conversion_context(ctx);
27228 }
27229
27230 #ifdef _WIN64
27231 static void thunk64_vkCmdBeginRendering(void *args)
27232 {
27233     struct vkCmdBeginRendering_params *params = args;
27234
27235     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
27236 }
27237 #endif /* _WIN64 */
27238
27239 static void thunk32_vkCmdBeginRendering(void *args)
27240 {
27241     struct
27242     {
27243         PTR32 commandBuffer;
27244         PTR32 pRenderingInfo;
27245     } *params = args;
27246     VkRenderingInfo pRenderingInfo_host;
27247     struct conversion_context local_ctx;
27248     struct conversion_context *ctx = &local_ctx;
27249
27250     init_conversion_context(ctx);
27251     convert_VkRenderingInfo_win32_to_host(ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
27252     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);
27253     free_conversion_context(ctx);
27254 }
27255
27256 #ifdef _WIN64
27257 static void thunk64_vkCmdBeginRenderingKHR(void *args)
27258 {
27259     struct vkCmdBeginRenderingKHR_params *params = args;
27260
27261     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
27262 }
27263 #endif /* _WIN64 */
27264
27265 static void thunk32_vkCmdBeginRenderingKHR(void *args)
27266 {
27267     struct
27268     {
27269         PTR32 commandBuffer;
27270         PTR32 pRenderingInfo;
27271     } *params = args;
27272     VkRenderingInfo pRenderingInfo_host;
27273     struct conversion_context local_ctx;
27274     struct conversion_context *ctx = &local_ctx;
27275
27276     init_conversion_context(ctx);
27277     convert_VkRenderingInfo_win32_to_host(ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
27278     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);
27279     free_conversion_context(ctx);
27280 }
27281
27282 #ifdef _WIN64
27283 static void thunk64_vkCmdBeginTransformFeedbackEXT(void *args)
27284 {
27285     struct vkCmdBeginTransformFeedbackEXT_params *params = args;
27286
27287     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);
27288 }
27289 #endif /* _WIN64 */
27290
27291 static void thunk32_vkCmdBeginTransformFeedbackEXT(void *args)
27292 {
27293     struct
27294     {
27295         PTR32 commandBuffer;
27296         uint32_t firstCounterBuffer;
27297         uint32_t counterBufferCount;
27298         PTR32 pCounterBuffers;
27299         PTR32 pCounterBufferOffsets;
27300     } *params = args;
27301
27302     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));
27303 }
27304
27305 #ifdef _WIN64
27306 static void thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
27307 {
27308     struct vkCmdBindDescriptorBufferEmbeddedSamplersEXT_params *params = args;
27309
27310     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);
27311 }
27312 #endif /* _WIN64 */
27313
27314 static void thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
27315 {
27316     struct
27317     {
27318         PTR32 commandBuffer;
27319         VkPipelineBindPoint pipelineBindPoint;
27320         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
27321         uint32_t set;
27322     } *params = args;
27323
27324     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);
27325 }
27326
27327 #ifdef _WIN64
27328 static void thunk64_vkCmdBindDescriptorBuffersEXT(void *args)
27329 {
27330     struct vkCmdBindDescriptorBuffersEXT_params *params = args;
27331
27332     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorBuffersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->bufferCount, params->pBindingInfos);
27333 }
27334 #endif /* _WIN64 */
27335
27336 static void thunk32_vkCmdBindDescriptorBuffersEXT(void *args)
27337 {
27338     struct
27339     {
27340         PTR32 commandBuffer;
27341         uint32_t bufferCount;
27342         PTR32 pBindingInfos;
27343     } *params = args;
27344     const VkDescriptorBufferBindingInfoEXT *pBindingInfos_host;
27345     struct conversion_context local_ctx;
27346     struct conversion_context *ctx = &local_ctx;
27347
27348     init_conversion_context(ctx);
27349     pBindingInfos_host = convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(ctx, (const VkDescriptorBufferBindingInfoEXT32 *)UlongToPtr(params->pBindingInfos), params->bufferCount);
27350     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);
27351     free_conversion_context(ctx);
27352 }
27353
27354 #ifdef _WIN64
27355 static void thunk64_vkCmdBindDescriptorSets(void *args)
27356 {
27357     struct vkCmdBindDescriptorSets_params *params = args;
27358
27359     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);
27360 }
27361 #endif /* _WIN64 */
27362
27363 static void thunk32_vkCmdBindDescriptorSets(void *args)
27364 {
27365     struct
27366     {
27367         PTR32 commandBuffer;
27368         VkPipelineBindPoint pipelineBindPoint;
27369         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
27370         uint32_t firstSet;
27371         uint32_t descriptorSetCount;
27372         PTR32 pDescriptorSets;
27373         uint32_t dynamicOffsetCount;
27374         PTR32 pDynamicOffsets;
27375     } *params = args;
27376
27377     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));
27378 }
27379
27380 #ifdef _WIN64
27381 static void thunk64_vkCmdBindIndexBuffer(void *args)
27382 {
27383     struct vkCmdBindIndexBuffer_params *params = args;
27384
27385     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);
27386 }
27387 #endif /* _WIN64 */
27388
27389 static void thunk32_vkCmdBindIndexBuffer(void *args)
27390 {
27391     struct
27392     {
27393         PTR32 commandBuffer;
27394         VkBuffer DECLSPEC_ALIGN(8) buffer;
27395         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27396         VkIndexType indexType;
27397     } *params = args;
27398
27399     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);
27400 }
27401
27402 #ifdef _WIN64
27403 static void thunk64_vkCmdBindInvocationMaskHUAWEI(void *args)
27404 {
27405     struct vkCmdBindInvocationMaskHUAWEI_params *params = args;
27406
27407     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
27408 }
27409 #endif /* _WIN64 */
27410
27411 static void thunk32_vkCmdBindInvocationMaskHUAWEI(void *args)
27412 {
27413     struct
27414     {
27415         PTR32 commandBuffer;
27416         VkImageView DECLSPEC_ALIGN(8) imageView;
27417         VkImageLayout imageLayout;
27418     } *params = args;
27419
27420     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);
27421 }
27422
27423 #ifdef _WIN64
27424 static void thunk64_vkCmdBindPipeline(void *args)
27425 {
27426     struct vkCmdBindPipeline_params *params = args;
27427
27428     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipeline(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline);
27429 }
27430 #endif /* _WIN64 */
27431
27432 static void thunk32_vkCmdBindPipeline(void *args)
27433 {
27434     struct
27435     {
27436         PTR32 commandBuffer;
27437         VkPipelineBindPoint pipelineBindPoint;
27438         VkPipeline DECLSPEC_ALIGN(8) pipeline;
27439     } *params = args;
27440
27441     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);
27442 }
27443
27444 #ifdef _WIN64
27445 static void thunk64_vkCmdBindPipelineShaderGroupNV(void *args)
27446 {
27447     struct vkCmdBindPipelineShaderGroupNV_params *params = args;
27448
27449     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);
27450 }
27451 #endif /* _WIN64 */
27452
27453 static void thunk32_vkCmdBindPipelineShaderGroupNV(void *args)
27454 {
27455     struct
27456     {
27457         PTR32 commandBuffer;
27458         VkPipelineBindPoint pipelineBindPoint;
27459         VkPipeline DECLSPEC_ALIGN(8) pipeline;
27460         uint32_t groupIndex;
27461     } *params = args;
27462
27463     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);
27464 }
27465
27466 #ifdef _WIN64
27467 static void thunk64_vkCmdBindShadersEXT(void *args)
27468 {
27469     struct vkCmdBindShadersEXT_params *params = args;
27470
27471     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);
27472 }
27473 #endif /* _WIN64 */
27474
27475 static void thunk32_vkCmdBindShadersEXT(void *args)
27476 {
27477     struct
27478     {
27479         PTR32 commandBuffer;
27480         uint32_t stageCount;
27481         PTR32 pStages;
27482         PTR32 pShaders;
27483     } *params = args;
27484
27485     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));
27486 }
27487
27488 #ifdef _WIN64
27489 static void thunk64_vkCmdBindShadingRateImageNV(void *args)
27490 {
27491     struct vkCmdBindShadingRateImageNV_params *params = args;
27492
27493     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindShadingRateImageNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
27494 }
27495 #endif /* _WIN64 */
27496
27497 static void thunk32_vkCmdBindShadingRateImageNV(void *args)
27498 {
27499     struct
27500     {
27501         PTR32 commandBuffer;
27502         VkImageView DECLSPEC_ALIGN(8) imageView;
27503         VkImageLayout imageLayout;
27504     } *params = args;
27505
27506     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);
27507 }
27508
27509 #ifdef _WIN64
27510 static void thunk64_vkCmdBindTransformFeedbackBuffersEXT(void *args)
27511 {
27512     struct vkCmdBindTransformFeedbackBuffersEXT_params *params = args;
27513
27514     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);
27515 }
27516 #endif /* _WIN64 */
27517
27518 static void thunk32_vkCmdBindTransformFeedbackBuffersEXT(void *args)
27519 {
27520     struct
27521     {
27522         PTR32 commandBuffer;
27523         uint32_t firstBinding;
27524         uint32_t bindingCount;
27525         PTR32 pBuffers;
27526         PTR32 pOffsets;
27527         PTR32 pSizes;
27528     } *params = args;
27529
27530     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));
27531 }
27532
27533 #ifdef _WIN64
27534 static void thunk64_vkCmdBindVertexBuffers(void *args)
27535 {
27536     struct vkCmdBindVertexBuffers_params *params = args;
27537
27538     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);
27539 }
27540 #endif /* _WIN64 */
27541
27542 static void thunk32_vkCmdBindVertexBuffers(void *args)
27543 {
27544     struct
27545     {
27546         PTR32 commandBuffer;
27547         uint32_t firstBinding;
27548         uint32_t bindingCount;
27549         PTR32 pBuffers;
27550         PTR32 pOffsets;
27551     } *params = args;
27552
27553     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));
27554 }
27555
27556 #ifdef _WIN64
27557 static void thunk64_vkCmdBindVertexBuffers2(void *args)
27558 {
27559     struct vkCmdBindVertexBuffers2_params *params = args;
27560
27561     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);
27562 }
27563 #endif /* _WIN64 */
27564
27565 static void thunk32_vkCmdBindVertexBuffers2(void *args)
27566 {
27567     struct
27568     {
27569         PTR32 commandBuffer;
27570         uint32_t firstBinding;
27571         uint32_t bindingCount;
27572         PTR32 pBuffers;
27573         PTR32 pOffsets;
27574         PTR32 pSizes;
27575         PTR32 pStrides;
27576     } *params = args;
27577
27578     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));
27579 }
27580
27581 #ifdef _WIN64
27582 static void thunk64_vkCmdBindVertexBuffers2EXT(void *args)
27583 {
27584     struct vkCmdBindVertexBuffers2EXT_params *params = args;
27585
27586     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);
27587 }
27588 #endif /* _WIN64 */
27589
27590 static void thunk32_vkCmdBindVertexBuffers2EXT(void *args)
27591 {
27592     struct
27593     {
27594         PTR32 commandBuffer;
27595         uint32_t firstBinding;
27596         uint32_t bindingCount;
27597         PTR32 pBuffers;
27598         PTR32 pOffsets;
27599         PTR32 pSizes;
27600         PTR32 pStrides;
27601     } *params = args;
27602
27603     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));
27604 }
27605
27606 #ifdef _WIN64
27607 static void thunk64_vkCmdBlitImage(void *args)
27608 {
27609     struct vkCmdBlitImage_params *params = args;
27610
27611     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);
27612 }
27613 #endif /* _WIN64 */
27614
27615 static void thunk32_vkCmdBlitImage(void *args)
27616 {
27617     struct
27618     {
27619         PTR32 commandBuffer;
27620         VkImage DECLSPEC_ALIGN(8) srcImage;
27621         VkImageLayout srcImageLayout;
27622         VkImage DECLSPEC_ALIGN(8) dstImage;
27623         VkImageLayout dstImageLayout;
27624         uint32_t regionCount;
27625         PTR32 pRegions;
27626         VkFilter filter;
27627     } *params = args;
27628
27629     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);
27630 }
27631
27632 #ifdef _WIN64
27633 static void thunk64_vkCmdBlitImage2(void *args)
27634 {
27635     struct vkCmdBlitImage2_params *params = args;
27636
27637     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
27638 }
27639 #endif /* _WIN64 */
27640
27641 static void thunk32_vkCmdBlitImage2(void *args)
27642 {
27643     struct
27644     {
27645         PTR32 commandBuffer;
27646         PTR32 pBlitImageInfo;
27647     } *params = args;
27648     VkBlitImageInfo2 pBlitImageInfo_host;
27649     struct conversion_context local_ctx;
27650     struct conversion_context *ctx = &local_ctx;
27651
27652     init_conversion_context(ctx);
27653     convert_VkBlitImageInfo2_win32_to_host(ctx, (const VkBlitImageInfo232 *)UlongToPtr(params->pBlitImageInfo), &pBlitImageInfo_host);
27654     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);
27655     free_conversion_context(ctx);
27656 }
27657
27658 #ifdef _WIN64
27659 static void thunk64_vkCmdBlitImage2KHR(void *args)
27660 {
27661     struct vkCmdBlitImage2KHR_params *params = args;
27662
27663     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
27664 }
27665 #endif /* _WIN64 */
27666
27667 static void thunk32_vkCmdBlitImage2KHR(void *args)
27668 {
27669     struct
27670     {
27671         PTR32 commandBuffer;
27672         PTR32 pBlitImageInfo;
27673     } *params = args;
27674     VkBlitImageInfo2 pBlitImageInfo_host;
27675     struct conversion_context local_ctx;
27676     struct conversion_context *ctx = &local_ctx;
27677
27678     init_conversion_context(ctx);
27679     convert_VkBlitImageInfo2_win32_to_host(ctx, (const VkBlitImageInfo232 *)UlongToPtr(params->pBlitImageInfo), &pBlitImageInfo_host);
27680     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);
27681     free_conversion_context(ctx);
27682 }
27683
27684 #ifdef _WIN64
27685 static void thunk64_vkCmdBuildAccelerationStructureNV(void *args)
27686 {
27687     struct vkCmdBuildAccelerationStructureNV_params *params = args;
27688
27689     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);
27690 }
27691 #endif /* _WIN64 */
27692
27693 static void thunk32_vkCmdBuildAccelerationStructureNV(void *args)
27694 {
27695     struct
27696     {
27697         PTR32 commandBuffer;
27698         PTR32 pInfo;
27699         VkBuffer DECLSPEC_ALIGN(8) instanceData;
27700         VkDeviceSize DECLSPEC_ALIGN(8) instanceOffset;
27701         VkBool32 update;
27702         VkAccelerationStructureNV DECLSPEC_ALIGN(8) dst;
27703         VkAccelerationStructureNV DECLSPEC_ALIGN(8) src;
27704         VkBuffer DECLSPEC_ALIGN(8) scratch;
27705         VkDeviceSize DECLSPEC_ALIGN(8) scratchOffset;
27706     } *params = args;
27707     VkAccelerationStructureInfoNV pInfo_host;
27708     struct conversion_context local_ctx;
27709     struct conversion_context *ctx = &local_ctx;
27710
27711     init_conversion_context(ctx);
27712     convert_VkAccelerationStructureInfoNV_win32_to_host(ctx, (const VkAccelerationStructureInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
27713     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);
27714     free_conversion_context(ctx);
27715 }
27716
27717 #ifdef _WIN64
27718 static void thunk64_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
27719 {
27720     struct vkCmdBuildAccelerationStructuresIndirectKHR_params *params = args;
27721
27722     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);
27723 }
27724 #endif /* _WIN64 */
27725
27726 static void thunk32_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
27727 {
27728     struct
27729     {
27730         PTR32 commandBuffer;
27731         uint32_t infoCount;
27732         PTR32 pInfos;
27733         PTR32 pIndirectDeviceAddresses;
27734         PTR32 pIndirectStrides;
27735         PTR32 ppMaxPrimitiveCounts;
27736     } *params = args;
27737     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
27738     struct conversion_context local_ctx;
27739     struct conversion_context *ctx = &local_ctx;
27740
27741     init_conversion_context(ctx);
27742     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
27743     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));
27744     free_conversion_context(ctx);
27745 }
27746
27747 #ifdef _WIN64
27748 static void thunk64_vkCmdBuildAccelerationStructuresKHR(void *args)
27749 {
27750     struct vkCmdBuildAccelerationStructuresKHR_params *params = args;
27751
27752     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);
27753 }
27754 #endif /* _WIN64 */
27755
27756 static void thunk32_vkCmdBuildAccelerationStructuresKHR(void *args)
27757 {
27758     struct
27759     {
27760         PTR32 commandBuffer;
27761         uint32_t infoCount;
27762         PTR32 pInfos;
27763         PTR32 ppBuildRangeInfos;
27764     } *params = args;
27765     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
27766     struct conversion_context local_ctx;
27767     struct conversion_context *ctx = &local_ctx;
27768
27769     init_conversion_context(ctx);
27770     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
27771     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));
27772     free_conversion_context(ctx);
27773 }
27774
27775 #ifdef _WIN64
27776 static void thunk64_vkCmdBuildMicromapsEXT(void *args)
27777 {
27778     struct vkCmdBuildMicromapsEXT_params *params = args;
27779
27780     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos);
27781 }
27782 #endif /* _WIN64 */
27783
27784 static void thunk32_vkCmdBuildMicromapsEXT(void *args)
27785 {
27786     struct
27787     {
27788         PTR32 commandBuffer;
27789         uint32_t infoCount;
27790         PTR32 pInfos;
27791     } *params = args;
27792     const VkMicromapBuildInfoEXT *pInfos_host;
27793     struct conversion_context local_ctx;
27794     struct conversion_context *ctx = &local_ctx;
27795
27796     init_conversion_context(ctx);
27797     pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pInfos), params->infoCount);
27798     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);
27799     free_conversion_context(ctx);
27800 }
27801
27802 #ifdef _WIN64
27803 static void thunk64_vkCmdClearAttachments(void *args)
27804 {
27805     struct vkCmdClearAttachments_params *params = args;
27806
27807     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);
27808 }
27809 #endif /* _WIN64 */
27810
27811 static void thunk32_vkCmdClearAttachments(void *args)
27812 {
27813     struct
27814     {
27815         PTR32 commandBuffer;
27816         uint32_t attachmentCount;
27817         PTR32 pAttachments;
27818         uint32_t rectCount;
27819         PTR32 pRects;
27820     } *params = args;
27821
27822     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));
27823 }
27824
27825 #ifdef _WIN64
27826 static void thunk64_vkCmdClearColorImage(void *args)
27827 {
27828     struct vkCmdClearColorImage_params *params = args;
27829
27830     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);
27831 }
27832 #endif /* _WIN64 */
27833
27834 static void thunk32_vkCmdClearColorImage(void *args)
27835 {
27836     struct
27837     {
27838         PTR32 commandBuffer;
27839         VkImage DECLSPEC_ALIGN(8) image;
27840         VkImageLayout imageLayout;
27841         PTR32 pColor;
27842         uint32_t rangeCount;
27843         PTR32 pRanges;
27844     } *params = args;
27845
27846     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));
27847 }
27848
27849 #ifdef _WIN64
27850 static void thunk64_vkCmdClearDepthStencilImage(void *args)
27851 {
27852     struct vkCmdClearDepthStencilImage_params *params = args;
27853
27854     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);
27855 }
27856 #endif /* _WIN64 */
27857
27858 static void thunk32_vkCmdClearDepthStencilImage(void *args)
27859 {
27860     struct
27861     {
27862         PTR32 commandBuffer;
27863         VkImage DECLSPEC_ALIGN(8) image;
27864         VkImageLayout imageLayout;
27865         PTR32 pDepthStencil;
27866         uint32_t rangeCount;
27867         PTR32 pRanges;
27868     } *params = args;
27869
27870     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));
27871 }
27872
27873 #ifdef _WIN64
27874 static void thunk64_vkCmdCopyAccelerationStructureKHR(void *args)
27875 {
27876     struct vkCmdCopyAccelerationStructureKHR_params *params = args;
27877
27878     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
27879 }
27880 #endif /* _WIN64 */
27881
27882 static void thunk32_vkCmdCopyAccelerationStructureKHR(void *args)
27883 {
27884     struct
27885     {
27886         PTR32 commandBuffer;
27887         PTR32 pInfo;
27888     } *params = args;
27889     VkCopyAccelerationStructureInfoKHR pInfo_host;
27890
27891     convert_VkCopyAccelerationStructureInfoKHR_win32_to_host((const VkCopyAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
27892     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);
27893 }
27894
27895 #ifdef _WIN64
27896 static void thunk64_vkCmdCopyAccelerationStructureNV(void *args)
27897 {
27898     struct vkCmdCopyAccelerationStructureNV_params *params = args;
27899
27900     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);
27901 }
27902 #endif /* _WIN64 */
27903
27904 static void thunk32_vkCmdCopyAccelerationStructureNV(void *args)
27905 {
27906     struct
27907     {
27908         PTR32 commandBuffer;
27909         VkAccelerationStructureNV DECLSPEC_ALIGN(8) dst;
27910         VkAccelerationStructureNV DECLSPEC_ALIGN(8) src;
27911         VkCopyAccelerationStructureModeKHR mode;
27912     } *params = args;
27913
27914     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);
27915 }
27916
27917 #ifdef _WIN64
27918 static void thunk64_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
27919 {
27920     struct vkCmdCopyAccelerationStructureToMemoryKHR_params *params = args;
27921
27922     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
27923 }
27924 #endif /* _WIN64 */
27925
27926 static void thunk32_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
27927 {
27928     struct
27929     {
27930         PTR32 commandBuffer;
27931         PTR32 pInfo;
27932     } *params = args;
27933     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;
27934
27935     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host((const VkCopyAccelerationStructureToMemoryInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
27936     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);
27937 }
27938
27939 #ifdef _WIN64
27940 static void thunk64_vkCmdCopyBuffer(void *args)
27941 {
27942     struct vkCmdCopyBuffer_params *params = args;
27943
27944     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);
27945 }
27946 #endif /* _WIN64 */
27947
27948 static void thunk32_vkCmdCopyBuffer(void *args)
27949 {
27950     struct
27951     {
27952         PTR32 commandBuffer;
27953         VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
27954         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
27955         uint32_t regionCount;
27956         PTR32 pRegions;
27957     } *params = args;
27958     const VkBufferCopy *pRegions_host;
27959     struct conversion_context local_ctx;
27960     struct conversion_context *ctx = &local_ctx;
27961
27962     init_conversion_context(ctx);
27963     pRegions_host = convert_VkBufferCopy_array_win32_to_host(ctx, (const VkBufferCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
27964     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);
27965     free_conversion_context(ctx);
27966 }
27967
27968 #ifdef _WIN64
27969 static void thunk64_vkCmdCopyBuffer2(void *args)
27970 {
27971     struct vkCmdCopyBuffer2_params *params = args;
27972
27973     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
27974 }
27975 #endif /* _WIN64 */
27976
27977 static void thunk32_vkCmdCopyBuffer2(void *args)
27978 {
27979     struct
27980     {
27981         PTR32 commandBuffer;
27982         PTR32 pCopyBufferInfo;
27983     } *params = args;
27984     VkCopyBufferInfo2 pCopyBufferInfo_host;
27985     struct conversion_context local_ctx;
27986     struct conversion_context *ctx = &local_ctx;
27987
27988     init_conversion_context(ctx);
27989     convert_VkCopyBufferInfo2_win32_to_host(ctx, (const VkCopyBufferInfo232 *)UlongToPtr(params->pCopyBufferInfo), &pCopyBufferInfo_host);
27990     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);
27991     free_conversion_context(ctx);
27992 }
27993
27994 #ifdef _WIN64
27995 static void thunk64_vkCmdCopyBuffer2KHR(void *args)
27996 {
27997     struct vkCmdCopyBuffer2KHR_params *params = args;
27998
27999     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
28000 }
28001 #endif /* _WIN64 */
28002
28003 static void thunk32_vkCmdCopyBuffer2KHR(void *args)
28004 {
28005     struct
28006     {
28007         PTR32 commandBuffer;
28008         PTR32 pCopyBufferInfo;
28009     } *params = args;
28010     VkCopyBufferInfo2 pCopyBufferInfo_host;
28011     struct conversion_context local_ctx;
28012     struct conversion_context *ctx = &local_ctx;
28013
28014     init_conversion_context(ctx);
28015     convert_VkCopyBufferInfo2_win32_to_host(ctx, (const VkCopyBufferInfo232 *)UlongToPtr(params->pCopyBufferInfo), &pCopyBufferInfo_host);
28016     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);
28017     free_conversion_context(ctx);
28018 }
28019
28020 #ifdef _WIN64
28021 static void thunk64_vkCmdCopyBufferToImage(void *args)
28022 {
28023     struct vkCmdCopyBufferToImage_params *params = args;
28024
28025     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);
28026 }
28027 #endif /* _WIN64 */
28028
28029 static void thunk32_vkCmdCopyBufferToImage(void *args)
28030 {
28031     struct
28032     {
28033         PTR32 commandBuffer;
28034         VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
28035         VkImage DECLSPEC_ALIGN(8) dstImage;
28036         VkImageLayout dstImageLayout;
28037         uint32_t regionCount;
28038         PTR32 pRegions;
28039     } *params = args;
28040     const VkBufferImageCopy *pRegions_host;
28041     struct conversion_context local_ctx;
28042     struct conversion_context *ctx = &local_ctx;
28043
28044     init_conversion_context(ctx);
28045     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(ctx, (const VkBufferImageCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
28046     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);
28047     free_conversion_context(ctx);
28048 }
28049
28050 #ifdef _WIN64
28051 static void thunk64_vkCmdCopyBufferToImage2(void *args)
28052 {
28053     struct vkCmdCopyBufferToImage2_params *params = args;
28054
28055     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
28056 }
28057 #endif /* _WIN64 */
28058
28059 static void thunk32_vkCmdCopyBufferToImage2(void *args)
28060 {
28061     struct
28062     {
28063         PTR32 commandBuffer;
28064         PTR32 pCopyBufferToImageInfo;
28065     } *params = args;
28066     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
28067     struct conversion_context local_ctx;
28068     struct conversion_context *ctx = &local_ctx;
28069
28070     init_conversion_context(ctx);
28071     convert_VkCopyBufferToImageInfo2_win32_to_host(ctx, (const VkCopyBufferToImageInfo232 *)UlongToPtr(params->pCopyBufferToImageInfo), &pCopyBufferToImageInfo_host);
28072     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);
28073     free_conversion_context(ctx);
28074 }
28075
28076 #ifdef _WIN64
28077 static void thunk64_vkCmdCopyBufferToImage2KHR(void *args)
28078 {
28079     struct vkCmdCopyBufferToImage2KHR_params *params = args;
28080
28081     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
28082 }
28083 #endif /* _WIN64 */
28084
28085 static void thunk32_vkCmdCopyBufferToImage2KHR(void *args)
28086 {
28087     struct
28088     {
28089         PTR32 commandBuffer;
28090         PTR32 pCopyBufferToImageInfo;
28091     } *params = args;
28092     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
28093     struct conversion_context local_ctx;
28094     struct conversion_context *ctx = &local_ctx;
28095
28096     init_conversion_context(ctx);
28097     convert_VkCopyBufferToImageInfo2_win32_to_host(ctx, (const VkCopyBufferToImageInfo232 *)UlongToPtr(params->pCopyBufferToImageInfo), &pCopyBufferToImageInfo_host);
28098     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);
28099     free_conversion_context(ctx);
28100 }
28101
28102 #ifdef _WIN64
28103 static void thunk64_vkCmdCopyImage(void *args)
28104 {
28105     struct vkCmdCopyImage_params *params = args;
28106
28107     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);
28108 }
28109 #endif /* _WIN64 */
28110
28111 static void thunk32_vkCmdCopyImage(void *args)
28112 {
28113     struct
28114     {
28115         PTR32 commandBuffer;
28116         VkImage DECLSPEC_ALIGN(8) srcImage;
28117         VkImageLayout srcImageLayout;
28118         VkImage DECLSPEC_ALIGN(8) dstImage;
28119         VkImageLayout dstImageLayout;
28120         uint32_t regionCount;
28121         PTR32 pRegions;
28122     } *params = args;
28123
28124     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));
28125 }
28126
28127 #ifdef _WIN64
28128 static void thunk64_vkCmdCopyImage2(void *args)
28129 {
28130     struct vkCmdCopyImage2_params *params = args;
28131
28132     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
28133 }
28134 #endif /* _WIN64 */
28135
28136 static void thunk32_vkCmdCopyImage2(void *args)
28137 {
28138     struct
28139     {
28140         PTR32 commandBuffer;
28141         PTR32 pCopyImageInfo;
28142     } *params = args;
28143     VkCopyImageInfo2 pCopyImageInfo_host;
28144     struct conversion_context local_ctx;
28145     struct conversion_context *ctx = &local_ctx;
28146
28147     init_conversion_context(ctx);
28148     convert_VkCopyImageInfo2_win32_to_host(ctx, (const VkCopyImageInfo232 *)UlongToPtr(params->pCopyImageInfo), &pCopyImageInfo_host);
28149     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);
28150     free_conversion_context(ctx);
28151 }
28152
28153 #ifdef _WIN64
28154 static void thunk64_vkCmdCopyImage2KHR(void *args)
28155 {
28156     struct vkCmdCopyImage2KHR_params *params = args;
28157
28158     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
28159 }
28160 #endif /* _WIN64 */
28161
28162 static void thunk32_vkCmdCopyImage2KHR(void *args)
28163 {
28164     struct
28165     {
28166         PTR32 commandBuffer;
28167         PTR32 pCopyImageInfo;
28168     } *params = args;
28169     VkCopyImageInfo2 pCopyImageInfo_host;
28170     struct conversion_context local_ctx;
28171     struct conversion_context *ctx = &local_ctx;
28172
28173     init_conversion_context(ctx);
28174     convert_VkCopyImageInfo2_win32_to_host(ctx, (const VkCopyImageInfo232 *)UlongToPtr(params->pCopyImageInfo), &pCopyImageInfo_host);
28175     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);
28176     free_conversion_context(ctx);
28177 }
28178
28179 #ifdef _WIN64
28180 static void thunk64_vkCmdCopyImageToBuffer(void *args)
28181 {
28182     struct vkCmdCopyImageToBuffer_params *params = args;
28183
28184     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);
28185 }
28186 #endif /* _WIN64 */
28187
28188 static void thunk32_vkCmdCopyImageToBuffer(void *args)
28189 {
28190     struct
28191     {
28192         PTR32 commandBuffer;
28193         VkImage DECLSPEC_ALIGN(8) srcImage;
28194         VkImageLayout srcImageLayout;
28195         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
28196         uint32_t regionCount;
28197         PTR32 pRegions;
28198     } *params = args;
28199     const VkBufferImageCopy *pRegions_host;
28200     struct conversion_context local_ctx;
28201     struct conversion_context *ctx = &local_ctx;
28202
28203     init_conversion_context(ctx);
28204     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(ctx, (const VkBufferImageCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
28205     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);
28206     free_conversion_context(ctx);
28207 }
28208
28209 #ifdef _WIN64
28210 static void thunk64_vkCmdCopyImageToBuffer2(void *args)
28211 {
28212     struct vkCmdCopyImageToBuffer2_params *params = args;
28213
28214     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
28215 }
28216 #endif /* _WIN64 */
28217
28218 static void thunk32_vkCmdCopyImageToBuffer2(void *args)
28219 {
28220     struct
28221     {
28222         PTR32 commandBuffer;
28223         PTR32 pCopyImageToBufferInfo;
28224     } *params = args;
28225     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
28226     struct conversion_context local_ctx;
28227     struct conversion_context *ctx = &local_ctx;
28228
28229     init_conversion_context(ctx);
28230     convert_VkCopyImageToBufferInfo2_win32_to_host(ctx, (const VkCopyImageToBufferInfo232 *)UlongToPtr(params->pCopyImageToBufferInfo), &pCopyImageToBufferInfo_host);
28231     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);
28232     free_conversion_context(ctx);
28233 }
28234
28235 #ifdef _WIN64
28236 static void thunk64_vkCmdCopyImageToBuffer2KHR(void *args)
28237 {
28238     struct vkCmdCopyImageToBuffer2KHR_params *params = args;
28239
28240     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
28241 }
28242 #endif /* _WIN64 */
28243
28244 static void thunk32_vkCmdCopyImageToBuffer2KHR(void *args)
28245 {
28246     struct
28247     {
28248         PTR32 commandBuffer;
28249         PTR32 pCopyImageToBufferInfo;
28250     } *params = args;
28251     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
28252     struct conversion_context local_ctx;
28253     struct conversion_context *ctx = &local_ctx;
28254
28255     init_conversion_context(ctx);
28256     convert_VkCopyImageToBufferInfo2_win32_to_host(ctx, (const VkCopyImageToBufferInfo232 *)UlongToPtr(params->pCopyImageToBufferInfo), &pCopyImageToBufferInfo_host);
28257     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);
28258     free_conversion_context(ctx);
28259 }
28260
28261 #ifdef _WIN64
28262 static void thunk64_vkCmdCopyMemoryIndirectNV(void *args)
28263 {
28264     struct vkCmdCopyMemoryIndirectNV_params *params = args;
28265
28266     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);
28267 }
28268 #endif /* _WIN64 */
28269
28270 static void thunk32_vkCmdCopyMemoryIndirectNV(void *args)
28271 {
28272     struct
28273     {
28274         PTR32 commandBuffer;
28275         VkDeviceAddress DECLSPEC_ALIGN(8) copyBufferAddress;
28276         uint32_t copyCount;
28277         uint32_t stride;
28278     } *params = args;
28279
28280     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);
28281 }
28282
28283 #ifdef _WIN64
28284 static void thunk64_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
28285 {
28286     struct vkCmdCopyMemoryToAccelerationStructureKHR_params *params = args;
28287
28288     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
28289 }
28290 #endif /* _WIN64 */
28291
28292 static void thunk32_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
28293 {
28294     struct
28295     {
28296         PTR32 commandBuffer;
28297         PTR32 pInfo;
28298     } *params = args;
28299     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;
28300
28301     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host((const VkCopyMemoryToAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
28302     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);
28303 }
28304
28305 #ifdef _WIN64
28306 static void thunk64_vkCmdCopyMemoryToImageIndirectNV(void *args)
28307 {
28308     struct vkCmdCopyMemoryToImageIndirectNV_params *params = args;
28309
28310     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);
28311 }
28312 #endif /* _WIN64 */
28313
28314 static void thunk32_vkCmdCopyMemoryToImageIndirectNV(void *args)
28315 {
28316     struct
28317     {
28318         PTR32 commandBuffer;
28319         VkDeviceAddress DECLSPEC_ALIGN(8) copyBufferAddress;
28320         uint32_t copyCount;
28321         uint32_t stride;
28322         VkImage DECLSPEC_ALIGN(8) dstImage;
28323         VkImageLayout dstImageLayout;
28324         PTR32 pImageSubresources;
28325     } *params = args;
28326
28327     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));
28328 }
28329
28330 #ifdef _WIN64
28331 static void thunk64_vkCmdCopyMemoryToMicromapEXT(void *args)
28332 {
28333     struct vkCmdCopyMemoryToMicromapEXT_params *params = args;
28334
28335     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
28336 }
28337 #endif /* _WIN64 */
28338
28339 static void thunk32_vkCmdCopyMemoryToMicromapEXT(void *args)
28340 {
28341     struct
28342     {
28343         PTR32 commandBuffer;
28344         PTR32 pInfo;
28345     } *params = args;
28346     VkCopyMemoryToMicromapInfoEXT pInfo_host;
28347
28348     convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host((const VkCopyMemoryToMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
28349     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);
28350 }
28351
28352 #ifdef _WIN64
28353 static void thunk64_vkCmdCopyMicromapEXT(void *args)
28354 {
28355     struct vkCmdCopyMicromapEXT_params *params = args;
28356
28357     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
28358 }
28359 #endif /* _WIN64 */
28360
28361 static void thunk32_vkCmdCopyMicromapEXT(void *args)
28362 {
28363     struct
28364     {
28365         PTR32 commandBuffer;
28366         PTR32 pInfo;
28367     } *params = args;
28368     VkCopyMicromapInfoEXT pInfo_host;
28369
28370     convert_VkCopyMicromapInfoEXT_win32_to_host((const VkCopyMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
28371     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);
28372 }
28373
28374 #ifdef _WIN64
28375 static void thunk64_vkCmdCopyMicromapToMemoryEXT(void *args)
28376 {
28377     struct vkCmdCopyMicromapToMemoryEXT_params *params = args;
28378
28379     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
28380 }
28381 #endif /* _WIN64 */
28382
28383 static void thunk32_vkCmdCopyMicromapToMemoryEXT(void *args)
28384 {
28385     struct
28386     {
28387         PTR32 commandBuffer;
28388         PTR32 pInfo;
28389     } *params = args;
28390     VkCopyMicromapToMemoryInfoEXT pInfo_host;
28391
28392     convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host((const VkCopyMicromapToMemoryInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
28393     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);
28394 }
28395
28396 #ifdef _WIN64
28397 static void thunk64_vkCmdCopyQueryPoolResults(void *args)
28398 {
28399     struct vkCmdCopyQueryPoolResults_params *params = args;
28400
28401     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);
28402 }
28403 #endif /* _WIN64 */
28404
28405 static void thunk32_vkCmdCopyQueryPoolResults(void *args)
28406 {
28407     struct
28408     {
28409         PTR32 commandBuffer;
28410         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
28411         uint32_t firstQuery;
28412         uint32_t queryCount;
28413         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
28414         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
28415         VkDeviceSize DECLSPEC_ALIGN(8) stride;
28416         VkQueryResultFlags flags;
28417     } *params = args;
28418
28419     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);
28420 }
28421
28422 #ifdef _WIN64
28423 static void thunk64_vkCmdCuLaunchKernelNVX(void *args)
28424 {
28425     struct vkCmdCuLaunchKernelNVX_params *params = args;
28426
28427     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLaunchInfo);
28428 }
28429 #endif /* _WIN64 */
28430
28431 static void thunk32_vkCmdCuLaunchKernelNVX(void *args)
28432 {
28433     struct
28434     {
28435         PTR32 commandBuffer;
28436         PTR32 pLaunchInfo;
28437     } *params = args;
28438     VkCuLaunchInfoNVX pLaunchInfo_host;
28439
28440     convert_VkCuLaunchInfoNVX_win32_to_host((const VkCuLaunchInfoNVX32 *)UlongToPtr(params->pLaunchInfo), &pLaunchInfo_host);
28441     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);
28442 }
28443
28444 #ifdef _WIN64
28445 static void thunk64_vkCmdDebugMarkerBeginEXT(void *args)
28446 {
28447     struct vkCmdDebugMarkerBeginEXT_params *params = args;
28448
28449     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerBeginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
28450 }
28451 #endif /* _WIN64 */
28452
28453 static void thunk32_vkCmdDebugMarkerBeginEXT(void *args)
28454 {
28455     struct
28456     {
28457         PTR32 commandBuffer;
28458         PTR32 pMarkerInfo;
28459     } *params = args;
28460     VkDebugMarkerMarkerInfoEXT pMarkerInfo_host;
28461
28462     convert_VkDebugMarkerMarkerInfoEXT_win32_to_host((const VkDebugMarkerMarkerInfoEXT32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
28463     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);
28464 }
28465
28466 #ifdef _WIN64
28467 static void thunk64_vkCmdDebugMarkerEndEXT(void *args)
28468 {
28469     struct vkCmdDebugMarkerEndEXT_params *params = args;
28470
28471     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
28472 }
28473 #endif /* _WIN64 */
28474
28475 static void thunk32_vkCmdDebugMarkerEndEXT(void *args)
28476 {
28477     struct
28478     {
28479         PTR32 commandBuffer;
28480     } *params = args;
28481
28482     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
28483 }
28484
28485 #ifdef _WIN64
28486 static void thunk64_vkCmdDebugMarkerInsertEXT(void *args)
28487 {
28488     struct vkCmdDebugMarkerInsertEXT_params *params = args;
28489
28490     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerInsertEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
28491 }
28492 #endif /* _WIN64 */
28493
28494 static void thunk32_vkCmdDebugMarkerInsertEXT(void *args)
28495 {
28496     struct
28497     {
28498         PTR32 commandBuffer;
28499         PTR32 pMarkerInfo;
28500     } *params = args;
28501     VkDebugMarkerMarkerInfoEXT pMarkerInfo_host;
28502
28503     convert_VkDebugMarkerMarkerInfoEXT_win32_to_host((const VkDebugMarkerMarkerInfoEXT32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
28504     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);
28505 }
28506
28507 #ifdef _WIN64
28508 static void thunk64_vkCmdDecompressMemoryIndirectCountNV(void *args)
28509 {
28510     struct vkCmdDecompressMemoryIndirectCountNV_params *params = args;
28511
28512     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);
28513 }
28514 #endif /* _WIN64 */
28515
28516 static void thunk32_vkCmdDecompressMemoryIndirectCountNV(void *args)
28517 {
28518     struct
28519     {
28520         PTR32 commandBuffer;
28521         VkDeviceAddress DECLSPEC_ALIGN(8) indirectCommandsAddress;
28522         VkDeviceAddress DECLSPEC_ALIGN(8) indirectCommandsCountAddress;
28523         uint32_t stride;
28524     } *params = args;
28525
28526     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);
28527 }
28528
28529 #ifdef _WIN64
28530 static void thunk64_vkCmdDecompressMemoryNV(void *args)
28531 {
28532     struct vkCmdDecompressMemoryNV_params *params = args;
28533
28534     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
28535 }
28536 #endif /* _WIN64 */
28537
28538 static void thunk32_vkCmdDecompressMemoryNV(void *args)
28539 {
28540     struct
28541     {
28542         PTR32 commandBuffer;
28543         uint32_t decompressRegionCount;
28544         PTR32 pDecompressMemoryRegions;
28545     } *params = args;
28546     const VkDecompressMemoryRegionNV *pDecompressMemoryRegions_host;
28547     struct conversion_context local_ctx;
28548     struct conversion_context *ctx = &local_ctx;
28549
28550     init_conversion_context(ctx);
28551     pDecompressMemoryRegions_host = convert_VkDecompressMemoryRegionNV_array_win32_to_host(ctx, (const VkDecompressMemoryRegionNV32 *)UlongToPtr(params->pDecompressMemoryRegions), params->decompressRegionCount);
28552     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);
28553     free_conversion_context(ctx);
28554 }
28555
28556 #ifdef _WIN64
28557 static void thunk64_vkCmdDispatch(void *args)
28558 {
28559     struct vkCmdDispatch_params *params = args;
28560
28561     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);
28562 }
28563 #endif /* _WIN64 */
28564
28565 static void thunk32_vkCmdDispatch(void *args)
28566 {
28567     struct
28568     {
28569         PTR32 commandBuffer;
28570         uint32_t groupCountX;
28571         uint32_t groupCountY;
28572         uint32_t groupCountZ;
28573     } *params = args;
28574
28575     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);
28576 }
28577
28578 #ifdef _WIN64
28579 static void thunk64_vkCmdDispatchBase(void *args)
28580 {
28581     struct vkCmdDispatchBase_params *params = args;
28582
28583     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);
28584 }
28585 #endif /* _WIN64 */
28586
28587 static void thunk32_vkCmdDispatchBase(void *args)
28588 {
28589     struct
28590     {
28591         PTR32 commandBuffer;
28592         uint32_t baseGroupX;
28593         uint32_t baseGroupY;
28594         uint32_t baseGroupZ;
28595         uint32_t groupCountX;
28596         uint32_t groupCountY;
28597         uint32_t groupCountZ;
28598     } *params = args;
28599
28600     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);
28601 }
28602
28603 #ifdef _WIN64
28604 static void thunk64_vkCmdDispatchBaseKHR(void *args)
28605 {
28606     struct vkCmdDispatchBaseKHR_params *params = args;
28607
28608     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);
28609 }
28610 #endif /* _WIN64 */
28611
28612 static void thunk32_vkCmdDispatchBaseKHR(void *args)
28613 {
28614     struct
28615     {
28616         PTR32 commandBuffer;
28617         uint32_t baseGroupX;
28618         uint32_t baseGroupY;
28619         uint32_t baseGroupZ;
28620         uint32_t groupCountX;
28621         uint32_t groupCountY;
28622         uint32_t groupCountZ;
28623     } *params = args;
28624
28625     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);
28626 }
28627
28628 #ifdef _WIN64
28629 static void thunk64_vkCmdDispatchIndirect(void *args)
28630 {
28631     struct vkCmdDispatchIndirect_params *params = args;
28632
28633     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset);
28634 }
28635 #endif /* _WIN64 */
28636
28637 static void thunk32_vkCmdDispatchIndirect(void *args)
28638 {
28639     struct
28640     {
28641         PTR32 commandBuffer;
28642         VkBuffer DECLSPEC_ALIGN(8) buffer;
28643         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28644     } *params = args;
28645
28646     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);
28647 }
28648
28649 #ifdef _WIN64
28650 static void thunk64_vkCmdDraw(void *args)
28651 {
28652     struct vkCmdDraw_params *params = args;
28653
28654     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);
28655 }
28656 #endif /* _WIN64 */
28657
28658 static void thunk32_vkCmdDraw(void *args)
28659 {
28660     struct
28661     {
28662         PTR32 commandBuffer;
28663         uint32_t vertexCount;
28664         uint32_t instanceCount;
28665         uint32_t firstVertex;
28666         uint32_t firstInstance;
28667     } *params = args;
28668
28669     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);
28670 }
28671
28672 #ifdef _WIN64
28673 static void thunk64_vkCmdDrawClusterHUAWEI(void *args)
28674 {
28675     struct vkCmdDrawClusterHUAWEI_params *params = args;
28676
28677     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);
28678 }
28679 #endif /* _WIN64 */
28680
28681 static void thunk32_vkCmdDrawClusterHUAWEI(void *args)
28682 {
28683     struct
28684     {
28685         PTR32 commandBuffer;
28686         uint32_t groupCountX;
28687         uint32_t groupCountY;
28688         uint32_t groupCountZ;
28689     } *params = args;
28690
28691     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);
28692 }
28693
28694 #ifdef _WIN64
28695 static void thunk64_vkCmdDrawClusterIndirectHUAWEI(void *args)
28696 {
28697     struct vkCmdDrawClusterIndirectHUAWEI_params *params = args;
28698
28699     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawClusterIndirectHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset);
28700 }
28701 #endif /* _WIN64 */
28702
28703 static void thunk32_vkCmdDrawClusterIndirectHUAWEI(void *args)
28704 {
28705     struct
28706     {
28707         PTR32 commandBuffer;
28708         VkBuffer DECLSPEC_ALIGN(8) buffer;
28709         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28710     } *params = args;
28711
28712     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);
28713 }
28714
28715 #ifdef _WIN64
28716 static void thunk64_vkCmdDrawIndexed(void *args)
28717 {
28718     struct vkCmdDrawIndexed_params *params = args;
28719
28720     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);
28721 }
28722 #endif /* _WIN64 */
28723
28724 static void thunk32_vkCmdDrawIndexed(void *args)
28725 {
28726     struct
28727     {
28728         PTR32 commandBuffer;
28729         uint32_t indexCount;
28730         uint32_t instanceCount;
28731         uint32_t firstIndex;
28732         int32_t vertexOffset;
28733         uint32_t firstInstance;
28734     } *params = args;
28735
28736     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);
28737 }
28738
28739 #ifdef _WIN64
28740 static void thunk64_vkCmdDrawIndexedIndirect(void *args)
28741 {
28742     struct vkCmdDrawIndexedIndirect_params *params = args;
28743
28744     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);
28745 }
28746 #endif /* _WIN64 */
28747
28748 static void thunk32_vkCmdDrawIndexedIndirect(void *args)
28749 {
28750     struct
28751     {
28752         PTR32 commandBuffer;
28753         VkBuffer DECLSPEC_ALIGN(8) buffer;
28754         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28755         uint32_t drawCount;
28756         uint32_t stride;
28757     } *params = args;
28758
28759     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);
28760 }
28761
28762 #ifdef _WIN64
28763 static void thunk64_vkCmdDrawIndexedIndirectCount(void *args)
28764 {
28765     struct vkCmdDrawIndexedIndirectCount_params *params = args;
28766
28767     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);
28768 }
28769 #endif /* _WIN64 */
28770
28771 static void thunk32_vkCmdDrawIndexedIndirectCount(void *args)
28772 {
28773     struct
28774     {
28775         PTR32 commandBuffer;
28776         VkBuffer DECLSPEC_ALIGN(8) buffer;
28777         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28778         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28779         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
28780         uint32_t maxDrawCount;
28781         uint32_t stride;
28782     } *params = args;
28783
28784     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);
28785 }
28786
28787 #ifdef _WIN64
28788 static void thunk64_vkCmdDrawIndexedIndirectCountAMD(void *args)
28789 {
28790     struct vkCmdDrawIndexedIndirectCountAMD_params *params = args;
28791
28792     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);
28793 }
28794 #endif /* _WIN64 */
28795
28796 static void thunk32_vkCmdDrawIndexedIndirectCountAMD(void *args)
28797 {
28798     struct
28799     {
28800         PTR32 commandBuffer;
28801         VkBuffer DECLSPEC_ALIGN(8) buffer;
28802         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28803         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28804         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
28805         uint32_t maxDrawCount;
28806         uint32_t stride;
28807     } *params = args;
28808
28809     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);
28810 }
28811
28812 #ifdef _WIN64
28813 static void thunk64_vkCmdDrawIndexedIndirectCountKHR(void *args)
28814 {
28815     struct vkCmdDrawIndexedIndirectCountKHR_params *params = args;
28816
28817     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);
28818 }
28819 #endif /* _WIN64 */
28820
28821 static void thunk32_vkCmdDrawIndexedIndirectCountKHR(void *args)
28822 {
28823     struct
28824     {
28825         PTR32 commandBuffer;
28826         VkBuffer DECLSPEC_ALIGN(8) buffer;
28827         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28828         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28829         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
28830         uint32_t maxDrawCount;
28831         uint32_t stride;
28832     } *params = args;
28833
28834     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);
28835 }
28836
28837 #ifdef _WIN64
28838 static void thunk64_vkCmdDrawIndirect(void *args)
28839 {
28840     struct vkCmdDrawIndirect_params *params = args;
28841
28842     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);
28843 }
28844 #endif /* _WIN64 */
28845
28846 static void thunk32_vkCmdDrawIndirect(void *args)
28847 {
28848     struct
28849     {
28850         PTR32 commandBuffer;
28851         VkBuffer DECLSPEC_ALIGN(8) buffer;
28852         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28853         uint32_t drawCount;
28854         uint32_t stride;
28855     } *params = args;
28856
28857     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);
28858 }
28859
28860 #ifdef _WIN64
28861 static void thunk64_vkCmdDrawIndirectByteCountEXT(void *args)
28862 {
28863     struct vkCmdDrawIndirectByteCountEXT_params *params = args;
28864
28865     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);
28866 }
28867 #endif /* _WIN64 */
28868
28869 static void thunk32_vkCmdDrawIndirectByteCountEXT(void *args)
28870 {
28871     struct
28872     {
28873         PTR32 commandBuffer;
28874         uint32_t instanceCount;
28875         uint32_t firstInstance;
28876         VkBuffer DECLSPEC_ALIGN(8) counterBuffer;
28877         VkDeviceSize DECLSPEC_ALIGN(8) counterBufferOffset;
28878         uint32_t counterOffset;
28879         uint32_t vertexStride;
28880     } *params = args;
28881
28882     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);
28883 }
28884
28885 #ifdef _WIN64
28886 static void thunk64_vkCmdDrawIndirectCount(void *args)
28887 {
28888     struct vkCmdDrawIndirectCount_params *params = args;
28889
28890     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);
28891 }
28892 #endif /* _WIN64 */
28893
28894 static void thunk32_vkCmdDrawIndirectCount(void *args)
28895 {
28896     struct
28897     {
28898         PTR32 commandBuffer;
28899         VkBuffer DECLSPEC_ALIGN(8) buffer;
28900         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28901         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28902         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
28903         uint32_t maxDrawCount;
28904         uint32_t stride;
28905     } *params = args;
28906
28907     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);
28908 }
28909
28910 #ifdef _WIN64
28911 static void thunk64_vkCmdDrawIndirectCountAMD(void *args)
28912 {
28913     struct vkCmdDrawIndirectCountAMD_params *params = args;
28914
28915     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);
28916 }
28917 #endif /* _WIN64 */
28918
28919 static void thunk32_vkCmdDrawIndirectCountAMD(void *args)
28920 {
28921     struct
28922     {
28923         PTR32 commandBuffer;
28924         VkBuffer DECLSPEC_ALIGN(8) buffer;
28925         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28926         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28927         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
28928         uint32_t maxDrawCount;
28929         uint32_t stride;
28930     } *params = args;
28931
28932     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);
28933 }
28934
28935 #ifdef _WIN64
28936 static void thunk64_vkCmdDrawIndirectCountKHR(void *args)
28937 {
28938     struct vkCmdDrawIndirectCountKHR_params *params = args;
28939
28940     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);
28941 }
28942 #endif /* _WIN64 */
28943
28944 static void thunk32_vkCmdDrawIndirectCountKHR(void *args)
28945 {
28946     struct
28947     {
28948         PTR32 commandBuffer;
28949         VkBuffer DECLSPEC_ALIGN(8) buffer;
28950         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28951         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28952         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
28953         uint32_t maxDrawCount;
28954         uint32_t stride;
28955     } *params = args;
28956
28957     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);
28958 }
28959
28960 #ifdef _WIN64
28961 static void thunk64_vkCmdDrawMeshTasksEXT(void *args)
28962 {
28963     struct vkCmdDrawMeshTasksEXT_params *params = args;
28964
28965     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);
28966 }
28967 #endif /* _WIN64 */
28968
28969 static void thunk32_vkCmdDrawMeshTasksEXT(void *args)
28970 {
28971     struct
28972     {
28973         PTR32 commandBuffer;
28974         uint32_t groupCountX;
28975         uint32_t groupCountY;
28976         uint32_t groupCountZ;
28977     } *params = args;
28978
28979     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);
28980 }
28981
28982 #ifdef _WIN64
28983 static void thunk64_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
28984 {
28985     struct vkCmdDrawMeshTasksIndirectCountEXT_params *params = args;
28986
28987     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);
28988 }
28989 #endif /* _WIN64 */
28990
28991 static void thunk32_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
28992 {
28993     struct
28994     {
28995         PTR32 commandBuffer;
28996         VkBuffer DECLSPEC_ALIGN(8) buffer;
28997         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28998         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
28999         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
29000         uint32_t maxDrawCount;
29001         uint32_t stride;
29002     } *params = args;
29003
29004     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);
29005 }
29006
29007 #ifdef _WIN64
29008 static void thunk64_vkCmdDrawMeshTasksIndirectCountNV(void *args)
29009 {
29010     struct vkCmdDrawMeshTasksIndirectCountNV_params *params = args;
29011
29012     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);
29013 }
29014 #endif /* _WIN64 */
29015
29016 static void thunk32_vkCmdDrawMeshTasksIndirectCountNV(void *args)
29017 {
29018     struct
29019     {
29020         PTR32 commandBuffer;
29021         VkBuffer DECLSPEC_ALIGN(8) buffer;
29022         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29023         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
29024         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
29025         uint32_t maxDrawCount;
29026         uint32_t stride;
29027     } *params = args;
29028
29029     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);
29030 }
29031
29032 #ifdef _WIN64
29033 static void thunk64_vkCmdDrawMeshTasksIndirectEXT(void *args)
29034 {
29035     struct vkCmdDrawMeshTasksIndirectEXT_params *params = args;
29036
29037     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);
29038 }
29039 #endif /* _WIN64 */
29040
29041 static void thunk32_vkCmdDrawMeshTasksIndirectEXT(void *args)
29042 {
29043     struct
29044     {
29045         PTR32 commandBuffer;
29046         VkBuffer DECLSPEC_ALIGN(8) buffer;
29047         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29048         uint32_t drawCount;
29049         uint32_t stride;
29050     } *params = args;
29051
29052     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);
29053 }
29054
29055 #ifdef _WIN64
29056 static void thunk64_vkCmdDrawMeshTasksIndirectNV(void *args)
29057 {
29058     struct vkCmdDrawMeshTasksIndirectNV_params *params = args;
29059
29060     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);
29061 }
29062 #endif /* _WIN64 */
29063
29064 static void thunk32_vkCmdDrawMeshTasksIndirectNV(void *args)
29065 {
29066     struct
29067     {
29068         PTR32 commandBuffer;
29069         VkBuffer DECLSPEC_ALIGN(8) buffer;
29070         VkDeviceSize DECLSPEC_ALIGN(8) offset;
29071         uint32_t drawCount;
29072         uint32_t stride;
29073     } *params = args;
29074
29075     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);
29076 }
29077
29078 #ifdef _WIN64
29079 static void thunk64_vkCmdDrawMeshTasksNV(void *args)
29080 {
29081     struct vkCmdDrawMeshTasksNV_params *params = args;
29082
29083     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->taskCount, params->firstTask);
29084 }
29085 #endif /* _WIN64 */
29086
29087 static void thunk32_vkCmdDrawMeshTasksNV(void *args)
29088 {
29089     struct
29090     {
29091         PTR32 commandBuffer;
29092         uint32_t taskCount;
29093         uint32_t firstTask;
29094     } *params = args;
29095
29096     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);
29097 }
29098
29099 #ifdef _WIN64
29100 static void thunk64_vkCmdDrawMultiEXT(void *args)
29101 {
29102     struct vkCmdDrawMultiEXT_params *params = args;
29103
29104     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);
29105 }
29106 #endif /* _WIN64 */
29107
29108 static void thunk32_vkCmdDrawMultiEXT(void *args)
29109 {
29110     struct
29111     {
29112         PTR32 commandBuffer;
29113         uint32_t drawCount;
29114         PTR32 pVertexInfo;
29115         uint32_t instanceCount;
29116         uint32_t firstInstance;
29117         uint32_t stride;
29118     } *params = args;
29119
29120     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);
29121 }
29122
29123 #ifdef _WIN64
29124 static void thunk64_vkCmdDrawMultiIndexedEXT(void *args)
29125 {
29126     struct vkCmdDrawMultiIndexedEXT_params *params = args;
29127
29128     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);
29129 }
29130 #endif /* _WIN64 */
29131
29132 static void thunk32_vkCmdDrawMultiIndexedEXT(void *args)
29133 {
29134     struct
29135     {
29136         PTR32 commandBuffer;
29137         uint32_t drawCount;
29138         PTR32 pIndexInfo;
29139         uint32_t instanceCount;
29140         uint32_t firstInstance;
29141         uint32_t stride;
29142         PTR32 pVertexOffset;
29143     } *params = args;
29144
29145     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));
29146 }
29147
29148 #ifdef _WIN64
29149 static void thunk64_vkCmdEndConditionalRenderingEXT(void *args)
29150 {
29151     struct vkCmdEndConditionalRenderingEXT_params *params = args;
29152
29153     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
29154 }
29155 #endif /* _WIN64 */
29156
29157 static void thunk32_vkCmdEndConditionalRenderingEXT(void *args)
29158 {
29159     struct
29160     {
29161         PTR32 commandBuffer;
29162     } *params = args;
29163
29164     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
29165 }
29166
29167 #ifdef _WIN64
29168 static void thunk64_vkCmdEndDebugUtilsLabelEXT(void *args)
29169 {
29170     struct vkCmdEndDebugUtilsLabelEXT_params *params = args;
29171
29172     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
29173 }
29174 #endif /* _WIN64 */
29175
29176 static void thunk32_vkCmdEndDebugUtilsLabelEXT(void *args)
29177 {
29178     struct
29179     {
29180         PTR32 commandBuffer;
29181     } *params = args;
29182
29183     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
29184 }
29185
29186 #ifdef _WIN64
29187 static void thunk64_vkCmdEndQuery(void *args)
29188 {
29189     struct vkCmdEndQuery_params *params = args;
29190
29191     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query);
29192 }
29193 #endif /* _WIN64 */
29194
29195 static void thunk32_vkCmdEndQuery(void *args)
29196 {
29197     struct
29198     {
29199         PTR32 commandBuffer;
29200         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
29201         uint32_t query;
29202     } *params = args;
29203
29204     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);
29205 }
29206
29207 #ifdef _WIN64
29208 static void thunk64_vkCmdEndQueryIndexedEXT(void *args)
29209 {
29210     struct vkCmdEndQueryIndexedEXT_params *params = args;
29211
29212     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);
29213 }
29214 #endif /* _WIN64 */
29215
29216 static void thunk32_vkCmdEndQueryIndexedEXT(void *args)
29217 {
29218     struct
29219     {
29220         PTR32 commandBuffer;
29221         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
29222         uint32_t query;
29223         uint32_t index;
29224     } *params = args;
29225
29226     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);
29227 }
29228
29229 #ifdef _WIN64
29230 static void thunk64_vkCmdEndRenderPass(void *args)
29231 {
29232     struct vkCmdEndRenderPass_params *params = args;
29233
29234     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
29235 }
29236 #endif /* _WIN64 */
29237
29238 static void thunk32_vkCmdEndRenderPass(void *args)
29239 {
29240     struct
29241     {
29242         PTR32 commandBuffer;
29243     } *params = args;
29244
29245     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
29246 }
29247
29248 #ifdef _WIN64
29249 static void thunk64_vkCmdEndRenderPass2(void *args)
29250 {
29251     struct vkCmdEndRenderPass2_params *params = args;
29252
29253     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
29254 }
29255 #endif /* _WIN64 */
29256
29257 static void thunk32_vkCmdEndRenderPass2(void *args)
29258 {
29259     struct
29260     {
29261         PTR32 commandBuffer;
29262         PTR32 pSubpassEndInfo;
29263     } *params = args;
29264     VkSubpassEndInfo pSubpassEndInfo_host;
29265     struct conversion_context local_ctx;
29266     struct conversion_context *ctx = &local_ctx;
29267
29268     init_conversion_context(ctx);
29269     convert_VkSubpassEndInfo_win32_to_host(ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
29270     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);
29271     free_conversion_context(ctx);
29272 }
29273
29274 #ifdef _WIN64
29275 static void thunk64_vkCmdEndRenderPass2KHR(void *args)
29276 {
29277     struct vkCmdEndRenderPass2KHR_params *params = args;
29278
29279     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
29280 }
29281 #endif /* _WIN64 */
29282
29283 static void thunk32_vkCmdEndRenderPass2KHR(void *args)
29284 {
29285     struct
29286     {
29287         PTR32 commandBuffer;
29288         PTR32 pSubpassEndInfo;
29289     } *params = args;
29290     VkSubpassEndInfo pSubpassEndInfo_host;
29291     struct conversion_context local_ctx;
29292     struct conversion_context *ctx = &local_ctx;
29293
29294     init_conversion_context(ctx);
29295     convert_VkSubpassEndInfo_win32_to_host(ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
29296     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);
29297     free_conversion_context(ctx);
29298 }
29299
29300 #ifdef _WIN64
29301 static void thunk64_vkCmdEndRendering(void *args)
29302 {
29303     struct vkCmdEndRendering_params *params = args;
29304
29305     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
29306 }
29307 #endif /* _WIN64 */
29308
29309 static void thunk32_vkCmdEndRendering(void *args)
29310 {
29311     struct
29312     {
29313         PTR32 commandBuffer;
29314     } *params = args;
29315
29316     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
29317 }
29318
29319 #ifdef _WIN64
29320 static void thunk64_vkCmdEndRenderingKHR(void *args)
29321 {
29322     struct vkCmdEndRenderingKHR_params *params = args;
29323
29324     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
29325 }
29326 #endif /* _WIN64 */
29327
29328 static void thunk32_vkCmdEndRenderingKHR(void *args)
29329 {
29330     struct
29331     {
29332         PTR32 commandBuffer;
29333     } *params = args;
29334
29335     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
29336 }
29337
29338 #ifdef _WIN64
29339 static void thunk64_vkCmdEndTransformFeedbackEXT(void *args)
29340 {
29341     struct vkCmdEndTransformFeedbackEXT_params *params = args;
29342
29343     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);
29344 }
29345 #endif /* _WIN64 */
29346
29347 static void thunk32_vkCmdEndTransformFeedbackEXT(void *args)
29348 {
29349     struct
29350     {
29351         PTR32 commandBuffer;
29352         uint32_t firstCounterBuffer;
29353         uint32_t counterBufferCount;
29354         PTR32 pCounterBuffers;
29355         PTR32 pCounterBufferOffsets;
29356     } *params = args;
29357
29358     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));
29359 }
29360
29361 #ifdef _WIN64
29362 static void thunk64_vkCmdExecuteCommands(void *args)
29363 {
29364     struct vkCmdExecuteCommands_params *params = args;
29365     const VkCommandBuffer *pCommandBuffers_host;
29366     struct conversion_context local_ctx;
29367     struct conversion_context *ctx = &local_ctx;
29368
29369     init_conversion_context(ctx);
29370     pCommandBuffers_host = convert_VkCommandBuffer_array_win64_to_host(ctx, params->pCommandBuffers, params->commandBufferCount);
29371     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->commandBufferCount, pCommandBuffers_host);
29372     free_conversion_context(ctx);
29373 }
29374 #endif /* _WIN64 */
29375
29376 static void thunk32_vkCmdExecuteCommands(void *args)
29377 {
29378     struct
29379     {
29380         PTR32 commandBuffer;
29381         uint32_t commandBufferCount;
29382         PTR32 pCommandBuffers;
29383     } *params = args;
29384     const VkCommandBuffer *pCommandBuffers_host;
29385     struct conversion_context local_ctx;
29386     struct conversion_context *ctx = &local_ctx;
29387
29388     init_conversion_context(ctx);
29389     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(params->pCommandBuffers), params->commandBufferCount);
29390     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);
29391     free_conversion_context(ctx);
29392 }
29393
29394 #ifdef _WIN64
29395 static void thunk64_vkCmdExecuteGeneratedCommandsNV(void *args)
29396 {
29397     struct vkCmdExecuteGeneratedCommandsNV_params *params = args;
29398
29399     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
29400 }
29401 #endif /* _WIN64 */
29402
29403 static void thunk32_vkCmdExecuteGeneratedCommandsNV(void *args)
29404 {
29405     struct
29406     {
29407         PTR32 commandBuffer;
29408         VkBool32 isPreprocessed;
29409         PTR32 pGeneratedCommandsInfo;
29410     } *params = args;
29411     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
29412     struct conversion_context local_ctx;
29413     struct conversion_context *ctx = &local_ctx;
29414
29415     init_conversion_context(ctx);
29416     convert_VkGeneratedCommandsInfoNV_win32_to_host(ctx, (const VkGeneratedCommandsInfoNV32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
29417     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);
29418     free_conversion_context(ctx);
29419 }
29420
29421 #ifdef _WIN64
29422 static void thunk64_vkCmdFillBuffer(void *args)
29423 {
29424     struct vkCmdFillBuffer_params *params = args;
29425
29426     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);
29427 }
29428 #endif /* _WIN64 */
29429
29430 static void thunk32_vkCmdFillBuffer(void *args)
29431 {
29432     struct
29433     {
29434         PTR32 commandBuffer;
29435         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
29436         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
29437         VkDeviceSize DECLSPEC_ALIGN(8) size;
29438         uint32_t data;
29439     } *params = args;
29440
29441     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);
29442 }
29443
29444 #ifdef _WIN64
29445 static void thunk64_vkCmdInsertDebugUtilsLabelEXT(void *args)
29446 {
29447     struct vkCmdInsertDebugUtilsLabelEXT_params *params = args;
29448
29449     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
29450 }
29451 #endif /* _WIN64 */
29452
29453 static void thunk32_vkCmdInsertDebugUtilsLabelEXT(void *args)
29454 {
29455     struct
29456     {
29457         PTR32 commandBuffer;
29458         PTR32 pLabelInfo;
29459     } *params = args;
29460     VkDebugUtilsLabelEXT pLabelInfo_host;
29461
29462     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
29463     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);
29464 }
29465
29466 #ifdef _WIN64
29467 static void thunk64_vkCmdNextSubpass(void *args)
29468 {
29469     struct vkCmdNextSubpass_params *params = args;
29470
29471     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->contents);
29472 }
29473 #endif /* _WIN64 */
29474
29475 static void thunk32_vkCmdNextSubpass(void *args)
29476 {
29477     struct
29478     {
29479         PTR32 commandBuffer;
29480         VkSubpassContents contents;
29481     } *params = args;
29482
29483     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);
29484 }
29485
29486 #ifdef _WIN64
29487 static void thunk64_vkCmdNextSubpass2(void *args)
29488 {
29489     struct vkCmdNextSubpass2_params *params = args;
29490
29491     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
29492 }
29493 #endif /* _WIN64 */
29494
29495 static void thunk32_vkCmdNextSubpass2(void *args)
29496 {
29497     struct
29498     {
29499         PTR32 commandBuffer;
29500         PTR32 pSubpassBeginInfo;
29501         PTR32 pSubpassEndInfo;
29502     } *params = args;
29503     VkSubpassBeginInfo pSubpassBeginInfo_host;
29504     VkSubpassEndInfo pSubpassEndInfo_host;
29505     struct conversion_context local_ctx;
29506     struct conversion_context *ctx = &local_ctx;
29507
29508     init_conversion_context(ctx);
29509     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
29510     convert_VkSubpassEndInfo_win32_to_host(ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
29511     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);
29512     free_conversion_context(ctx);
29513 }
29514
29515 #ifdef _WIN64
29516 static void thunk64_vkCmdNextSubpass2KHR(void *args)
29517 {
29518     struct vkCmdNextSubpass2KHR_params *params = args;
29519
29520     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
29521 }
29522 #endif /* _WIN64 */
29523
29524 static void thunk32_vkCmdNextSubpass2KHR(void *args)
29525 {
29526     struct
29527     {
29528         PTR32 commandBuffer;
29529         PTR32 pSubpassBeginInfo;
29530         PTR32 pSubpassEndInfo;
29531     } *params = args;
29532     VkSubpassBeginInfo pSubpassBeginInfo_host;
29533     VkSubpassEndInfo pSubpassEndInfo_host;
29534     struct conversion_context local_ctx;
29535     struct conversion_context *ctx = &local_ctx;
29536
29537     init_conversion_context(ctx);
29538     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
29539     convert_VkSubpassEndInfo_win32_to_host(ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
29540     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);
29541     free_conversion_context(ctx);
29542 }
29543
29544 #ifdef _WIN64
29545 static void thunk64_vkCmdOpticalFlowExecuteNV(void *args)
29546 {
29547     struct vkCmdOpticalFlowExecuteNV_params *params = args;
29548
29549     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->session, params->pExecuteInfo);
29550 }
29551 #endif /* _WIN64 */
29552
29553 static void thunk32_vkCmdOpticalFlowExecuteNV(void *args)
29554 {
29555     struct
29556     {
29557         PTR32 commandBuffer;
29558         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
29559         PTR32 pExecuteInfo;
29560     } *params = args;
29561     VkOpticalFlowExecuteInfoNV pExecuteInfo_host;
29562
29563     convert_VkOpticalFlowExecuteInfoNV_win32_to_host((const VkOpticalFlowExecuteInfoNV32 *)UlongToPtr(params->pExecuteInfo), &pExecuteInfo_host);
29564     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);
29565 }
29566
29567 #ifdef _WIN64
29568 static void thunk64_vkCmdPipelineBarrier(void *args)
29569 {
29570     struct vkCmdPipelineBarrier_params *params = args;
29571
29572     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);
29573 }
29574 #endif /* _WIN64 */
29575
29576 static void thunk32_vkCmdPipelineBarrier(void *args)
29577 {
29578     struct
29579     {
29580         PTR32 commandBuffer;
29581         VkPipelineStageFlags srcStageMask;
29582         VkPipelineStageFlags dstStageMask;
29583         VkDependencyFlags dependencyFlags;
29584         uint32_t memoryBarrierCount;
29585         PTR32 pMemoryBarriers;
29586         uint32_t bufferMemoryBarrierCount;
29587         PTR32 pBufferMemoryBarriers;
29588         uint32_t imageMemoryBarrierCount;
29589         PTR32 pImageMemoryBarriers;
29590     } *params = args;
29591     const VkMemoryBarrier *pMemoryBarriers_host;
29592     const VkBufferMemoryBarrier *pBufferMemoryBarriers_host;
29593     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
29594     struct conversion_context local_ctx;
29595     struct conversion_context *ctx = &local_ctx;
29596
29597     init_conversion_context(ctx);
29598     pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(ctx, (const VkMemoryBarrier32 *)UlongToPtr(params->pMemoryBarriers), params->memoryBarrierCount);
29599     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(ctx, (const VkBufferMemoryBarrier32 *)UlongToPtr(params->pBufferMemoryBarriers), params->bufferMemoryBarrierCount);
29600     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(ctx, (const VkImageMemoryBarrier32 *)UlongToPtr(params->pImageMemoryBarriers), params->imageMemoryBarrierCount);
29601     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);
29602     free_conversion_context(ctx);
29603 }
29604
29605 #ifdef _WIN64
29606 static void thunk64_vkCmdPipelineBarrier2(void *args)
29607 {
29608     struct vkCmdPipelineBarrier2_params *params = args;
29609
29610     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
29611 }
29612 #endif /* _WIN64 */
29613
29614 static void thunk32_vkCmdPipelineBarrier2(void *args)
29615 {
29616     struct
29617     {
29618         PTR32 commandBuffer;
29619         PTR32 pDependencyInfo;
29620     } *params = args;
29621     VkDependencyInfo pDependencyInfo_host;
29622     struct conversion_context local_ctx;
29623     struct conversion_context *ctx = &local_ctx;
29624
29625     init_conversion_context(ctx);
29626     convert_VkDependencyInfo_win32_to_host(ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
29627     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);
29628     free_conversion_context(ctx);
29629 }
29630
29631 #ifdef _WIN64
29632 static void thunk64_vkCmdPipelineBarrier2KHR(void *args)
29633 {
29634     struct vkCmdPipelineBarrier2KHR_params *params = args;
29635
29636     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
29637 }
29638 #endif /* _WIN64 */
29639
29640 static void thunk32_vkCmdPipelineBarrier2KHR(void *args)
29641 {
29642     struct
29643     {
29644         PTR32 commandBuffer;
29645         PTR32 pDependencyInfo;
29646     } *params = args;
29647     VkDependencyInfo pDependencyInfo_host;
29648     struct conversion_context local_ctx;
29649     struct conversion_context *ctx = &local_ctx;
29650
29651     init_conversion_context(ctx);
29652     convert_VkDependencyInfo_win32_to_host(ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
29653     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);
29654     free_conversion_context(ctx);
29655 }
29656
29657 #ifdef _WIN64
29658 static void thunk64_vkCmdPreprocessGeneratedCommandsNV(void *args)
29659 {
29660     struct vkCmdPreprocessGeneratedCommandsNV_params *params = args;
29661
29662     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pGeneratedCommandsInfo);
29663 }
29664 #endif /* _WIN64 */
29665
29666 static void thunk32_vkCmdPreprocessGeneratedCommandsNV(void *args)
29667 {
29668     struct
29669     {
29670         PTR32 commandBuffer;
29671         PTR32 pGeneratedCommandsInfo;
29672     } *params = args;
29673     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
29674     struct conversion_context local_ctx;
29675     struct conversion_context *ctx = &local_ctx;
29676
29677     init_conversion_context(ctx);
29678     convert_VkGeneratedCommandsInfoNV_win32_to_host(ctx, (const VkGeneratedCommandsInfoNV32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
29679     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);
29680     free_conversion_context(ctx);
29681 }
29682
29683 #ifdef _WIN64
29684 static void thunk64_vkCmdPushConstants(void *args)
29685 {
29686     struct vkCmdPushConstants_params *params = args;
29687
29688     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);
29689 }
29690 #endif /* _WIN64 */
29691
29692 static void thunk32_vkCmdPushConstants(void *args)
29693 {
29694     struct
29695     {
29696         PTR32 commandBuffer;
29697         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
29698         VkShaderStageFlags stageFlags;
29699         uint32_t offset;
29700         uint32_t size;
29701         PTR32 pValues;
29702     } *params = args;
29703
29704     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));
29705 }
29706
29707 #ifdef _WIN64
29708 static void thunk64_vkCmdPushDescriptorSetKHR(void *args)
29709 {
29710     struct vkCmdPushDescriptorSetKHR_params *params = args;
29711
29712     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);
29713 }
29714 #endif /* _WIN64 */
29715
29716 static void thunk32_vkCmdPushDescriptorSetKHR(void *args)
29717 {
29718     struct
29719     {
29720         PTR32 commandBuffer;
29721         VkPipelineBindPoint pipelineBindPoint;
29722         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
29723         uint32_t set;
29724         uint32_t descriptorWriteCount;
29725         PTR32 pDescriptorWrites;
29726     } *params = args;
29727     const VkWriteDescriptorSet *pDescriptorWrites_host;
29728     struct conversion_context local_ctx;
29729     struct conversion_context *ctx = &local_ctx;
29730
29731     init_conversion_context(ctx);
29732     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(ctx, (const VkWriteDescriptorSet32 *)UlongToPtr(params->pDescriptorWrites), params->descriptorWriteCount);
29733     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);
29734     free_conversion_context(ctx);
29735 }
29736
29737 #ifdef _WIN64
29738 static void thunk64_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
29739 {
29740     struct vkCmdPushDescriptorSetWithTemplateKHR_params *params = args;
29741
29742     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);
29743 }
29744 #endif /* _WIN64 */
29745
29746 static void thunk32_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
29747 {
29748     struct
29749     {
29750         PTR32 commandBuffer;
29751         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
29752         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
29753         uint32_t set;
29754         PTR32 pData;
29755     } *params = args;
29756
29757     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));
29758 }
29759
29760 #ifdef _WIN64
29761 static void thunk64_vkCmdResetEvent(void *args)
29762 {
29763     struct vkCmdResetEvent_params *params = args;
29764
29765     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
29766 }
29767 #endif /* _WIN64 */
29768
29769 static void thunk32_vkCmdResetEvent(void *args)
29770 {
29771     struct
29772     {
29773         PTR32 commandBuffer;
29774         VkEvent DECLSPEC_ALIGN(8) event;
29775         VkPipelineStageFlags stageMask;
29776     } *params = args;
29777
29778     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);
29779 }
29780
29781 #ifdef _WIN64
29782 static void thunk64_vkCmdResetEvent2(void *args)
29783 {
29784     struct vkCmdResetEvent2_params *params = args;
29785
29786     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
29787 }
29788 #endif /* _WIN64 */
29789
29790 static void thunk32_vkCmdResetEvent2(void *args)
29791 {
29792     struct
29793     {
29794         PTR32 commandBuffer;
29795         VkEvent DECLSPEC_ALIGN(8) event;
29796         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
29797     } *params = args;
29798
29799     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);
29800 }
29801
29802 #ifdef _WIN64
29803 static void thunk64_vkCmdResetEvent2KHR(void *args)
29804 {
29805     struct vkCmdResetEvent2KHR_params *params = args;
29806
29807     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
29808 }
29809 #endif /* _WIN64 */
29810
29811 static void thunk32_vkCmdResetEvent2KHR(void *args)
29812 {
29813     struct
29814     {
29815         PTR32 commandBuffer;
29816         VkEvent DECLSPEC_ALIGN(8) event;
29817         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
29818     } *params = args;
29819
29820     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);
29821 }
29822
29823 #ifdef _WIN64
29824 static void thunk64_vkCmdResetQueryPool(void *args)
29825 {
29826     struct vkCmdResetQueryPool_params *params = args;
29827
29828     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);
29829 }
29830 #endif /* _WIN64 */
29831
29832 static void thunk32_vkCmdResetQueryPool(void *args)
29833 {
29834     struct
29835     {
29836         PTR32 commandBuffer;
29837         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
29838         uint32_t firstQuery;
29839         uint32_t queryCount;
29840     } *params = args;
29841
29842     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);
29843 }
29844
29845 #ifdef _WIN64
29846 static void thunk64_vkCmdResolveImage(void *args)
29847 {
29848     struct vkCmdResolveImage_params *params = args;
29849
29850     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);
29851 }
29852 #endif /* _WIN64 */
29853
29854 static void thunk32_vkCmdResolveImage(void *args)
29855 {
29856     struct
29857     {
29858         PTR32 commandBuffer;
29859         VkImage DECLSPEC_ALIGN(8) srcImage;
29860         VkImageLayout srcImageLayout;
29861         VkImage DECLSPEC_ALIGN(8) dstImage;
29862         VkImageLayout dstImageLayout;
29863         uint32_t regionCount;
29864         PTR32 pRegions;
29865     } *params = args;
29866
29867     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));
29868 }
29869
29870 #ifdef _WIN64
29871 static void thunk64_vkCmdResolveImage2(void *args)
29872 {
29873     struct vkCmdResolveImage2_params *params = args;
29874
29875     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
29876 }
29877 #endif /* _WIN64 */
29878
29879 static void thunk32_vkCmdResolveImage2(void *args)
29880 {
29881     struct
29882     {
29883         PTR32 commandBuffer;
29884         PTR32 pResolveImageInfo;
29885     } *params = args;
29886     VkResolveImageInfo2 pResolveImageInfo_host;
29887     struct conversion_context local_ctx;
29888     struct conversion_context *ctx = &local_ctx;
29889
29890     init_conversion_context(ctx);
29891     convert_VkResolveImageInfo2_win32_to_host(ctx, (const VkResolveImageInfo232 *)UlongToPtr(params->pResolveImageInfo), &pResolveImageInfo_host);
29892     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);
29893     free_conversion_context(ctx);
29894 }
29895
29896 #ifdef _WIN64
29897 static void thunk64_vkCmdResolveImage2KHR(void *args)
29898 {
29899     struct vkCmdResolveImage2KHR_params *params = args;
29900
29901     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
29902 }
29903 #endif /* _WIN64 */
29904
29905 static void thunk32_vkCmdResolveImage2KHR(void *args)
29906 {
29907     struct
29908     {
29909         PTR32 commandBuffer;
29910         PTR32 pResolveImageInfo;
29911     } *params = args;
29912     VkResolveImageInfo2 pResolveImageInfo_host;
29913     struct conversion_context local_ctx;
29914     struct conversion_context *ctx = &local_ctx;
29915
29916     init_conversion_context(ctx);
29917     convert_VkResolveImageInfo2_win32_to_host(ctx, (const VkResolveImageInfo232 *)UlongToPtr(params->pResolveImageInfo), &pResolveImageInfo_host);
29918     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);
29919     free_conversion_context(ctx);
29920 }
29921
29922 #ifdef _WIN64
29923 static void thunk64_vkCmdSetAlphaToCoverageEnableEXT(void *args)
29924 {
29925     struct vkCmdSetAlphaToCoverageEnableEXT_params *params = args;
29926
29927     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToCoverageEnable);
29928 }
29929 #endif /* _WIN64 */
29930
29931 static void thunk32_vkCmdSetAlphaToCoverageEnableEXT(void *args)
29932 {
29933     struct
29934     {
29935         PTR32 commandBuffer;
29936         VkBool32 alphaToCoverageEnable;
29937     } *params = args;
29938
29939     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);
29940 }
29941
29942 #ifdef _WIN64
29943 static void thunk64_vkCmdSetAlphaToOneEnableEXT(void *args)
29944 {
29945     struct vkCmdSetAlphaToOneEnableEXT_params *params = args;
29946
29947     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToOneEnable);
29948 }
29949 #endif /* _WIN64 */
29950
29951 static void thunk32_vkCmdSetAlphaToOneEnableEXT(void *args)
29952 {
29953     struct
29954     {
29955         PTR32 commandBuffer;
29956         VkBool32 alphaToOneEnable;
29957     } *params = args;
29958
29959     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);
29960 }
29961
29962 #ifdef _WIN64
29963 static void thunk64_vkCmdSetAttachmentFeedbackLoopEnableEXT(void *args)
29964 {
29965     struct vkCmdSetAttachmentFeedbackLoopEnableEXT_params *params = args;
29966
29967     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAttachmentFeedbackLoopEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->aspectMask);
29968 }
29969 #endif /* _WIN64 */
29970
29971 static void thunk32_vkCmdSetAttachmentFeedbackLoopEnableEXT(void *args)
29972 {
29973     struct
29974     {
29975         PTR32 commandBuffer;
29976         VkImageAspectFlags aspectMask;
29977     } *params = args;
29978
29979     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);
29980 }
29981
29982 #ifdef _WIN64
29983 static void thunk64_vkCmdSetBlendConstants(void *args)
29984 {
29985     struct vkCmdSetBlendConstants_params *params = args;
29986
29987     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->blendConstants);
29988 }
29989 #endif /* _WIN64 */
29990
29991 static void thunk32_vkCmdSetBlendConstants(void *args)
29992 {
29993     struct
29994     {
29995         PTR32 commandBuffer;
29996         PTR32 blendConstants;
29997     } *params = args;
29998
29999     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));
30000 }
30001
30002 #ifdef _WIN64
30003 static void thunk64_vkCmdSetCheckpointNV(void *args)
30004 {
30005     struct vkCmdSetCheckpointNV_params *params = args;
30006
30007     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCheckpointMarker);
30008 }
30009 #endif /* _WIN64 */
30010
30011 static void thunk32_vkCmdSetCheckpointNV(void *args)
30012 {
30013     struct
30014     {
30015         PTR32 commandBuffer;
30016         PTR32 pCheckpointMarker;
30017     } *params = args;
30018
30019     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));
30020 }
30021
30022 #ifdef _WIN64
30023 static void thunk64_vkCmdSetCoarseSampleOrderNV(void *args)
30024 {
30025     struct vkCmdSetCoarseSampleOrderNV_params *params = args;
30026
30027     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);
30028 }
30029 #endif /* _WIN64 */
30030
30031 static void thunk32_vkCmdSetCoarseSampleOrderNV(void *args)
30032 {
30033     struct
30034     {
30035         PTR32 commandBuffer;
30036         VkCoarseSampleOrderTypeNV sampleOrderType;
30037         uint32_t customSampleOrderCount;
30038         PTR32 pCustomSampleOrders;
30039     } *params = args;
30040     const VkCoarseSampleOrderCustomNV *pCustomSampleOrders_host;
30041     struct conversion_context local_ctx;
30042     struct conversion_context *ctx = &local_ctx;
30043
30044     init_conversion_context(ctx);
30045     pCustomSampleOrders_host = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(params->pCustomSampleOrders), params->customSampleOrderCount);
30046     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);
30047     free_conversion_context(ctx);
30048 }
30049
30050 #ifdef _WIN64
30051 static void thunk64_vkCmdSetColorBlendAdvancedEXT(void *args)
30052 {
30053     struct vkCmdSetColorBlendAdvancedEXT_params *params = args;
30054
30055     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);
30056 }
30057 #endif /* _WIN64 */
30058
30059 static void thunk32_vkCmdSetColorBlendAdvancedEXT(void *args)
30060 {
30061     struct
30062     {
30063         PTR32 commandBuffer;
30064         uint32_t firstAttachment;
30065         uint32_t attachmentCount;
30066         PTR32 pColorBlendAdvanced;
30067     } *params = args;
30068
30069     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));
30070 }
30071
30072 #ifdef _WIN64
30073 static void thunk64_vkCmdSetColorBlendEnableEXT(void *args)
30074 {
30075     struct vkCmdSetColorBlendEnableEXT_params *params = args;
30076
30077     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);
30078 }
30079 #endif /* _WIN64 */
30080
30081 static void thunk32_vkCmdSetColorBlendEnableEXT(void *args)
30082 {
30083     struct
30084     {
30085         PTR32 commandBuffer;
30086         uint32_t firstAttachment;
30087         uint32_t attachmentCount;
30088         PTR32 pColorBlendEnables;
30089     } *params = args;
30090
30091     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));
30092 }
30093
30094 #ifdef _WIN64
30095 static void thunk64_vkCmdSetColorBlendEquationEXT(void *args)
30096 {
30097     struct vkCmdSetColorBlendEquationEXT_params *params = args;
30098
30099     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);
30100 }
30101 #endif /* _WIN64 */
30102
30103 static void thunk32_vkCmdSetColorBlendEquationEXT(void *args)
30104 {
30105     struct
30106     {
30107         PTR32 commandBuffer;
30108         uint32_t firstAttachment;
30109         uint32_t attachmentCount;
30110         PTR32 pColorBlendEquations;
30111     } *params = args;
30112
30113     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));
30114 }
30115
30116 #ifdef _WIN64
30117 static void thunk64_vkCmdSetColorWriteEnableEXT(void *args)
30118 {
30119     struct vkCmdSetColorWriteEnableEXT_params *params = args;
30120
30121     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
30122 }
30123 #endif /* _WIN64 */
30124
30125 static void thunk32_vkCmdSetColorWriteEnableEXT(void *args)
30126 {
30127     struct
30128     {
30129         PTR32 commandBuffer;
30130         uint32_t attachmentCount;
30131         PTR32 pColorWriteEnables;
30132     } *params = args;
30133
30134     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));
30135 }
30136
30137 #ifdef _WIN64
30138 static void thunk64_vkCmdSetColorWriteMaskEXT(void *args)
30139 {
30140     struct vkCmdSetColorWriteMaskEXT_params *params = args;
30141
30142     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);
30143 }
30144 #endif /* _WIN64 */
30145
30146 static void thunk32_vkCmdSetColorWriteMaskEXT(void *args)
30147 {
30148     struct
30149     {
30150         PTR32 commandBuffer;
30151         uint32_t firstAttachment;
30152         uint32_t attachmentCount;
30153         PTR32 pColorWriteMasks;
30154     } *params = args;
30155
30156     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));
30157 }
30158
30159 #ifdef _WIN64
30160 static void thunk64_vkCmdSetConservativeRasterizationModeEXT(void *args)
30161 {
30162     struct vkCmdSetConservativeRasterizationModeEXT_params *params = args;
30163
30164     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->conservativeRasterizationMode);
30165 }
30166 #endif /* _WIN64 */
30167
30168 static void thunk32_vkCmdSetConservativeRasterizationModeEXT(void *args)
30169 {
30170     struct
30171     {
30172         PTR32 commandBuffer;
30173         VkConservativeRasterizationModeEXT conservativeRasterizationMode;
30174     } *params = args;
30175
30176     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);
30177 }
30178
30179 #ifdef _WIN64
30180 static void thunk64_vkCmdSetCoverageModulationModeNV(void *args)
30181 {
30182     struct vkCmdSetCoverageModulationModeNV_params *params = args;
30183
30184     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationMode);
30185 }
30186 #endif /* _WIN64 */
30187
30188 static void thunk32_vkCmdSetCoverageModulationModeNV(void *args)
30189 {
30190     struct
30191     {
30192         PTR32 commandBuffer;
30193         VkCoverageModulationModeNV coverageModulationMode;
30194     } *params = args;
30195
30196     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);
30197 }
30198
30199 #ifdef _WIN64
30200 static void thunk64_vkCmdSetCoverageModulationTableEnableNV(void *args)
30201 {
30202     struct vkCmdSetCoverageModulationTableEnableNV_params *params = args;
30203
30204     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableEnable);
30205 }
30206 #endif /* _WIN64 */
30207
30208 static void thunk32_vkCmdSetCoverageModulationTableEnableNV(void *args)
30209 {
30210     struct
30211     {
30212         PTR32 commandBuffer;
30213         VkBool32 coverageModulationTableEnable;
30214     } *params = args;
30215
30216     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);
30217 }
30218
30219 #ifdef _WIN64
30220 static void thunk64_vkCmdSetCoverageModulationTableNV(void *args)
30221 {
30222     struct vkCmdSetCoverageModulationTableNV_params *params = args;
30223
30224     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
30225 }
30226 #endif /* _WIN64 */
30227
30228 static void thunk32_vkCmdSetCoverageModulationTableNV(void *args)
30229 {
30230     struct
30231     {
30232         PTR32 commandBuffer;
30233         uint32_t coverageModulationTableCount;
30234         PTR32 pCoverageModulationTable;
30235     } *params = args;
30236
30237     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));
30238 }
30239
30240 #ifdef _WIN64
30241 static void thunk64_vkCmdSetCoverageReductionModeNV(void *args)
30242 {
30243     struct vkCmdSetCoverageReductionModeNV_params *params = args;
30244
30245     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageReductionMode);
30246 }
30247 #endif /* _WIN64 */
30248
30249 static void thunk32_vkCmdSetCoverageReductionModeNV(void *args)
30250 {
30251     struct
30252     {
30253         PTR32 commandBuffer;
30254         VkCoverageReductionModeNV coverageReductionMode;
30255     } *params = args;
30256
30257     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);
30258 }
30259
30260 #ifdef _WIN64
30261 static void thunk64_vkCmdSetCoverageToColorEnableNV(void *args)
30262 {
30263     struct vkCmdSetCoverageToColorEnableNV_params *params = args;
30264
30265     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorEnable);
30266 }
30267 #endif /* _WIN64 */
30268
30269 static void thunk32_vkCmdSetCoverageToColorEnableNV(void *args)
30270 {
30271     struct
30272     {
30273         PTR32 commandBuffer;
30274         VkBool32 coverageToColorEnable;
30275     } *params = args;
30276
30277     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);
30278 }
30279
30280 #ifdef _WIN64
30281 static void thunk64_vkCmdSetCoverageToColorLocationNV(void *args)
30282 {
30283     struct vkCmdSetCoverageToColorLocationNV_params *params = args;
30284
30285     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorLocation);
30286 }
30287 #endif /* _WIN64 */
30288
30289 static void thunk32_vkCmdSetCoverageToColorLocationNV(void *args)
30290 {
30291     struct
30292     {
30293         PTR32 commandBuffer;
30294         uint32_t coverageToColorLocation;
30295     } *params = args;
30296
30297     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);
30298 }
30299
30300 #ifdef _WIN64
30301 static void thunk64_vkCmdSetCullMode(void *args)
30302 {
30303     struct vkCmdSetCullMode_params *params = args;
30304
30305     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
30306 }
30307 #endif /* _WIN64 */
30308
30309 static void thunk32_vkCmdSetCullMode(void *args)
30310 {
30311     struct
30312     {
30313         PTR32 commandBuffer;
30314         VkCullModeFlags cullMode;
30315     } *params = args;
30316
30317     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);
30318 }
30319
30320 #ifdef _WIN64
30321 static void thunk64_vkCmdSetCullModeEXT(void *args)
30322 {
30323     struct vkCmdSetCullModeEXT_params *params = args;
30324
30325     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
30326 }
30327 #endif /* _WIN64 */
30328
30329 static void thunk32_vkCmdSetCullModeEXT(void *args)
30330 {
30331     struct
30332     {
30333         PTR32 commandBuffer;
30334         VkCullModeFlags cullMode;
30335     } *params = args;
30336
30337     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);
30338 }
30339
30340 #ifdef _WIN64
30341 static void thunk64_vkCmdSetDepthBias(void *args)
30342 {
30343     struct vkCmdSetDepthBias_params *params = args;
30344
30345     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);
30346 }
30347 #endif /* _WIN64 */
30348
30349 static void thunk32_vkCmdSetDepthBias(void *args)
30350 {
30351     struct
30352     {
30353         PTR32 commandBuffer;
30354         float depthBiasConstantFactor;
30355         float depthBiasClamp;
30356         float depthBiasSlopeFactor;
30357     } *params = args;
30358
30359     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);
30360 }
30361
30362 #ifdef _WIN64
30363 static void thunk64_vkCmdSetDepthBias2EXT(void *args)
30364 {
30365     struct vkCmdSetDepthBias2EXT_params *params = args;
30366
30367     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBias2EXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDepthBiasInfo);
30368 }
30369 #endif /* _WIN64 */
30370
30371 static void thunk32_vkCmdSetDepthBias2EXT(void *args)
30372 {
30373     struct
30374     {
30375         PTR32 commandBuffer;
30376         PTR32 pDepthBiasInfo;
30377     } *params = args;
30378     VkDepthBiasInfoEXT pDepthBiasInfo_host;
30379     struct conversion_context local_ctx;
30380     struct conversion_context *ctx = &local_ctx;
30381
30382     init_conversion_context(ctx);
30383     convert_VkDepthBiasInfoEXT_win32_to_host(ctx, (const VkDepthBiasInfoEXT32 *)UlongToPtr(params->pDepthBiasInfo), &pDepthBiasInfo_host);
30384     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);
30385     free_conversion_context(ctx);
30386 }
30387
30388 #ifdef _WIN64
30389 static void thunk64_vkCmdSetDepthBiasEnable(void *args)
30390 {
30391     struct vkCmdSetDepthBiasEnable_params *params = args;
30392
30393     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
30394 }
30395 #endif /* _WIN64 */
30396
30397 static void thunk32_vkCmdSetDepthBiasEnable(void *args)
30398 {
30399     struct
30400     {
30401         PTR32 commandBuffer;
30402         VkBool32 depthBiasEnable;
30403     } *params = args;
30404
30405     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);
30406 }
30407
30408 #ifdef _WIN64
30409 static void thunk64_vkCmdSetDepthBiasEnableEXT(void *args)
30410 {
30411     struct vkCmdSetDepthBiasEnableEXT_params *params = args;
30412
30413     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
30414 }
30415 #endif /* _WIN64 */
30416
30417 static void thunk32_vkCmdSetDepthBiasEnableEXT(void *args)
30418 {
30419     struct
30420     {
30421         PTR32 commandBuffer;
30422         VkBool32 depthBiasEnable;
30423     } *params = args;
30424
30425     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);
30426 }
30427
30428 #ifdef _WIN64
30429 static void thunk64_vkCmdSetDepthBounds(void *args)
30430 {
30431     struct vkCmdSetDepthBounds_params *params = args;
30432
30433     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
30434 }
30435 #endif /* _WIN64 */
30436
30437 static void thunk32_vkCmdSetDepthBounds(void *args)
30438 {
30439     struct
30440     {
30441         PTR32 commandBuffer;
30442         float minDepthBounds;
30443         float maxDepthBounds;
30444     } *params = args;
30445
30446     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);
30447 }
30448
30449 #ifdef _WIN64
30450 static void thunk64_vkCmdSetDepthBoundsTestEnable(void *args)
30451 {
30452     struct vkCmdSetDepthBoundsTestEnable_params *params = args;
30453
30454     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
30455 }
30456 #endif /* _WIN64 */
30457
30458 static void thunk32_vkCmdSetDepthBoundsTestEnable(void *args)
30459 {
30460     struct
30461     {
30462         PTR32 commandBuffer;
30463         VkBool32 depthBoundsTestEnable;
30464     } *params = args;
30465
30466     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);
30467 }
30468
30469 #ifdef _WIN64
30470 static void thunk64_vkCmdSetDepthBoundsTestEnableEXT(void *args)
30471 {
30472     struct vkCmdSetDepthBoundsTestEnableEXT_params *params = args;
30473
30474     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
30475 }
30476 #endif /* _WIN64 */
30477
30478 static void thunk32_vkCmdSetDepthBoundsTestEnableEXT(void *args)
30479 {
30480     struct
30481     {
30482         PTR32 commandBuffer;
30483         VkBool32 depthBoundsTestEnable;
30484     } *params = args;
30485
30486     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);
30487 }
30488
30489 #ifdef _WIN64
30490 static void thunk64_vkCmdSetDepthClampEnableEXT(void *args)
30491 {
30492     struct vkCmdSetDepthClampEnableEXT_params *params = args;
30493
30494     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClampEnable);
30495 }
30496 #endif /* _WIN64 */
30497
30498 static void thunk32_vkCmdSetDepthClampEnableEXT(void *args)
30499 {
30500     struct
30501     {
30502         PTR32 commandBuffer;
30503         VkBool32 depthClampEnable;
30504     } *params = args;
30505
30506     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);
30507 }
30508
30509 #ifdef _WIN64
30510 static void thunk64_vkCmdSetDepthClipEnableEXT(void *args)
30511 {
30512     struct vkCmdSetDepthClipEnableEXT_params *params = args;
30513
30514     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClipEnable);
30515 }
30516 #endif /* _WIN64 */
30517
30518 static void thunk32_vkCmdSetDepthClipEnableEXT(void *args)
30519 {
30520     struct
30521     {
30522         PTR32 commandBuffer;
30523         VkBool32 depthClipEnable;
30524     } *params = args;
30525
30526     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);
30527 }
30528
30529 #ifdef _WIN64
30530 static void thunk64_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
30531 {
30532     struct vkCmdSetDepthClipNegativeOneToOneEXT_params *params = args;
30533
30534     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->negativeOneToOne);
30535 }
30536 #endif /* _WIN64 */
30537
30538 static void thunk32_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
30539 {
30540     struct
30541     {
30542         PTR32 commandBuffer;
30543         VkBool32 negativeOneToOne;
30544     } *params = args;
30545
30546     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);
30547 }
30548
30549 #ifdef _WIN64
30550 static void thunk64_vkCmdSetDepthCompareOp(void *args)
30551 {
30552     struct vkCmdSetDepthCompareOp_params *params = args;
30553
30554     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
30555 }
30556 #endif /* _WIN64 */
30557
30558 static void thunk32_vkCmdSetDepthCompareOp(void *args)
30559 {
30560     struct
30561     {
30562         PTR32 commandBuffer;
30563         VkCompareOp depthCompareOp;
30564     } *params = args;
30565
30566     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);
30567 }
30568
30569 #ifdef _WIN64
30570 static void thunk64_vkCmdSetDepthCompareOpEXT(void *args)
30571 {
30572     struct vkCmdSetDepthCompareOpEXT_params *params = args;
30573
30574     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
30575 }
30576 #endif /* _WIN64 */
30577
30578 static void thunk32_vkCmdSetDepthCompareOpEXT(void *args)
30579 {
30580     struct
30581     {
30582         PTR32 commandBuffer;
30583         VkCompareOp depthCompareOp;
30584     } *params = args;
30585
30586     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);
30587 }
30588
30589 #ifdef _WIN64
30590 static void thunk64_vkCmdSetDepthTestEnable(void *args)
30591 {
30592     struct vkCmdSetDepthTestEnable_params *params = args;
30593
30594     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
30595 }
30596 #endif /* _WIN64 */
30597
30598 static void thunk32_vkCmdSetDepthTestEnable(void *args)
30599 {
30600     struct
30601     {
30602         PTR32 commandBuffer;
30603         VkBool32 depthTestEnable;
30604     } *params = args;
30605
30606     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);
30607 }
30608
30609 #ifdef _WIN64
30610 static void thunk64_vkCmdSetDepthTestEnableEXT(void *args)
30611 {
30612     struct vkCmdSetDepthTestEnableEXT_params *params = args;
30613
30614     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
30615 }
30616 #endif /* _WIN64 */
30617
30618 static void thunk32_vkCmdSetDepthTestEnableEXT(void *args)
30619 {
30620     struct
30621     {
30622         PTR32 commandBuffer;
30623         VkBool32 depthTestEnable;
30624     } *params = args;
30625
30626     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);
30627 }
30628
30629 #ifdef _WIN64
30630 static void thunk64_vkCmdSetDepthWriteEnable(void *args)
30631 {
30632     struct vkCmdSetDepthWriteEnable_params *params = args;
30633
30634     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
30635 }
30636 #endif /* _WIN64 */
30637
30638 static void thunk32_vkCmdSetDepthWriteEnable(void *args)
30639 {
30640     struct
30641     {
30642         PTR32 commandBuffer;
30643         VkBool32 depthWriteEnable;
30644     } *params = args;
30645
30646     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);
30647 }
30648
30649 #ifdef _WIN64
30650 static void thunk64_vkCmdSetDepthWriteEnableEXT(void *args)
30651 {
30652     struct vkCmdSetDepthWriteEnableEXT_params *params = args;
30653
30654     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
30655 }
30656 #endif /* _WIN64 */
30657
30658 static void thunk32_vkCmdSetDepthWriteEnableEXT(void *args)
30659 {
30660     struct
30661     {
30662         PTR32 commandBuffer;
30663         VkBool32 depthWriteEnable;
30664     } *params = args;
30665
30666     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);
30667 }
30668
30669 #ifdef _WIN64
30670 static void thunk64_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
30671 {
30672     struct vkCmdSetDescriptorBufferOffsetsEXT_params *params = args;
30673
30674     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);
30675 }
30676 #endif /* _WIN64 */
30677
30678 static void thunk32_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
30679 {
30680     struct
30681     {
30682         PTR32 commandBuffer;
30683         VkPipelineBindPoint pipelineBindPoint;
30684         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
30685         uint32_t firstSet;
30686         uint32_t setCount;
30687         PTR32 pBufferIndices;
30688         PTR32 pOffsets;
30689     } *params = args;
30690
30691     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));
30692 }
30693
30694 #ifdef _WIN64
30695 static void thunk64_vkCmdSetDeviceMask(void *args)
30696 {
30697     struct vkCmdSetDeviceMask_params *params = args;
30698
30699     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
30700 }
30701 #endif /* _WIN64 */
30702
30703 static void thunk32_vkCmdSetDeviceMask(void *args)
30704 {
30705     struct
30706     {
30707         PTR32 commandBuffer;
30708         uint32_t deviceMask;
30709     } *params = args;
30710
30711     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);
30712 }
30713
30714 #ifdef _WIN64
30715 static void thunk64_vkCmdSetDeviceMaskKHR(void *args)
30716 {
30717     struct vkCmdSetDeviceMaskKHR_params *params = args;
30718
30719     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
30720 }
30721 #endif /* _WIN64 */
30722
30723 static void thunk32_vkCmdSetDeviceMaskKHR(void *args)
30724 {
30725     struct
30726     {
30727         PTR32 commandBuffer;
30728         uint32_t deviceMask;
30729     } *params = args;
30730
30731     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);
30732 }
30733
30734 #ifdef _WIN64
30735 static void thunk64_vkCmdSetDiscardRectangleEXT(void *args)
30736 {
30737     struct vkCmdSetDiscardRectangleEXT_params *params = args;
30738
30739     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);
30740 }
30741 #endif /* _WIN64 */
30742
30743 static void thunk32_vkCmdSetDiscardRectangleEXT(void *args)
30744 {
30745     struct
30746     {
30747         PTR32 commandBuffer;
30748         uint32_t firstDiscardRectangle;
30749         uint32_t discardRectangleCount;
30750         PTR32 pDiscardRectangles;
30751     } *params = args;
30752
30753     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));
30754 }
30755
30756 #ifdef _WIN64
30757 static void thunk64_vkCmdSetDiscardRectangleEnableEXT(void *args)
30758 {
30759     struct vkCmdSetDiscardRectangleEnableEXT_params *params = args;
30760
30761     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDiscardRectangleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->discardRectangleEnable);
30762 }
30763 #endif /* _WIN64 */
30764
30765 static void thunk32_vkCmdSetDiscardRectangleEnableEXT(void *args)
30766 {
30767     struct
30768     {
30769         PTR32 commandBuffer;
30770         VkBool32 discardRectangleEnable;
30771     } *params = args;
30772
30773     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);
30774 }
30775
30776 #ifdef _WIN64
30777 static void thunk64_vkCmdSetDiscardRectangleModeEXT(void *args)
30778 {
30779     struct vkCmdSetDiscardRectangleModeEXT_params *params = args;
30780
30781     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDiscardRectangleModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->discardRectangleMode);
30782 }
30783 #endif /* _WIN64 */
30784
30785 static void thunk32_vkCmdSetDiscardRectangleModeEXT(void *args)
30786 {
30787     struct
30788     {
30789         PTR32 commandBuffer;
30790         VkDiscardRectangleModeEXT discardRectangleMode;
30791     } *params = args;
30792
30793     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);
30794 }
30795
30796 #ifdef _WIN64
30797 static void thunk64_vkCmdSetEvent(void *args)
30798 {
30799     struct vkCmdSetEvent_params *params = args;
30800
30801     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
30802 }
30803 #endif /* _WIN64 */
30804
30805 static void thunk32_vkCmdSetEvent(void *args)
30806 {
30807     struct
30808     {
30809         PTR32 commandBuffer;
30810         VkEvent DECLSPEC_ALIGN(8) event;
30811         VkPipelineStageFlags stageMask;
30812     } *params = args;
30813
30814     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);
30815 }
30816
30817 #ifdef _WIN64
30818 static void thunk64_vkCmdSetEvent2(void *args)
30819 {
30820     struct vkCmdSetEvent2_params *params = args;
30821
30822     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
30823 }
30824 #endif /* _WIN64 */
30825
30826 static void thunk32_vkCmdSetEvent2(void *args)
30827 {
30828     struct
30829     {
30830         PTR32 commandBuffer;
30831         VkEvent DECLSPEC_ALIGN(8) event;
30832         PTR32 pDependencyInfo;
30833     } *params = args;
30834     VkDependencyInfo pDependencyInfo_host;
30835     struct conversion_context local_ctx;
30836     struct conversion_context *ctx = &local_ctx;
30837
30838     init_conversion_context(ctx);
30839     convert_VkDependencyInfo_win32_to_host(ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
30840     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);
30841     free_conversion_context(ctx);
30842 }
30843
30844 #ifdef _WIN64
30845 static void thunk64_vkCmdSetEvent2KHR(void *args)
30846 {
30847     struct vkCmdSetEvent2KHR_params *params = args;
30848
30849     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
30850 }
30851 #endif /* _WIN64 */
30852
30853 static void thunk32_vkCmdSetEvent2KHR(void *args)
30854 {
30855     struct
30856     {
30857         PTR32 commandBuffer;
30858         VkEvent DECLSPEC_ALIGN(8) event;
30859         PTR32 pDependencyInfo;
30860     } *params = args;
30861     VkDependencyInfo pDependencyInfo_host;
30862     struct conversion_context local_ctx;
30863     struct conversion_context *ctx = &local_ctx;
30864
30865     init_conversion_context(ctx);
30866     convert_VkDependencyInfo_win32_to_host(ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
30867     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);
30868     free_conversion_context(ctx);
30869 }
30870
30871 #ifdef _WIN64
30872 static void thunk64_vkCmdSetExclusiveScissorEnableNV(void *args)
30873 {
30874     struct vkCmdSetExclusiveScissorEnableNV_params *params = args;
30875
30876     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);
30877 }
30878 #endif /* _WIN64 */
30879
30880 static void thunk32_vkCmdSetExclusiveScissorEnableNV(void *args)
30881 {
30882     struct
30883     {
30884         PTR32 commandBuffer;
30885         uint32_t firstExclusiveScissor;
30886         uint32_t exclusiveScissorCount;
30887         PTR32 pExclusiveScissorEnables;
30888     } *params = args;
30889
30890     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));
30891 }
30892
30893 #ifdef _WIN64
30894 static void thunk64_vkCmdSetExclusiveScissorNV(void *args)
30895 {
30896     struct vkCmdSetExclusiveScissorNV_params *params = args;
30897
30898     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);
30899 }
30900 #endif /* _WIN64 */
30901
30902 static void thunk32_vkCmdSetExclusiveScissorNV(void *args)
30903 {
30904     struct
30905     {
30906         PTR32 commandBuffer;
30907         uint32_t firstExclusiveScissor;
30908         uint32_t exclusiveScissorCount;
30909         PTR32 pExclusiveScissors;
30910     } *params = args;
30911
30912     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));
30913 }
30914
30915 #ifdef _WIN64
30916 static void thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
30917 {
30918     struct vkCmdSetExtraPrimitiveOverestimationSizeEXT_params *params = args;
30919
30920     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->extraPrimitiveOverestimationSize);
30921 }
30922 #endif /* _WIN64 */
30923
30924 static void thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
30925 {
30926     struct
30927     {
30928         PTR32 commandBuffer;
30929         float extraPrimitiveOverestimationSize;
30930     } *params = args;
30931
30932     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);
30933 }
30934
30935 #ifdef _WIN64
30936 static void thunk64_vkCmdSetFragmentShadingRateEnumNV(void *args)
30937 {
30938     struct vkCmdSetFragmentShadingRateEnumNV_params *params = args;
30939
30940     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRate, params->combinerOps);
30941 }
30942 #endif /* _WIN64 */
30943
30944 static void thunk32_vkCmdSetFragmentShadingRateEnumNV(void *args)
30945 {
30946     struct
30947     {
30948         PTR32 commandBuffer;
30949         VkFragmentShadingRateNV shadingRate;
30950         PTR32 combinerOps;
30951     } *params = args;
30952
30953     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));
30954 }
30955
30956 #ifdef _WIN64
30957 static void thunk64_vkCmdSetFragmentShadingRateKHR(void *args)
30958 {
30959     struct vkCmdSetFragmentShadingRateKHR_params *params = args;
30960
30961     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pFragmentSize, params->combinerOps);
30962 }
30963 #endif /* _WIN64 */
30964
30965 static void thunk32_vkCmdSetFragmentShadingRateKHR(void *args)
30966 {
30967     struct
30968     {
30969         PTR32 commandBuffer;
30970         PTR32 pFragmentSize;
30971         PTR32 combinerOps;
30972     } *params = args;
30973
30974     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));
30975 }
30976
30977 #ifdef _WIN64
30978 static void thunk64_vkCmdSetFrontFace(void *args)
30979 {
30980     struct vkCmdSetFrontFace_params *params = args;
30981
30982     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
30983 }
30984 #endif /* _WIN64 */
30985
30986 static void thunk32_vkCmdSetFrontFace(void *args)
30987 {
30988     struct
30989     {
30990         PTR32 commandBuffer;
30991         VkFrontFace frontFace;
30992     } *params = args;
30993
30994     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);
30995 }
30996
30997 #ifdef _WIN64
30998 static void thunk64_vkCmdSetFrontFaceEXT(void *args)
30999 {
31000     struct vkCmdSetFrontFaceEXT_params *params = args;
31001
31002     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
31003 }
31004 #endif /* _WIN64 */
31005
31006 static void thunk32_vkCmdSetFrontFaceEXT(void *args)
31007 {
31008     struct
31009     {
31010         PTR32 commandBuffer;
31011         VkFrontFace frontFace;
31012     } *params = args;
31013
31014     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);
31015 }
31016
31017 #ifdef _WIN64
31018 static void thunk64_vkCmdSetLineRasterizationModeEXT(void *args)
31019 {
31020     struct vkCmdSetLineRasterizationModeEXT_params *params = args;
31021
31022     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineRasterizationMode);
31023 }
31024 #endif /* _WIN64 */
31025
31026 static void thunk32_vkCmdSetLineRasterizationModeEXT(void *args)
31027 {
31028     struct
31029     {
31030         PTR32 commandBuffer;
31031         VkLineRasterizationModeEXT lineRasterizationMode;
31032     } *params = args;
31033
31034     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);
31035 }
31036
31037 #ifdef _WIN64
31038 static void thunk64_vkCmdSetLineStippleEXT(void *args)
31039 {
31040     struct vkCmdSetLineStippleEXT_params *params = args;
31041
31042     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
31043 }
31044 #endif /* _WIN64 */
31045
31046 static void thunk32_vkCmdSetLineStippleEXT(void *args)
31047 {
31048     struct
31049     {
31050         PTR32 commandBuffer;
31051         uint32_t lineStippleFactor;
31052         uint16_t lineStipplePattern;
31053     } *params = args;
31054
31055     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);
31056 }
31057
31058 #ifdef _WIN64
31059 static void thunk64_vkCmdSetLineStippleEnableEXT(void *args)
31060 {
31061     struct vkCmdSetLineStippleEnableEXT_params *params = args;
31062
31063     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stippledLineEnable);
31064 }
31065 #endif /* _WIN64 */
31066
31067 static void thunk32_vkCmdSetLineStippleEnableEXT(void *args)
31068 {
31069     struct
31070     {
31071         PTR32 commandBuffer;
31072         VkBool32 stippledLineEnable;
31073     } *params = args;
31074
31075     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);
31076 }
31077
31078 #ifdef _WIN64
31079 static void thunk64_vkCmdSetLineWidth(void *args)
31080 {
31081     struct vkCmdSetLineWidth_params *params = args;
31082
31083     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineWidth);
31084 }
31085 #endif /* _WIN64 */
31086
31087 static void thunk32_vkCmdSetLineWidth(void *args)
31088 {
31089     struct
31090     {
31091         PTR32 commandBuffer;
31092         float lineWidth;
31093     } *params = args;
31094
31095     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);
31096 }
31097
31098 #ifdef _WIN64
31099 static void thunk64_vkCmdSetLogicOpEXT(void *args)
31100 {
31101     struct vkCmdSetLogicOpEXT_params *params = args;
31102
31103     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOp);
31104 }
31105 #endif /* _WIN64 */
31106
31107 static void thunk32_vkCmdSetLogicOpEXT(void *args)
31108 {
31109     struct
31110     {
31111         PTR32 commandBuffer;
31112         VkLogicOp logicOp;
31113     } *params = args;
31114
31115     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);
31116 }
31117
31118 #ifdef _WIN64
31119 static void thunk64_vkCmdSetLogicOpEnableEXT(void *args)
31120 {
31121     struct vkCmdSetLogicOpEnableEXT_params *params = args;
31122
31123     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOpEnable);
31124 }
31125 #endif /* _WIN64 */
31126
31127 static void thunk32_vkCmdSetLogicOpEnableEXT(void *args)
31128 {
31129     struct
31130     {
31131         PTR32 commandBuffer;
31132         VkBool32 logicOpEnable;
31133     } *params = args;
31134
31135     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);
31136 }
31137
31138 #ifdef _WIN64
31139 static void thunk64_vkCmdSetPatchControlPointsEXT(void *args)
31140 {
31141     struct vkCmdSetPatchControlPointsEXT_params *params = args;
31142
31143     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->patchControlPoints);
31144 }
31145 #endif /* _WIN64 */
31146
31147 static void thunk32_vkCmdSetPatchControlPointsEXT(void *args)
31148 {
31149     struct
31150     {
31151         PTR32 commandBuffer;
31152         uint32_t patchControlPoints;
31153     } *params = args;
31154
31155     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);
31156 }
31157
31158 #ifdef _WIN64
31159 static NTSTATUS thunk64_vkCmdSetPerformanceMarkerINTEL(void *args)
31160 {
31161     struct vkCmdSetPerformanceMarkerINTEL_params *params = args;
31162
31163     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
31164
31165     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
31166     return STATUS_SUCCESS;
31167 }
31168 #endif /* _WIN64 */
31169
31170 static NTSTATUS thunk32_vkCmdSetPerformanceMarkerINTEL(void *args)
31171 {
31172     struct
31173     {
31174         PTR32 commandBuffer;
31175         PTR32 pMarkerInfo;
31176         VkResult result;
31177     } *params = args;
31178     VkPerformanceMarkerInfoINTEL pMarkerInfo_host;
31179
31180     TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);
31181
31182     convert_VkPerformanceMarkerInfoINTEL_win32_to_host((const VkPerformanceMarkerInfoINTEL32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
31183     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);
31184     return STATUS_SUCCESS;
31185 }
31186
31187 #ifdef _WIN64
31188 static NTSTATUS thunk64_vkCmdSetPerformanceOverrideINTEL(void *args)
31189 {
31190     struct vkCmdSetPerformanceOverrideINTEL_params *params = args;
31191
31192     TRACE("%p, %p\n", params->commandBuffer, params->pOverrideInfo);
31193
31194     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pOverrideInfo);
31195     return STATUS_SUCCESS;
31196 }
31197 #endif /* _WIN64 */
31198
31199 static NTSTATUS thunk32_vkCmdSetPerformanceOverrideINTEL(void *args)
31200 {
31201     struct
31202     {
31203         PTR32 commandBuffer;
31204         PTR32 pOverrideInfo;
31205         VkResult result;
31206     } *params = args;
31207     VkPerformanceOverrideInfoINTEL pOverrideInfo_host;
31208
31209     TRACE("%#x, %#x\n", params->commandBuffer, params->pOverrideInfo);
31210
31211     convert_VkPerformanceOverrideInfoINTEL_win32_to_host((const VkPerformanceOverrideInfoINTEL32 *)UlongToPtr(params->pOverrideInfo), &pOverrideInfo_host);
31212     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);
31213     return STATUS_SUCCESS;
31214 }
31215
31216 #ifdef _WIN64
31217 static NTSTATUS thunk64_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
31218 {
31219     struct vkCmdSetPerformanceStreamMarkerINTEL_params *params = args;
31220
31221     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
31222
31223     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
31224     return STATUS_SUCCESS;
31225 }
31226 #endif /* _WIN64 */
31227
31228 static NTSTATUS thunk32_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
31229 {
31230     struct
31231     {
31232         PTR32 commandBuffer;
31233         PTR32 pMarkerInfo;
31234         VkResult result;
31235     } *params = args;
31236     VkPerformanceStreamMarkerInfoINTEL pMarkerInfo_host;
31237
31238     TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);
31239
31240     convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host((const VkPerformanceStreamMarkerInfoINTEL32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
31241     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);
31242     return STATUS_SUCCESS;
31243 }
31244
31245 #ifdef _WIN64
31246 static void thunk64_vkCmdSetPolygonModeEXT(void *args)
31247 {
31248     struct vkCmdSetPolygonModeEXT_params *params = args;
31249
31250     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->polygonMode);
31251 }
31252 #endif /* _WIN64 */
31253
31254 static void thunk32_vkCmdSetPolygonModeEXT(void *args)
31255 {
31256     struct
31257     {
31258         PTR32 commandBuffer;
31259         VkPolygonMode polygonMode;
31260     } *params = args;
31261
31262     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);
31263 }
31264
31265 #ifdef _WIN64
31266 static void thunk64_vkCmdSetPrimitiveRestartEnable(void *args)
31267 {
31268     struct vkCmdSetPrimitiveRestartEnable_params *params = args;
31269
31270     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
31271 }
31272 #endif /* _WIN64 */
31273
31274 static void thunk32_vkCmdSetPrimitiveRestartEnable(void *args)
31275 {
31276     struct
31277     {
31278         PTR32 commandBuffer;
31279         VkBool32 primitiveRestartEnable;
31280     } *params = args;
31281
31282     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);
31283 }
31284
31285 #ifdef _WIN64
31286 static void thunk64_vkCmdSetPrimitiveRestartEnableEXT(void *args)
31287 {
31288     struct vkCmdSetPrimitiveRestartEnableEXT_params *params = args;
31289
31290     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
31291 }
31292 #endif /* _WIN64 */
31293
31294 static void thunk32_vkCmdSetPrimitiveRestartEnableEXT(void *args)
31295 {
31296     struct
31297     {
31298         PTR32 commandBuffer;
31299         VkBool32 primitiveRestartEnable;
31300     } *params = args;
31301
31302     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);
31303 }
31304
31305 #ifdef _WIN64
31306 static void thunk64_vkCmdSetPrimitiveTopology(void *args)
31307 {
31308     struct vkCmdSetPrimitiveTopology_params *params = args;
31309
31310     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
31311 }
31312 #endif /* _WIN64 */
31313
31314 static void thunk32_vkCmdSetPrimitiveTopology(void *args)
31315 {
31316     struct
31317     {
31318         PTR32 commandBuffer;
31319         VkPrimitiveTopology primitiveTopology;
31320     } *params = args;
31321
31322     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);
31323 }
31324
31325 #ifdef _WIN64
31326 static void thunk64_vkCmdSetPrimitiveTopologyEXT(void *args)
31327 {
31328     struct vkCmdSetPrimitiveTopologyEXT_params *params = args;
31329
31330     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
31331 }
31332 #endif /* _WIN64 */
31333
31334 static void thunk32_vkCmdSetPrimitiveTopologyEXT(void *args)
31335 {
31336     struct
31337     {
31338         PTR32 commandBuffer;
31339         VkPrimitiveTopology primitiveTopology;
31340     } *params = args;
31341
31342     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);
31343 }
31344
31345 #ifdef _WIN64
31346 static void thunk64_vkCmdSetProvokingVertexModeEXT(void *args)
31347 {
31348     struct vkCmdSetProvokingVertexModeEXT_params *params = args;
31349
31350     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->provokingVertexMode);
31351 }
31352 #endif /* _WIN64 */
31353
31354 static void thunk32_vkCmdSetProvokingVertexModeEXT(void *args)
31355 {
31356     struct
31357     {
31358         PTR32 commandBuffer;
31359         VkProvokingVertexModeEXT provokingVertexMode;
31360     } *params = args;
31361
31362     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);
31363 }
31364
31365 #ifdef _WIN64
31366 static void thunk64_vkCmdSetRasterizationSamplesEXT(void *args)
31367 {
31368     struct vkCmdSetRasterizationSamplesEXT_params *params = args;
31369
31370     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationSamples);
31371 }
31372 #endif /* _WIN64 */
31373
31374 static void thunk32_vkCmdSetRasterizationSamplesEXT(void *args)
31375 {
31376     struct
31377     {
31378         PTR32 commandBuffer;
31379         VkSampleCountFlagBits rasterizationSamples;
31380     } *params = args;
31381
31382     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);
31383 }
31384
31385 #ifdef _WIN64
31386 static void thunk64_vkCmdSetRasterizationStreamEXT(void *args)
31387 {
31388     struct vkCmdSetRasterizationStreamEXT_params *params = args;
31389
31390     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationStream);
31391 }
31392 #endif /* _WIN64 */
31393
31394 static void thunk32_vkCmdSetRasterizationStreamEXT(void *args)
31395 {
31396     struct
31397     {
31398         PTR32 commandBuffer;
31399         uint32_t rasterizationStream;
31400     } *params = args;
31401
31402     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);
31403 }
31404
31405 #ifdef _WIN64
31406 static void thunk64_vkCmdSetRasterizerDiscardEnable(void *args)
31407 {
31408     struct vkCmdSetRasterizerDiscardEnable_params *params = args;
31409
31410     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
31411 }
31412 #endif /* _WIN64 */
31413
31414 static void thunk32_vkCmdSetRasterizerDiscardEnable(void *args)
31415 {
31416     struct
31417     {
31418         PTR32 commandBuffer;
31419         VkBool32 rasterizerDiscardEnable;
31420     } *params = args;
31421
31422     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);
31423 }
31424
31425 #ifdef _WIN64
31426 static void thunk64_vkCmdSetRasterizerDiscardEnableEXT(void *args)
31427 {
31428     struct vkCmdSetRasterizerDiscardEnableEXT_params *params = args;
31429
31430     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
31431 }
31432 #endif /* _WIN64 */
31433
31434 static void thunk32_vkCmdSetRasterizerDiscardEnableEXT(void *args)
31435 {
31436     struct
31437     {
31438         PTR32 commandBuffer;
31439         VkBool32 rasterizerDiscardEnable;
31440     } *params = args;
31441
31442     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);
31443 }
31444
31445 #ifdef _WIN64
31446 static void thunk64_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
31447 {
31448     struct vkCmdSetRayTracingPipelineStackSizeKHR_params *params = args;
31449
31450     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStackSize);
31451 }
31452 #endif /* _WIN64 */
31453
31454 static void thunk32_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
31455 {
31456     struct
31457     {
31458         PTR32 commandBuffer;
31459         uint32_t pipelineStackSize;
31460     } *params = args;
31461
31462     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);
31463 }
31464
31465 #ifdef _WIN64
31466 static void thunk64_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
31467 {
31468     struct vkCmdSetRepresentativeFragmentTestEnableNV_params *params = args;
31469
31470     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->representativeFragmentTestEnable);
31471 }
31472 #endif /* _WIN64 */
31473
31474 static void thunk32_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
31475 {
31476     struct
31477     {
31478         PTR32 commandBuffer;
31479         VkBool32 representativeFragmentTestEnable;
31480     } *params = args;
31481
31482     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);
31483 }
31484
31485 #ifdef _WIN64
31486 static void thunk64_vkCmdSetSampleLocationsEXT(void *args)
31487 {
31488     struct vkCmdSetSampleLocationsEXT_params *params = args;
31489
31490     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSampleLocationsInfo);
31491 }
31492 #endif /* _WIN64 */
31493
31494 static void thunk32_vkCmdSetSampleLocationsEXT(void *args)
31495 {
31496     struct
31497     {
31498         PTR32 commandBuffer;
31499         PTR32 pSampleLocationsInfo;
31500     } *params = args;
31501     VkSampleLocationsInfoEXT pSampleLocationsInfo_host;
31502
31503     convert_VkSampleLocationsInfoEXT_win32_to_host((const VkSampleLocationsInfoEXT32 *)UlongToPtr(params->pSampleLocationsInfo), &pSampleLocationsInfo_host);
31504     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);
31505 }
31506
31507 #ifdef _WIN64
31508 static void thunk64_vkCmdSetSampleLocationsEnableEXT(void *args)
31509 {
31510     struct vkCmdSetSampleLocationsEnableEXT_params *params = args;
31511
31512     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleLocationsEnable);
31513 }
31514 #endif /* _WIN64 */
31515
31516 static void thunk32_vkCmdSetSampleLocationsEnableEXT(void *args)
31517 {
31518     struct
31519     {
31520         PTR32 commandBuffer;
31521         VkBool32 sampleLocationsEnable;
31522     } *params = args;
31523
31524     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);
31525 }
31526
31527 #ifdef _WIN64
31528 static void thunk64_vkCmdSetSampleMaskEXT(void *args)
31529 {
31530     struct vkCmdSetSampleMaskEXT_params *params = args;
31531
31532     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->samples, params->pSampleMask);
31533 }
31534 #endif /* _WIN64 */
31535
31536 static void thunk32_vkCmdSetSampleMaskEXT(void *args)
31537 {
31538     struct
31539     {
31540         PTR32 commandBuffer;
31541         VkSampleCountFlagBits samples;
31542         PTR32 pSampleMask;
31543     } *params = args;
31544
31545     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));
31546 }
31547
31548 #ifdef _WIN64
31549 static void thunk64_vkCmdSetScissor(void *args)
31550 {
31551     struct vkCmdSetScissor_params *params = args;
31552
31553     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);
31554 }
31555 #endif /* _WIN64 */
31556
31557 static void thunk32_vkCmdSetScissor(void *args)
31558 {
31559     struct
31560     {
31561         PTR32 commandBuffer;
31562         uint32_t firstScissor;
31563         uint32_t scissorCount;
31564         PTR32 pScissors;
31565     } *params = args;
31566
31567     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));
31568 }
31569
31570 #ifdef _WIN64
31571 static void thunk64_vkCmdSetScissorWithCount(void *args)
31572 {
31573     struct vkCmdSetScissorWithCount_params *params = args;
31574
31575     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
31576 }
31577 #endif /* _WIN64 */
31578
31579 static void thunk32_vkCmdSetScissorWithCount(void *args)
31580 {
31581     struct
31582     {
31583         PTR32 commandBuffer;
31584         uint32_t scissorCount;
31585         PTR32 pScissors;
31586     } *params = args;
31587
31588     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));
31589 }
31590
31591 #ifdef _WIN64
31592 static void thunk64_vkCmdSetScissorWithCountEXT(void *args)
31593 {
31594     struct vkCmdSetScissorWithCountEXT_params *params = args;
31595
31596     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
31597 }
31598 #endif /* _WIN64 */
31599
31600 static void thunk32_vkCmdSetScissorWithCountEXT(void *args)
31601 {
31602     struct
31603     {
31604         PTR32 commandBuffer;
31605         uint32_t scissorCount;
31606         PTR32 pScissors;
31607     } *params = args;
31608
31609     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));
31610 }
31611
31612 #ifdef _WIN64
31613 static void thunk64_vkCmdSetShadingRateImageEnableNV(void *args)
31614 {
31615     struct vkCmdSetShadingRateImageEnableNV_params *params = args;
31616
31617     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRateImageEnable);
31618 }
31619 #endif /* _WIN64 */
31620
31621 static void thunk32_vkCmdSetShadingRateImageEnableNV(void *args)
31622 {
31623     struct
31624     {
31625         PTR32 commandBuffer;
31626         VkBool32 shadingRateImageEnable;
31627     } *params = args;
31628
31629     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);
31630 }
31631
31632 #ifdef _WIN64
31633 static void thunk64_vkCmdSetStencilCompareMask(void *args)
31634 {
31635     struct vkCmdSetStencilCompareMask_params *params = args;
31636
31637     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->compareMask);
31638 }
31639 #endif /* _WIN64 */
31640
31641 static void thunk32_vkCmdSetStencilCompareMask(void *args)
31642 {
31643     struct
31644     {
31645         PTR32 commandBuffer;
31646         VkStencilFaceFlags faceMask;
31647         uint32_t compareMask;
31648     } *params = args;
31649
31650     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);
31651 }
31652
31653 #ifdef _WIN64
31654 static void thunk64_vkCmdSetStencilOp(void *args)
31655 {
31656     struct vkCmdSetStencilOp_params *params = args;
31657
31658     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);
31659 }
31660 #endif /* _WIN64 */
31661
31662 static void thunk32_vkCmdSetStencilOp(void *args)
31663 {
31664     struct
31665     {
31666         PTR32 commandBuffer;
31667         VkStencilFaceFlags faceMask;
31668         VkStencilOp failOp;
31669         VkStencilOp passOp;
31670         VkStencilOp depthFailOp;
31671         VkCompareOp compareOp;
31672     } *params = args;
31673
31674     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);
31675 }
31676
31677 #ifdef _WIN64
31678 static void thunk64_vkCmdSetStencilOpEXT(void *args)
31679 {
31680     struct vkCmdSetStencilOpEXT_params *params = args;
31681
31682     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);
31683 }
31684 #endif /* _WIN64 */
31685
31686 static void thunk32_vkCmdSetStencilOpEXT(void *args)
31687 {
31688     struct
31689     {
31690         PTR32 commandBuffer;
31691         VkStencilFaceFlags faceMask;
31692         VkStencilOp failOp;
31693         VkStencilOp passOp;
31694         VkStencilOp depthFailOp;
31695         VkCompareOp compareOp;
31696     } *params = args;
31697
31698     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);
31699 }
31700
31701 #ifdef _WIN64
31702 static void thunk64_vkCmdSetStencilReference(void *args)
31703 {
31704     struct vkCmdSetStencilReference_params *params = args;
31705
31706     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->reference);
31707 }
31708 #endif /* _WIN64 */
31709
31710 static void thunk32_vkCmdSetStencilReference(void *args)
31711 {
31712     struct
31713     {
31714         PTR32 commandBuffer;
31715         VkStencilFaceFlags faceMask;
31716         uint32_t reference;
31717     } *params = args;
31718
31719     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);
31720 }
31721
31722 #ifdef _WIN64
31723 static void thunk64_vkCmdSetStencilTestEnable(void *args)
31724 {
31725     struct vkCmdSetStencilTestEnable_params *params = args;
31726
31727     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
31728 }
31729 #endif /* _WIN64 */
31730
31731 static void thunk32_vkCmdSetStencilTestEnable(void *args)
31732 {
31733     struct
31734     {
31735         PTR32 commandBuffer;
31736         VkBool32 stencilTestEnable;
31737     } *params = args;
31738
31739     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);
31740 }
31741
31742 #ifdef _WIN64
31743 static void thunk64_vkCmdSetStencilTestEnableEXT(void *args)
31744 {
31745     struct vkCmdSetStencilTestEnableEXT_params *params = args;
31746
31747     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
31748 }
31749 #endif /* _WIN64 */
31750
31751 static void thunk32_vkCmdSetStencilTestEnableEXT(void *args)
31752 {
31753     struct
31754     {
31755         PTR32 commandBuffer;
31756         VkBool32 stencilTestEnable;
31757     } *params = args;
31758
31759     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);
31760 }
31761
31762 #ifdef _WIN64
31763 static void thunk64_vkCmdSetStencilWriteMask(void *args)
31764 {
31765     struct vkCmdSetStencilWriteMask_params *params = args;
31766
31767     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
31768 }
31769 #endif /* _WIN64 */
31770
31771 static void thunk32_vkCmdSetStencilWriteMask(void *args)
31772 {
31773     struct
31774     {
31775         PTR32 commandBuffer;
31776         VkStencilFaceFlags faceMask;
31777         uint32_t writeMask;
31778     } *params = args;
31779
31780     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);
31781 }
31782
31783 #ifdef _WIN64
31784 static void thunk64_vkCmdSetTessellationDomainOriginEXT(void *args)
31785 {
31786     struct vkCmdSetTessellationDomainOriginEXT_params *params = args;
31787
31788     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->domainOrigin);
31789 }
31790 #endif /* _WIN64 */
31791
31792 static void thunk32_vkCmdSetTessellationDomainOriginEXT(void *args)
31793 {
31794     struct
31795     {
31796         PTR32 commandBuffer;
31797         VkTessellationDomainOrigin domainOrigin;
31798     } *params = args;
31799
31800     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);
31801 }
31802
31803 #ifdef _WIN64
31804 static void thunk64_vkCmdSetVertexInputEXT(void *args)
31805 {
31806     struct vkCmdSetVertexInputEXT_params *params = args;
31807
31808     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);
31809 }
31810 #endif /* _WIN64 */
31811
31812 static void thunk32_vkCmdSetVertexInputEXT(void *args)
31813 {
31814     struct
31815     {
31816         PTR32 commandBuffer;
31817         uint32_t vertexBindingDescriptionCount;
31818         PTR32 pVertexBindingDescriptions;
31819         uint32_t vertexAttributeDescriptionCount;
31820         PTR32 pVertexAttributeDescriptions;
31821     } *params = args;
31822     const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions_host;
31823     const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions_host;
31824     struct conversion_context local_ctx;
31825     struct conversion_context *ctx = &local_ctx;
31826
31827     init_conversion_context(ctx);
31828     pVertexBindingDescriptions_host = convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(ctx, (const VkVertexInputBindingDescription2EXT32 *)UlongToPtr(params->pVertexBindingDescriptions), params->vertexBindingDescriptionCount);
31829     pVertexAttributeDescriptions_host = convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(ctx, (const VkVertexInputAttributeDescription2EXT32 *)UlongToPtr(params->pVertexAttributeDescriptions), params->vertexAttributeDescriptionCount);
31830     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);
31831     free_conversion_context(ctx);
31832 }
31833
31834 #ifdef _WIN64
31835 static void thunk64_vkCmdSetViewport(void *args)
31836 {
31837     struct vkCmdSetViewport_params *params = args;
31838
31839     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);
31840 }
31841 #endif /* _WIN64 */
31842
31843 static void thunk32_vkCmdSetViewport(void *args)
31844 {
31845     struct
31846     {
31847         PTR32 commandBuffer;
31848         uint32_t firstViewport;
31849         uint32_t viewportCount;
31850         PTR32 pViewports;
31851     } *params = args;
31852
31853     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));
31854 }
31855
31856 #ifdef _WIN64
31857 static void thunk64_vkCmdSetViewportShadingRatePaletteNV(void *args)
31858 {
31859     struct vkCmdSetViewportShadingRatePaletteNV_params *params = args;
31860
31861     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);
31862 }
31863 #endif /* _WIN64 */
31864
31865 static void thunk32_vkCmdSetViewportShadingRatePaletteNV(void *args)
31866 {
31867     struct
31868     {
31869         PTR32 commandBuffer;
31870         uint32_t firstViewport;
31871         uint32_t viewportCount;
31872         PTR32 pShadingRatePalettes;
31873     } *params = args;
31874     const VkShadingRatePaletteNV *pShadingRatePalettes_host;
31875     struct conversion_context local_ctx;
31876     struct conversion_context *ctx = &local_ctx;
31877
31878     init_conversion_context(ctx);
31879     pShadingRatePalettes_host = convert_VkShadingRatePaletteNV_array_win32_to_host(ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(params->pShadingRatePalettes), params->viewportCount);
31880     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);
31881     free_conversion_context(ctx);
31882 }
31883
31884 #ifdef _WIN64
31885 static void thunk64_vkCmdSetViewportSwizzleNV(void *args)
31886 {
31887     struct vkCmdSetViewportSwizzleNV_params *params = args;
31888
31889     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);
31890 }
31891 #endif /* _WIN64 */
31892
31893 static void thunk32_vkCmdSetViewportSwizzleNV(void *args)
31894 {
31895     struct
31896     {
31897         PTR32 commandBuffer;
31898         uint32_t firstViewport;
31899         uint32_t viewportCount;
31900         PTR32 pViewportSwizzles;
31901     } *params = args;
31902
31903     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));
31904 }
31905
31906 #ifdef _WIN64
31907 static void thunk64_vkCmdSetViewportWScalingEnableNV(void *args)
31908 {
31909     struct vkCmdSetViewportWScalingEnableNV_params *params = args;
31910
31911     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportWScalingEnable);
31912 }
31913 #endif /* _WIN64 */
31914
31915 static void thunk32_vkCmdSetViewportWScalingEnableNV(void *args)
31916 {
31917     struct
31918     {
31919         PTR32 commandBuffer;
31920         VkBool32 viewportWScalingEnable;
31921     } *params = args;
31922
31923     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);
31924 }
31925
31926 #ifdef _WIN64
31927 static void thunk64_vkCmdSetViewportWScalingNV(void *args)
31928 {
31929     struct vkCmdSetViewportWScalingNV_params *params = args;
31930
31931     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);
31932 }
31933 #endif /* _WIN64 */
31934
31935 static void thunk32_vkCmdSetViewportWScalingNV(void *args)
31936 {
31937     struct
31938     {
31939         PTR32 commandBuffer;
31940         uint32_t firstViewport;
31941         uint32_t viewportCount;
31942         PTR32 pViewportWScalings;
31943     } *params = args;
31944
31945     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));
31946 }
31947
31948 #ifdef _WIN64
31949 static void thunk64_vkCmdSetViewportWithCount(void *args)
31950 {
31951     struct vkCmdSetViewportWithCount_params *params = args;
31952
31953     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
31954 }
31955 #endif /* _WIN64 */
31956
31957 static void thunk32_vkCmdSetViewportWithCount(void *args)
31958 {
31959     struct
31960     {
31961         PTR32 commandBuffer;
31962         uint32_t viewportCount;
31963         PTR32 pViewports;
31964     } *params = args;
31965
31966     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));
31967 }
31968
31969 #ifdef _WIN64
31970 static void thunk64_vkCmdSetViewportWithCountEXT(void *args)
31971 {
31972     struct vkCmdSetViewportWithCountEXT_params *params = args;
31973
31974     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
31975 }
31976 #endif /* _WIN64 */
31977
31978 static void thunk32_vkCmdSetViewportWithCountEXT(void *args)
31979 {
31980     struct
31981     {
31982         PTR32 commandBuffer;
31983         uint32_t viewportCount;
31984         PTR32 pViewports;
31985     } *params = args;
31986
31987     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));
31988 }
31989
31990 #ifdef _WIN64
31991 static void thunk64_vkCmdSubpassShadingHUAWEI(void *args)
31992 {
31993     struct vkCmdSubpassShadingHUAWEI_params *params = args;
31994
31995     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
31996 }
31997 #endif /* _WIN64 */
31998
31999 static void thunk32_vkCmdSubpassShadingHUAWEI(void *args)
32000 {
32001     struct
32002     {
32003         PTR32 commandBuffer;
32004     } *params = args;
32005
32006     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
32007 }
32008
32009 #ifdef _WIN64
32010 static void thunk64_vkCmdTraceRaysIndirect2KHR(void *args)
32011 {
32012     struct vkCmdTraceRaysIndirect2KHR_params *params = args;
32013
32014     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectDeviceAddress);
32015 }
32016 #endif /* _WIN64 */
32017
32018 static void thunk32_vkCmdTraceRaysIndirect2KHR(void *args)
32019 {
32020     struct
32021     {
32022         PTR32 commandBuffer;
32023         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
32024     } *params = args;
32025
32026     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);
32027 }
32028
32029 #ifdef _WIN64
32030 static void thunk64_vkCmdTraceRaysIndirectKHR(void *args)
32031 {
32032     struct vkCmdTraceRaysIndirectKHR_params *params = args;
32033
32034     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);
32035 }
32036 #endif /* _WIN64 */
32037
32038 static void thunk32_vkCmdTraceRaysIndirectKHR(void *args)
32039 {
32040     struct
32041     {
32042         PTR32 commandBuffer;
32043         PTR32 pRaygenShaderBindingTable;
32044         PTR32 pMissShaderBindingTable;
32045         PTR32 pHitShaderBindingTable;
32046         PTR32 pCallableShaderBindingTable;
32047         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
32048     } *params = args;
32049     VkStridedDeviceAddressRegionKHR pRaygenShaderBindingTable_host;
32050     VkStridedDeviceAddressRegionKHR pMissShaderBindingTable_host;
32051     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
32052     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;
32053
32054     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pRaygenShaderBindingTable), &pRaygenShaderBindingTable_host);
32055     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pMissShaderBindingTable), &pMissShaderBindingTable_host);
32056     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pHitShaderBindingTable), &pHitShaderBindingTable_host);
32057     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pCallableShaderBindingTable), &pCallableShaderBindingTable_host);
32058     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);
32059 }
32060
32061 #ifdef _WIN64
32062 static void thunk64_vkCmdTraceRaysKHR(void *args)
32063 {
32064     struct vkCmdTraceRaysKHR_params *params = args;
32065
32066     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);
32067 }
32068 #endif /* _WIN64 */
32069
32070 static void thunk32_vkCmdTraceRaysKHR(void *args)
32071 {
32072     struct
32073     {
32074         PTR32 commandBuffer;
32075         PTR32 pRaygenShaderBindingTable;
32076         PTR32 pMissShaderBindingTable;
32077         PTR32 pHitShaderBindingTable;
32078         PTR32 pCallableShaderBindingTable;
32079         uint32_t width;
32080         uint32_t height;
32081         uint32_t depth;
32082     } *params = args;
32083     VkStridedDeviceAddressRegionKHR pRaygenShaderBindingTable_host;
32084     VkStridedDeviceAddressRegionKHR pMissShaderBindingTable_host;
32085     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
32086     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;
32087
32088     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pRaygenShaderBindingTable), &pRaygenShaderBindingTable_host);
32089     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pMissShaderBindingTable), &pMissShaderBindingTable_host);
32090     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pHitShaderBindingTable), &pHitShaderBindingTable_host);
32091     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pCallableShaderBindingTable), &pCallableShaderBindingTable_host);
32092     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);
32093 }
32094
32095 #ifdef _WIN64
32096 static void thunk64_vkCmdTraceRaysNV(void *args)
32097 {
32098     struct vkCmdTraceRaysNV_params *params = args;
32099
32100     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);
32101 }
32102 #endif /* _WIN64 */
32103
32104 static void thunk32_vkCmdTraceRaysNV(void *args)
32105 {
32106     struct
32107     {
32108         PTR32 commandBuffer;
32109         VkBuffer DECLSPEC_ALIGN(8) raygenShaderBindingTableBuffer;
32110         VkDeviceSize DECLSPEC_ALIGN(8) raygenShaderBindingOffset;
32111         VkBuffer DECLSPEC_ALIGN(8) missShaderBindingTableBuffer;
32112         VkDeviceSize DECLSPEC_ALIGN(8) missShaderBindingOffset;
32113         VkDeviceSize DECLSPEC_ALIGN(8) missShaderBindingStride;
32114         VkBuffer DECLSPEC_ALIGN(8) hitShaderBindingTableBuffer;
32115         VkDeviceSize DECLSPEC_ALIGN(8) hitShaderBindingOffset;
32116         VkDeviceSize DECLSPEC_ALIGN(8) hitShaderBindingStride;
32117         VkBuffer DECLSPEC_ALIGN(8) callableShaderBindingTableBuffer;
32118         VkDeviceSize DECLSPEC_ALIGN(8) callableShaderBindingOffset;
32119         VkDeviceSize DECLSPEC_ALIGN(8) callableShaderBindingStride;
32120         uint32_t width;
32121         uint32_t height;
32122         uint32_t depth;
32123     } *params = args;
32124
32125     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);
32126 }
32127
32128 #ifdef _WIN64
32129 static void thunk64_vkCmdUpdateBuffer(void *args)
32130 {
32131     struct vkCmdUpdateBuffer_params *params = args;
32132
32133     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);
32134 }
32135 #endif /* _WIN64 */
32136
32137 static void thunk32_vkCmdUpdateBuffer(void *args)
32138 {
32139     struct
32140     {
32141         PTR32 commandBuffer;
32142         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
32143         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
32144         VkDeviceSize DECLSPEC_ALIGN(8) dataSize;
32145         PTR32 pData;
32146     } *params = args;
32147
32148     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));
32149 }
32150
32151 #ifdef _WIN64
32152 static void thunk64_vkCmdWaitEvents(void *args)
32153 {
32154     struct vkCmdWaitEvents_params *params = args;
32155
32156     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);
32157 }
32158 #endif /* _WIN64 */
32159
32160 static void thunk32_vkCmdWaitEvents(void *args)
32161 {
32162     struct
32163     {
32164         PTR32 commandBuffer;
32165         uint32_t eventCount;
32166         PTR32 pEvents;
32167         VkPipelineStageFlags srcStageMask;
32168         VkPipelineStageFlags dstStageMask;
32169         uint32_t memoryBarrierCount;
32170         PTR32 pMemoryBarriers;
32171         uint32_t bufferMemoryBarrierCount;
32172         PTR32 pBufferMemoryBarriers;
32173         uint32_t imageMemoryBarrierCount;
32174         PTR32 pImageMemoryBarriers;
32175     } *params = args;
32176     const VkMemoryBarrier *pMemoryBarriers_host;
32177     const VkBufferMemoryBarrier *pBufferMemoryBarriers_host;
32178     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
32179     struct conversion_context local_ctx;
32180     struct conversion_context *ctx = &local_ctx;
32181
32182     init_conversion_context(ctx);
32183     pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(ctx, (const VkMemoryBarrier32 *)UlongToPtr(params->pMemoryBarriers), params->memoryBarrierCount);
32184     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(ctx, (const VkBufferMemoryBarrier32 *)UlongToPtr(params->pBufferMemoryBarriers), params->bufferMemoryBarrierCount);
32185     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(ctx, (const VkImageMemoryBarrier32 *)UlongToPtr(params->pImageMemoryBarriers), params->imageMemoryBarrierCount);
32186     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);
32187     free_conversion_context(ctx);
32188 }
32189
32190 #ifdef _WIN64
32191 static void thunk64_vkCmdWaitEvents2(void *args)
32192 {
32193     struct vkCmdWaitEvents2_params *params = args;
32194
32195     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);
32196 }
32197 #endif /* _WIN64 */
32198
32199 static void thunk32_vkCmdWaitEvents2(void *args)
32200 {
32201     struct
32202     {
32203         PTR32 commandBuffer;
32204         uint32_t eventCount;
32205         PTR32 pEvents;
32206         PTR32 pDependencyInfos;
32207     } *params = args;
32208     const VkDependencyInfo *pDependencyInfos_host;
32209     struct conversion_context local_ctx;
32210     struct conversion_context *ctx = &local_ctx;
32211
32212     init_conversion_context(ctx);
32213     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfos), params->eventCount);
32214     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);
32215     free_conversion_context(ctx);
32216 }
32217
32218 #ifdef _WIN64
32219 static void thunk64_vkCmdWaitEvents2KHR(void *args)
32220 {
32221     struct vkCmdWaitEvents2KHR_params *params = args;
32222
32223     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);
32224 }
32225 #endif /* _WIN64 */
32226
32227 static void thunk32_vkCmdWaitEvents2KHR(void *args)
32228 {
32229     struct
32230     {
32231         PTR32 commandBuffer;
32232         uint32_t eventCount;
32233         PTR32 pEvents;
32234         PTR32 pDependencyInfos;
32235     } *params = args;
32236     const VkDependencyInfo *pDependencyInfos_host;
32237     struct conversion_context local_ctx;
32238     struct conversion_context *ctx = &local_ctx;
32239
32240     init_conversion_context(ctx);
32241     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfos), params->eventCount);
32242     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);
32243     free_conversion_context(ctx);
32244 }
32245
32246 #ifdef _WIN64
32247 static void thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
32248 {
32249     struct vkCmdWriteAccelerationStructuresPropertiesKHR_params *params = args;
32250
32251     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);
32252 }
32253 #endif /* _WIN64 */
32254
32255 static void thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
32256 {
32257     struct
32258     {
32259         PTR32 commandBuffer;
32260         uint32_t accelerationStructureCount;
32261         PTR32 pAccelerationStructures;
32262         VkQueryType queryType;
32263         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
32264         uint32_t firstQuery;
32265     } *params = args;
32266
32267     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);
32268 }
32269
32270 #ifdef _WIN64
32271 static void thunk64_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
32272 {
32273     struct vkCmdWriteAccelerationStructuresPropertiesNV_params *params = args;
32274
32275     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);
32276 }
32277 #endif /* _WIN64 */
32278
32279 static void thunk32_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
32280 {
32281     struct
32282     {
32283         PTR32 commandBuffer;
32284         uint32_t accelerationStructureCount;
32285         PTR32 pAccelerationStructures;
32286         VkQueryType queryType;
32287         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
32288         uint32_t firstQuery;
32289     } *params = args;
32290
32291     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);
32292 }
32293
32294 #ifdef _WIN64
32295 static void thunk64_vkCmdWriteBufferMarker2AMD(void *args)
32296 {
32297     struct vkCmdWriteBufferMarker2AMD_params *params = args;
32298
32299     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);
32300 }
32301 #endif /* _WIN64 */
32302
32303 static void thunk32_vkCmdWriteBufferMarker2AMD(void *args)
32304 {
32305     struct
32306     {
32307         PTR32 commandBuffer;
32308         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
32309         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
32310         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
32311         uint32_t marker;
32312     } *params = args;
32313
32314     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);
32315 }
32316
32317 #ifdef _WIN64
32318 static void thunk64_vkCmdWriteBufferMarkerAMD(void *args)
32319 {
32320     struct vkCmdWriteBufferMarkerAMD_params *params = args;
32321
32322     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);
32323 }
32324 #endif /* _WIN64 */
32325
32326 static void thunk32_vkCmdWriteBufferMarkerAMD(void *args)
32327 {
32328     struct
32329     {
32330         PTR32 commandBuffer;
32331         VkPipelineStageFlagBits pipelineStage;
32332         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
32333         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
32334         uint32_t marker;
32335     } *params = args;
32336
32337     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);
32338 }
32339
32340 #ifdef _WIN64
32341 static void thunk64_vkCmdWriteMicromapsPropertiesEXT(void *args)
32342 {
32343     struct vkCmdWriteMicromapsPropertiesEXT_params *params = args;
32344
32345     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);
32346 }
32347 #endif /* _WIN64 */
32348
32349 static void thunk32_vkCmdWriteMicromapsPropertiesEXT(void *args)
32350 {
32351     struct
32352     {
32353         PTR32 commandBuffer;
32354         uint32_t micromapCount;
32355         PTR32 pMicromaps;
32356         VkQueryType queryType;
32357         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
32358         uint32_t firstQuery;
32359     } *params = args;
32360
32361     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);
32362 }
32363
32364 #ifdef _WIN64
32365 static void thunk64_vkCmdWriteTimestamp(void *args)
32366 {
32367     struct vkCmdWriteTimestamp_params *params = args;
32368
32369     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);
32370 }
32371 #endif /* _WIN64 */
32372
32373 static void thunk32_vkCmdWriteTimestamp(void *args)
32374 {
32375     struct
32376     {
32377         PTR32 commandBuffer;
32378         VkPipelineStageFlagBits pipelineStage;
32379         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
32380         uint32_t query;
32381     } *params = args;
32382
32383     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);
32384 }
32385
32386 #ifdef _WIN64
32387 static void thunk64_vkCmdWriteTimestamp2(void *args)
32388 {
32389     struct vkCmdWriteTimestamp2_params *params = args;
32390
32391     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);
32392 }
32393 #endif /* _WIN64 */
32394
32395 static void thunk32_vkCmdWriteTimestamp2(void *args)
32396 {
32397     struct
32398     {
32399         PTR32 commandBuffer;
32400         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
32401         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
32402         uint32_t query;
32403     } *params = args;
32404
32405     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);
32406 }
32407
32408 #ifdef _WIN64
32409 static void thunk64_vkCmdWriteTimestamp2KHR(void *args)
32410 {
32411     struct vkCmdWriteTimestamp2KHR_params *params = args;
32412
32413     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);
32414 }
32415 #endif /* _WIN64 */
32416
32417 static void thunk32_vkCmdWriteTimestamp2KHR(void *args)
32418 {
32419     struct
32420     {
32421         PTR32 commandBuffer;
32422         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
32423         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
32424         uint32_t query;
32425     } *params = args;
32426
32427     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);
32428 }
32429
32430 #ifdef _WIN64
32431 static NTSTATUS thunk64_vkCompileDeferredNV(void *args)
32432 {
32433     struct vkCompileDeferredNV_params *params = args;
32434
32435     TRACE("%p, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);
32436
32437     params->result = wine_device_from_handle(params->device)->funcs.p_vkCompileDeferredNV(wine_device_from_handle(params->device)->device, params->pipeline, params->shader);
32438     return STATUS_SUCCESS;
32439 }
32440 #endif /* _WIN64 */
32441
32442 static NTSTATUS thunk32_vkCompileDeferredNV(void *args)
32443 {
32444     struct
32445     {
32446         PTR32 device;
32447         VkPipeline DECLSPEC_ALIGN(8) pipeline;
32448         uint32_t shader;
32449         VkResult result;
32450     } *params = args;
32451
32452     TRACE("%#x, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);
32453
32454     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);
32455     return STATUS_SUCCESS;
32456 }
32457
32458 #ifdef _WIN64
32459 static NTSTATUS thunk64_vkCopyAccelerationStructureKHR(void *args)
32460 {
32461     struct vkCopyAccelerationStructureKHR_params *params = args;
32462
32463     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32464
32465     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);
32466     return STATUS_SUCCESS;
32467 }
32468 #endif /* _WIN64 */
32469
32470 static NTSTATUS thunk32_vkCopyAccelerationStructureKHR(void *args)
32471 {
32472     struct
32473     {
32474         PTR32 device;
32475         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32476         PTR32 pInfo;
32477         VkResult result;
32478     } *params = args;
32479     VkCopyAccelerationStructureInfoKHR pInfo_host;
32480
32481     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32482
32483     convert_VkCopyAccelerationStructureInfoKHR_win32_to_host((const VkCopyAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
32484     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);
32485     return STATUS_SUCCESS;
32486 }
32487
32488 #ifdef _WIN64
32489 static NTSTATUS thunk64_vkCopyAccelerationStructureToMemoryKHR(void *args)
32490 {
32491     struct vkCopyAccelerationStructureToMemoryKHR_params *params = args;
32492
32493     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32494
32495     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);
32496     return STATUS_SUCCESS;
32497 }
32498 #endif /* _WIN64 */
32499
32500 static NTSTATUS thunk32_vkCopyAccelerationStructureToMemoryKHR(void *args)
32501 {
32502     struct
32503     {
32504         PTR32 device;
32505         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32506         PTR32 pInfo;
32507         VkResult result;
32508     } *params = args;
32509     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;
32510
32511     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32512
32513     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host((const VkCopyAccelerationStructureToMemoryInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
32514     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);
32515     return STATUS_SUCCESS;
32516 }
32517
32518 #ifdef _WIN64
32519 static NTSTATUS thunk64_vkCopyMemoryToAccelerationStructureKHR(void *args)
32520 {
32521     struct vkCopyMemoryToAccelerationStructureKHR_params *params = args;
32522
32523     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32524
32525     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);
32526     return STATUS_SUCCESS;
32527 }
32528 #endif /* _WIN64 */
32529
32530 static NTSTATUS thunk32_vkCopyMemoryToAccelerationStructureKHR(void *args)
32531 {
32532     struct
32533     {
32534         PTR32 device;
32535         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32536         PTR32 pInfo;
32537         VkResult result;
32538     } *params = args;
32539     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;
32540
32541     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32542
32543     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host((const VkCopyMemoryToAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
32544     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);
32545     return STATUS_SUCCESS;
32546 }
32547
32548 #ifdef _WIN64
32549 static NTSTATUS thunk64_vkCopyMemoryToMicromapEXT(void *args)
32550 {
32551     struct vkCopyMemoryToMicromapEXT_params *params = args;
32552
32553     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32554
32555     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);
32556     return STATUS_SUCCESS;
32557 }
32558 #endif /* _WIN64 */
32559
32560 static NTSTATUS thunk32_vkCopyMemoryToMicromapEXT(void *args)
32561 {
32562     struct
32563     {
32564         PTR32 device;
32565         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32566         PTR32 pInfo;
32567         VkResult result;
32568     } *params = args;
32569     VkCopyMemoryToMicromapInfoEXT pInfo_host;
32570
32571     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32572
32573     convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host((const VkCopyMemoryToMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
32574     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);
32575     return STATUS_SUCCESS;
32576 }
32577
32578 #ifdef _WIN64
32579 static NTSTATUS thunk64_vkCopyMicromapEXT(void *args)
32580 {
32581     struct vkCopyMicromapEXT_params *params = args;
32582
32583     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32584
32585     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);
32586     return STATUS_SUCCESS;
32587 }
32588 #endif /* _WIN64 */
32589
32590 static NTSTATUS thunk32_vkCopyMicromapEXT(void *args)
32591 {
32592     struct
32593     {
32594         PTR32 device;
32595         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32596         PTR32 pInfo;
32597         VkResult result;
32598     } *params = args;
32599     VkCopyMicromapInfoEXT pInfo_host;
32600
32601     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32602
32603     convert_VkCopyMicromapInfoEXT_win32_to_host((const VkCopyMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
32604     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);
32605     return STATUS_SUCCESS;
32606 }
32607
32608 #ifdef _WIN64
32609 static NTSTATUS thunk64_vkCopyMicromapToMemoryEXT(void *args)
32610 {
32611     struct vkCopyMicromapToMemoryEXT_params *params = args;
32612
32613     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32614
32615     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);
32616     return STATUS_SUCCESS;
32617 }
32618 #endif /* _WIN64 */
32619
32620 static NTSTATUS thunk32_vkCopyMicromapToMemoryEXT(void *args)
32621 {
32622     struct
32623     {
32624         PTR32 device;
32625         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
32626         PTR32 pInfo;
32627         VkResult result;
32628     } *params = args;
32629     VkCopyMicromapToMemoryInfoEXT pInfo_host;
32630
32631     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
32632
32633     convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host((const VkCopyMicromapToMemoryInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
32634     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);
32635     return STATUS_SUCCESS;
32636 }
32637
32638 #ifdef _WIN64
32639 static NTSTATUS thunk64_vkCreateAccelerationStructureKHR(void *args)
32640 {
32641     struct vkCreateAccelerationStructureKHR_params *params = args;
32642
32643     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32644
32645     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
32646     return STATUS_SUCCESS;
32647 }
32648 #endif /* _WIN64 */
32649
32650 static NTSTATUS thunk32_vkCreateAccelerationStructureKHR(void *args)
32651 {
32652     struct
32653     {
32654         PTR32 device;
32655         PTR32 pCreateInfo;
32656         PTR32 pAllocator;
32657         PTR32 pAccelerationStructure;
32658         VkResult result;
32659     } *params = args;
32660     VkAccelerationStructureCreateInfoKHR pCreateInfo_host;
32661     struct conversion_context local_ctx;
32662     struct conversion_context *ctx = &local_ctx;
32663
32664     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32665
32666     init_conversion_context(ctx);
32667     convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(ctx, (const VkAccelerationStructureCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32668     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));
32669     free_conversion_context(ctx);
32670     return STATUS_SUCCESS;
32671 }
32672
32673 #ifdef _WIN64
32674 static NTSTATUS thunk64_vkCreateAccelerationStructureNV(void *args)
32675 {
32676     struct vkCreateAccelerationStructureNV_params *params = args;
32677
32678     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32679
32680     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
32681     return STATUS_SUCCESS;
32682 }
32683 #endif /* _WIN64 */
32684
32685 static NTSTATUS thunk32_vkCreateAccelerationStructureNV(void *args)
32686 {
32687     struct
32688     {
32689         PTR32 device;
32690         PTR32 pCreateInfo;
32691         PTR32 pAllocator;
32692         PTR32 pAccelerationStructure;
32693         VkResult result;
32694     } *params = args;
32695     VkAccelerationStructureCreateInfoNV pCreateInfo_host;
32696     struct conversion_context local_ctx;
32697     struct conversion_context *ctx = &local_ctx;
32698
32699     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32700
32701     init_conversion_context(ctx);
32702     convert_VkAccelerationStructureCreateInfoNV_win32_to_host(ctx, (const VkAccelerationStructureCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32703     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));
32704     free_conversion_context(ctx);
32705     return STATUS_SUCCESS;
32706 }
32707
32708 #ifdef _WIN64
32709 static NTSTATUS thunk64_vkCreateBuffer(void *args)
32710 {
32711     struct vkCreateBuffer_params *params = args;
32712
32713     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
32714
32715     params->result = wine_vkCreateBuffer(params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
32716     return STATUS_SUCCESS;
32717 }
32718 #endif /* _WIN64 */
32719
32720 static NTSTATUS thunk32_vkCreateBuffer(void *args)
32721 {
32722     struct
32723     {
32724         PTR32 device;
32725         PTR32 pCreateInfo;
32726         PTR32 pAllocator;
32727         PTR32 pBuffer;
32728         VkResult result;
32729     } *params = args;
32730     VkBufferCreateInfo pCreateInfo_host;
32731     struct conversion_context local_ctx;
32732     struct conversion_context *ctx = &local_ctx;
32733
32734     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
32735
32736     init_conversion_context(ctx);
32737     convert_VkBufferCreateInfo_win32_to_host(ctx, (const VkBufferCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32738     params->result = wine_vkCreateBuffer((VkDevice)UlongToPtr(params->device), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkBuffer *)UlongToPtr(params->pBuffer));
32739     free_conversion_context(ctx);
32740     return STATUS_SUCCESS;
32741 }
32742
32743 #ifdef _WIN64
32744 static NTSTATUS thunk64_vkCreateBufferView(void *args)
32745 {
32746     struct vkCreateBufferView_params *params = args;
32747
32748     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
32749
32750     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBufferView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
32751     return STATUS_SUCCESS;
32752 }
32753 #endif /* _WIN64 */
32754
32755 static NTSTATUS thunk32_vkCreateBufferView(void *args)
32756 {
32757     struct
32758     {
32759         PTR32 device;
32760         PTR32 pCreateInfo;
32761         PTR32 pAllocator;
32762         PTR32 pView;
32763         VkResult result;
32764     } *params = args;
32765     VkBufferViewCreateInfo pCreateInfo_host;
32766
32767     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
32768
32769     convert_VkBufferViewCreateInfo_win32_to_host((const VkBufferViewCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32770     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));
32771     return STATUS_SUCCESS;
32772 }
32773
32774 #ifdef _WIN64
32775 static NTSTATUS thunk64_vkCreateCommandPool(void *args)
32776 {
32777     struct vkCreateCommandPool_params *params = args;
32778
32779     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);
32780
32781     params->result = wine_vkCreateCommandPool(params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool, params->client_ptr);
32782     return STATUS_SUCCESS;
32783 }
32784 #endif /* _WIN64 */
32785
32786 static NTSTATUS thunk32_vkCreateCommandPool(void *args)
32787 {
32788     struct
32789     {
32790         PTR32 device;
32791         PTR32 pCreateInfo;
32792         PTR32 pAllocator;
32793         PTR32 pCommandPool;
32794         PTR32 client_ptr;
32795         VkResult result;
32796     } *params = args;
32797     VkCommandPoolCreateInfo pCreateInfo_host;
32798
32799     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);
32800
32801     convert_VkCommandPoolCreateInfo_win32_to_host((const VkCommandPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32802     params->result = wine_vkCreateCommandPool((VkDevice)UlongToPtr(params->device), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkCommandPool *)UlongToPtr(params->pCommandPool), UlongToPtr(params->client_ptr));
32803     return STATUS_SUCCESS;
32804 }
32805
32806 #ifdef _WIN64
32807 static NTSTATUS thunk64_vkCreateComputePipelines(void *args)
32808 {
32809     struct vkCreateComputePipelines_params *params = args;
32810     const VkComputePipelineCreateInfo *pCreateInfos_host;
32811     struct conversion_context local_ctx;
32812     struct conversion_context *ctx = &local_ctx;
32813
32814     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
32815
32816     init_conversion_context(ctx);
32817     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win64_to_host(ctx, params->pCreateInfos, params->createInfoCount);
32818     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);
32819     free_conversion_context(ctx);
32820     return STATUS_SUCCESS;
32821 }
32822 #endif /* _WIN64 */
32823
32824 static NTSTATUS thunk32_vkCreateComputePipelines(void *args)
32825 {
32826     struct
32827     {
32828         PTR32 device;
32829         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
32830         uint32_t createInfoCount;
32831         PTR32 pCreateInfos;
32832         PTR32 pAllocator;
32833         PTR32 pPipelines;
32834         VkResult result;
32835     } *params = args;
32836     const VkComputePipelineCreateInfo *pCreateInfos_host;
32837     struct conversion_context local_ctx;
32838     struct conversion_context *ctx = &local_ctx;
32839
32840     TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
32841
32842     init_conversion_context(ctx);
32843     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win32_to_host(ctx, (const VkComputePipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
32844     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));
32845     convert_VkComputePipelineCreateInfo_array_host_to_win32(pCreateInfos_host, (const VkComputePipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
32846     free_conversion_context(ctx);
32847     return STATUS_SUCCESS;
32848 }
32849
32850 #ifdef _WIN64
32851 static NTSTATUS thunk64_vkCreateCuFunctionNVX(void *args)
32852 {
32853     struct vkCreateCuFunctionNVX_params *params = args;
32854
32855     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);
32856
32857     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFunction);
32858     return STATUS_SUCCESS;
32859 }
32860 #endif /* _WIN64 */
32861
32862 static NTSTATUS thunk32_vkCreateCuFunctionNVX(void *args)
32863 {
32864     struct
32865     {
32866         PTR32 device;
32867         PTR32 pCreateInfo;
32868         PTR32 pAllocator;
32869         PTR32 pFunction;
32870         VkResult result;
32871     } *params = args;
32872     VkCuFunctionCreateInfoNVX pCreateInfo_host;
32873
32874     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);
32875
32876     convert_VkCuFunctionCreateInfoNVX_win32_to_host((const VkCuFunctionCreateInfoNVX32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32877     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));
32878     return STATUS_SUCCESS;
32879 }
32880
32881 #ifdef _WIN64
32882 static NTSTATUS thunk64_vkCreateCuModuleNVX(void *args)
32883 {
32884     struct vkCreateCuModuleNVX_params *params = args;
32885
32886     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);
32887
32888     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pModule);
32889     return STATUS_SUCCESS;
32890 }
32891 #endif /* _WIN64 */
32892
32893 static NTSTATUS thunk32_vkCreateCuModuleNVX(void *args)
32894 {
32895     struct
32896     {
32897         PTR32 device;
32898         PTR32 pCreateInfo;
32899         PTR32 pAllocator;
32900         PTR32 pModule;
32901         VkResult result;
32902     } *params = args;
32903     VkCuModuleCreateInfoNVX pCreateInfo_host;
32904
32905     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);
32906
32907     convert_VkCuModuleCreateInfoNVX_win32_to_host((const VkCuModuleCreateInfoNVX32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32908     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));
32909     return STATUS_SUCCESS;
32910 }
32911
32912 #ifdef _WIN64
32913 static NTSTATUS thunk64_vkCreateDebugReportCallbackEXT(void *args)
32914 {
32915     struct vkCreateDebugReportCallbackEXT_params *params = args;
32916
32917     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
32918
32919     params->result = wine_vkCreateDebugReportCallbackEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
32920     return STATUS_SUCCESS;
32921 }
32922 #endif /* _WIN64 */
32923
32924 static NTSTATUS thunk32_vkCreateDebugReportCallbackEXT(void *args)
32925 {
32926     struct
32927     {
32928         PTR32 instance;
32929         PTR32 pCreateInfo;
32930         PTR32 pAllocator;
32931         PTR32 pCallback;
32932         VkResult result;
32933     } *params = args;
32934     VkDebugReportCallbackCreateInfoEXT pCreateInfo_host;
32935
32936     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
32937
32938     convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host((const VkDebugReportCallbackCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32939     params->result = wine_vkCreateDebugReportCallbackEXT((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDebugReportCallbackEXT *)UlongToPtr(params->pCallback));
32940     return STATUS_SUCCESS;
32941 }
32942
32943 #ifdef _WIN64
32944 static NTSTATUS thunk64_vkCreateDebugUtilsMessengerEXT(void *args)
32945 {
32946     struct vkCreateDebugUtilsMessengerEXT_params *params = args;
32947
32948     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
32949
32950     params->result = wine_vkCreateDebugUtilsMessengerEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
32951     return STATUS_SUCCESS;
32952 }
32953 #endif /* _WIN64 */
32954
32955 static NTSTATUS thunk32_vkCreateDebugUtilsMessengerEXT(void *args)
32956 {
32957     struct
32958     {
32959         PTR32 instance;
32960         PTR32 pCreateInfo;
32961         PTR32 pAllocator;
32962         PTR32 pMessenger;
32963         VkResult result;
32964     } *params = args;
32965     VkDebugUtilsMessengerCreateInfoEXT pCreateInfo_host;
32966
32967     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
32968
32969     convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host((const VkDebugUtilsMessengerCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32970     params->result = wine_vkCreateDebugUtilsMessengerEXT((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDebugUtilsMessengerEXT *)UlongToPtr(params->pMessenger));
32971     return STATUS_SUCCESS;
32972 }
32973
32974 #ifdef _WIN64
32975 static NTSTATUS thunk64_vkCreateDeferredOperationKHR(void *args)
32976 {
32977     struct vkCreateDeferredOperationKHR_params *params = args;
32978
32979     TRACE("%p, %p, %p\n", params->device, params->pAllocator, params->pDeferredOperation);
32980
32981     params->result = wine_vkCreateDeferredOperationKHR(params->device, params->pAllocator, params->pDeferredOperation);
32982     return STATUS_SUCCESS;
32983 }
32984 #endif /* _WIN64 */
32985
32986 static NTSTATUS thunk32_vkCreateDeferredOperationKHR(void *args)
32987 {
32988     struct
32989     {
32990         PTR32 device;
32991         PTR32 pAllocator;
32992         PTR32 pDeferredOperation;
32993         VkResult result;
32994     } *params = args;
32995
32996     TRACE("%#x, %#x, %#x\n", params->device, params->pAllocator, params->pDeferredOperation);
32997
32998     params->result = wine_vkCreateDeferredOperationKHR((VkDevice)UlongToPtr(params->device), (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDeferredOperationKHR *)UlongToPtr(params->pDeferredOperation));
32999     return STATUS_SUCCESS;
33000 }
33001
33002 #ifdef _WIN64
33003 static NTSTATUS thunk64_vkCreateDescriptorPool(void *args)
33004 {
33005     struct vkCreateDescriptorPool_params *params = args;
33006
33007     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);
33008
33009     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorPool);
33010     return STATUS_SUCCESS;
33011 }
33012 #endif /* _WIN64 */
33013
33014 static NTSTATUS thunk32_vkCreateDescriptorPool(void *args)
33015 {
33016     struct
33017     {
33018         PTR32 device;
33019         PTR32 pCreateInfo;
33020         PTR32 pAllocator;
33021         PTR32 pDescriptorPool;
33022         VkResult result;
33023     } *params = args;
33024     VkDescriptorPoolCreateInfo pCreateInfo_host;
33025     struct conversion_context local_ctx;
33026     struct conversion_context *ctx = &local_ctx;
33027
33028     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);
33029
33030     init_conversion_context(ctx);
33031     convert_VkDescriptorPoolCreateInfo_win32_to_host(ctx, (const VkDescriptorPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33032     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));
33033     free_conversion_context(ctx);
33034     return STATUS_SUCCESS;
33035 }
33036
33037 #ifdef _WIN64
33038 static NTSTATUS thunk64_vkCreateDescriptorSetLayout(void *args)
33039 {
33040     struct vkCreateDescriptorSetLayout_params *params = args;
33041
33042     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);
33043
33044     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSetLayout);
33045     return STATUS_SUCCESS;
33046 }
33047 #endif /* _WIN64 */
33048
33049 static NTSTATUS thunk32_vkCreateDescriptorSetLayout(void *args)
33050 {
33051     struct
33052     {
33053         PTR32 device;
33054         PTR32 pCreateInfo;
33055         PTR32 pAllocator;
33056         PTR32 pSetLayout;
33057         VkResult result;
33058     } *params = args;
33059     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
33060     struct conversion_context local_ctx;
33061     struct conversion_context *ctx = &local_ctx;
33062
33063     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);
33064
33065     init_conversion_context(ctx);
33066     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33067     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));
33068     free_conversion_context(ctx);
33069     return STATUS_SUCCESS;
33070 }
33071
33072 #ifdef _WIN64
33073 static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplate(void *args)
33074 {
33075     struct vkCreateDescriptorUpdateTemplate_params *params = args;
33076
33077     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
33078
33079     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
33080     return STATUS_SUCCESS;
33081 }
33082 #endif /* _WIN64 */
33083
33084 static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplate(void *args)
33085 {
33086     struct
33087     {
33088         PTR32 device;
33089         PTR32 pCreateInfo;
33090         PTR32 pAllocator;
33091         PTR32 pDescriptorUpdateTemplate;
33092         VkResult result;
33093     } *params = args;
33094     VkDescriptorUpdateTemplateCreateInfo pCreateInfo_host;
33095     struct conversion_context local_ctx;
33096     struct conversion_context *ctx = &local_ctx;
33097
33098     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
33099
33100     init_conversion_context(ctx);
33101     convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(ctx, (const VkDescriptorUpdateTemplateCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33102     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));
33103     free_conversion_context(ctx);
33104     return STATUS_SUCCESS;
33105 }
33106
33107 #ifdef _WIN64
33108 static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplateKHR(void *args)
33109 {
33110     struct vkCreateDescriptorUpdateTemplateKHR_params *params = args;
33111
33112     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
33113
33114     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
33115     return STATUS_SUCCESS;
33116 }
33117 #endif /* _WIN64 */
33118
33119 static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplateKHR(void *args)
33120 {
33121     struct
33122     {
33123         PTR32 device;
33124         PTR32 pCreateInfo;
33125         PTR32 pAllocator;
33126         PTR32 pDescriptorUpdateTemplate;
33127         VkResult result;
33128     } *params = args;
33129     VkDescriptorUpdateTemplateCreateInfo pCreateInfo_host;
33130     struct conversion_context local_ctx;
33131     struct conversion_context *ctx = &local_ctx;
33132
33133     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
33134
33135     init_conversion_context(ctx);
33136     convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(ctx, (const VkDescriptorUpdateTemplateCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33137     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));
33138     free_conversion_context(ctx);
33139     return STATUS_SUCCESS;
33140 }
33141
33142 #ifdef _WIN64
33143 static NTSTATUS thunk64_vkCreateDevice(void *args)
33144 {
33145     struct vkCreateDevice_params *params = args;
33146     VkDeviceCreateInfo pCreateInfo_host;
33147     struct conversion_context local_ctx;
33148     struct conversion_context *ctx = &local_ctx;
33149
33150     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);
33151
33152     init_conversion_context(ctx);
33153     convert_VkDeviceCreateInfo_win64_to_host(ctx, params->pCreateInfo, &pCreateInfo_host);
33154     params->result = wine_vkCreateDevice(params->physicalDevice, &pCreateInfo_host, params->pAllocator, params->pDevice, params->client_ptr);
33155     free_conversion_context(ctx);
33156     return STATUS_SUCCESS;
33157 }
33158 #endif /* _WIN64 */
33159
33160 static NTSTATUS thunk32_vkCreateDevice(void *args)
33161 {
33162     struct
33163     {
33164         PTR32 physicalDevice;
33165         PTR32 pCreateInfo;
33166         PTR32 pAllocator;
33167         PTR32 pDevice;
33168         PTR32 client_ptr;
33169         VkResult result;
33170     } *params = args;
33171     VkDeviceCreateInfo pCreateInfo_host;
33172     VkDevice pDevice_host;
33173     struct conversion_context local_ctx;
33174     struct conversion_context *ctx = &local_ctx;
33175
33176     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);
33177
33178     init_conversion_context(ctx);
33179     convert_VkDeviceCreateInfo_win32_to_host(ctx, (const VkDeviceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33180     pDevice_host = UlongToPtr(*(PTR32 *)UlongToPtr(params->pDevice));
33181     params->result = wine_vkCreateDevice((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), &pDevice_host, UlongToPtr(params->client_ptr));
33182     *(PTR32 *)UlongToPtr(params->pDevice) = PtrToUlong(pDevice_host);
33183     free_conversion_context(ctx);
33184     return STATUS_SUCCESS;
33185 }
33186
33187 #ifdef _WIN64
33188 static NTSTATUS thunk64_vkCreateEvent(void *args)
33189 {
33190     struct vkCreateEvent_params *params = args;
33191
33192     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);
33193
33194     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateEvent(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pEvent);
33195     return STATUS_SUCCESS;
33196 }
33197 #endif /* _WIN64 */
33198
33199 static NTSTATUS thunk32_vkCreateEvent(void *args)
33200 {
33201     struct
33202     {
33203         PTR32 device;
33204         PTR32 pCreateInfo;
33205         PTR32 pAllocator;
33206         PTR32 pEvent;
33207         VkResult result;
33208     } *params = args;
33209     VkEventCreateInfo pCreateInfo_host;
33210
33211     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);
33212
33213     convert_VkEventCreateInfo_win32_to_host((const VkEventCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33214     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));
33215     return STATUS_SUCCESS;
33216 }
33217
33218 #ifdef _WIN64
33219 static NTSTATUS thunk64_vkCreateFence(void *args)
33220 {
33221     struct vkCreateFence_params *params = args;
33222
33223     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);
33224
33225     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFence(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFence);
33226     return STATUS_SUCCESS;
33227 }
33228 #endif /* _WIN64 */
33229
33230 static NTSTATUS thunk32_vkCreateFence(void *args)
33231 {
33232     struct
33233     {
33234         PTR32 device;
33235         PTR32 pCreateInfo;
33236         PTR32 pAllocator;
33237         PTR32 pFence;
33238         VkResult result;
33239     } *params = args;
33240     VkFenceCreateInfo pCreateInfo_host;
33241     struct conversion_context local_ctx;
33242     struct conversion_context *ctx = &local_ctx;
33243
33244     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);
33245
33246     init_conversion_context(ctx);
33247     convert_VkFenceCreateInfo_win32_to_host(ctx, (const VkFenceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33248     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));
33249     free_conversion_context(ctx);
33250     return STATUS_SUCCESS;
33251 }
33252
33253 #ifdef _WIN64
33254 static NTSTATUS thunk64_vkCreateFramebuffer(void *args)
33255 {
33256     struct vkCreateFramebuffer_params *params = args;
33257
33258     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);
33259
33260     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFramebuffer(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFramebuffer);
33261     return STATUS_SUCCESS;
33262 }
33263 #endif /* _WIN64 */
33264
33265 static NTSTATUS thunk32_vkCreateFramebuffer(void *args)
33266 {
33267     struct
33268     {
33269         PTR32 device;
33270         PTR32 pCreateInfo;
33271         PTR32 pAllocator;
33272         PTR32 pFramebuffer;
33273         VkResult result;
33274     } *params = args;
33275     VkFramebufferCreateInfo pCreateInfo_host;
33276     struct conversion_context local_ctx;
33277     struct conversion_context *ctx = &local_ctx;
33278
33279     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);
33280
33281     init_conversion_context(ctx);
33282     convert_VkFramebufferCreateInfo_win32_to_host(ctx, (const VkFramebufferCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33283     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));
33284     free_conversion_context(ctx);
33285     return STATUS_SUCCESS;
33286 }
33287
33288 #ifdef _WIN64
33289 static NTSTATUS thunk64_vkCreateGraphicsPipelines(void *args)
33290 {
33291     struct vkCreateGraphicsPipelines_params *params = args;
33292     const VkGraphicsPipelineCreateInfo *pCreateInfos_host;
33293     struct conversion_context local_ctx;
33294     struct conversion_context *ctx = &local_ctx;
33295
33296     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33297
33298     init_conversion_context(ctx);
33299     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(ctx, params->pCreateInfos, params->createInfoCount);
33300     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);
33301     free_conversion_context(ctx);
33302     return STATUS_SUCCESS;
33303 }
33304 #endif /* _WIN64 */
33305
33306 static NTSTATUS thunk32_vkCreateGraphicsPipelines(void *args)
33307 {
33308     struct
33309     {
33310         PTR32 device;
33311         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
33312         uint32_t createInfoCount;
33313         PTR32 pCreateInfos;
33314         PTR32 pAllocator;
33315         PTR32 pPipelines;
33316         VkResult result;
33317     } *params = args;
33318     const VkGraphicsPipelineCreateInfo *pCreateInfos_host;
33319     struct conversion_context local_ctx;
33320     struct conversion_context *ctx = &local_ctx;
33321
33322     TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33323
33324     init_conversion_context(ctx);
33325     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(ctx, (const VkGraphicsPipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33326     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));
33327     convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(pCreateInfos_host, (const VkGraphicsPipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33328     free_conversion_context(ctx);
33329     return STATUS_SUCCESS;
33330 }
33331
33332 #ifdef _WIN64
33333 static NTSTATUS thunk64_vkCreateImage(void *args)
33334 {
33335     struct vkCreateImage_params *params = args;
33336
33337     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);
33338
33339     params->result = wine_vkCreateImage(params->device, params->pCreateInfo, params->pAllocator, params->pImage);
33340     return STATUS_SUCCESS;
33341 }
33342 #endif /* _WIN64 */
33343
33344 static NTSTATUS thunk32_vkCreateImage(void *args)
33345 {
33346     struct
33347     {
33348         PTR32 device;
33349         PTR32 pCreateInfo;
33350         PTR32 pAllocator;
33351         PTR32 pImage;
33352         VkResult result;
33353     } *params = args;
33354     VkImageCreateInfo pCreateInfo_host;
33355     struct conversion_context local_ctx;
33356     struct conversion_context *ctx = &local_ctx;
33357
33358     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);
33359
33360     init_conversion_context(ctx);
33361     convert_VkImageCreateInfo_win32_to_host(ctx, (const VkImageCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33362     params->result = wine_vkCreateImage((VkDevice)UlongToPtr(params->device), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkImage *)UlongToPtr(params->pImage));
33363     free_conversion_context(ctx);
33364     return STATUS_SUCCESS;
33365 }
33366
33367 #ifdef _WIN64
33368 static NTSTATUS thunk64_vkCreateImageView(void *args)
33369 {
33370     struct vkCreateImageView_params *params = args;
33371
33372     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
33373
33374     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImageView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
33375     return STATUS_SUCCESS;
33376 }
33377 #endif /* _WIN64 */
33378
33379 static NTSTATUS thunk32_vkCreateImageView(void *args)
33380 {
33381     struct
33382     {
33383         PTR32 device;
33384         PTR32 pCreateInfo;
33385         PTR32 pAllocator;
33386         PTR32 pView;
33387         VkResult result;
33388     } *params = args;
33389     VkImageViewCreateInfo pCreateInfo_host;
33390     struct conversion_context local_ctx;
33391     struct conversion_context *ctx = &local_ctx;
33392
33393     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
33394
33395     init_conversion_context(ctx);
33396     convert_VkImageViewCreateInfo_win32_to_host(ctx, (const VkImageViewCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33397     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));
33398     free_conversion_context(ctx);
33399     return STATUS_SUCCESS;
33400 }
33401
33402 #ifdef _WIN64
33403 static NTSTATUS thunk64_vkCreateIndirectCommandsLayoutNV(void *args)
33404 {
33405     struct vkCreateIndirectCommandsLayoutNV_params *params = args;
33406
33407     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
33408
33409     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pIndirectCommandsLayout);
33410     return STATUS_SUCCESS;
33411 }
33412 #endif /* _WIN64 */
33413
33414 static NTSTATUS thunk32_vkCreateIndirectCommandsLayoutNV(void *args)
33415 {
33416     struct
33417     {
33418         PTR32 device;
33419         PTR32 pCreateInfo;
33420         PTR32 pAllocator;
33421         PTR32 pIndirectCommandsLayout;
33422         VkResult result;
33423     } *params = args;
33424     VkIndirectCommandsLayoutCreateInfoNV pCreateInfo_host;
33425     struct conversion_context local_ctx;
33426     struct conversion_context *ctx = &local_ctx;
33427
33428     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
33429
33430     init_conversion_context(ctx);
33431     convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(ctx, (const VkIndirectCommandsLayoutCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33432     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));
33433     free_conversion_context(ctx);
33434     return STATUS_SUCCESS;
33435 }
33436
33437 #ifdef _WIN64
33438 static NTSTATUS thunk64_vkCreateInstance(void *args)
33439 {
33440     struct vkCreateInstance_params *params = args;
33441     VkInstanceCreateInfo pCreateInfo_host;
33442     struct conversion_context local_ctx;
33443     struct conversion_context *ctx = &local_ctx;
33444
33445     TRACE("%p, %p, %p\n", params->pCreateInfo, params->pAllocator, params->pInstance);
33446
33447     init_conversion_context(ctx);
33448     convert_VkInstanceCreateInfo_win64_to_host(ctx, params->pCreateInfo, &pCreateInfo_host);
33449     params->result = wine_vkCreateInstance(&pCreateInfo_host, params->pAllocator, params->pInstance, params->client_ptr);
33450     free_conversion_context(ctx);
33451     return STATUS_SUCCESS;
33452 }
33453 #endif /* _WIN64 */
33454
33455 static NTSTATUS thunk32_vkCreateInstance(void *args)
33456 {
33457     struct
33458     {
33459         PTR32 pCreateInfo;
33460         PTR32 pAllocator;
33461         PTR32 pInstance;
33462         PTR32 client_ptr;
33463         VkResult result;
33464     } *params = args;
33465     VkInstanceCreateInfo pCreateInfo_host;
33466     VkInstance pInstance_host;
33467     struct conversion_context local_ctx;
33468     struct conversion_context *ctx = &local_ctx;
33469
33470     TRACE("%#x, %#x, %#x\n", params->pCreateInfo, params->pAllocator, params->pInstance);
33471
33472     init_conversion_context(ctx);
33473     convert_VkInstanceCreateInfo_win32_to_host(ctx, (const VkInstanceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33474     pInstance_host = UlongToPtr(*(PTR32 *)UlongToPtr(params->pInstance));
33475     params->result = wine_vkCreateInstance(&pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), &pInstance_host, UlongToPtr(params->client_ptr));
33476     *(PTR32 *)UlongToPtr(params->pInstance) = PtrToUlong(pInstance_host);
33477     free_conversion_context(ctx);
33478     return STATUS_SUCCESS;
33479 }
33480
33481 #ifdef _WIN64
33482 static NTSTATUS thunk64_vkCreateMicromapEXT(void *args)
33483 {
33484     struct vkCreateMicromapEXT_params *params = args;
33485
33486     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
33487
33488     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateMicromapEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pMicromap);
33489     return STATUS_SUCCESS;
33490 }
33491 #endif /* _WIN64 */
33492
33493 static NTSTATUS thunk32_vkCreateMicromapEXT(void *args)
33494 {
33495     struct
33496     {
33497         PTR32 device;
33498         PTR32 pCreateInfo;
33499         PTR32 pAllocator;
33500         PTR32 pMicromap;
33501         VkResult result;
33502     } *params = args;
33503     VkMicromapCreateInfoEXT pCreateInfo_host;
33504
33505     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
33506
33507     convert_VkMicromapCreateInfoEXT_win32_to_host((const VkMicromapCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33508     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));
33509     return STATUS_SUCCESS;
33510 }
33511
33512 #ifdef _WIN64
33513 static NTSTATUS thunk64_vkCreateOpticalFlowSessionNV(void *args)
33514 {
33515     struct vkCreateOpticalFlowSessionNV_params *params = args;
33516
33517     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
33518
33519     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSession);
33520     return STATUS_SUCCESS;
33521 }
33522 #endif /* _WIN64 */
33523
33524 static NTSTATUS thunk32_vkCreateOpticalFlowSessionNV(void *args)
33525 {
33526     struct
33527     {
33528         PTR32 device;
33529         PTR32 pCreateInfo;
33530         PTR32 pAllocator;
33531         PTR32 pSession;
33532         VkResult result;
33533     } *params = args;
33534     VkOpticalFlowSessionCreateInfoNV pCreateInfo_host;
33535     struct conversion_context local_ctx;
33536     struct conversion_context *ctx = &local_ctx;
33537
33538     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
33539
33540     init_conversion_context(ctx);
33541     convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(ctx, (const VkOpticalFlowSessionCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33542     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));
33543     free_conversion_context(ctx);
33544     return STATUS_SUCCESS;
33545 }
33546
33547 #ifdef _WIN64
33548 static NTSTATUS thunk64_vkCreatePipelineCache(void *args)
33549 {
33550     struct vkCreatePipelineCache_params *params = args;
33551
33552     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);
33553
33554     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineCache(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineCache);
33555     return STATUS_SUCCESS;
33556 }
33557 #endif /* _WIN64 */
33558
33559 static NTSTATUS thunk32_vkCreatePipelineCache(void *args)
33560 {
33561     struct
33562     {
33563         PTR32 device;
33564         PTR32 pCreateInfo;
33565         PTR32 pAllocator;
33566         PTR32 pPipelineCache;
33567         VkResult result;
33568     } *params = args;
33569     VkPipelineCacheCreateInfo pCreateInfo_host;
33570
33571     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);
33572
33573     convert_VkPipelineCacheCreateInfo_win32_to_host((const VkPipelineCacheCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33574     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));
33575     return STATUS_SUCCESS;
33576 }
33577
33578 #ifdef _WIN64
33579 static NTSTATUS thunk64_vkCreatePipelineLayout(void *args)
33580 {
33581     struct vkCreatePipelineLayout_params *params = args;
33582
33583     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);
33584
33585     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineLayout);
33586     return STATUS_SUCCESS;
33587 }
33588 #endif /* _WIN64 */
33589
33590 static NTSTATUS thunk32_vkCreatePipelineLayout(void *args)
33591 {
33592     struct
33593     {
33594         PTR32 device;
33595         PTR32 pCreateInfo;
33596         PTR32 pAllocator;
33597         PTR32 pPipelineLayout;
33598         VkResult result;
33599     } *params = args;
33600     VkPipelineLayoutCreateInfo pCreateInfo_host;
33601
33602     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);
33603
33604     convert_VkPipelineLayoutCreateInfo_win32_to_host((const VkPipelineLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33605     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));
33606     return STATUS_SUCCESS;
33607 }
33608
33609 #ifdef _WIN64
33610 static NTSTATUS thunk64_vkCreatePrivateDataSlot(void *args)
33611 {
33612     struct vkCreatePrivateDataSlot_params *params = args;
33613
33614     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
33615
33616     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
33617     return STATUS_SUCCESS;
33618 }
33619 #endif /* _WIN64 */
33620
33621 static NTSTATUS thunk32_vkCreatePrivateDataSlot(void *args)
33622 {
33623     struct
33624     {
33625         PTR32 device;
33626         PTR32 pCreateInfo;
33627         PTR32 pAllocator;
33628         PTR32 pPrivateDataSlot;
33629         VkResult result;
33630     } *params = args;
33631     VkPrivateDataSlotCreateInfo pCreateInfo_host;
33632
33633     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
33634
33635     convert_VkPrivateDataSlotCreateInfo_win32_to_host((const VkPrivateDataSlotCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33636     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));
33637     return STATUS_SUCCESS;
33638 }
33639
33640 #ifdef _WIN64
33641 static NTSTATUS thunk64_vkCreatePrivateDataSlotEXT(void *args)
33642 {
33643     struct vkCreatePrivateDataSlotEXT_params *params = args;
33644
33645     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
33646
33647     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
33648     return STATUS_SUCCESS;
33649 }
33650 #endif /* _WIN64 */
33651
33652 static NTSTATUS thunk32_vkCreatePrivateDataSlotEXT(void *args)
33653 {
33654     struct
33655     {
33656         PTR32 device;
33657         PTR32 pCreateInfo;
33658         PTR32 pAllocator;
33659         PTR32 pPrivateDataSlot;
33660         VkResult result;
33661     } *params = args;
33662     VkPrivateDataSlotCreateInfo pCreateInfo_host;
33663
33664     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
33665
33666     convert_VkPrivateDataSlotCreateInfo_win32_to_host((const VkPrivateDataSlotCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33667     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));
33668     return STATUS_SUCCESS;
33669 }
33670
33671 #ifdef _WIN64
33672 static NTSTATUS thunk64_vkCreateQueryPool(void *args)
33673 {
33674     struct vkCreateQueryPool_params *params = args;
33675
33676     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);
33677
33678     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateQueryPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pQueryPool);
33679     return STATUS_SUCCESS;
33680 }
33681 #endif /* _WIN64 */
33682
33683 static NTSTATUS thunk32_vkCreateQueryPool(void *args)
33684 {
33685     struct
33686     {
33687         PTR32 device;
33688         PTR32 pCreateInfo;
33689         PTR32 pAllocator;
33690         PTR32 pQueryPool;
33691         VkResult result;
33692     } *params = args;
33693     VkQueryPoolCreateInfo pCreateInfo_host;
33694     struct conversion_context local_ctx;
33695     struct conversion_context *ctx = &local_ctx;
33696
33697     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);
33698
33699     init_conversion_context(ctx);
33700     convert_VkQueryPoolCreateInfo_win32_to_host(ctx, (const VkQueryPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33701     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));
33702     free_conversion_context(ctx);
33703     return STATUS_SUCCESS;
33704 }
33705
33706 #ifdef _WIN64
33707 static NTSTATUS thunk64_vkCreateRayTracingPipelinesKHR(void *args)
33708 {
33709     struct vkCreateRayTracingPipelinesKHR_params *params = args;
33710     const VkRayTracingPipelineCreateInfoKHR *pCreateInfos_host;
33711     struct conversion_context local_ctx;
33712     struct conversion_context *ctx = &local_ctx;
33713
33714     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);
33715
33716     if (params->deferredOperation == VK_NULL_HANDLE)
33717         init_conversion_context(ctx);
33718     else
33719         ctx = &wine_deferred_operation_from_handle(params->deferredOperation)->ctx;
33720     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(ctx, params->pCreateInfos, params->createInfoCount);
33721     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);
33722     if (params->deferredOperation == VK_NULL_HANDLE)
33723         free_conversion_context(ctx);
33724     return STATUS_SUCCESS;
33725 }
33726 #endif /* _WIN64 */
33727
33728 static NTSTATUS thunk32_vkCreateRayTracingPipelinesKHR(void *args)
33729 {
33730     struct
33731     {
33732         PTR32 device;
33733         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
33734         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
33735         uint32_t createInfoCount;
33736         PTR32 pCreateInfos;
33737         PTR32 pAllocator;
33738         PTR32 pPipelines;
33739         VkResult result;
33740     } *params = args;
33741     const VkRayTracingPipelineCreateInfoKHR *pCreateInfos_host;
33742     struct conversion_context local_ctx;
33743     struct conversion_context *ctx = &local_ctx;
33744
33745     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);
33746
33747     if (params->deferredOperation == VK_NULL_HANDLE)
33748         init_conversion_context(ctx);
33749     else
33750         ctx = &wine_deferred_operation_from_handle(params->deferredOperation)->ctx;
33751     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(ctx, (const VkRayTracingPipelineCreateInfoKHR32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33752     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));
33753     convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(pCreateInfos_host, (const VkRayTracingPipelineCreateInfoKHR32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33754     if (params->deferredOperation == VK_NULL_HANDLE)
33755         free_conversion_context(ctx);
33756     return STATUS_SUCCESS;
33757 }
33758
33759 #ifdef _WIN64
33760 static NTSTATUS thunk64_vkCreateRayTracingPipelinesNV(void *args)
33761 {
33762     struct vkCreateRayTracingPipelinesNV_params *params = args;
33763     const VkRayTracingPipelineCreateInfoNV *pCreateInfos_host;
33764     struct conversion_context local_ctx;
33765     struct conversion_context *ctx = &local_ctx;
33766
33767     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33768
33769     init_conversion_context(ctx);
33770     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(ctx, params->pCreateInfos, params->createInfoCount);
33771     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);
33772     free_conversion_context(ctx);
33773     return STATUS_SUCCESS;
33774 }
33775 #endif /* _WIN64 */
33776
33777 static NTSTATUS thunk32_vkCreateRayTracingPipelinesNV(void *args)
33778 {
33779     struct
33780     {
33781         PTR32 device;
33782         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
33783         uint32_t createInfoCount;
33784         PTR32 pCreateInfos;
33785         PTR32 pAllocator;
33786         PTR32 pPipelines;
33787         VkResult result;
33788     } *params = args;
33789     const VkRayTracingPipelineCreateInfoNV *pCreateInfos_host;
33790     struct conversion_context local_ctx;
33791     struct conversion_context *ctx = &local_ctx;
33792
33793     TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33794
33795     init_conversion_context(ctx);
33796     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(ctx, (const VkRayTracingPipelineCreateInfoNV32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33797     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));
33798     convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(pCreateInfos_host, (const VkRayTracingPipelineCreateInfoNV32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33799     free_conversion_context(ctx);
33800     return STATUS_SUCCESS;
33801 }
33802
33803 #ifdef _WIN64
33804 static NTSTATUS thunk64_vkCreateRenderPass(void *args)
33805 {
33806     struct vkCreateRenderPass_params *params = args;
33807
33808     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33809
33810     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
33811     return STATUS_SUCCESS;
33812 }
33813 #endif /* _WIN64 */
33814
33815 static NTSTATUS thunk32_vkCreateRenderPass(void *args)
33816 {
33817     struct
33818     {
33819         PTR32 device;
33820         PTR32 pCreateInfo;
33821         PTR32 pAllocator;
33822         PTR32 pRenderPass;
33823         VkResult result;
33824     } *params = args;
33825     VkRenderPassCreateInfo pCreateInfo_host;
33826     struct conversion_context local_ctx;
33827     struct conversion_context *ctx = &local_ctx;
33828
33829     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33830
33831     init_conversion_context(ctx);
33832     convert_VkRenderPassCreateInfo_win32_to_host(ctx, (const VkRenderPassCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33833     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));
33834     free_conversion_context(ctx);
33835     return STATUS_SUCCESS;
33836 }
33837
33838 #ifdef _WIN64
33839 static NTSTATUS thunk64_vkCreateRenderPass2(void *args)
33840 {
33841     struct vkCreateRenderPass2_params *params = args;
33842
33843     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33844
33845     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
33846     return STATUS_SUCCESS;
33847 }
33848 #endif /* _WIN64 */
33849
33850 static NTSTATUS thunk32_vkCreateRenderPass2(void *args)
33851 {
33852     struct
33853     {
33854         PTR32 device;
33855         PTR32 pCreateInfo;
33856         PTR32 pAllocator;
33857         PTR32 pRenderPass;
33858         VkResult result;
33859     } *params = args;
33860     VkRenderPassCreateInfo2 pCreateInfo_host;
33861     struct conversion_context local_ctx;
33862     struct conversion_context *ctx = &local_ctx;
33863
33864     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33865
33866     init_conversion_context(ctx);
33867     convert_VkRenderPassCreateInfo2_win32_to_host(ctx, (const VkRenderPassCreateInfo232 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33868     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));
33869     free_conversion_context(ctx);
33870     return STATUS_SUCCESS;
33871 }
33872
33873 #ifdef _WIN64
33874 static NTSTATUS thunk64_vkCreateRenderPass2KHR(void *args)
33875 {
33876     struct vkCreateRenderPass2KHR_params *params = args;
33877
33878     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33879
33880     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
33881     return STATUS_SUCCESS;
33882 }
33883 #endif /* _WIN64 */
33884
33885 static NTSTATUS thunk32_vkCreateRenderPass2KHR(void *args)
33886 {
33887     struct
33888     {
33889         PTR32 device;
33890         PTR32 pCreateInfo;
33891         PTR32 pAllocator;
33892         PTR32 pRenderPass;
33893         VkResult result;
33894     } *params = args;
33895     VkRenderPassCreateInfo2 pCreateInfo_host;
33896     struct conversion_context local_ctx;
33897     struct conversion_context *ctx = &local_ctx;
33898
33899     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33900
33901     init_conversion_context(ctx);
33902     convert_VkRenderPassCreateInfo2_win32_to_host(ctx, (const VkRenderPassCreateInfo232 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33903     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));
33904     free_conversion_context(ctx);
33905     return STATUS_SUCCESS;
33906 }
33907
33908 #ifdef _WIN64
33909 static NTSTATUS thunk64_vkCreateSampler(void *args)
33910 {
33911     struct vkCreateSampler_params *params = args;
33912
33913     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);
33914
33915     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSampler(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSampler);
33916     return STATUS_SUCCESS;
33917 }
33918 #endif /* _WIN64 */
33919
33920 static NTSTATUS thunk32_vkCreateSampler(void *args)
33921 {
33922     struct
33923     {
33924         PTR32 device;
33925         PTR32 pCreateInfo;
33926         PTR32 pAllocator;
33927         PTR32 pSampler;
33928         VkResult result;
33929     } *params = args;
33930     VkSamplerCreateInfo pCreateInfo_host;
33931     struct conversion_context local_ctx;
33932     struct conversion_context *ctx = &local_ctx;
33933
33934     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);
33935
33936     init_conversion_context(ctx);
33937     convert_VkSamplerCreateInfo_win32_to_host(ctx, (const VkSamplerCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33938     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));
33939     free_conversion_context(ctx);
33940     return STATUS_SUCCESS;
33941 }
33942
33943 #ifdef _WIN64
33944 static NTSTATUS thunk64_vkCreateSamplerYcbcrConversion(void *args)
33945 {
33946     struct vkCreateSamplerYcbcrConversion_params *params = args;
33947
33948     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33949
33950     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
33951     return STATUS_SUCCESS;
33952 }
33953 #endif /* _WIN64 */
33954
33955 static NTSTATUS thunk32_vkCreateSamplerYcbcrConversion(void *args)
33956 {
33957     struct
33958     {
33959         PTR32 device;
33960         PTR32 pCreateInfo;
33961         PTR32 pAllocator;
33962         PTR32 pYcbcrConversion;
33963         VkResult result;
33964     } *params = args;
33965     VkSamplerYcbcrConversionCreateInfo pCreateInfo_host;
33966
33967     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33968
33969     convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host((const VkSamplerYcbcrConversionCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33970     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));
33971     return STATUS_SUCCESS;
33972 }
33973
33974 #ifdef _WIN64
33975 static NTSTATUS thunk64_vkCreateSamplerYcbcrConversionKHR(void *args)
33976 {
33977     struct vkCreateSamplerYcbcrConversionKHR_params *params = args;
33978
33979     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33980
33981     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
33982     return STATUS_SUCCESS;
33983 }
33984 #endif /* _WIN64 */
33985
33986 static NTSTATUS thunk32_vkCreateSamplerYcbcrConversionKHR(void *args)
33987 {
33988     struct
33989     {
33990         PTR32 device;
33991         PTR32 pCreateInfo;
33992         PTR32 pAllocator;
33993         PTR32 pYcbcrConversion;
33994         VkResult result;
33995     } *params = args;
33996     VkSamplerYcbcrConversionCreateInfo pCreateInfo_host;
33997
33998     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33999
34000     convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host((const VkSamplerYcbcrConversionCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34001     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));
34002     return STATUS_SUCCESS;
34003 }
34004
34005 #ifdef _WIN64
34006 static NTSTATUS thunk64_vkCreateSemaphore(void *args)
34007 {
34008     struct vkCreateSemaphore_params *params = args;
34009
34010     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);
34011
34012     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSemaphore(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSemaphore);
34013     return STATUS_SUCCESS;
34014 }
34015 #endif /* _WIN64 */
34016
34017 static NTSTATUS thunk32_vkCreateSemaphore(void *args)
34018 {
34019     struct
34020     {
34021         PTR32 device;
34022         PTR32 pCreateInfo;
34023         PTR32 pAllocator;
34024         PTR32 pSemaphore;
34025         VkResult result;
34026     } *params = args;
34027     VkSemaphoreCreateInfo pCreateInfo_host;
34028     struct conversion_context local_ctx;
34029     struct conversion_context *ctx = &local_ctx;
34030
34031     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);
34032
34033     init_conversion_context(ctx);
34034     convert_VkSemaphoreCreateInfo_win32_to_host(ctx, (const VkSemaphoreCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34035     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));
34036     free_conversion_context(ctx);
34037     return STATUS_SUCCESS;
34038 }
34039
34040 #ifdef _WIN64
34041 static NTSTATUS thunk64_vkCreateShaderModule(void *args)
34042 {
34043     struct vkCreateShaderModule_params *params = args;
34044
34045     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);
34046
34047     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateShaderModule(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pShaderModule);
34048     return STATUS_SUCCESS;
34049 }
34050 #endif /* _WIN64 */
34051
34052 static NTSTATUS thunk32_vkCreateShaderModule(void *args)
34053 {
34054     struct
34055     {
34056         PTR32 device;
34057         PTR32 pCreateInfo;
34058         PTR32 pAllocator;
34059         PTR32 pShaderModule;
34060         VkResult result;
34061     } *params = args;
34062     VkShaderModuleCreateInfo pCreateInfo_host;
34063     struct conversion_context local_ctx;
34064     struct conversion_context *ctx = &local_ctx;
34065
34066     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);
34067
34068     init_conversion_context(ctx);
34069     convert_VkShaderModuleCreateInfo_win32_to_host(ctx, (const VkShaderModuleCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34070     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));
34071     free_conversion_context(ctx);
34072     return STATUS_SUCCESS;
34073 }
34074
34075 #ifdef _WIN64
34076 static NTSTATUS thunk64_vkCreateShadersEXT(void *args)
34077 {
34078     struct vkCreateShadersEXT_params *params = args;
34079
34080     TRACE("%p, %u, %p, %p, %p\n", params->device, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pShaders);
34081
34082     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);
34083     return STATUS_SUCCESS;
34084 }
34085 #endif /* _WIN64 */
34086
34087 static NTSTATUS thunk32_vkCreateShadersEXT(void *args)
34088 {
34089     struct
34090     {
34091         PTR32 device;
34092         uint32_t createInfoCount;
34093         PTR32 pCreateInfos;
34094         PTR32 pAllocator;
34095         PTR32 pShaders;
34096         VkResult result;
34097     } *params = args;
34098     const VkShaderCreateInfoEXT *pCreateInfos_host;
34099     struct conversion_context local_ctx;
34100     struct conversion_context *ctx = &local_ctx;
34101
34102     TRACE("%#x, %u, %#x, %#x, %#x\n", params->device, params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pShaders);
34103
34104     init_conversion_context(ctx);
34105     pCreateInfos_host = convert_VkShaderCreateInfoEXT_array_win32_to_host(ctx, (const VkShaderCreateInfoEXT32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
34106     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));
34107     free_conversion_context(ctx);
34108     return STATUS_SUCCESS;
34109 }
34110
34111 #ifdef _WIN64
34112 static NTSTATUS thunk64_vkCreateSwapchainKHR(void *args)
34113 {
34114     struct vkCreateSwapchainKHR_params *params = args;
34115     VkSwapchainCreateInfoKHR pCreateInfo_host;
34116
34117     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);
34118
34119     convert_VkSwapchainCreateInfoKHR_win64_to_host(params->pCreateInfo, &pCreateInfo_host);
34120     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSwapchain);
34121     return STATUS_SUCCESS;
34122 }
34123 #endif /* _WIN64 */
34124
34125 static NTSTATUS thunk32_vkCreateSwapchainKHR(void *args)
34126 {
34127     struct
34128     {
34129         PTR32 device;
34130         PTR32 pCreateInfo;
34131         PTR32 pAllocator;
34132         PTR32 pSwapchain;
34133         VkResult result;
34134     } *params = args;
34135     VkSwapchainCreateInfoKHR pCreateInfo_host;
34136     struct conversion_context local_ctx;
34137     struct conversion_context *ctx = &local_ctx;
34138
34139     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);
34140
34141     init_conversion_context(ctx);
34142     convert_VkSwapchainCreateInfoKHR_win32_to_host(ctx, (const VkSwapchainCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34143     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));
34144     free_conversion_context(ctx);
34145     return STATUS_SUCCESS;
34146 }
34147
34148 #ifdef _WIN64
34149 static NTSTATUS thunk64_vkCreateValidationCacheEXT(void *args)
34150 {
34151     struct vkCreateValidationCacheEXT_params *params = args;
34152
34153     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);
34154
34155     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pValidationCache);
34156     return STATUS_SUCCESS;
34157 }
34158 #endif /* _WIN64 */
34159
34160 static NTSTATUS thunk32_vkCreateValidationCacheEXT(void *args)
34161 {
34162     struct
34163     {
34164         PTR32 device;
34165         PTR32 pCreateInfo;
34166         PTR32 pAllocator;
34167         PTR32 pValidationCache;
34168         VkResult result;
34169     } *params = args;
34170     VkValidationCacheCreateInfoEXT pCreateInfo_host;
34171
34172     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);
34173
34174     convert_VkValidationCacheCreateInfoEXT_win32_to_host((const VkValidationCacheCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34175     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));
34176     return STATUS_SUCCESS;
34177 }
34178
34179 #ifdef _WIN64
34180 static NTSTATUS thunk64_vkCreateWin32SurfaceKHR(void *args)
34181 {
34182     struct vkCreateWin32SurfaceKHR_params *params = args;
34183
34184     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
34185
34186     params->result = wine_vkCreateWin32SurfaceKHR(params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
34187     return STATUS_SUCCESS;
34188 }
34189 #endif /* _WIN64 */
34190
34191 static NTSTATUS thunk32_vkCreateWin32SurfaceKHR(void *args)
34192 {
34193     struct
34194     {
34195         PTR32 instance;
34196         PTR32 pCreateInfo;
34197         PTR32 pAllocator;
34198         PTR32 pSurface;
34199         VkResult result;
34200     } *params = args;
34201     VkWin32SurfaceCreateInfoKHR pCreateInfo_host;
34202
34203     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
34204
34205     convert_VkWin32SurfaceCreateInfoKHR_win32_to_host((const VkWin32SurfaceCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
34206     params->result = wine_vkCreateWin32SurfaceKHR((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkSurfaceKHR *)UlongToPtr(params->pSurface));
34207     return STATUS_SUCCESS;
34208 }
34209
34210 #ifdef _WIN64
34211 static NTSTATUS thunk64_vkDebugMarkerSetObjectNameEXT(void *args)
34212 {
34213     struct vkDebugMarkerSetObjectNameEXT_params *params = args;
34214     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;
34215
34216     TRACE("%p, %p\n", params->device, params->pNameInfo);
34217
34218     convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(params->pNameInfo, &pNameInfo_host);
34219     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
34220     return STATUS_SUCCESS;
34221 }
34222 #endif /* _WIN64 */
34223
34224 static NTSTATUS thunk32_vkDebugMarkerSetObjectNameEXT(void *args)
34225 {
34226     struct
34227     {
34228         PTR32 device;
34229         PTR32 pNameInfo;
34230         VkResult result;
34231     } *params = args;
34232     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;
34233
34234     TRACE("%#x, %#x\n", params->device, params->pNameInfo);
34235
34236     convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host((const VkDebugMarkerObjectNameInfoEXT32 *)UlongToPtr(params->pNameInfo), &pNameInfo_host);
34237     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pNameInfo_host);
34238     return STATUS_SUCCESS;
34239 }
34240
34241 #ifdef _WIN64
34242 static NTSTATUS thunk64_vkDebugMarkerSetObjectTagEXT(void *args)
34243 {
34244     struct vkDebugMarkerSetObjectTagEXT_params *params = args;
34245     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;
34246
34247     TRACE("%p, %p\n", params->device, params->pTagInfo);
34248
34249     convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(params->pTagInfo, &pTagInfo_host);
34250     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
34251     return STATUS_SUCCESS;
34252 }
34253 #endif /* _WIN64 */
34254
34255 static NTSTATUS thunk32_vkDebugMarkerSetObjectTagEXT(void *args)
34256 {
34257     struct
34258     {
34259         PTR32 device;
34260         PTR32 pTagInfo;
34261         VkResult result;
34262     } *params = args;
34263     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;
34264
34265     TRACE("%#x, %#x\n", params->device, params->pTagInfo);
34266
34267     convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host((const VkDebugMarkerObjectTagInfoEXT32 *)UlongToPtr(params->pTagInfo), &pTagInfo_host);
34268     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pTagInfo_host);
34269     return STATUS_SUCCESS;
34270 }
34271
34272 #ifdef _WIN64
34273 static NTSTATUS thunk64_vkDebugReportMessageEXT(void *args)
34274 {
34275     struct vkDebugReportMessageEXT_params *params = args;
34276
34277     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);
34278
34279     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);
34280     return STATUS_SUCCESS;
34281 }
34282 #endif /* _WIN64 */
34283
34284 static NTSTATUS thunk32_vkDebugReportMessageEXT(void *args)
34285 {
34286     struct
34287     {
34288         PTR32 instance;
34289         VkDebugReportFlagsEXT flags;
34290         VkDebugReportObjectTypeEXT objectType;
34291         uint64_t DECLSPEC_ALIGN(8) object;
34292         PTR32 location;
34293         int32_t messageCode;
34294         PTR32 pLayerPrefix;
34295         PTR32 pMessage;
34296     } *params = args;
34297
34298     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);
34299
34300     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));
34301     return STATUS_SUCCESS;
34302 }
34303
34304 #ifdef _WIN64
34305 static NTSTATUS thunk64_vkDeferredOperationJoinKHR(void *args)
34306 {
34307     struct vkDeferredOperationJoinKHR_params *params = args;
34308
34309     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
34310
34311     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);
34312     return STATUS_SUCCESS;
34313 }
34314 #endif /* _WIN64 */
34315
34316 static NTSTATUS thunk32_vkDeferredOperationJoinKHR(void *args)
34317 {
34318     struct
34319     {
34320         PTR32 device;
34321         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
34322         VkResult result;
34323     } *params = args;
34324
34325     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
34326
34327     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);
34328     return STATUS_SUCCESS;
34329 }
34330
34331 #ifdef _WIN64
34332 static NTSTATUS thunk64_vkDestroyAccelerationStructureKHR(void *args)
34333 {
34334     struct vkDestroyAccelerationStructureKHR_params *params = args;
34335
34336     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
34337
34338     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
34339     return STATUS_SUCCESS;
34340 }
34341 #endif /* _WIN64 */
34342
34343 static NTSTATUS thunk32_vkDestroyAccelerationStructureKHR(void *args)
34344 {
34345     struct
34346     {
34347         PTR32 device;
34348         VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
34349         PTR32 pAllocator;
34350     } *params = args;
34351
34352     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
34353
34354     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->accelerationStructure, NULL);
34355     return STATUS_SUCCESS;
34356 }
34357
34358 #ifdef _WIN64
34359 static NTSTATUS thunk64_vkDestroyAccelerationStructureNV(void *args)
34360 {
34361     struct vkDestroyAccelerationStructureNV_params *params = args;
34362
34363     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
34364
34365     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
34366     return STATUS_SUCCESS;
34367 }
34368 #endif /* _WIN64 */
34369
34370 static NTSTATUS thunk32_vkDestroyAccelerationStructureNV(void *args)
34371 {
34372     struct
34373     {
34374         PTR32 device;
34375         VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
34376         PTR32 pAllocator;
34377     } *params = args;
34378
34379     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
34380
34381     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyAccelerationStructureNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->accelerationStructure, NULL);
34382     return STATUS_SUCCESS;
34383 }
34384
34385 #ifdef _WIN64
34386 static NTSTATUS thunk64_vkDestroyBuffer(void *args)
34387 {
34388     struct vkDestroyBuffer_params *params = args;
34389
34390     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pAllocator);
34391
34392     wine_device_from_handle(params->device)->funcs.p_vkDestroyBuffer(wine_device_from_handle(params->device)->device, params->buffer, NULL);
34393     return STATUS_SUCCESS;
34394 }
34395 #endif /* _WIN64 */
34396
34397 static NTSTATUS thunk32_vkDestroyBuffer(void *args)
34398 {
34399     struct
34400     {
34401         PTR32 device;
34402         VkBuffer DECLSPEC_ALIGN(8) buffer;
34403         PTR32 pAllocator;
34404     } *params = args;
34405
34406     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->buffer), params->pAllocator);
34407
34408     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyBuffer(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buffer, NULL);
34409     return STATUS_SUCCESS;
34410 }
34411
34412 #ifdef _WIN64
34413 static NTSTATUS thunk64_vkDestroyBufferView(void *args)
34414 {
34415     struct vkDestroyBufferView_params *params = args;
34416
34417     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->bufferView), params->pAllocator);
34418
34419     wine_device_from_handle(params->device)->funcs.p_vkDestroyBufferView(wine_device_from_handle(params->device)->device, params->bufferView, NULL);
34420     return STATUS_SUCCESS;
34421 }
34422 #endif /* _WIN64 */
34423
34424 static NTSTATUS thunk32_vkDestroyBufferView(void *args)
34425 {
34426     struct
34427     {
34428         PTR32 device;
34429         VkBufferView DECLSPEC_ALIGN(8) bufferView;
34430         PTR32 pAllocator;
34431     } *params = args;
34432
34433     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->bufferView), params->pAllocator);
34434
34435     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyBufferView(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bufferView, NULL);
34436     return STATUS_SUCCESS;
34437 }
34438
34439 #ifdef _WIN64
34440 static NTSTATUS thunk64_vkDestroyCommandPool(void *args)
34441 {
34442     struct vkDestroyCommandPool_params *params = args;
34443
34444     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->pAllocator);
34445
34446     wine_vkDestroyCommandPool(params->device, params->commandPool, params->pAllocator);
34447     return STATUS_SUCCESS;
34448 }
34449 #endif /* _WIN64 */
34450
34451 static NTSTATUS thunk32_vkDestroyCommandPool(void *args)
34452 {
34453     struct
34454     {
34455         PTR32 device;
34456         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
34457         PTR32 pAllocator;
34458     } *params = args;
34459
34460     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->pAllocator);
34461
34462     wine_vkDestroyCommandPool((VkDevice)UlongToPtr(params->device), params->commandPool, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34463     return STATUS_SUCCESS;
34464 }
34465
34466 #ifdef _WIN64
34467 static NTSTATUS thunk64_vkDestroyCuFunctionNVX(void *args)
34468 {
34469     struct vkDestroyCuFunctionNVX_params *params = args;
34470
34471     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator);
34472
34473     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuFunctionNVX(wine_device_from_handle(params->device)->device, params->function, NULL);
34474     return STATUS_SUCCESS;
34475 }
34476 #endif /* _WIN64 */
34477
34478 static NTSTATUS thunk32_vkDestroyCuFunctionNVX(void *args)
34479 {
34480     struct
34481     {
34482         PTR32 device;
34483         VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
34484         PTR32 pAllocator;
34485     } *params = args;
34486
34487     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator);
34488
34489     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyCuFunctionNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->function, NULL);
34490     return STATUS_SUCCESS;
34491 }
34492
34493 #ifdef _WIN64
34494 static NTSTATUS thunk64_vkDestroyCuModuleNVX(void *args)
34495 {
34496     struct vkDestroyCuModuleNVX_params *params = args;
34497
34498     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator);
34499
34500     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuModuleNVX(wine_device_from_handle(params->device)->device, params->module, NULL);
34501     return STATUS_SUCCESS;
34502 }
34503 #endif /* _WIN64 */
34504
34505 static NTSTATUS thunk32_vkDestroyCuModuleNVX(void *args)
34506 {
34507     struct
34508     {
34509         PTR32 device;
34510         VkCuModuleNVX DECLSPEC_ALIGN(8) module;
34511         PTR32 pAllocator;
34512     } *params = args;
34513
34514     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator);
34515
34516     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyCuModuleNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->module, NULL);
34517     return STATUS_SUCCESS;
34518 }
34519
34520 #ifdef _WIN64
34521 static NTSTATUS thunk64_vkDestroyDebugReportCallbackEXT(void *args)
34522 {
34523     struct vkDestroyDebugReportCallbackEXT_params *params = args;
34524
34525     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->callback), params->pAllocator);
34526
34527     wine_vkDestroyDebugReportCallbackEXT(params->instance, params->callback, params->pAllocator);
34528     return STATUS_SUCCESS;
34529 }
34530 #endif /* _WIN64 */
34531
34532 static NTSTATUS thunk32_vkDestroyDebugReportCallbackEXT(void *args)
34533 {
34534     struct
34535     {
34536         PTR32 instance;
34537         VkDebugReportCallbackEXT DECLSPEC_ALIGN(8) callback;
34538         PTR32 pAllocator;
34539     } *params = args;
34540
34541     TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->callback), params->pAllocator);
34542
34543     wine_vkDestroyDebugReportCallbackEXT((VkInstance)UlongToPtr(params->instance), params->callback, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34544     return STATUS_SUCCESS;
34545 }
34546
34547 #ifdef _WIN64
34548 static NTSTATUS thunk64_vkDestroyDebugUtilsMessengerEXT(void *args)
34549 {
34550     struct vkDestroyDebugUtilsMessengerEXT_params *params = args;
34551
34552     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->messenger), params->pAllocator);
34553
34554     wine_vkDestroyDebugUtilsMessengerEXT(params->instance, params->messenger, params->pAllocator);
34555     return STATUS_SUCCESS;
34556 }
34557 #endif /* _WIN64 */
34558
34559 static NTSTATUS thunk32_vkDestroyDebugUtilsMessengerEXT(void *args)
34560 {
34561     struct
34562     {
34563         PTR32 instance;
34564         VkDebugUtilsMessengerEXT DECLSPEC_ALIGN(8) messenger;
34565         PTR32 pAllocator;
34566     } *params = args;
34567
34568     TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->messenger), params->pAllocator);
34569
34570     wine_vkDestroyDebugUtilsMessengerEXT((VkInstance)UlongToPtr(params->instance), params->messenger, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34571     return STATUS_SUCCESS;
34572 }
34573
34574 #ifdef _WIN64
34575 static NTSTATUS thunk64_vkDestroyDeferredOperationKHR(void *args)
34576 {
34577     struct vkDestroyDeferredOperationKHR_params *params = args;
34578
34579     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->operation), params->pAllocator);
34580
34581     wine_vkDestroyDeferredOperationKHR(params->device, params->operation, params->pAllocator);
34582     return STATUS_SUCCESS;
34583 }
34584 #endif /* _WIN64 */
34585
34586 static NTSTATUS thunk32_vkDestroyDeferredOperationKHR(void *args)
34587 {
34588     struct
34589     {
34590         PTR32 device;
34591         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
34592         PTR32 pAllocator;
34593     } *params = args;
34594
34595     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->operation), params->pAllocator);
34596
34597     wine_vkDestroyDeferredOperationKHR((VkDevice)UlongToPtr(params->device), params->operation, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34598     return STATUS_SUCCESS;
34599 }
34600
34601 #ifdef _WIN64
34602 static NTSTATUS thunk64_vkDestroyDescriptorPool(void *args)
34603 {
34604     struct vkDestroyDescriptorPool_params *params = args;
34605
34606     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->pAllocator);
34607
34608     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, NULL);
34609     return STATUS_SUCCESS;
34610 }
34611 #endif /* _WIN64 */
34612
34613 static NTSTATUS thunk32_vkDestroyDescriptorPool(void *args)
34614 {
34615     struct
34616     {
34617         PTR32 device;
34618         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
34619         PTR32 pAllocator;
34620     } *params = args;
34621
34622     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->pAllocator);
34623
34624     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorPool, NULL);
34625     return STATUS_SUCCESS;
34626 }
34627
34628 #ifdef _WIN64
34629 static NTSTATUS thunk64_vkDestroyDescriptorSetLayout(void *args)
34630 {
34631     struct vkDestroyDescriptorSetLayout_params *params = args;
34632
34633     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSetLayout), params->pAllocator);
34634
34635     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->descriptorSetLayout, NULL);
34636     return STATUS_SUCCESS;
34637 }
34638 #endif /* _WIN64 */
34639
34640 static NTSTATUS thunk32_vkDestroyDescriptorSetLayout(void *args)
34641 {
34642     struct
34643     {
34644         PTR32 device;
34645         VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
34646         PTR32 pAllocator;
34647     } *params = args;
34648
34649     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSetLayout), params->pAllocator);
34650
34651     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorSetLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorSetLayout, NULL);
34652     return STATUS_SUCCESS;
34653 }
34654
34655 #ifdef _WIN64
34656 static NTSTATUS thunk64_vkDestroyDescriptorUpdateTemplate(void *args)
34657 {
34658     struct vkDestroyDescriptorUpdateTemplate_params *params = args;
34659
34660     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
34661
34662     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
34663     return STATUS_SUCCESS;
34664 }
34665 #endif /* _WIN64 */
34666
34667 static NTSTATUS thunk32_vkDestroyDescriptorUpdateTemplate(void *args)
34668 {
34669     struct
34670     {
34671         PTR32 device;
34672         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
34673         PTR32 pAllocator;
34674     } *params = args;
34675
34676     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
34677
34678     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorUpdateTemplate(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorUpdateTemplate, NULL);
34679     return STATUS_SUCCESS;
34680 }
34681
34682 #ifdef _WIN64
34683 static NTSTATUS thunk64_vkDestroyDescriptorUpdateTemplateKHR(void *args)
34684 {
34685     struct vkDestroyDescriptorUpdateTemplateKHR_params *params = args;
34686
34687     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
34688
34689     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
34690     return STATUS_SUCCESS;
34691 }
34692 #endif /* _WIN64 */
34693
34694 static NTSTATUS thunk32_vkDestroyDescriptorUpdateTemplateKHR(void *args)
34695 {
34696     struct
34697     {
34698         PTR32 device;
34699         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
34700         PTR32 pAllocator;
34701     } *params = args;
34702
34703     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
34704
34705     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorUpdateTemplate, NULL);
34706     return STATUS_SUCCESS;
34707 }
34708
34709 #ifdef _WIN64
34710 static NTSTATUS thunk64_vkDestroyDevice(void *args)
34711 {
34712     struct vkDestroyDevice_params *params = args;
34713
34714     TRACE("%p, %p\n", params->device, params->pAllocator);
34715
34716     if (!params->device)
34717         return STATUS_SUCCESS;
34718
34719     wine_vkDestroyDevice(params->device, params->pAllocator);
34720     return STATUS_SUCCESS;
34721 }
34722 #endif /* _WIN64 */
34723
34724 static NTSTATUS thunk32_vkDestroyDevice(void *args)
34725 {
34726     struct
34727     {
34728         PTR32 device;
34729         PTR32 pAllocator;
34730     } *params = args;
34731
34732     TRACE("%#x, %#x\n", params->device, params->pAllocator);
34733
34734     if (!params->device)
34735         return STATUS_SUCCESS;
34736
34737     wine_vkDestroyDevice((VkDevice)UlongToPtr(params->device), (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34738     return STATUS_SUCCESS;
34739 }
34740
34741 #ifdef _WIN64
34742 static NTSTATUS thunk64_vkDestroyEvent(void *args)
34743 {
34744     struct vkDestroyEvent_params *params = args;
34745
34746     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->event), params->pAllocator);
34747
34748     wine_device_from_handle(params->device)->funcs.p_vkDestroyEvent(wine_device_from_handle(params->device)->device, params->event, NULL);
34749     return STATUS_SUCCESS;
34750 }
34751 #endif /* _WIN64 */
34752
34753 static NTSTATUS thunk32_vkDestroyEvent(void *args)
34754 {
34755     struct
34756     {
34757         PTR32 device;
34758         VkEvent DECLSPEC_ALIGN(8) event;
34759         PTR32 pAllocator;
34760     } *params = args;
34761
34762     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->event), params->pAllocator);
34763
34764     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event, NULL);
34765     return STATUS_SUCCESS;
34766 }
34767
34768 #ifdef _WIN64
34769 static NTSTATUS thunk64_vkDestroyFence(void *args)
34770 {
34771     struct vkDestroyFence_params *params = args;
34772
34773     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
34774
34775     wine_device_from_handle(params->device)->funcs.p_vkDestroyFence(wine_device_from_handle(params->device)->device, params->fence, NULL);
34776     return STATUS_SUCCESS;
34777 }
34778 #endif /* _WIN64 */
34779
34780 static NTSTATUS thunk32_vkDestroyFence(void *args)
34781 {
34782     struct
34783     {
34784         PTR32 device;
34785         VkFence DECLSPEC_ALIGN(8) fence;
34786         PTR32 pAllocator;
34787     } *params = args;
34788
34789     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
34790
34791     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyFence(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->fence, NULL);
34792     return STATUS_SUCCESS;
34793 }
34794
34795 #ifdef _WIN64
34796 static NTSTATUS thunk64_vkDestroyFramebuffer(void *args)
34797 {
34798     struct vkDestroyFramebuffer_params *params = args;
34799
34800     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pAllocator);
34801
34802     wine_device_from_handle(params->device)->funcs.p_vkDestroyFramebuffer(wine_device_from_handle(params->device)->device, params->framebuffer, NULL);
34803     return STATUS_SUCCESS;
34804 }
34805 #endif /* _WIN64 */
34806
34807 static NTSTATUS thunk32_vkDestroyFramebuffer(void *args)
34808 {
34809     struct
34810     {
34811         PTR32 device;
34812         VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
34813         PTR32 pAllocator;
34814     } *params = args;
34815
34816     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pAllocator);
34817
34818     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyFramebuffer(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->framebuffer, NULL);
34819     return STATUS_SUCCESS;
34820 }
34821
34822 #ifdef _WIN64
34823 static NTSTATUS thunk64_vkDestroyImage(void *args)
34824 {
34825     struct vkDestroyImage_params *params = args;
34826
34827     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pAllocator);
34828
34829     wine_device_from_handle(params->device)->funcs.p_vkDestroyImage(wine_device_from_handle(params->device)->device, params->image, NULL);
34830     return STATUS_SUCCESS;
34831 }
34832 #endif /* _WIN64 */
34833
34834 static NTSTATUS thunk32_vkDestroyImage(void *args)
34835 {
34836     struct
34837     {
34838         PTR32 device;
34839         VkImage DECLSPEC_ALIGN(8) image;
34840         PTR32 pAllocator;
34841     } *params = args;
34842
34843     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pAllocator);
34844
34845     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyImage(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, NULL);
34846     return STATUS_SUCCESS;
34847 }
34848
34849 #ifdef _WIN64
34850 static NTSTATUS thunk64_vkDestroyImageView(void *args)
34851 {
34852     struct vkDestroyImageView_params *params = args;
34853
34854     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pAllocator);
34855
34856     wine_device_from_handle(params->device)->funcs.p_vkDestroyImageView(wine_device_from_handle(params->device)->device, params->imageView, NULL);
34857     return STATUS_SUCCESS;
34858 }
34859 #endif /* _WIN64 */
34860
34861 static NTSTATUS thunk32_vkDestroyImageView(void *args)
34862 {
34863     struct
34864     {
34865         PTR32 device;
34866         VkImageView DECLSPEC_ALIGN(8) imageView;
34867         PTR32 pAllocator;
34868     } *params = args;
34869
34870     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->imageView), params->pAllocator);
34871
34872     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyImageView(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->imageView, NULL);
34873     return STATUS_SUCCESS;
34874 }
34875
34876 #ifdef _WIN64
34877 static NTSTATUS thunk64_vkDestroyIndirectCommandsLayoutNV(void *args)
34878 {
34879     struct vkDestroyIndirectCommandsLayoutNV_params *params = args;
34880
34881     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
34882
34883     wine_device_from_handle(params->device)->funcs.p_vkDestroyIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->indirectCommandsLayout, NULL);
34884     return STATUS_SUCCESS;
34885 }
34886 #endif /* _WIN64 */
34887
34888 static NTSTATUS thunk32_vkDestroyIndirectCommandsLayoutNV(void *args)
34889 {
34890     struct
34891     {
34892         PTR32 device;
34893         VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
34894         PTR32 pAllocator;
34895     } *params = args;
34896
34897     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
34898
34899     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyIndirectCommandsLayoutNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->indirectCommandsLayout, NULL);
34900     return STATUS_SUCCESS;
34901 }
34902
34903 #ifdef _WIN64
34904 static NTSTATUS thunk64_vkDestroyInstance(void *args)
34905 {
34906     struct vkDestroyInstance_params *params = args;
34907
34908     TRACE("%p, %p\n", params->instance, params->pAllocator);
34909
34910     if (!params->instance)
34911         return STATUS_SUCCESS;
34912
34913     wine_vkDestroyInstance(params->instance, params->pAllocator);
34914     return STATUS_SUCCESS;
34915 }
34916 #endif /* _WIN64 */
34917
34918 static NTSTATUS thunk32_vkDestroyInstance(void *args)
34919 {
34920     struct
34921     {
34922         PTR32 instance;
34923         PTR32 pAllocator;
34924     } *params = args;
34925
34926     TRACE("%#x, %#x\n", params->instance, params->pAllocator);
34927
34928     if (!params->instance)
34929         return STATUS_SUCCESS;
34930
34931     wine_vkDestroyInstance((VkInstance)UlongToPtr(params->instance), (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34932     return STATUS_SUCCESS;
34933 }
34934
34935 #ifdef _WIN64
34936 static NTSTATUS thunk64_vkDestroyMicromapEXT(void *args)
34937 {
34938     struct vkDestroyMicromapEXT_params *params = args;
34939
34940     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
34941
34942     wine_device_from_handle(params->device)->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle(params->device)->device, params->micromap, NULL);
34943     return STATUS_SUCCESS;
34944 }
34945 #endif /* _WIN64 */
34946
34947 static NTSTATUS thunk32_vkDestroyMicromapEXT(void *args)
34948 {
34949     struct
34950     {
34951         PTR32 device;
34952         VkMicromapEXT DECLSPEC_ALIGN(8) micromap;
34953         PTR32 pAllocator;
34954     } *params = args;
34955
34956     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
34957
34958     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->micromap, NULL);
34959     return STATUS_SUCCESS;
34960 }
34961
34962 #ifdef _WIN64
34963 static NTSTATUS thunk64_vkDestroyOpticalFlowSessionNV(void *args)
34964 {
34965     struct vkDestroyOpticalFlowSessionNV_params *params = args;
34966
34967     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
34968
34969     wine_device_from_handle(params->device)->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->session, NULL);
34970     return STATUS_SUCCESS;
34971 }
34972 #endif /* _WIN64 */
34973
34974 static NTSTATUS thunk32_vkDestroyOpticalFlowSessionNV(void *args)
34975 {
34976     struct
34977     {
34978         PTR32 device;
34979         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
34980         PTR32 pAllocator;
34981     } *params = args;
34982
34983     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
34984
34985     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->session, NULL);
34986     return STATUS_SUCCESS;
34987 }
34988
34989 #ifdef _WIN64
34990 static NTSTATUS thunk64_vkDestroyPipeline(void *args)
34991 {
34992     struct vkDestroyPipeline_params *params = args;
34993
34994     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->pAllocator);
34995
34996     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipeline(wine_device_from_handle(params->device)->device, params->pipeline, NULL);
34997     return STATUS_SUCCESS;
34998 }
34999 #endif /* _WIN64 */
35000
35001 static NTSTATUS thunk32_vkDestroyPipeline(void *args)
35002 {
35003     struct
35004     {
35005         PTR32 device;
35006         VkPipeline DECLSPEC_ALIGN(8) pipeline;
35007         PTR32 pAllocator;
35008     } *params = args;
35009
35010     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->pAllocator);
35011
35012     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipeline(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, NULL);
35013     return STATUS_SUCCESS;
35014 }
35015
35016 #ifdef _WIN64
35017 static NTSTATUS thunk64_vkDestroyPipelineCache(void *args)
35018 {
35019     struct vkDestroyPipelineCache_params *params = args;
35020
35021     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pAllocator);
35022
35023     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineCache(wine_device_from_handle(params->device)->device, params->pipelineCache, NULL);
35024     return STATUS_SUCCESS;
35025 }
35026 #endif /* _WIN64 */
35027
35028 static NTSTATUS thunk32_vkDestroyPipelineCache(void *args)
35029 {
35030     struct
35031     {
35032         PTR32 device;
35033         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
35034         PTR32 pAllocator;
35035     } *params = args;
35036
35037     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pAllocator);
35038
35039     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipelineCache(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineCache, NULL);
35040     return STATUS_SUCCESS;
35041 }
35042
35043 #ifdef _WIN64
35044 static NTSTATUS thunk64_vkDestroyPipelineLayout(void *args)
35045 {
35046     struct vkDestroyPipelineLayout_params *params = args;
35047
35048     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineLayout), params->pAllocator);
35049
35050     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineLayout(wine_device_from_handle(params->device)->device, params->pipelineLayout, NULL);
35051     return STATUS_SUCCESS;
35052 }
35053 #endif /* _WIN64 */
35054
35055 static NTSTATUS thunk32_vkDestroyPipelineLayout(void *args)
35056 {
35057     struct
35058     {
35059         PTR32 device;
35060         VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
35061         PTR32 pAllocator;
35062     } *params = args;
35063
35064     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineLayout), params->pAllocator);
35065
35066     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipelineLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineLayout, NULL);
35067     return STATUS_SUCCESS;
35068 }
35069
35070 #ifdef _WIN64
35071 static NTSTATUS thunk64_vkDestroyPrivateDataSlot(void *args)
35072 {
35073     struct vkDestroyPrivateDataSlot_params *params = args;
35074
35075     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
35076
35077     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlot(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
35078     return STATUS_SUCCESS;
35079 }
35080 #endif /* _WIN64 */
35081
35082 static NTSTATUS thunk32_vkDestroyPrivateDataSlot(void *args)
35083 {
35084     struct
35085     {
35086         PTR32 device;
35087         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
35088         PTR32 pAllocator;
35089     } *params = args;
35090
35091     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
35092
35093     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPrivateDataSlot(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->privateDataSlot, NULL);
35094     return STATUS_SUCCESS;
35095 }
35096
35097 #ifdef _WIN64
35098 static NTSTATUS thunk64_vkDestroyPrivateDataSlotEXT(void *args)
35099 {
35100     struct vkDestroyPrivateDataSlotEXT_params *params = args;
35101
35102     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
35103
35104     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
35105     return STATUS_SUCCESS;
35106 }
35107 #endif /* _WIN64 */
35108
35109 static NTSTATUS thunk32_vkDestroyPrivateDataSlotEXT(void *args)
35110 {
35111     struct
35112     {
35113         PTR32 device;
35114         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
35115         PTR32 pAllocator;
35116     } *params = args;
35117
35118     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
35119
35120     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPrivateDataSlotEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->privateDataSlot, NULL);
35121     return STATUS_SUCCESS;
35122 }
35123
35124 #ifdef _WIN64
35125 static NTSTATUS thunk64_vkDestroyQueryPool(void *args)
35126 {
35127     struct vkDestroyQueryPool_params *params = args;
35128
35129     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->queryPool), params->pAllocator);
35130
35131     wine_device_from_handle(params->device)->funcs.p_vkDestroyQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, NULL);
35132     return STATUS_SUCCESS;
35133 }
35134 #endif /* _WIN64 */
35135
35136 static NTSTATUS thunk32_vkDestroyQueryPool(void *args)
35137 {
35138     struct
35139     {
35140         PTR32 device;
35141         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
35142         PTR32 pAllocator;
35143     } *params = args;
35144
35145     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->queryPool), params->pAllocator);
35146
35147     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyQueryPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->queryPool, NULL);
35148     return STATUS_SUCCESS;
35149 }
35150
35151 #ifdef _WIN64
35152 static NTSTATUS thunk64_vkDestroyRenderPass(void *args)
35153 {
35154     struct vkDestroyRenderPass_params *params = args;
35155
35156     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pAllocator);
35157
35158     wine_device_from_handle(params->device)->funcs.p_vkDestroyRenderPass(wine_device_from_handle(params->device)->device, params->renderPass, NULL);
35159     return STATUS_SUCCESS;
35160 }
35161 #endif /* _WIN64 */
35162
35163 static NTSTATUS thunk32_vkDestroyRenderPass(void *args)
35164 {
35165     struct
35166     {
35167         PTR32 device;
35168         VkRenderPass DECLSPEC_ALIGN(8) renderPass;
35169         PTR32 pAllocator;
35170     } *params = args;
35171
35172     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pAllocator);
35173
35174     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyRenderPass(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->renderPass, NULL);
35175     return STATUS_SUCCESS;
35176 }
35177
35178 #ifdef _WIN64
35179 static NTSTATUS thunk64_vkDestroySampler(void *args)
35180 {
35181     struct vkDestroySampler_params *params = args;
35182
35183     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->sampler), params->pAllocator);
35184
35185     wine_device_from_handle(params->device)->funcs.p_vkDestroySampler(wine_device_from_handle(params->device)->device, params->sampler, NULL);
35186     return STATUS_SUCCESS;
35187 }
35188 #endif /* _WIN64 */
35189
35190 static NTSTATUS thunk32_vkDestroySampler(void *args)
35191 {
35192     struct
35193     {
35194         PTR32 device;
35195         VkSampler DECLSPEC_ALIGN(8) sampler;
35196         PTR32 pAllocator;
35197     } *params = args;
35198
35199     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->sampler), params->pAllocator);
35200
35201     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySampler(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->sampler, NULL);
35202     return STATUS_SUCCESS;
35203 }
35204
35205 #ifdef _WIN64
35206 static NTSTATUS thunk64_vkDestroySamplerYcbcrConversion(void *args)
35207 {
35208     struct vkDestroySamplerYcbcrConversion_params *params = args;
35209
35210     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
35211
35212     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
35213     return STATUS_SUCCESS;
35214 }
35215 #endif /* _WIN64 */
35216
35217 static NTSTATUS thunk32_vkDestroySamplerYcbcrConversion(void *args)
35218 {
35219     struct
35220     {
35221         PTR32 device;
35222         VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) ycbcrConversion;
35223         PTR32 pAllocator;
35224     } *params = args;
35225
35226     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
35227
35228     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySamplerYcbcrConversion(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->ycbcrConversion, NULL);
35229     return STATUS_SUCCESS;
35230 }
35231
35232 #ifdef _WIN64
35233 static NTSTATUS thunk64_vkDestroySamplerYcbcrConversionKHR(void *args)
35234 {
35235     struct vkDestroySamplerYcbcrConversionKHR_params *params = args;
35236
35237     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
35238
35239     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
35240     return STATUS_SUCCESS;
35241 }
35242 #endif /* _WIN64 */
35243
35244 static NTSTATUS thunk32_vkDestroySamplerYcbcrConversionKHR(void *args)
35245 {
35246     struct
35247     {
35248         PTR32 device;
35249         VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) ycbcrConversion;
35250         PTR32 pAllocator;
35251     } *params = args;
35252
35253     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
35254
35255     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySamplerYcbcrConversionKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->ycbcrConversion, NULL);
35256     return STATUS_SUCCESS;
35257 }
35258
35259 #ifdef _WIN64
35260 static NTSTATUS thunk64_vkDestroySemaphore(void *args)
35261 {
35262     struct vkDestroySemaphore_params *params = args;
35263
35264     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pAllocator);
35265
35266     wine_device_from_handle(params->device)->funcs.p_vkDestroySemaphore(wine_device_from_handle(params->device)->device, params->semaphore, NULL);
35267     return STATUS_SUCCESS;
35268 }
35269 #endif /* _WIN64 */
35270
35271 static NTSTATUS thunk32_vkDestroySemaphore(void *args)
35272 {
35273     struct
35274     {
35275         PTR32 device;
35276         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
35277         PTR32 pAllocator;
35278     } *params = args;
35279
35280     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pAllocator);
35281
35282     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySemaphore(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->semaphore, NULL);
35283     return STATUS_SUCCESS;
35284 }
35285
35286 #ifdef _WIN64
35287 static NTSTATUS thunk64_vkDestroyShaderEXT(void *args)
35288 {
35289     struct vkDestroyShaderEXT_params *params = args;
35290
35291     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shader), params->pAllocator);
35292
35293     wine_device_from_handle(params->device)->funcs.p_vkDestroyShaderEXT(wine_device_from_handle(params->device)->device, params->shader, NULL);
35294     return STATUS_SUCCESS;
35295 }
35296 #endif /* _WIN64 */
35297
35298 static NTSTATUS thunk32_vkDestroyShaderEXT(void *args)
35299 {
35300     struct
35301     {
35302         PTR32 device;
35303         VkShaderEXT DECLSPEC_ALIGN(8) shader;
35304         PTR32 pAllocator;
35305     } *params = args;
35306
35307     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->shader), params->pAllocator);
35308
35309     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyShaderEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->shader, NULL);
35310     return STATUS_SUCCESS;
35311 }
35312
35313 #ifdef _WIN64
35314 static NTSTATUS thunk64_vkDestroyShaderModule(void *args)
35315 {
35316     struct vkDestroyShaderModule_params *params = args;
35317
35318     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pAllocator);
35319
35320     wine_device_from_handle(params->device)->funcs.p_vkDestroyShaderModule(wine_device_from_handle(params->device)->device, params->shaderModule, NULL);
35321     return STATUS_SUCCESS;
35322 }
35323 #endif /* _WIN64 */
35324
35325 static NTSTATUS thunk32_vkDestroyShaderModule(void *args)
35326 {
35327     struct
35328     {
35329         PTR32 device;
35330         VkShaderModule DECLSPEC_ALIGN(8) shaderModule;
35331         PTR32 pAllocator;
35332     } *params = args;
35333
35334     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pAllocator);
35335
35336     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyShaderModule(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->shaderModule, NULL);
35337     return STATUS_SUCCESS;
35338 }
35339
35340 #ifdef _WIN64
35341 static NTSTATUS thunk64_vkDestroySurfaceKHR(void *args)
35342 {
35343     struct vkDestroySurfaceKHR_params *params = args;
35344
35345     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->surface), params->pAllocator);
35346
35347     wine_vkDestroySurfaceKHR(params->instance, params->surface, params->pAllocator);
35348     return STATUS_SUCCESS;
35349 }
35350 #endif /* _WIN64 */
35351
35352 static NTSTATUS thunk32_vkDestroySurfaceKHR(void *args)
35353 {
35354     struct
35355     {
35356         PTR32 instance;
35357         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
35358         PTR32 pAllocator;
35359     } *params = args;
35360
35361     TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->surface), params->pAllocator);
35362
35363     wine_vkDestroySurfaceKHR((VkInstance)UlongToPtr(params->instance), params->surface, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
35364     return STATUS_SUCCESS;
35365 }
35366
35367 #ifdef _WIN64
35368 static NTSTATUS thunk64_vkDestroySwapchainKHR(void *args)
35369 {
35370     struct vkDestroySwapchainKHR_params *params = args;
35371
35372     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pAllocator);
35373
35374     wine_device_from_handle(params->device)->funcs.p_vkDestroySwapchainKHR(wine_device_from_handle(params->device)->device, params->swapchain, NULL);
35375     return STATUS_SUCCESS;
35376 }
35377 #endif /* _WIN64 */
35378
35379 static NTSTATUS thunk32_vkDestroySwapchainKHR(void *args)
35380 {
35381     struct
35382     {
35383         PTR32 device;
35384         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
35385         PTR32 pAllocator;
35386     } *params = args;
35387
35388     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pAllocator);
35389
35390     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySwapchainKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->swapchain, NULL);
35391     return STATUS_SUCCESS;
35392 }
35393
35394 #ifdef _WIN64
35395 static NTSTATUS thunk64_vkDestroyValidationCacheEXT(void *args)
35396 {
35397     struct vkDestroyValidationCacheEXT_params *params = args;
35398
35399     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pAllocator);
35400
35401     wine_device_from_handle(params->device)->funcs.p_vkDestroyValidationCacheEXT(wine_device_from_handle(params->device)->device, params->validationCache, NULL);
35402     return STATUS_SUCCESS;
35403 }
35404 #endif /* _WIN64 */
35405
35406 static NTSTATUS thunk32_vkDestroyValidationCacheEXT(void *args)
35407 {
35408     struct
35409     {
35410         PTR32 device;
35411         VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
35412         PTR32 pAllocator;
35413     } *params = args;
35414
35415     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pAllocator);
35416
35417     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyValidationCacheEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->validationCache, NULL);
35418     return STATUS_SUCCESS;
35419 }
35420
35421 #ifdef _WIN64
35422 static NTSTATUS thunk64_vkDeviceWaitIdle(void *args)
35423 {
35424     struct vkDeviceWaitIdle_params *params = args;
35425
35426     TRACE("%p\n", params->device);
35427
35428     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeviceWaitIdle(wine_device_from_handle(params->device)->device);
35429     return STATUS_SUCCESS;
35430 }
35431 #endif /* _WIN64 */
35432
35433 static NTSTATUS thunk32_vkDeviceWaitIdle(void *args)
35434 {
35435     struct
35436     {
35437         PTR32 device;
35438         VkResult result;
35439     } *params = args;
35440
35441     TRACE("%#x\n", params->device);
35442
35443     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDeviceWaitIdle(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
35444     return STATUS_SUCCESS;
35445 }
35446
35447 #ifdef _WIN64
35448 static NTSTATUS thunk64_vkEndCommandBuffer(void *args)
35449 {
35450     struct vkEndCommandBuffer_params *params = args;
35451
35452     TRACE("%p\n", params->commandBuffer);
35453
35454     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
35455     return STATUS_SUCCESS;
35456 }
35457 #endif /* _WIN64 */
35458
35459 static NTSTATUS thunk32_vkEndCommandBuffer(void *args)
35460 {
35461     struct
35462     {
35463         PTR32 commandBuffer;
35464         VkResult result;
35465     } *params = args;
35466
35467     TRACE("%#x\n", params->commandBuffer);
35468
35469     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);
35470     return STATUS_SUCCESS;
35471 }
35472
35473 #ifdef _WIN64
35474 static NTSTATUS thunk64_vkEnumerateDeviceExtensionProperties(void *args)
35475 {
35476     struct vkEnumerateDeviceExtensionProperties_params *params = args;
35477
35478     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
35479
35480     params->result = wine_vkEnumerateDeviceExtensionProperties(params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
35481     return STATUS_SUCCESS;
35482 }
35483 #endif /* _WIN64 */
35484
35485 static NTSTATUS thunk32_vkEnumerateDeviceExtensionProperties(void *args)
35486 {
35487     struct
35488     {
35489         PTR32 physicalDevice;
35490         PTR32 pLayerName;
35491         PTR32 pPropertyCount;
35492         PTR32 pProperties;
35493         VkResult result;
35494     } *params = args;
35495
35496     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
35497
35498     params->result = wine_vkEnumerateDeviceExtensionProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (const char *)UlongToPtr(params->pLayerName), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkExtensionProperties *)UlongToPtr(params->pProperties));
35499     return STATUS_SUCCESS;
35500 }
35501
35502 #ifdef _WIN64
35503 static NTSTATUS thunk64_vkEnumerateDeviceLayerProperties(void *args)
35504 {
35505     struct vkEnumerateDeviceLayerProperties_params *params = args;
35506
35507     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
35508
35509     params->result = wine_vkEnumerateDeviceLayerProperties(params->physicalDevice, params->pPropertyCount, params->pProperties);
35510     return STATUS_SUCCESS;
35511 }
35512 #endif /* _WIN64 */
35513
35514 static NTSTATUS thunk32_vkEnumerateDeviceLayerProperties(void *args)
35515 {
35516     struct
35517     {
35518         PTR32 physicalDevice;
35519         PTR32 pPropertyCount;
35520         PTR32 pProperties;
35521         VkResult result;
35522     } *params = args;
35523
35524     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
35525
35526     params->result = wine_vkEnumerateDeviceLayerProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkLayerProperties *)UlongToPtr(params->pProperties));
35527     return STATUS_SUCCESS;
35528 }
35529
35530 #ifdef _WIN64
35531 static NTSTATUS thunk64_vkEnumerateInstanceExtensionProperties(void *args)
35532 {
35533     struct vkEnumerateInstanceExtensionProperties_params *params = args;
35534
35535     TRACE("%p, %p, %p\n", params->pLayerName, params->pPropertyCount, params->pProperties);
35536
35537     params->result = wine_vkEnumerateInstanceExtensionProperties(params->pLayerName, params->pPropertyCount, params->pProperties);
35538     return STATUS_SUCCESS;
35539 }
35540 #endif /* _WIN64 */
35541
35542 static NTSTATUS thunk32_vkEnumerateInstanceExtensionProperties(void *args)
35543 {
35544     struct
35545     {
35546         PTR32 pLayerName;
35547         PTR32 pPropertyCount;
35548         PTR32 pProperties;
35549         VkResult result;
35550     } *params = args;
35551
35552     TRACE("%#x, %#x, %#x\n", params->pLayerName, params->pPropertyCount, params->pProperties);
35553
35554     params->result = wine_vkEnumerateInstanceExtensionProperties((const char *)UlongToPtr(params->pLayerName), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkExtensionProperties *)UlongToPtr(params->pProperties));
35555     return STATUS_SUCCESS;
35556 }
35557
35558 #ifdef _WIN64
35559 static NTSTATUS thunk64_vkEnumerateInstanceVersion(void *args)
35560 {
35561     struct vkEnumerateInstanceVersion_params *params = args;
35562
35563     TRACE("%p\n", params->pApiVersion);
35564
35565     params->result = wine_vkEnumerateInstanceVersion(params->pApiVersion);
35566     return STATUS_SUCCESS;
35567 }
35568 #endif /* _WIN64 */
35569
35570 static NTSTATUS thunk32_vkEnumerateInstanceVersion(void *args)
35571 {
35572     struct
35573     {
35574         PTR32 pApiVersion;
35575         VkResult result;
35576     } *params = args;
35577
35578     TRACE("%#x\n", params->pApiVersion);
35579
35580     params->result = wine_vkEnumerateInstanceVersion((uint32_t *)UlongToPtr(params->pApiVersion));
35581     return STATUS_SUCCESS;
35582 }
35583
35584 #ifdef _WIN64
35585 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroups(void *args)
35586 {
35587     struct vkEnumeratePhysicalDeviceGroups_params *params = args;
35588
35589     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35590
35591     params->result = wine_vkEnumeratePhysicalDeviceGroups(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35592     return STATUS_SUCCESS;
35593 }
35594 #endif /* _WIN64 */
35595
35596 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroups(void *args)
35597 {
35598     struct
35599     {
35600         PTR32 instance;
35601         PTR32 pPhysicalDeviceGroupCount;
35602         PTR32 pPhysicalDeviceGroupProperties;
35603         VkResult result;
35604     } *params = args;
35605     VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties_host;
35606     struct conversion_context local_ctx;
35607     struct conversion_context *ctx = &local_ctx;
35608
35609     TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35610
35611     init_conversion_context(ctx);
35612     pPhysicalDeviceGroupProperties_host = convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(ctx, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
35613     params->result = wine_vkEnumeratePhysicalDeviceGroups((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount), pPhysicalDeviceGroupProperties_host);
35614     convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(pPhysicalDeviceGroupProperties_host, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
35615     free_conversion_context(ctx);
35616     return STATUS_SUCCESS;
35617 }
35618
35619 #ifdef _WIN64
35620 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
35621 {
35622     struct vkEnumeratePhysicalDeviceGroupsKHR_params *params = args;
35623
35624     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35625
35626     params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35627     return STATUS_SUCCESS;
35628 }
35629 #endif /* _WIN64 */
35630
35631 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
35632 {
35633     struct
35634     {
35635         PTR32 instance;
35636         PTR32 pPhysicalDeviceGroupCount;
35637         PTR32 pPhysicalDeviceGroupProperties;
35638         VkResult result;
35639     } *params = args;
35640     VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties_host;
35641     struct conversion_context local_ctx;
35642     struct conversion_context *ctx = &local_ctx;
35643
35644     TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
35645
35646     init_conversion_context(ctx);
35647     pPhysicalDeviceGroupProperties_host = convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(ctx, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
35648     params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount), pPhysicalDeviceGroupProperties_host);
35649     convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(pPhysicalDeviceGroupProperties_host, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
35650     free_conversion_context(ctx);
35651     return STATUS_SUCCESS;
35652 }
35653
35654 #ifdef _WIN64
35655 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(void *args)
35656 {
35657     struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_params *params = args;
35658
35659     TRACE("%p, %u, %p, %p, %p\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
35660
35661     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);
35662     return STATUS_SUCCESS;
35663 }
35664 #endif /* _WIN64 */
35665
35666 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(void *args)
35667 {
35668     struct
35669     {
35670         PTR32 physicalDevice;
35671         uint32_t queueFamilyIndex;
35672         PTR32 pCounterCount;
35673         PTR32 pCounters;
35674         PTR32 pCounterDescriptions;
35675         VkResult result;
35676     } *params = args;
35677     VkPerformanceCounterKHR *pCounters_host;
35678     VkPerformanceCounterDescriptionKHR *pCounterDescriptions_host;
35679     struct conversion_context local_ctx;
35680     struct conversion_context *ctx = &local_ctx;
35681
35682     TRACE("%#x, %u, %#x, %#x, %#x\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
35683
35684     init_conversion_context(ctx);
35685     pCounters_host = convert_VkPerformanceCounterKHR_array_win32_to_host(ctx, (VkPerformanceCounterKHR32 *)UlongToPtr(params->pCounters), *(uint32_t *)UlongToPtr(params->pCounterCount));
35686     pCounterDescriptions_host = convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(ctx, (VkPerformanceCounterDescriptionKHR32 *)UlongToPtr(params->pCounterDescriptions), *(uint32_t *)UlongToPtr(params->pCounterCount));
35687     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);
35688     convert_VkPerformanceCounterKHR_array_host_to_win32(pCounters_host, (VkPerformanceCounterKHR32 *)UlongToPtr(params->pCounters), *(uint32_t *)UlongToPtr(params->pCounterCount));
35689     convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(pCounterDescriptions_host, (VkPerformanceCounterDescriptionKHR32 *)UlongToPtr(params->pCounterDescriptions), *(uint32_t *)UlongToPtr(params->pCounterCount));
35690     free_conversion_context(ctx);
35691     return STATUS_SUCCESS;
35692 }
35693
35694 #ifdef _WIN64
35695 static NTSTATUS thunk64_vkEnumeratePhysicalDevices(void *args)
35696 {
35697     struct vkEnumeratePhysicalDevices_params *params = args;
35698
35699     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
35700
35701     params->result = wine_vkEnumeratePhysicalDevices(params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
35702     return STATUS_SUCCESS;
35703 }
35704 #endif /* _WIN64 */
35705
35706 static NTSTATUS thunk32_vkEnumeratePhysicalDevices(void *args)
35707 {
35708     struct
35709     {
35710         PTR32 instance;
35711         PTR32 pPhysicalDeviceCount;
35712         PTR32 pPhysicalDevices;
35713         VkResult result;
35714     } *params = args;
35715     VkPhysicalDevice *pPhysicalDevices_host;
35716     struct conversion_context local_ctx;
35717     struct conversion_context *ctx = &local_ctx;
35718
35719     TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
35720
35721     init_conversion_context(ctx);
35722     pPhysicalDevices_host = (params->pPhysicalDevices && *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount)) ? conversion_context_alloc(ctx, sizeof(*pPhysicalDevices_host) * *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount)) : NULL;
35723     params->result = wine_vkEnumeratePhysicalDevices((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceCount), pPhysicalDevices_host);
35724     convert_VkPhysicalDevice_array_unwrapped_host_to_win32(pPhysicalDevices_host, (PTR32 *)UlongToPtr(params->pPhysicalDevices), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount));
35725     free_conversion_context(ctx);
35726     return STATUS_SUCCESS;
35727 }
35728
35729 #ifdef _WIN64
35730 static NTSTATUS thunk64_vkFlushMappedMemoryRanges(void *args)
35731 {
35732     struct vkFlushMappedMemoryRanges_params *params = args;
35733     const VkMappedMemoryRange *pMemoryRanges_host;
35734     struct conversion_context local_ctx;
35735     struct conversion_context *ctx = &local_ctx;
35736
35737     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
35738
35739     init_conversion_context(ctx);
35740     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win64_to_host(ctx, params->pMemoryRanges, params->memoryRangeCount);
35741     params->result = wine_device_from_handle(params->device)->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
35742     free_conversion_context(ctx);
35743     return STATUS_SUCCESS;
35744 }
35745 #endif /* _WIN64 */
35746
35747 static NTSTATUS thunk32_vkFlushMappedMemoryRanges(void *args)
35748 {
35749     struct
35750     {
35751         PTR32 device;
35752         uint32_t memoryRangeCount;
35753         PTR32 pMemoryRanges;
35754         VkResult result;
35755     } *params = args;
35756     const VkMappedMemoryRange *pMemoryRanges_host;
35757     struct conversion_context local_ctx;
35758     struct conversion_context *ctx = &local_ctx;
35759
35760     TRACE("%#x, %u, %#x\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
35761
35762     init_conversion_context(ctx);
35763     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(ctx, (const VkMappedMemoryRange32 *)UlongToPtr(params->pMemoryRanges), params->memoryRangeCount);
35764     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);
35765     free_conversion_context(ctx);
35766     return STATUS_SUCCESS;
35767 }
35768
35769 #ifdef _WIN64
35770 static NTSTATUS thunk64_vkFreeCommandBuffers(void *args)
35771 {
35772     struct vkFreeCommandBuffers_params *params = args;
35773
35774     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->commandBufferCount, params->pCommandBuffers);
35775
35776     wine_vkFreeCommandBuffers(params->device, params->commandPool, params->commandBufferCount, params->pCommandBuffers);
35777     return STATUS_SUCCESS;
35778 }
35779 #endif /* _WIN64 */
35780
35781 static NTSTATUS thunk32_vkFreeCommandBuffers(void *args)
35782 {
35783     struct
35784     {
35785         PTR32 device;
35786         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
35787         uint32_t commandBufferCount;
35788         PTR32 pCommandBuffers;
35789     } *params = args;
35790     const VkCommandBuffer *pCommandBuffers_host;
35791     struct conversion_context local_ctx;
35792     struct conversion_context *ctx = &local_ctx;
35793
35794     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->commandBufferCount, params->pCommandBuffers);
35795
35796     init_conversion_context(ctx);
35797     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_unwrapped_host(ctx, (const PTR32 *)UlongToPtr(params->pCommandBuffers), params->commandBufferCount);
35798     wine_vkFreeCommandBuffers((VkDevice)UlongToPtr(params->device), params->commandPool, params->commandBufferCount, pCommandBuffers_host);
35799     free_conversion_context(ctx);
35800     return STATUS_SUCCESS;
35801 }
35802
35803 #ifdef _WIN64
35804 static NTSTATUS thunk64_vkFreeDescriptorSets(void *args)
35805 {
35806     struct vkFreeDescriptorSets_params *params = args;
35807
35808     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);
35809
35810     params->result = wine_device_from_handle(params->device)->funcs.p_vkFreeDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorPool, params->descriptorSetCount, params->pDescriptorSets);
35811     return STATUS_SUCCESS;
35812 }
35813 #endif /* _WIN64 */
35814
35815 static NTSTATUS thunk32_vkFreeDescriptorSets(void *args)
35816 {
35817     struct
35818     {
35819         PTR32 device;
35820         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
35821         uint32_t descriptorSetCount;
35822         PTR32 pDescriptorSets;
35823         VkResult result;
35824     } *params = args;
35825
35826     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);
35827
35828     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));
35829     return STATUS_SUCCESS;
35830 }
35831
35832 #ifdef _WIN64
35833 static NTSTATUS thunk64_vkFreeMemory(void *args)
35834 {
35835     struct vkFreeMemory_params *params = args;
35836
35837     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pAllocator);
35838
35839     wine_vkFreeMemory(params->device, params->memory, params->pAllocator);
35840     return STATUS_SUCCESS;
35841 }
35842 #endif /* _WIN64 */
35843
35844 static NTSTATUS thunk32_vkFreeMemory(void *args)
35845 {
35846     struct
35847     {
35848         PTR32 device;
35849         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
35850         PTR32 pAllocator;
35851     } *params = args;
35852
35853     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->memory), params->pAllocator);
35854
35855     wine_vkFreeMemory((VkDevice)UlongToPtr(params->device), params->memory, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
35856     return STATUS_SUCCESS;
35857 }
35858
35859 #ifdef _WIN64
35860 static NTSTATUS thunk64_vkGetAccelerationStructureBuildSizesKHR(void *args)
35861 {
35862     struct vkGetAccelerationStructureBuildSizesKHR_params *params = args;
35863
35864     TRACE("%p, %#x, %p, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
35865
35866     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureBuildSizesKHR(wine_device_from_handle(params->device)->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
35867     return STATUS_SUCCESS;
35868 }
35869 #endif /* _WIN64 */
35870
35871 static NTSTATUS thunk32_vkGetAccelerationStructureBuildSizesKHR(void *args)
35872 {
35873     struct
35874     {
35875         PTR32 device;
35876         VkAccelerationStructureBuildTypeKHR buildType;
35877         PTR32 pBuildInfo;
35878         PTR32 pMaxPrimitiveCounts;
35879         PTR32 pSizeInfo;
35880     } *params = args;
35881     VkAccelerationStructureBuildGeometryInfoKHR pBuildInfo_host;
35882     VkAccelerationStructureBuildSizesInfoKHR pSizeInfo_host;
35883     struct conversion_context local_ctx;
35884     struct conversion_context *ctx = &local_ctx;
35885
35886     TRACE("%#x, %#x, %#x, %#x, %#x\n", params->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
35887
35888     init_conversion_context(ctx);
35889     convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pBuildInfo), &pBuildInfo_host);
35890     convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host((VkAccelerationStructureBuildSizesInfoKHR32 *)UlongToPtr(params->pSizeInfo), &pSizeInfo_host);
35891     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);
35892     convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(&pSizeInfo_host, (VkAccelerationStructureBuildSizesInfoKHR32 *)UlongToPtr(params->pSizeInfo));
35893     free_conversion_context(ctx);
35894     return STATUS_SUCCESS;
35895 }
35896
35897 #ifdef _WIN64
35898 static NTSTATUS thunk64_vkGetAccelerationStructureDeviceAddressKHR(void *args)
35899 {
35900     struct vkGetAccelerationStructureDeviceAddressKHR_params *params = args;
35901
35902     TRACE("%p, %p\n", params->device, params->pInfo);
35903
35904     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
35905     return STATUS_SUCCESS;
35906 }
35907 #endif /* _WIN64 */
35908
35909 static NTSTATUS thunk32_vkGetAccelerationStructureDeviceAddressKHR(void *args)
35910 {
35911     struct
35912     {
35913         PTR32 device;
35914         PTR32 pInfo;
35915         VkDeviceAddress result;
35916     } *params = args;
35917     VkAccelerationStructureDeviceAddressInfoKHR pInfo_host;
35918
35919     TRACE("%#x, %#x\n", params->device, params->pInfo);
35920
35921     convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host((const VkAccelerationStructureDeviceAddressInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
35922     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
35923     return STATUS_SUCCESS;
35924 }
35925
35926 #ifdef _WIN64
35927 static NTSTATUS thunk64_vkGetAccelerationStructureHandleNV(void *args)
35928 {
35929     struct vkGetAccelerationStructureHandleNV_params *params = args;
35930
35931     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);
35932
35933     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, params->dataSize, params->pData);
35934     return STATUS_SUCCESS;
35935 }
35936 #endif /* _WIN64 */
35937
35938 static NTSTATUS thunk32_vkGetAccelerationStructureHandleNV(void *args)
35939 {
35940     struct
35941     {
35942         PTR32 device;
35943         VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
35944         PTR32 dataSize;
35945         PTR32 pData;
35946         VkResult result;
35947     } *params = args;
35948
35949     TRACE("%#x, 0x%s, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);
35950
35951     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));
35952     return STATUS_SUCCESS;
35953 }
35954
35955 #ifdef _WIN64
35956 static NTSTATUS thunk64_vkGetAccelerationStructureMemoryRequirementsNV(void *args)
35957 {
35958     struct vkGetAccelerationStructureMemoryRequirementsNV_params *params = args;
35959
35960     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
35961
35962     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
35963     return STATUS_SUCCESS;
35964 }
35965 #endif /* _WIN64 */
35966
35967 static NTSTATUS thunk32_vkGetAccelerationStructureMemoryRequirementsNV(void *args)
35968 {
35969     struct
35970     {
35971         PTR32 device;
35972         PTR32 pInfo;
35973         PTR32 pMemoryRequirements;
35974     } *params = args;
35975     VkAccelerationStructureMemoryRequirementsInfoNV pInfo_host;
35976     VkMemoryRequirements2KHR pMemoryRequirements_host;
35977
35978     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
35979
35980     convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host((const VkAccelerationStructureMemoryRequirementsInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
35981     convert_VkMemoryRequirements2KHR_win32_to_host((VkMemoryRequirements2KHR32 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
35982     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
35983     convert_VkMemoryRequirements2KHR_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements2KHR32 *)UlongToPtr(params->pMemoryRequirements));
35984     return STATUS_SUCCESS;
35985 }
35986
35987 #ifdef _WIN64
35988 static NTSTATUS thunk64_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(void *args)
35989 {
35990     struct vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_params *params = args;
35991
35992     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
35993
35994     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
35995     return STATUS_SUCCESS;
35996 }
35997 #endif /* _WIN64 */
35998
35999 static NTSTATUS thunk32_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(void *args)
36000 {
36001     struct
36002     {
36003         PTR32 device;
36004         PTR32 pInfo;
36005         PTR32 pData;
36006         VkResult result;
36007     } *params = args;
36008     VkAccelerationStructureCaptureDescriptorDataInfoEXT pInfo_host;
36009
36010     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
36011
36012     convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_win32_to_host((const VkAccelerationStructureCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
36013     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));
36014     return STATUS_SUCCESS;
36015 }
36016
36017 #ifdef _WIN64
36018 static NTSTATUS thunk64_vkGetBufferDeviceAddress(void *args)
36019 {
36020     struct vkGetBufferDeviceAddress_params *params = args;
36021
36022     TRACE("%p, %p\n", params->device, params->pInfo);
36023
36024     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddress(wine_device_from_handle(params->device)->device, params->pInfo);
36025     return STATUS_SUCCESS;
36026 }
36027 #endif /* _WIN64 */
36028
36029 static NTSTATUS thunk32_vkGetBufferDeviceAddress(void *args)
36030 {
36031     struct
36032     {
36033         PTR32 device;
36034         PTR32 pInfo;
36035         VkDeviceAddress result;
36036     } *params = args;
36037     VkBufferDeviceAddressInfo pInfo_host;
36038
36039     TRACE("%#x, %#x\n", params->device, params->pInfo);
36040
36041     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
36042     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
36043     return STATUS_SUCCESS;
36044 }
36045
36046 #ifdef _WIN64
36047 static NTSTATUS thunk64_vkGetBufferDeviceAddressEXT(void *args)
36048 {
36049     struct vkGetBufferDeviceAddressEXT_params *params = args;
36050
36051     TRACE("%p, %p\n", params->device, params->pInfo);
36052
36053     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressEXT(wine_device_from_handle(params->device)->device, params->pInfo);
36054     return STATUS_SUCCESS;
36055 }
36056 #endif /* _WIN64 */
36057
36058 static NTSTATUS thunk32_vkGetBufferDeviceAddressEXT(void *args)
36059 {
36060     struct
36061     {
36062         PTR32 device;
36063         PTR32 pInfo;
36064         VkDeviceAddress result;
36065     } *params = args;
36066     VkBufferDeviceAddressInfo pInfo_host;
36067
36068     TRACE("%#x, %#x\n", params->device, params->pInfo);
36069
36070     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
36071     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddressEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
36072     return STATUS_SUCCESS;
36073 }
36074
36075 #ifdef _WIN64
36076 static NTSTATUS thunk64_vkGetBufferDeviceAddressKHR(void *args)
36077 {
36078     struct vkGetBufferDeviceAddressKHR_params *params = args;
36079
36080     TRACE("%p, %p\n", params->device, params->pInfo);
36081
36082     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
36083     return STATUS_SUCCESS;
36084 }
36085 #endif /* _WIN64 */
36086
36087 static NTSTATUS thunk32_vkGetBufferDeviceAddressKHR(void *args)
36088 {
36089     struct
36090     {
36091         PTR32 device;
36092         PTR32 pInfo;
36093         VkDeviceAddress result;
36094     } *params = args;
36095     VkBufferDeviceAddressInfo pInfo_host;
36096
36097     TRACE("%#x, %#x\n", params->device, params->pInfo);
36098
36099     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
36100     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
36101     return STATUS_SUCCESS;
36102 }
36103
36104 #ifdef _WIN64
36105 static NTSTATUS thunk64_vkGetBufferMemoryRequirements(void *args)
36106 {
36107     struct vkGetBufferMemoryRequirements_params *params = args;
36108
36109     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pMemoryRequirements);
36110
36111     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->buffer, params->pMemoryRequirements);
36112     return STATUS_SUCCESS;
36113 }
36114 #endif /* _WIN64 */
36115
36116 static NTSTATUS thunk32_vkGetBufferMemoryRequirements(void *args)
36117 {
36118     struct
36119     {
36120         PTR32 device;
36121         VkBuffer DECLSPEC_ALIGN(8) buffer;
36122         PTR32 pMemoryRequirements;
36123     } *params = args;
36124     VkMemoryRequirements pMemoryRequirements_host;
36125
36126     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->buffer), params->pMemoryRequirements);
36127
36128     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buffer, &pMemoryRequirements_host);
36129     convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements32 *)UlongToPtr(params->pMemoryRequirements));
36130     return STATUS_SUCCESS;
36131 }
36132
36133 #ifdef _WIN64
36134 static NTSTATUS thunk64_vkGetBufferMemoryRequirements2(void *args)
36135 {
36136     struct vkGetBufferMemoryRequirements2_params *params = args;
36137
36138     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36139
36140     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36141     return STATUS_SUCCESS;
36142 }
36143 #endif /* _WIN64 */
36144
36145 static NTSTATUS thunk32_vkGetBufferMemoryRequirements2(void *args)
36146 {
36147     struct
36148     {
36149         PTR32 device;
36150         PTR32 pInfo;
36151         PTR32 pMemoryRequirements;
36152     } *params = args;
36153     VkBufferMemoryRequirementsInfo2 pInfo_host;
36154     VkMemoryRequirements2 pMemoryRequirements_host;
36155     struct conversion_context local_ctx;
36156     struct conversion_context *ctx = &local_ctx;
36157
36158     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36159
36160     init_conversion_context(ctx);
36161     convert_VkBufferMemoryRequirementsInfo2_win32_to_host((const VkBufferMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
36162     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36163     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36164     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36165     free_conversion_context(ctx);
36166     return STATUS_SUCCESS;
36167 }
36168
36169 #ifdef _WIN64
36170 static NTSTATUS thunk64_vkGetBufferMemoryRequirements2KHR(void *args)
36171 {
36172     struct vkGetBufferMemoryRequirements2KHR_params *params = args;
36173
36174     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36175
36176     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36177     return STATUS_SUCCESS;
36178 }
36179 #endif /* _WIN64 */
36180
36181 static NTSTATUS thunk32_vkGetBufferMemoryRequirements2KHR(void *args)
36182 {
36183     struct
36184     {
36185         PTR32 device;
36186         PTR32 pInfo;
36187         PTR32 pMemoryRequirements;
36188     } *params = args;
36189     VkBufferMemoryRequirementsInfo2 pInfo_host;
36190     VkMemoryRequirements2 pMemoryRequirements_host;
36191     struct conversion_context local_ctx;
36192     struct conversion_context *ctx = &local_ctx;
36193
36194     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36195
36196     init_conversion_context(ctx);
36197     convert_VkBufferMemoryRequirementsInfo2_win32_to_host((const VkBufferMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
36198     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36199     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36200     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36201     free_conversion_context(ctx);
36202     return STATUS_SUCCESS;
36203 }
36204
36205 #ifdef _WIN64
36206 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureAddress(void *args)
36207 {
36208     struct vkGetBufferOpaqueCaptureAddress_params *params = args;
36209
36210     TRACE("%p, %p\n", params->device, params->pInfo);
36211
36212     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, params->pInfo);
36213     return STATUS_SUCCESS;
36214 }
36215 #endif /* _WIN64 */
36216
36217 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddress(void *args)
36218 {
36219     struct
36220     {
36221         PTR32 device;
36222         PTR32 pInfo;
36223         uint64_t result;
36224     } *params = args;
36225     VkBufferDeviceAddressInfo pInfo_host;
36226
36227     TRACE("%#x, %#x\n", params->device, params->pInfo);
36228
36229     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
36230     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferOpaqueCaptureAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
36231     return STATUS_SUCCESS;
36232 }
36233
36234 #ifdef _WIN64
36235 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureAddressKHR(void *args)
36236 {
36237     struct vkGetBufferOpaqueCaptureAddressKHR_params *params = args;
36238
36239     TRACE("%p, %p\n", params->device, params->pInfo);
36240
36241     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
36242     return STATUS_SUCCESS;
36243 }
36244 #endif /* _WIN64 */
36245
36246 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddressKHR(void *args)
36247 {
36248     struct
36249     {
36250         PTR32 device;
36251         PTR32 pInfo;
36252         uint64_t result;
36253     } *params = args;
36254     VkBufferDeviceAddressInfo pInfo_host;
36255
36256     TRACE("%#x, %#x\n", params->device, params->pInfo);
36257
36258     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
36259     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
36260     return STATUS_SUCCESS;
36261 }
36262
36263 #ifdef _WIN64
36264 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureDescriptorDataEXT(void *args)
36265 {
36266     struct vkGetBufferOpaqueCaptureDescriptorDataEXT_params *params = args;
36267
36268     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
36269
36270     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
36271     return STATUS_SUCCESS;
36272 }
36273 #endif /* _WIN64 */
36274
36275 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureDescriptorDataEXT(void *args)
36276 {
36277     struct
36278     {
36279         PTR32 device;
36280         PTR32 pInfo;
36281         PTR32 pData;
36282         VkResult result;
36283     } *params = args;
36284     VkBufferCaptureDescriptorDataInfoEXT pInfo_host;
36285
36286     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
36287
36288     convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host((const VkBufferCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
36289     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));
36290     return STATUS_SUCCESS;
36291 }
36292
36293 #ifdef _WIN64
36294 static NTSTATUS thunk64_vkGetCalibratedTimestampsEXT(void *args)
36295 {
36296     struct vkGetCalibratedTimestampsEXT_params *params = args;
36297
36298     TRACE("%p, %u, %p, %p, %p\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
36299
36300     params->result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
36301     return STATUS_SUCCESS;
36302 }
36303 #endif /* _WIN64 */
36304
36305 static NTSTATUS thunk32_vkGetCalibratedTimestampsEXT(void *args)
36306 {
36307     struct
36308     {
36309         PTR32 device;
36310         uint32_t timestampCount;
36311         PTR32 pTimestampInfos;
36312         PTR32 pTimestamps;
36313         PTR32 pMaxDeviation;
36314         VkResult result;
36315     } *params = args;
36316     const VkCalibratedTimestampInfoEXT *pTimestampInfos_host;
36317     struct conversion_context local_ctx;
36318     struct conversion_context *ctx = &local_ctx;
36319
36320     TRACE("%#x, %u, %#x, %#x, %#x\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
36321
36322     init_conversion_context(ctx);
36323     pTimestampInfos_host = convert_VkCalibratedTimestampInfoEXT_array_win32_to_host(ctx, (const VkCalibratedTimestampInfoEXT32 *)UlongToPtr(params->pTimestampInfos), params->timestampCount);
36324     params->result = wine_vkGetCalibratedTimestampsEXT((VkDevice)UlongToPtr(params->device), params->timestampCount, pTimestampInfos_host, (uint64_t *)UlongToPtr(params->pTimestamps), (uint64_t *)UlongToPtr(params->pMaxDeviation));
36325     free_conversion_context(ctx);
36326     return STATUS_SUCCESS;
36327 }
36328
36329 #ifdef _WIN64
36330 static NTSTATUS thunk64_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
36331 {
36332     struct vkGetDeferredOperationMaxConcurrencyKHR_params *params = args;
36333
36334     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
36335
36336     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);
36337     return STATUS_SUCCESS;
36338 }
36339 #endif /* _WIN64 */
36340
36341 static NTSTATUS thunk32_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
36342 {
36343     struct
36344     {
36345         PTR32 device;
36346         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
36347         uint32_t result;
36348     } *params = args;
36349
36350     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
36351
36352     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);
36353     return STATUS_SUCCESS;
36354 }
36355
36356 #ifdef _WIN64
36357 static NTSTATUS thunk64_vkGetDeferredOperationResultKHR(void *args)
36358 {
36359     struct vkGetDeferredOperationResultKHR_params *params = args;
36360
36361     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
36362
36363     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);
36364     return STATUS_SUCCESS;
36365 }
36366 #endif /* _WIN64 */
36367
36368 static NTSTATUS thunk32_vkGetDeferredOperationResultKHR(void *args)
36369 {
36370     struct
36371     {
36372         PTR32 device;
36373         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
36374         VkResult result;
36375     } *params = args;
36376
36377     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
36378
36379     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);
36380     return STATUS_SUCCESS;
36381 }
36382
36383 #ifdef _WIN64
36384 static void thunk64_vkGetDescriptorEXT(void *args)
36385 {
36386     struct vkGetDescriptorEXT_params *params = args;
36387
36388     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorEXT(wine_device_from_handle(params->device)->device, params->pDescriptorInfo, params->dataSize, params->pDescriptor);
36389 }
36390 #endif /* _WIN64 */
36391
36392 static void thunk32_vkGetDescriptorEXT(void *args)
36393 {
36394     struct
36395     {
36396         PTR32 device;
36397         PTR32 pDescriptorInfo;
36398         PTR32 dataSize;
36399         PTR32 pDescriptor;
36400     } *params = args;
36401     VkDescriptorGetInfoEXT pDescriptorInfo_host;
36402     struct conversion_context local_ctx;
36403     struct conversion_context *ctx = &local_ctx;
36404
36405     init_conversion_context(ctx);
36406     convert_VkDescriptorGetInfoEXT_win32_to_host(ctx, (const VkDescriptorGetInfoEXT32 *)UlongToPtr(params->pDescriptorInfo), &pDescriptorInfo_host);
36407     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));
36408     free_conversion_context(ctx);
36409 }
36410
36411 #ifdef _WIN64
36412 static NTSTATUS thunk64_vkGetDescriptorSetHostMappingVALVE(void *args)
36413 {
36414     struct vkGetDescriptorSetHostMappingVALVE_params *params = args;
36415
36416     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), params->ppData);
36417
36418     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetHostMappingVALVE(wine_device_from_handle(params->device)->device, params->descriptorSet, params->ppData);
36419     return STATUS_SUCCESS;
36420 }
36421 #endif /* _WIN64 */
36422
36423 static NTSTATUS thunk32_vkGetDescriptorSetHostMappingVALVE(void *args)
36424 {
36425     struct
36426     {
36427         PTR32 device;
36428         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
36429         PTR32 ppData;
36430     } *params = args;
36431
36432     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSet), params->ppData);
36433
36434     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));
36435     return STATUS_SUCCESS;
36436 }
36437
36438 #ifdef _WIN64
36439 static NTSTATUS thunk64_vkGetDescriptorSetLayoutBindingOffsetEXT(void *args)
36440 {
36441     struct vkGetDescriptorSetLayoutBindingOffsetEXT_params *params = args;
36442
36443     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->layout), params->binding, params->pOffset);
36444
36445     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutBindingOffsetEXT(wine_device_from_handle(params->device)->device, params->layout, params->binding, params->pOffset);
36446     return STATUS_SUCCESS;
36447 }
36448 #endif /* _WIN64 */
36449
36450 static NTSTATUS thunk32_vkGetDescriptorSetLayoutBindingOffsetEXT(void *args)
36451 {
36452     struct
36453     {
36454         PTR32 device;
36455         VkDescriptorSetLayout DECLSPEC_ALIGN(8) layout;
36456         uint32_t binding;
36457         PTR32 pOffset;
36458     } *params = args;
36459
36460     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->layout), params->binding, params->pOffset);
36461
36462     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));
36463     return STATUS_SUCCESS;
36464 }
36465
36466 #ifdef _WIN64
36467 static NTSTATUS thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args)
36468 {
36469     struct vkGetDescriptorSetLayoutHostMappingInfoVALVE_params *params = args;
36470
36471     TRACE("%p, %p, %p\n", params->device, params->pBindingReference, params->pHostMapping);
36472
36473     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutHostMappingInfoVALVE(wine_device_from_handle(params->device)->device, params->pBindingReference, params->pHostMapping);
36474     return STATUS_SUCCESS;
36475 }
36476 #endif /* _WIN64 */
36477
36478 static NTSTATUS thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args)
36479 {
36480     struct
36481     {
36482         PTR32 device;
36483         PTR32 pBindingReference;
36484         PTR32 pHostMapping;
36485     } *params = args;
36486     VkDescriptorSetBindingReferenceVALVE pBindingReference_host;
36487     VkDescriptorSetLayoutHostMappingInfoVALVE pHostMapping_host;
36488
36489     TRACE("%#x, %#x, %#x\n", params->device, params->pBindingReference, params->pHostMapping);
36490
36491     convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host((const VkDescriptorSetBindingReferenceVALVE32 *)UlongToPtr(params->pBindingReference), &pBindingReference_host);
36492     convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host((VkDescriptorSetLayoutHostMappingInfoVALVE32 *)UlongToPtr(params->pHostMapping), &pHostMapping_host);
36493     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutHostMappingInfoVALVE(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pBindingReference_host, &pHostMapping_host);
36494     convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(&pHostMapping_host, (VkDescriptorSetLayoutHostMappingInfoVALVE32 *)UlongToPtr(params->pHostMapping));
36495     return STATUS_SUCCESS;
36496 }
36497
36498 #ifdef _WIN64
36499 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSizeEXT(void *args)
36500 {
36501     struct vkGetDescriptorSetLayoutSizeEXT_params *params = args;
36502
36503     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->layout), params->pLayoutSizeInBytes);
36504
36505     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSizeEXT(wine_device_from_handle(params->device)->device, params->layout, params->pLayoutSizeInBytes);
36506     return STATUS_SUCCESS;
36507 }
36508 #endif /* _WIN64 */
36509
36510 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSizeEXT(void *args)
36511 {
36512     struct
36513     {
36514         PTR32 device;
36515         VkDescriptorSetLayout DECLSPEC_ALIGN(8) layout;
36516         PTR32 pLayoutSizeInBytes;
36517     } *params = args;
36518
36519     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->layout), params->pLayoutSizeInBytes);
36520
36521     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));
36522     return STATUS_SUCCESS;
36523 }
36524
36525 #ifdef _WIN64
36526 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSupport(void *args)
36527 {
36528     struct vkGetDescriptorSetLayoutSupport_params *params = args;
36529
36530     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
36531
36532     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupport(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pSupport);
36533     return STATUS_SUCCESS;
36534 }
36535 #endif /* _WIN64 */
36536
36537 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSupport(void *args)
36538 {
36539     struct
36540     {
36541         PTR32 device;
36542         PTR32 pCreateInfo;
36543         PTR32 pSupport;
36544     } *params = args;
36545     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
36546     VkDescriptorSetLayoutSupport pSupport_host;
36547     struct conversion_context local_ctx;
36548     struct conversion_context *ctx = &local_ctx;
36549
36550     TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pSupport);
36551
36552     init_conversion_context(ctx);
36553     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
36554     convert_VkDescriptorSetLayoutSupport_win32_to_host(ctx, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport), &pSupport_host);
36555     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutSupport(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pSupport_host);
36556     convert_VkDescriptorSetLayoutSupport_host_to_win32(&pSupport_host, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport));
36557     free_conversion_context(ctx);
36558     return STATUS_SUCCESS;
36559 }
36560
36561 #ifdef _WIN64
36562 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSupportKHR(void *args)
36563 {
36564     struct vkGetDescriptorSetLayoutSupportKHR_params *params = args;
36565
36566     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
36567
36568     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupportKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pSupport);
36569     return STATUS_SUCCESS;
36570 }
36571 #endif /* _WIN64 */
36572
36573 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSupportKHR(void *args)
36574 {
36575     struct
36576     {
36577         PTR32 device;
36578         PTR32 pCreateInfo;
36579         PTR32 pSupport;
36580     } *params = args;
36581     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
36582     VkDescriptorSetLayoutSupport pSupport_host;
36583     struct conversion_context local_ctx;
36584     struct conversion_context *ctx = &local_ctx;
36585
36586     TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pSupport);
36587
36588     init_conversion_context(ctx);
36589     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
36590     convert_VkDescriptorSetLayoutSupport_win32_to_host(ctx, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport), &pSupport_host);
36591     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutSupportKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pSupport_host);
36592     convert_VkDescriptorSetLayoutSupport_host_to_win32(&pSupport_host, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport));
36593     free_conversion_context(ctx);
36594     return STATUS_SUCCESS;
36595 }
36596
36597 #ifdef _WIN64
36598 static NTSTATUS thunk64_vkGetDeviceAccelerationStructureCompatibilityKHR(void *args)
36599 {
36600     struct vkGetDeviceAccelerationStructureCompatibilityKHR_params *params = args;
36601
36602     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
36603
36604     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceAccelerationStructureCompatibilityKHR(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
36605     return STATUS_SUCCESS;
36606 }
36607 #endif /* _WIN64 */
36608
36609 static NTSTATUS thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR(void *args)
36610 {
36611     struct
36612     {
36613         PTR32 device;
36614         PTR32 pVersionInfo;
36615         PTR32 pCompatibility;
36616     } *params = args;
36617     VkAccelerationStructureVersionInfoKHR pVersionInfo_host;
36618
36619     TRACE("%#x, %#x, %#x\n", params->device, params->pVersionInfo, params->pCompatibility);
36620
36621     convert_VkAccelerationStructureVersionInfoKHR_win32_to_host((const VkAccelerationStructureVersionInfoKHR32 *)UlongToPtr(params->pVersionInfo), &pVersionInfo_host);
36622     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));
36623     return STATUS_SUCCESS;
36624 }
36625
36626 #ifdef _WIN64
36627 static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirements(void *args)
36628 {
36629     struct vkGetDeviceBufferMemoryRequirements_params *params = args;
36630
36631     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36632
36633     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36634     return STATUS_SUCCESS;
36635 }
36636 #endif /* _WIN64 */
36637
36638 static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirements(void *args)
36639 {
36640     struct
36641     {
36642         PTR32 device;
36643         PTR32 pInfo;
36644         PTR32 pMemoryRequirements;
36645     } *params = args;
36646     VkDeviceBufferMemoryRequirements pInfo_host;
36647     VkMemoryRequirements2 pMemoryRequirements_host;
36648     struct conversion_context local_ctx;
36649     struct conversion_context *ctx = &local_ctx;
36650
36651     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36652
36653     init_conversion_context(ctx);
36654     convert_VkDeviceBufferMemoryRequirements_win32_to_host(ctx, (const VkDeviceBufferMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36655     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36656     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceBufferMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36657     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36658     free_conversion_context(ctx);
36659     return STATUS_SUCCESS;
36660 }
36661
36662 #ifdef _WIN64
36663 static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirementsKHR(void *args)
36664 {
36665     struct vkGetDeviceBufferMemoryRequirementsKHR_params *params = args;
36666
36667     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36668
36669     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36670     return STATUS_SUCCESS;
36671 }
36672 #endif /* _WIN64 */
36673
36674 static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirementsKHR(void *args)
36675 {
36676     struct
36677     {
36678         PTR32 device;
36679         PTR32 pInfo;
36680         PTR32 pMemoryRequirements;
36681     } *params = args;
36682     VkDeviceBufferMemoryRequirements pInfo_host;
36683     VkMemoryRequirements2 pMemoryRequirements_host;
36684     struct conversion_context local_ctx;
36685     struct conversion_context *ctx = &local_ctx;
36686
36687     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36688
36689     init_conversion_context(ctx);
36690     convert_VkDeviceBufferMemoryRequirements_win32_to_host(ctx, (const VkDeviceBufferMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36691     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36692     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceBufferMemoryRequirementsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36693     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36694     free_conversion_context(ctx);
36695     return STATUS_SUCCESS;
36696 }
36697
36698 #ifdef _WIN64
36699 static NTSTATUS thunk64_vkGetDeviceFaultInfoEXT(void *args)
36700 {
36701     struct vkGetDeviceFaultInfoEXT_params *params = args;
36702
36703     TRACE("%p, %p, %p\n", params->device, params->pFaultCounts, params->pFaultInfo);
36704
36705     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceFaultInfoEXT(wine_device_from_handle(params->device)->device, params->pFaultCounts, params->pFaultInfo);
36706     return STATUS_SUCCESS;
36707 }
36708 #endif /* _WIN64 */
36709
36710 static NTSTATUS thunk32_vkGetDeviceFaultInfoEXT(void *args)
36711 {
36712     struct
36713     {
36714         PTR32 device;
36715         PTR32 pFaultCounts;
36716         PTR32 pFaultInfo;
36717         VkResult result;
36718     } *params = args;
36719     VkDeviceFaultCountsEXT pFaultCounts_host;
36720     VkDeviceFaultInfoEXT *pFaultInfo_host = NULL;
36721     struct conversion_context local_ctx;
36722     struct conversion_context *ctx = &local_ctx;
36723
36724     TRACE("%#x, %#x, %#x\n", params->device, params->pFaultCounts, params->pFaultInfo);
36725
36726     init_conversion_context(ctx);
36727     convert_VkDeviceFaultCountsEXT_win32_to_host((VkDeviceFaultCountsEXT32 *)UlongToPtr(params->pFaultCounts), &pFaultCounts_host);
36728     if (params->pFaultInfo)
36729     {
36730         pFaultInfo_host = conversion_context_alloc(ctx, sizeof(*pFaultInfo_host));
36731         convert_VkDeviceFaultInfoEXT_win32_to_host(ctx, (VkDeviceFaultInfoEXT32 *)UlongToPtr(params->pFaultInfo), pFaultInfo_host);
36732     }
36733     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);
36734     convert_VkDeviceFaultCountsEXT_host_to_win32(&pFaultCounts_host, (VkDeviceFaultCountsEXT32 *)UlongToPtr(params->pFaultCounts));
36735     convert_VkDeviceFaultInfoEXT_host_to_win32(pFaultInfo_host, (VkDeviceFaultInfoEXT32 *)UlongToPtr(params->pFaultInfo));
36736     free_conversion_context(ctx);
36737     return STATUS_SUCCESS;
36738 }
36739
36740 #ifdef _WIN64
36741 static NTSTATUS thunk64_vkGetDeviceGroupPeerMemoryFeatures(void *args)
36742 {
36743     struct vkGetDeviceGroupPeerMemoryFeatures_params *params = args;
36744
36745     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36746
36747     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36748     return STATUS_SUCCESS;
36749 }
36750 #endif /* _WIN64 */
36751
36752 static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeatures(void *args)
36753 {
36754     struct
36755     {
36756         PTR32 device;
36757         uint32_t heapIndex;
36758         uint32_t localDeviceIndex;
36759         uint32_t remoteDeviceIndex;
36760         PTR32 pPeerMemoryFeatures;
36761     } *params = args;
36762
36763     TRACE("%#x, %u, %u, %u, %#x\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36764
36765     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));
36766     return STATUS_SUCCESS;
36767 }
36768
36769 #ifdef _WIN64
36770 static NTSTATUS thunk64_vkGetDeviceGroupPeerMemoryFeaturesKHR(void *args)
36771 {
36772     struct vkGetDeviceGroupPeerMemoryFeaturesKHR_params *params = args;
36773
36774     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36775
36776     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36777     return STATUS_SUCCESS;
36778 }
36779 #endif /* _WIN64 */
36780
36781 static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR(void *args)
36782 {
36783     struct
36784     {
36785         PTR32 device;
36786         uint32_t heapIndex;
36787         uint32_t localDeviceIndex;
36788         uint32_t remoteDeviceIndex;
36789         PTR32 pPeerMemoryFeatures;
36790     } *params = args;
36791
36792     TRACE("%#x, %u, %u, %u, %#x\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36793
36794     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));
36795     return STATUS_SUCCESS;
36796 }
36797
36798 #ifdef _WIN64
36799 static NTSTATUS thunk64_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
36800 {
36801     struct vkGetDeviceGroupPresentCapabilitiesKHR_params *params = args;
36802
36803     TRACE("%p, %p\n", params->device, params->pDeviceGroupPresentCapabilities);
36804
36805     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle(params->device)->device, params->pDeviceGroupPresentCapabilities);
36806     return STATUS_SUCCESS;
36807 }
36808 #endif /* _WIN64 */
36809
36810 static NTSTATUS thunk32_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
36811 {
36812     struct
36813     {
36814         PTR32 device;
36815         PTR32 pDeviceGroupPresentCapabilities;
36816         VkResult result;
36817     } *params = args;
36818     VkDeviceGroupPresentCapabilitiesKHR pDeviceGroupPresentCapabilities_host;
36819
36820     TRACE("%#x, %#x\n", params->device, params->pDeviceGroupPresentCapabilities);
36821
36822     convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host((VkDeviceGroupPresentCapabilitiesKHR32 *)UlongToPtr(params->pDeviceGroupPresentCapabilities), &pDeviceGroupPresentCapabilities_host);
36823     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pDeviceGroupPresentCapabilities_host);
36824     convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(&pDeviceGroupPresentCapabilities_host, (VkDeviceGroupPresentCapabilitiesKHR32 *)UlongToPtr(params->pDeviceGroupPresentCapabilities));
36825     return STATUS_SUCCESS;
36826 }
36827
36828 #ifdef _WIN64
36829 static NTSTATUS thunk64_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
36830 {
36831     struct vkGetDeviceGroupSurfacePresentModesKHR_params *params = args;
36832
36833     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);
36834
36835     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);
36836     return STATUS_SUCCESS;
36837 }
36838 #endif /* _WIN64 */
36839
36840 static NTSTATUS thunk32_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
36841 {
36842     struct
36843     {
36844         PTR32 device;
36845         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
36846         PTR32 pModes;
36847         VkResult result;
36848     } *params = args;
36849
36850     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);
36851
36852     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));
36853     return STATUS_SUCCESS;
36854 }
36855
36856 #ifdef _WIN64
36857 static NTSTATUS thunk64_vkGetDeviceImageMemoryRequirements(void *args)
36858 {
36859     struct vkGetDeviceImageMemoryRequirements_params *params = args;
36860
36861     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36862
36863     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36864     return STATUS_SUCCESS;
36865 }
36866 #endif /* _WIN64 */
36867
36868 static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirements(void *args)
36869 {
36870     struct
36871     {
36872         PTR32 device;
36873         PTR32 pInfo;
36874         PTR32 pMemoryRequirements;
36875     } *params = args;
36876     VkDeviceImageMemoryRequirements pInfo_host;
36877     VkMemoryRequirements2 pMemoryRequirements_host;
36878     struct conversion_context local_ctx;
36879     struct conversion_context *ctx = &local_ctx;
36880
36881     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36882
36883     init_conversion_context(ctx);
36884     convert_VkDeviceImageMemoryRequirements_win32_to_host(ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36885     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36886     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36887     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36888     free_conversion_context(ctx);
36889     return STATUS_SUCCESS;
36890 }
36891
36892 #ifdef _WIN64
36893 static NTSTATUS thunk64_vkGetDeviceImageMemoryRequirementsKHR(void *args)
36894 {
36895     struct vkGetDeviceImageMemoryRequirementsKHR_params *params = args;
36896
36897     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36898
36899     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36900     return STATUS_SUCCESS;
36901 }
36902 #endif /* _WIN64 */
36903
36904 static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirementsKHR(void *args)
36905 {
36906     struct
36907     {
36908         PTR32 device;
36909         PTR32 pInfo;
36910         PTR32 pMemoryRequirements;
36911     } *params = args;
36912     VkDeviceImageMemoryRequirements pInfo_host;
36913     VkMemoryRequirements2 pMemoryRequirements_host;
36914     struct conversion_context local_ctx;
36915     struct conversion_context *ctx = &local_ctx;
36916
36917     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36918
36919     init_conversion_context(ctx);
36920     convert_VkDeviceImageMemoryRequirements_win32_to_host(ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36921     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36922     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageMemoryRequirementsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36923     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36924     free_conversion_context(ctx);
36925     return STATUS_SUCCESS;
36926 }
36927
36928 #ifdef _WIN64
36929 static NTSTATUS thunk64_vkGetDeviceImageSparseMemoryRequirements(void *args)
36930 {
36931     struct vkGetDeviceImageSparseMemoryRequirements_params *params = args;
36932
36933     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36934
36935     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36936     return STATUS_SUCCESS;
36937 }
36938 #endif /* _WIN64 */
36939
36940 static NTSTATUS thunk32_vkGetDeviceImageSparseMemoryRequirements(void *args)
36941 {
36942     struct
36943     {
36944         PTR32 device;
36945         PTR32 pInfo;
36946         PTR32 pSparseMemoryRequirementCount;
36947         PTR32 pSparseMemoryRequirements;
36948     } *params = args;
36949     VkDeviceImageMemoryRequirements pInfo_host;
36950     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
36951     struct conversion_context local_ctx;
36952     struct conversion_context *ctx = &local_ctx;
36953
36954     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36955
36956     init_conversion_context(ctx);
36957     convert_VkDeviceImageMemoryRequirements_win32_to_host(ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36958     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36959     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);
36960     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36961     free_conversion_context(ctx);
36962     return STATUS_SUCCESS;
36963 }
36964
36965 #ifdef _WIN64
36966 static NTSTATUS thunk64_vkGetDeviceImageSparseMemoryRequirementsKHR(void *args)
36967 {
36968     struct vkGetDeviceImageSparseMemoryRequirementsKHR_params *params = args;
36969
36970     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36971
36972     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36973     return STATUS_SUCCESS;
36974 }
36975 #endif /* _WIN64 */
36976
36977 static NTSTATUS thunk32_vkGetDeviceImageSparseMemoryRequirementsKHR(void *args)
36978 {
36979     struct
36980     {
36981         PTR32 device;
36982         PTR32 pInfo;
36983         PTR32 pSparseMemoryRequirementCount;
36984         PTR32 pSparseMemoryRequirements;
36985     } *params = args;
36986     VkDeviceImageMemoryRequirements pInfo_host;
36987     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
36988     struct conversion_context local_ctx;
36989     struct conversion_context *ctx = &local_ctx;
36990
36991     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36992
36993     init_conversion_context(ctx);
36994     convert_VkDeviceImageMemoryRequirements_win32_to_host(ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36995     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36996     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);
36997     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36998     free_conversion_context(ctx);
36999     return STATUS_SUCCESS;
37000 }
37001
37002 #ifdef _WIN64
37003 static NTSTATUS thunk64_vkGetDeviceMemoryCommitment(void *args)
37004 {
37005     struct vkGetDeviceMemoryCommitment_params *params = args;
37006
37007     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pCommittedMemoryInBytes);
37008
37009     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);
37010     return STATUS_SUCCESS;
37011 }
37012 #endif /* _WIN64 */
37013
37014 static NTSTATUS thunk32_vkGetDeviceMemoryCommitment(void *args)
37015 {
37016     struct
37017     {
37018         PTR32 device;
37019         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
37020         PTR32 pCommittedMemoryInBytes;
37021     } *params = args;
37022
37023     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->memory), params->pCommittedMemoryInBytes);
37024
37025     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));
37026     return STATUS_SUCCESS;
37027 }
37028
37029 #ifdef _WIN64
37030 static NTSTATUS thunk64_vkGetDeviceMemoryOpaqueCaptureAddress(void *args)
37031 {
37032     struct vkGetDeviceMemoryOpaqueCaptureAddress_params *params = args;
37033     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
37034
37035     TRACE("%p, %p\n", params->device, params->pInfo);
37036
37037     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host(params->pInfo, &pInfo_host);
37038     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, &pInfo_host);
37039     return STATUS_SUCCESS;
37040 }
37041 #endif /* _WIN64 */
37042
37043 static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddress(void *args)
37044 {
37045     struct
37046     {
37047         PTR32 device;
37048         PTR32 pInfo;
37049         uint64_t result;
37050     } *params = args;
37051     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
37052
37053     TRACE("%#x, %#x\n", params->device, params->pInfo);
37054
37055     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host((const VkDeviceMemoryOpaqueCaptureAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
37056     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
37057     return STATUS_SUCCESS;
37058 }
37059
37060 #ifdef _WIN64
37061 static NTSTATUS thunk64_vkGetDeviceMemoryOpaqueCaptureAddressKHR(void *args)
37062 {
37063     struct vkGetDeviceMemoryOpaqueCaptureAddressKHR_params *params = args;
37064     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
37065
37066     TRACE("%p, %p\n", params->device, params->pInfo);
37067
37068     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host(params->pInfo, &pInfo_host);
37069     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
37070     return STATUS_SUCCESS;
37071 }
37072 #endif /* _WIN64 */
37073
37074 static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR(void *args)
37075 {
37076     struct
37077     {
37078         PTR32 device;
37079         PTR32 pInfo;
37080         uint64_t result;
37081     } *params = args;
37082     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
37083
37084     TRACE("%#x, %#x\n", params->device, params->pInfo);
37085
37086     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host((const VkDeviceMemoryOpaqueCaptureAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
37087     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
37088     return STATUS_SUCCESS;
37089 }
37090
37091 #ifdef _WIN64
37092 static NTSTATUS thunk64_vkGetDeviceMicromapCompatibilityEXT(void *args)
37093 {
37094     struct vkGetDeviceMicromapCompatibilityEXT_params *params = args;
37095
37096     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
37097
37098     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMicromapCompatibilityEXT(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
37099     return STATUS_SUCCESS;
37100 }
37101 #endif /* _WIN64 */
37102
37103 static NTSTATUS thunk32_vkGetDeviceMicromapCompatibilityEXT(void *args)
37104 {
37105     struct
37106     {
37107         PTR32 device;
37108         PTR32 pVersionInfo;
37109         PTR32 pCompatibility;
37110     } *params = args;
37111     VkMicromapVersionInfoEXT pVersionInfo_host;
37112
37113     TRACE("%#x, %#x, %#x\n", params->device, params->pVersionInfo, params->pCompatibility);
37114
37115     convert_VkMicromapVersionInfoEXT_win32_to_host((const VkMicromapVersionInfoEXT32 *)UlongToPtr(params->pVersionInfo), &pVersionInfo_host);
37116     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));
37117     return STATUS_SUCCESS;
37118 }
37119
37120 #ifdef _WIN64
37121 static NTSTATUS thunk64_vkGetDeviceQueue(void *args)
37122 {
37123     struct vkGetDeviceQueue_params *params = args;
37124
37125     TRACE("%p, %u, %u, %p\n", params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
37126
37127     wine_vkGetDeviceQueue(params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
37128     return STATUS_SUCCESS;
37129 }
37130 #endif /* _WIN64 */
37131
37132 static NTSTATUS thunk32_vkGetDeviceQueue(void *args)
37133 {
37134     struct
37135     {
37136         PTR32 device;
37137         uint32_t queueFamilyIndex;
37138         uint32_t queueIndex;
37139         PTR32 pQueue;
37140     } *params = args;
37141     VkQueue pQueue_host;
37142
37143     TRACE("%#x, %u, %u, %#x\n", params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
37144
37145     pQueue_host = UlongToPtr(*(PTR32 *)UlongToPtr(params->pQueue));
37146     wine_vkGetDeviceQueue((VkDevice)UlongToPtr(params->device), params->queueFamilyIndex, params->queueIndex, &pQueue_host);
37147     *(PTR32 *)UlongToPtr(params->pQueue) = PtrToUlong(pQueue_host);
37148     return STATUS_SUCCESS;
37149 }
37150
37151 #ifdef _WIN64
37152 static NTSTATUS thunk64_vkGetDeviceQueue2(void *args)
37153 {
37154     struct vkGetDeviceQueue2_params *params = args;
37155
37156     TRACE("%p, %p, %p\n", params->device, params->pQueueInfo, params->pQueue);
37157
37158     wine_vkGetDeviceQueue2(params->device, params->pQueueInfo, params->pQueue);
37159     return STATUS_SUCCESS;
37160 }
37161 #endif /* _WIN64 */
37162
37163 static NTSTATUS thunk32_vkGetDeviceQueue2(void *args)
37164 {
37165     struct
37166     {
37167         PTR32 device;
37168         PTR32 pQueueInfo;
37169         PTR32 pQueue;
37170     } *params = args;
37171     VkDeviceQueueInfo2 pQueueInfo_host;
37172     VkQueue pQueue_host;
37173
37174     TRACE("%#x, %#x, %#x\n", params->device, params->pQueueInfo, params->pQueue);
37175
37176     convert_VkDeviceQueueInfo2_win32_to_host((const VkDeviceQueueInfo232 *)UlongToPtr(params->pQueueInfo), &pQueueInfo_host);
37177     pQueue_host = UlongToPtr(*(PTR32 *)UlongToPtr(params->pQueue));
37178     wine_vkGetDeviceQueue2((VkDevice)UlongToPtr(params->device), &pQueueInfo_host, &pQueue_host);
37179     *(PTR32 *)UlongToPtr(params->pQueue) = PtrToUlong(pQueue_host);
37180     return STATUS_SUCCESS;
37181 }
37182
37183 #ifdef _WIN64
37184 static NTSTATUS thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *args)
37185 {
37186     struct vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_params *params = args;
37187
37188     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);
37189
37190     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle(params->device)->device, params->renderpass, params->pMaxWorkgroupSize);
37191     return STATUS_SUCCESS;
37192 }
37193 #endif /* _WIN64 */
37194
37195 static NTSTATUS thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *args)
37196 {
37197     struct
37198     {
37199         PTR32 device;
37200         VkRenderPass DECLSPEC_ALIGN(8) renderpass;
37201         PTR32 pMaxWorkgroupSize;
37202         VkResult result;
37203     } *params = args;
37204
37205     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);
37206
37207     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));
37208     return STATUS_SUCCESS;
37209 }
37210
37211 #ifdef _WIN64
37212 static NTSTATUS thunk64_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
37213 {
37214     struct vkGetDynamicRenderingTilePropertiesQCOM_params *params = args;
37215
37216     TRACE("%p, %p, %p\n", params->device, params->pRenderingInfo, params->pProperties);
37217
37218     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->pRenderingInfo, params->pProperties);
37219     return STATUS_SUCCESS;
37220 }
37221 #endif /* _WIN64 */
37222
37223 static NTSTATUS thunk32_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
37224 {
37225     struct
37226     {
37227         PTR32 device;
37228         PTR32 pRenderingInfo;
37229         PTR32 pProperties;
37230         VkResult result;
37231     } *params = args;
37232     VkRenderingInfo pRenderingInfo_host;
37233     VkTilePropertiesQCOM pProperties_host;
37234     struct conversion_context local_ctx;
37235     struct conversion_context *ctx = &local_ctx;
37236
37237     TRACE("%#x, %#x, %#x\n", params->device, params->pRenderingInfo, params->pProperties);
37238
37239     init_conversion_context(ctx);
37240     convert_VkRenderingInfo_win32_to_host(ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
37241     convert_VkTilePropertiesQCOM_win32_to_host((VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), &pProperties_host);
37242     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);
37243     convert_VkTilePropertiesQCOM_host_to_win32(&pProperties_host, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties));
37244     free_conversion_context(ctx);
37245     return STATUS_SUCCESS;
37246 }
37247
37248 #ifdef _WIN64
37249 static NTSTATUS thunk64_vkGetEventStatus(void *args)
37250 {
37251     struct vkGetEventStatus_params *params = args;
37252
37253     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
37254
37255     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetEventStatus(wine_device_from_handle(params->device)->device, params->event);
37256     return STATUS_SUCCESS;
37257 }
37258 #endif /* _WIN64 */
37259
37260 static NTSTATUS thunk32_vkGetEventStatus(void *args)
37261 {
37262     struct
37263     {
37264         PTR32 device;
37265         VkEvent DECLSPEC_ALIGN(8) event;
37266         VkResult result;
37267     } *params = args;
37268
37269     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
37270
37271     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetEventStatus(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
37272     return STATUS_SUCCESS;
37273 }
37274
37275 #ifdef _WIN64
37276 static NTSTATUS thunk64_vkGetFenceStatus(void *args)
37277 {
37278     struct vkGetFenceStatus_params *params = args;
37279
37280     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));
37281
37282     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFenceStatus(wine_device_from_handle(params->device)->device, params->fence);
37283     return STATUS_SUCCESS;
37284 }
37285 #endif /* _WIN64 */
37286
37287 static NTSTATUS thunk32_vkGetFenceStatus(void *args)
37288 {
37289     struct
37290     {
37291         PTR32 device;
37292         VkFence DECLSPEC_ALIGN(8) fence;
37293         VkResult result;
37294     } *params = args;
37295
37296     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));
37297
37298     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetFenceStatus(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->fence);
37299     return STATUS_SUCCESS;
37300 }
37301
37302 #ifdef _WIN64
37303 static NTSTATUS thunk64_vkGetFramebufferTilePropertiesQCOM(void *args)
37304 {
37305     struct vkGetFramebufferTilePropertiesQCOM_params *params = args;
37306
37307     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);
37308
37309     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->framebuffer, params->pPropertiesCount, params->pProperties);
37310     return STATUS_SUCCESS;
37311 }
37312 #endif /* _WIN64 */
37313
37314 static NTSTATUS thunk32_vkGetFramebufferTilePropertiesQCOM(void *args)
37315 {
37316     struct
37317     {
37318         PTR32 device;
37319         VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
37320         PTR32 pPropertiesCount;
37321         PTR32 pProperties;
37322         VkResult result;
37323     } *params = args;
37324     VkTilePropertiesQCOM *pProperties_host;
37325     struct conversion_context local_ctx;
37326     struct conversion_context *ctx = &local_ctx;
37327
37328     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);
37329
37330     init_conversion_context(ctx);
37331     pProperties_host = convert_VkTilePropertiesQCOM_array_win32_to_host(ctx, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertiesCount));
37332     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);
37333     convert_VkTilePropertiesQCOM_array_host_to_win32(pProperties_host, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertiesCount));
37334     free_conversion_context(ctx);
37335     return STATUS_SUCCESS;
37336 }
37337
37338 #ifdef _WIN64
37339 static NTSTATUS thunk64_vkGetGeneratedCommandsMemoryRequirementsNV(void *args)
37340 {
37341     struct vkGetGeneratedCommandsMemoryRequirementsNV_params *params = args;
37342
37343     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37344
37345     wine_device_from_handle(params->device)->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
37346     return STATUS_SUCCESS;
37347 }
37348 #endif /* _WIN64 */
37349
37350 static NTSTATUS thunk32_vkGetGeneratedCommandsMemoryRequirementsNV(void *args)
37351 {
37352     struct
37353     {
37354         PTR32 device;
37355         PTR32 pInfo;
37356         PTR32 pMemoryRequirements;
37357     } *params = args;
37358     VkGeneratedCommandsMemoryRequirementsInfoNV pInfo_host;
37359     VkMemoryRequirements2 pMemoryRequirements_host;
37360     struct conversion_context local_ctx;
37361     struct conversion_context *ctx = &local_ctx;
37362
37363     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
37364
37365     init_conversion_context(ctx);
37366     convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host((const VkGeneratedCommandsMemoryRequirementsInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
37367     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
37368     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
37369     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
37370     free_conversion_context(ctx);
37371     return STATUS_SUCCESS;
37372 }
37373
37374 #ifdef _WIN64
37375 static NTSTATUS thunk64_vkGetImageMemoryRequirements(void *args)
37376 {
37377     struct vkGetImageMemoryRequirements_params *params = args;
37378
37379     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pMemoryRequirements);
37380
37381     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pMemoryRequirements);
37382     return STATUS_SUCCESS;
37383 }
37384 #endif /* _WIN64 */
37385
37386 static NTSTATUS thunk32_vkGetImageMemoryRequirements(void *args)
37387 {
37388     struct
37389     {
37390         PTR32 device;
37391         VkImage DECLSPEC_ALIGN(8) image;
37392         PTR32 pMemoryRequirements;
37393     } *params = args;
37394     VkMemoryRequirements pMemoryRequirements_host;
37395
37396     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pMemoryRequirements);
37397
37398     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, &pMemoryRequirements_host);
37399     convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements32 *)UlongToPtr(params->pMemoryRequirements));
37400     return STATUS_SUCCESS;
37401 }
37402
37403 #ifdef _WIN64
37404 static NTSTATUS thunk64_vkGetImageMemoryRequirements2(void *args)
37405 {
37406     struct vkGetImageMemoryRequirements2_params *params = args;
37407
37408     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37409
37410     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
37411     return STATUS_SUCCESS;
37412 }
37413 #endif /* _WIN64 */
37414
37415 static NTSTATUS thunk32_vkGetImageMemoryRequirements2(void *args)
37416 {
37417     struct
37418     {
37419         PTR32 device;
37420         PTR32 pInfo;
37421         PTR32 pMemoryRequirements;
37422     } *params = args;
37423     VkImageMemoryRequirementsInfo2 pInfo_host;
37424     VkMemoryRequirements2 pMemoryRequirements_host;
37425     struct conversion_context local_ctx;
37426     struct conversion_context *ctx = &local_ctx;
37427
37428     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
37429
37430     init_conversion_context(ctx);
37431     convert_VkImageMemoryRequirementsInfo2_win32_to_host(ctx, (const VkImageMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
37432     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
37433     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
37434     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
37435     free_conversion_context(ctx);
37436     return STATUS_SUCCESS;
37437 }
37438
37439 #ifdef _WIN64
37440 static NTSTATUS thunk64_vkGetImageMemoryRequirements2KHR(void *args)
37441 {
37442     struct vkGetImageMemoryRequirements2KHR_params *params = args;
37443
37444     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
37445
37446     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
37447     return STATUS_SUCCESS;
37448 }
37449 #endif /* _WIN64 */
37450
37451 static NTSTATUS thunk32_vkGetImageMemoryRequirements2KHR(void *args)
37452 {
37453     struct
37454     {
37455         PTR32 device;
37456         PTR32 pInfo;
37457         PTR32 pMemoryRequirements;
37458     } *params = args;
37459     VkImageMemoryRequirementsInfo2 pInfo_host;
37460     VkMemoryRequirements2 pMemoryRequirements_host;
37461     struct conversion_context local_ctx;
37462     struct conversion_context *ctx = &local_ctx;
37463
37464     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
37465
37466     init_conversion_context(ctx);
37467     convert_VkImageMemoryRequirementsInfo2_win32_to_host(ctx, (const VkImageMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
37468     convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
37469     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
37470     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
37471     free_conversion_context(ctx);
37472     return STATUS_SUCCESS;
37473 }
37474
37475 #ifdef _WIN64
37476 static NTSTATUS thunk64_vkGetImageOpaqueCaptureDescriptorDataEXT(void *args)
37477 {
37478     struct vkGetImageOpaqueCaptureDescriptorDataEXT_params *params = args;
37479
37480     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
37481
37482     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
37483     return STATUS_SUCCESS;
37484 }
37485 #endif /* _WIN64 */
37486
37487 static NTSTATUS thunk32_vkGetImageOpaqueCaptureDescriptorDataEXT(void *args)
37488 {
37489     struct
37490     {
37491         PTR32 device;
37492         PTR32 pInfo;
37493         PTR32 pData;
37494         VkResult result;
37495     } *params = args;
37496     VkImageCaptureDescriptorDataInfoEXT pInfo_host;
37497
37498     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
37499
37500     convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host((const VkImageCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
37501     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));
37502     return STATUS_SUCCESS;
37503 }
37504
37505 #ifdef _WIN64
37506 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements(void *args)
37507 {
37508     struct vkGetImageSparseMemoryRequirements_params *params = args;
37509
37510     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37511
37512     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37513     return STATUS_SUCCESS;
37514 }
37515 #endif /* _WIN64 */
37516
37517 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements(void *args)
37518 {
37519     struct
37520     {
37521         PTR32 device;
37522         VkImage DECLSPEC_ALIGN(8) image;
37523         PTR32 pSparseMemoryRequirementCount;
37524         PTR32 pSparseMemoryRequirements;
37525     } *params = args;
37526     VkSparseImageMemoryRequirements *pSparseMemoryRequirements_host;
37527     struct conversion_context local_ctx;
37528     struct conversion_context *ctx = &local_ctx;
37529
37530     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37531
37532     init_conversion_context(ctx);
37533     pSparseMemoryRequirements_host = (params->pSparseMemoryRequirements && *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount)) ? conversion_context_alloc(ctx, sizeof(*pSparseMemoryRequirements_host) * *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount)) : NULL;
37534     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);
37535     convert_VkSparseImageMemoryRequirements_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements32 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
37536     free_conversion_context(ctx);
37537     return STATUS_SUCCESS;
37538 }
37539
37540 #ifdef _WIN64
37541 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements2(void *args)
37542 {
37543     struct vkGetImageSparseMemoryRequirements2_params *params = args;
37544
37545     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37546
37547     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37548     return STATUS_SUCCESS;
37549 }
37550 #endif /* _WIN64 */
37551
37552 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements2(void *args)
37553 {
37554     struct
37555     {
37556         PTR32 device;
37557         PTR32 pInfo;
37558         PTR32 pSparseMemoryRequirementCount;
37559         PTR32 pSparseMemoryRequirements;
37560     } *params = args;
37561     VkImageSparseMemoryRequirementsInfo2 pInfo_host;
37562     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
37563     struct conversion_context local_ctx;
37564     struct conversion_context *ctx = &local_ctx;
37565
37566     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37567
37568     init_conversion_context(ctx);
37569     convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host((const VkImageSparseMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
37570     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
37571     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);
37572     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
37573     free_conversion_context(ctx);
37574     return STATUS_SUCCESS;
37575 }
37576
37577 #ifdef _WIN64
37578 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements2KHR(void *args)
37579 {
37580     struct vkGetImageSparseMemoryRequirements2KHR_params *params = args;
37581
37582     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37583
37584     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37585     return STATUS_SUCCESS;
37586 }
37587 #endif /* _WIN64 */
37588
37589 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements2KHR(void *args)
37590 {
37591     struct
37592     {
37593         PTR32 device;
37594         PTR32 pInfo;
37595         PTR32 pSparseMemoryRequirementCount;
37596         PTR32 pSparseMemoryRequirements;
37597     } *params = args;
37598     VkImageSparseMemoryRequirementsInfo2 pInfo_host;
37599     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
37600     struct conversion_context local_ctx;
37601     struct conversion_context *ctx = &local_ctx;
37602
37603     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
37604
37605     init_conversion_context(ctx);
37606     convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host((const VkImageSparseMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
37607     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
37608     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);
37609     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
37610     free_conversion_context(ctx);
37611     return STATUS_SUCCESS;
37612 }
37613
37614 #ifdef _WIN64
37615 static NTSTATUS thunk64_vkGetImageSubresourceLayout(void *args)
37616 {
37617     struct vkGetImageSubresourceLayout_params *params = args;
37618
37619     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
37620
37621     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, params->pLayout);
37622     return STATUS_SUCCESS;
37623 }
37624 #endif /* _WIN64 */
37625
37626 static NTSTATUS thunk32_vkGetImageSubresourceLayout(void *args)
37627 {
37628     struct
37629     {
37630         PTR32 device;
37631         VkImage DECLSPEC_ALIGN(8) image;
37632         PTR32 pSubresource;
37633         PTR32 pLayout;
37634     } *params = args;
37635     VkSubresourceLayout pLayout_host;
37636
37637     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
37638
37639     convert_VkSubresourceLayout_win32_to_host((VkSubresourceLayout32 *)UlongToPtr(params->pLayout), &pLayout_host);
37640     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);
37641     convert_VkSubresourceLayout_host_to_win32(&pLayout_host, (VkSubresourceLayout32 *)UlongToPtr(params->pLayout));
37642     return STATUS_SUCCESS;
37643 }
37644
37645 #ifdef _WIN64
37646 static NTSTATUS thunk64_vkGetImageSubresourceLayout2EXT(void *args)
37647 {
37648     struct vkGetImageSubresourceLayout2EXT_params *params = args;
37649
37650     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
37651
37652     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout2EXT(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, params->pLayout);
37653     return STATUS_SUCCESS;
37654 }
37655 #endif /* _WIN64 */
37656
37657 static NTSTATUS thunk32_vkGetImageSubresourceLayout2EXT(void *args)
37658 {
37659     struct
37660     {
37661         PTR32 device;
37662         VkImage DECLSPEC_ALIGN(8) image;
37663         PTR32 pSubresource;
37664         PTR32 pLayout;
37665     } *params = args;
37666     VkImageSubresource2EXT pSubresource_host;
37667     VkSubresourceLayout2EXT pLayout_host;
37668     struct conversion_context local_ctx;
37669     struct conversion_context *ctx = &local_ctx;
37670
37671     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
37672
37673     init_conversion_context(ctx);
37674     convert_VkImageSubresource2EXT_win32_to_host((const VkImageSubresource2EXT32 *)UlongToPtr(params->pSubresource), &pSubresource_host);
37675     convert_VkSubresourceLayout2EXT_win32_to_host(ctx, (VkSubresourceLayout2EXT32 *)UlongToPtr(params->pLayout), &pLayout_host);
37676     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);
37677     convert_VkSubresourceLayout2EXT_host_to_win32(&pLayout_host, (VkSubresourceLayout2EXT32 *)UlongToPtr(params->pLayout));
37678     free_conversion_context(ctx);
37679     return STATUS_SUCCESS;
37680 }
37681
37682 #ifdef _WIN64
37683 static NTSTATUS thunk64_vkGetImageViewAddressNVX(void *args)
37684 {
37685     struct vkGetImageViewAddressNVX_params *params = args;
37686
37687     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);
37688
37689     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle(params->device)->device, params->imageView, params->pProperties);
37690     return STATUS_SUCCESS;
37691 }
37692 #endif /* _WIN64 */
37693
37694 static NTSTATUS thunk32_vkGetImageViewAddressNVX(void *args)
37695 {
37696     struct
37697     {
37698         PTR32 device;
37699         VkImageView DECLSPEC_ALIGN(8) imageView;
37700         PTR32 pProperties;
37701         VkResult result;
37702     } *params = args;
37703     VkImageViewAddressPropertiesNVX pProperties_host;
37704
37705     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);
37706
37707     convert_VkImageViewAddressPropertiesNVX_win32_to_host((VkImageViewAddressPropertiesNVX32 *)UlongToPtr(params->pProperties), &pProperties_host);
37708     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);
37709     convert_VkImageViewAddressPropertiesNVX_host_to_win32(&pProperties_host, (VkImageViewAddressPropertiesNVX32 *)UlongToPtr(params->pProperties));
37710     return STATUS_SUCCESS;
37711 }
37712
37713 #ifdef _WIN64
37714 static NTSTATUS thunk64_vkGetImageViewHandleNVX(void *args)
37715 {
37716     struct vkGetImageViewHandleNVX_params *params = args;
37717
37718     TRACE("%p, %p\n", params->device, params->pInfo);
37719
37720     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle(params->device)->device, params->pInfo);
37721     return STATUS_SUCCESS;
37722 }
37723 #endif /* _WIN64 */
37724
37725 static NTSTATUS thunk32_vkGetImageViewHandleNVX(void *args)
37726 {
37727     struct
37728     {
37729         PTR32 device;
37730         PTR32 pInfo;
37731         uint32_t result;
37732     } *params = args;
37733     VkImageViewHandleInfoNVX pInfo_host;
37734
37735     TRACE("%#x, %#x\n", params->device, params->pInfo);
37736
37737     convert_VkImageViewHandleInfoNVX_win32_to_host((const VkImageViewHandleInfoNVX32 *)UlongToPtr(params->pInfo), &pInfo_host);
37738     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
37739     return STATUS_SUCCESS;
37740 }
37741
37742 #ifdef _WIN64
37743 static NTSTATUS thunk64_vkGetImageViewOpaqueCaptureDescriptorDataEXT(void *args)
37744 {
37745     struct vkGetImageViewOpaqueCaptureDescriptorDataEXT_params *params = args;
37746
37747     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
37748
37749     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
37750     return STATUS_SUCCESS;
37751 }
37752 #endif /* _WIN64 */
37753
37754 static NTSTATUS thunk32_vkGetImageViewOpaqueCaptureDescriptorDataEXT(void *args)
37755 {
37756     struct
37757     {
37758         PTR32 device;
37759         PTR32 pInfo;
37760         PTR32 pData;
37761         VkResult result;
37762     } *params = args;
37763     VkImageViewCaptureDescriptorDataInfoEXT pInfo_host;
37764
37765     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
37766
37767     convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host((const VkImageViewCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
37768     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));
37769     return STATUS_SUCCESS;
37770 }
37771
37772 #ifdef _WIN64
37773 static NTSTATUS thunk64_vkGetMemoryHostPointerPropertiesEXT(void *args)
37774 {
37775     struct vkGetMemoryHostPointerPropertiesEXT_params *params = args;
37776
37777     TRACE("%p, %#x, %p, %p\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
37778
37779     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle(params->device)->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
37780     return STATUS_SUCCESS;
37781 }
37782 #endif /* _WIN64 */
37783
37784 static NTSTATUS thunk32_vkGetMemoryHostPointerPropertiesEXT(void *args)
37785 {
37786     struct
37787     {
37788         PTR32 device;
37789         VkExternalMemoryHandleTypeFlagBits handleType;
37790         PTR32 pHostPointer;
37791         PTR32 pMemoryHostPointerProperties;
37792         VkResult result;
37793     } *params = args;
37794     VkMemoryHostPointerPropertiesEXT pMemoryHostPointerProperties_host;
37795
37796     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
37797
37798     convert_VkMemoryHostPointerPropertiesEXT_win32_to_host((VkMemoryHostPointerPropertiesEXT32 *)UlongToPtr(params->pMemoryHostPointerProperties), &pMemoryHostPointerProperties_host);
37799     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);
37800     convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(&pMemoryHostPointerProperties_host, (VkMemoryHostPointerPropertiesEXT32 *)UlongToPtr(params->pMemoryHostPointerProperties));
37801     return STATUS_SUCCESS;
37802 }
37803
37804 #ifdef _WIN64
37805 static NTSTATUS thunk64_vkGetMicromapBuildSizesEXT(void *args)
37806 {
37807     struct vkGetMicromapBuildSizesEXT_params *params = args;
37808
37809     TRACE("%p, %#x, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
37810
37811     wine_device_from_handle(params->device)->funcs.p_vkGetMicromapBuildSizesEXT(wine_device_from_handle(params->device)->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
37812     return STATUS_SUCCESS;
37813 }
37814 #endif /* _WIN64 */
37815
37816 static NTSTATUS thunk32_vkGetMicromapBuildSizesEXT(void *args)
37817 {
37818     struct
37819     {
37820         PTR32 device;
37821         VkAccelerationStructureBuildTypeKHR buildType;
37822         PTR32 pBuildInfo;
37823         PTR32 pSizeInfo;
37824     } *params = args;
37825     VkMicromapBuildInfoEXT pBuildInfo_host;
37826     VkMicromapBuildSizesInfoEXT pSizeInfo_host;
37827     struct conversion_context local_ctx;
37828     struct conversion_context *ctx = &local_ctx;
37829
37830     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
37831
37832     init_conversion_context(ctx);
37833     convert_VkMicromapBuildInfoEXT_win32_to_host(ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pBuildInfo), &pBuildInfo_host);
37834     convert_VkMicromapBuildSizesInfoEXT_win32_to_host((VkMicromapBuildSizesInfoEXT32 *)UlongToPtr(params->pSizeInfo), &pSizeInfo_host);
37835     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);
37836     convert_VkMicromapBuildSizesInfoEXT_host_to_win32(&pSizeInfo_host, (VkMicromapBuildSizesInfoEXT32 *)UlongToPtr(params->pSizeInfo));
37837     free_conversion_context(ctx);
37838     return STATUS_SUCCESS;
37839 }
37840
37841 #ifdef _WIN64
37842 static NTSTATUS thunk64_vkGetPerformanceParameterINTEL(void *args)
37843 {
37844     struct vkGetPerformanceParameterINTEL_params *params = args;
37845
37846     TRACE("%p, %#x, %p\n", params->device, params->parameter, params->pValue);
37847
37848     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle(params->device)->device, params->parameter, params->pValue);
37849     return STATUS_SUCCESS;
37850 }
37851 #endif /* _WIN64 */
37852
37853 static NTSTATUS thunk32_vkGetPerformanceParameterINTEL(void *args)
37854 {
37855     struct
37856     {
37857         PTR32 device;
37858         VkPerformanceParameterTypeINTEL parameter;
37859         PTR32 pValue;
37860         VkResult result;
37861     } *params = args;
37862     VkPerformanceValueINTEL pValue_host;
37863
37864     TRACE("%#x, %#x, %#x\n", params->device, params->parameter, params->pValue);
37865
37866     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);
37867     convert_VkPerformanceValueINTEL_host_to_win32(&pValue_host, (VkPerformanceValueINTEL32 *)UlongToPtr(params->pValue));
37868     return STATUS_SUCCESS;
37869 }
37870
37871 #ifdef _WIN64
37872 static NTSTATUS thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
37873 {
37874     struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params *params = args;
37875
37876     TRACE("%p, %p, %p\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
37877
37878     params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
37879     return STATUS_SUCCESS;
37880 }
37881 #endif /* _WIN64 */
37882
37883 static NTSTATUS thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
37884 {
37885     struct
37886     {
37887         PTR32 physicalDevice;
37888         PTR32 pTimeDomainCount;
37889         PTR32 pTimeDomains;
37890         VkResult result;
37891     } *params = args;
37892
37893     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
37894
37895     params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (uint32_t *)UlongToPtr(params->pTimeDomainCount), (VkTimeDomainEXT *)UlongToPtr(params->pTimeDomains));
37896     return STATUS_SUCCESS;
37897 }
37898
37899 #ifdef _WIN64
37900 static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
37901 {
37902     struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params *params = args;
37903
37904     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
37905
37906     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);
37907     return STATUS_SUCCESS;
37908 }
37909 #endif /* _WIN64 */
37910
37911 static NTSTATUS thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
37912 {
37913     struct
37914     {
37915         PTR32 physicalDevice;
37916         PTR32 pPropertyCount;
37917         PTR32 pProperties;
37918         VkResult result;
37919     } *params = args;
37920     VkCooperativeMatrixPropertiesNV *pProperties_host;
37921     struct conversion_context local_ctx;
37922     struct conversion_context *ctx = &local_ctx;
37923
37924     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
37925
37926     init_conversion_context(ctx);
37927     pProperties_host = convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(ctx, (VkCooperativeMatrixPropertiesNV32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
37928     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);
37929     convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(pProperties_host, (VkCooperativeMatrixPropertiesNV32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
37930     free_conversion_context(ctx);
37931     return STATUS_SUCCESS;
37932 }
37933
37934 #ifdef _WIN64
37935 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalBufferProperties(void *args)
37936 {
37937     struct vkGetPhysicalDeviceExternalBufferProperties_params *params = args;
37938
37939     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37940
37941     wine_vkGetPhysicalDeviceExternalBufferProperties(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37942     return STATUS_SUCCESS;
37943 }
37944 #endif /* _WIN64 */
37945
37946 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferProperties(void *args)
37947 {
37948     struct
37949     {
37950         PTR32 physicalDevice;
37951         PTR32 pExternalBufferInfo;
37952         PTR32 pExternalBufferProperties;
37953     } *params = args;
37954     VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo_host;
37955     VkExternalBufferProperties pExternalBufferProperties_host;
37956
37957     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37958
37959     convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host((const VkPhysicalDeviceExternalBufferInfo32 *)UlongToPtr(params->pExternalBufferInfo), &pExternalBufferInfo_host);
37960     convert_VkExternalBufferProperties_win32_to_host((VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties), &pExternalBufferProperties_host);
37961     wine_vkGetPhysicalDeviceExternalBufferProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalBufferInfo_host, &pExternalBufferProperties_host);
37962     convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, (VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties));
37963     return STATUS_SUCCESS;
37964 }
37965
37966 #ifdef _WIN64
37967 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args)
37968 {
37969     struct vkGetPhysicalDeviceExternalBufferPropertiesKHR_params *params = args;
37970
37971     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37972
37973     wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37974     return STATUS_SUCCESS;
37975 }
37976 #endif /* _WIN64 */
37977
37978 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args)
37979 {
37980     struct
37981     {
37982         PTR32 physicalDevice;
37983         PTR32 pExternalBufferInfo;
37984         PTR32 pExternalBufferProperties;
37985     } *params = args;
37986     VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo_host;
37987     VkExternalBufferProperties pExternalBufferProperties_host;
37988
37989     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37990
37991     convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host((const VkPhysicalDeviceExternalBufferInfo32 *)UlongToPtr(params->pExternalBufferInfo), &pExternalBufferInfo_host);
37992     convert_VkExternalBufferProperties_win32_to_host((VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties), &pExternalBufferProperties_host);
37993     wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalBufferInfo_host, &pExternalBufferProperties_host);
37994     convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, (VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties));
37995     return STATUS_SUCCESS;
37996 }
37997
37998 #ifdef _WIN64
37999 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalFenceProperties(void *args)
38000 {
38001     struct vkGetPhysicalDeviceExternalFenceProperties_params *params = args;
38002
38003     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
38004
38005     wine_vkGetPhysicalDeviceExternalFenceProperties(params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
38006     return STATUS_SUCCESS;
38007 }
38008 #endif /* _WIN64 */
38009
38010 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalFenceProperties(void *args)
38011 {
38012     struct
38013     {
38014         PTR32 physicalDevice;
38015         PTR32 pExternalFenceInfo;
38016         PTR32 pExternalFenceProperties;
38017     } *params = args;
38018     VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo_host;
38019     VkExternalFenceProperties pExternalFenceProperties_host;
38020
38021     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
38022
38023     convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host((const VkPhysicalDeviceExternalFenceInfo32 *)UlongToPtr(params->pExternalFenceInfo), &pExternalFenceInfo_host);
38024     convert_VkExternalFenceProperties_win32_to_host((VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties), &pExternalFenceProperties_host);
38025     wine_vkGetPhysicalDeviceExternalFenceProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalFenceInfo_host, &pExternalFenceProperties_host);
38026     convert_VkExternalFenceProperties_host_to_win32(&pExternalFenceProperties_host, (VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties));
38027     return STATUS_SUCCESS;
38028 }
38029
38030 #ifdef _WIN64
38031 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args)
38032 {
38033     struct vkGetPhysicalDeviceExternalFencePropertiesKHR_params *params = args;
38034
38035     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
38036
38037     wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
38038     return STATUS_SUCCESS;
38039 }
38040 #endif /* _WIN64 */
38041
38042 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args)
38043 {
38044     struct
38045     {
38046         PTR32 physicalDevice;
38047         PTR32 pExternalFenceInfo;
38048         PTR32 pExternalFenceProperties;
38049     } *params = args;
38050     VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo_host;
38051     VkExternalFenceProperties pExternalFenceProperties_host;
38052
38053     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
38054
38055     convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host((const VkPhysicalDeviceExternalFenceInfo32 *)UlongToPtr(params->pExternalFenceInfo), &pExternalFenceInfo_host);
38056     convert_VkExternalFenceProperties_win32_to_host((VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties), &pExternalFenceProperties_host);
38057     wine_vkGetPhysicalDeviceExternalFencePropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalFenceInfo_host, &pExternalFenceProperties_host);
38058     convert_VkExternalFenceProperties_host_to_win32(&pExternalFenceProperties_host, (VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties));
38059     return STATUS_SUCCESS;
38060 }
38061
38062 #ifdef _WIN64
38063 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalSemaphoreProperties(void *args)
38064 {
38065     struct vkGetPhysicalDeviceExternalSemaphoreProperties_params *params = args;
38066
38067     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
38068
38069     wine_vkGetPhysicalDeviceExternalSemaphoreProperties(params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
38070     return STATUS_SUCCESS;
38071 }
38072 #endif /* _WIN64 */
38073
38074 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphoreProperties(void *args)
38075 {
38076     struct
38077     {
38078         PTR32 physicalDevice;
38079         PTR32 pExternalSemaphoreInfo;
38080         PTR32 pExternalSemaphoreProperties;
38081     } *params = args;
38082     VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo_host;
38083     VkExternalSemaphoreProperties pExternalSemaphoreProperties_host;
38084     struct conversion_context local_ctx;
38085     struct conversion_context *ctx = &local_ctx;
38086
38087     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
38088
38089     init_conversion_context(ctx);
38090     convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(ctx, (const VkPhysicalDeviceExternalSemaphoreInfo32 *)UlongToPtr(params->pExternalSemaphoreInfo), &pExternalSemaphoreInfo_host);
38091     convert_VkExternalSemaphoreProperties_win32_to_host((VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties), &pExternalSemaphoreProperties_host);
38092     wine_vkGetPhysicalDeviceExternalSemaphoreProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalSemaphoreInfo_host, &pExternalSemaphoreProperties_host);
38093     convert_VkExternalSemaphoreProperties_host_to_win32(&pExternalSemaphoreProperties_host, (VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties));
38094     free_conversion_context(ctx);
38095     return STATUS_SUCCESS;
38096 }
38097
38098 #ifdef _WIN64
38099 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *args)
38100 {
38101     struct vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_params *params = args;
38102
38103     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
38104
38105     wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
38106     return STATUS_SUCCESS;
38107 }
38108 #endif /* _WIN64 */
38109
38110 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *args)
38111 {
38112     struct
38113     {
38114         PTR32 physicalDevice;
38115         PTR32 pExternalSemaphoreInfo;
38116         PTR32 pExternalSemaphoreProperties;
38117     } *params = args;
38118     VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo_host;
38119     VkExternalSemaphoreProperties pExternalSemaphoreProperties_host;
38120     struct conversion_context local_ctx;
38121     struct conversion_context *ctx = &local_ctx;
38122
38123     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
38124
38125     init_conversion_context(ctx);
38126     convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(ctx, (const VkPhysicalDeviceExternalSemaphoreInfo32 *)UlongToPtr(params->pExternalSemaphoreInfo), &pExternalSemaphoreInfo_host);
38127     convert_VkExternalSemaphoreProperties_win32_to_host((VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties), &pExternalSemaphoreProperties_host);
38128     wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalSemaphoreInfo_host, &pExternalSemaphoreProperties_host);
38129     convert_VkExternalSemaphoreProperties_host_to_win32(&pExternalSemaphoreProperties_host, (VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties));
38130     free_conversion_context(ctx);
38131     return STATUS_SUCCESS;
38132 }
38133
38134 #ifdef _WIN64
38135 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures(void *args)
38136 {
38137     struct vkGetPhysicalDeviceFeatures_params *params = args;
38138
38139     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
38140
38141     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
38142     return STATUS_SUCCESS;
38143 }
38144 #endif /* _WIN64 */
38145
38146 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures(void *args)
38147 {
38148     struct
38149     {
38150         PTR32 physicalDevice;
38151         PTR32 pFeatures;
38152     } *params = args;
38153
38154     TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);
38155
38156     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));
38157     return STATUS_SUCCESS;
38158 }
38159
38160 #ifdef _WIN64
38161 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures2(void *args)
38162 {
38163     struct vkGetPhysicalDeviceFeatures2_params *params = args;
38164
38165     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
38166
38167     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
38168     return STATUS_SUCCESS;
38169 }
38170 #endif /* _WIN64 */
38171
38172 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures2(void *args)
38173 {
38174     struct
38175     {
38176         PTR32 physicalDevice;
38177         PTR32 pFeatures;
38178     } *params = args;
38179     VkPhysicalDeviceFeatures2 pFeatures_host;
38180     struct conversion_context local_ctx;
38181     struct conversion_context *ctx = &local_ctx;
38182
38183     TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);
38184
38185     init_conversion_context(ctx);
38186     convert_VkPhysicalDeviceFeatures2_win32_to_host(ctx, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures), &pFeatures_host);
38187     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);
38188     convert_VkPhysicalDeviceFeatures2_host_to_win32(&pFeatures_host, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures));
38189     free_conversion_context(ctx);
38190     return STATUS_SUCCESS;
38191 }
38192
38193 #ifdef _WIN64
38194 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures2KHR(void *args)
38195 {
38196     struct vkGetPhysicalDeviceFeatures2KHR_params *params = args;
38197
38198     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
38199
38200     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
38201     return STATUS_SUCCESS;
38202 }
38203 #endif /* _WIN64 */
38204
38205 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures2KHR(void *args)
38206 {
38207     struct
38208     {
38209         PTR32 physicalDevice;
38210         PTR32 pFeatures;
38211     } *params = args;
38212     VkPhysicalDeviceFeatures2 pFeatures_host;
38213     struct conversion_context local_ctx;
38214     struct conversion_context *ctx = &local_ctx;
38215
38216     TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);
38217
38218     init_conversion_context(ctx);
38219     convert_VkPhysicalDeviceFeatures2_win32_to_host(ctx, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures), &pFeatures_host);
38220     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);
38221     convert_VkPhysicalDeviceFeatures2_host_to_win32(&pFeatures_host, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures));
38222     free_conversion_context(ctx);
38223     return STATUS_SUCCESS;
38224 }
38225
38226 #ifdef _WIN64
38227 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties(void *args)
38228 {
38229     struct vkGetPhysicalDeviceFormatProperties_params *params = args;
38230
38231     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
38232
38233     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
38234     return STATUS_SUCCESS;
38235 }
38236 #endif /* _WIN64 */
38237
38238 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties(void *args)
38239 {
38240     struct
38241     {
38242         PTR32 physicalDevice;
38243         VkFormat format;
38244         PTR32 pFormatProperties;
38245     } *params = args;
38246
38247     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);
38248
38249     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));
38250     return STATUS_SUCCESS;
38251 }
38252
38253 #ifdef _WIN64
38254 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties2(void *args)
38255 {
38256     struct vkGetPhysicalDeviceFormatProperties2_params *params = args;
38257
38258     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
38259
38260     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
38261     return STATUS_SUCCESS;
38262 }
38263 #endif /* _WIN64 */
38264
38265 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2(void *args)
38266 {
38267     struct
38268     {
38269         PTR32 physicalDevice;
38270         VkFormat format;
38271         PTR32 pFormatProperties;
38272     } *params = args;
38273     VkFormatProperties2 pFormatProperties_host;
38274     struct conversion_context local_ctx;
38275     struct conversion_context *ctx = &local_ctx;
38276
38277     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);
38278
38279     init_conversion_context(ctx);
38280     convert_VkFormatProperties2_win32_to_host(ctx, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties), &pFormatProperties_host);
38281     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);
38282     convert_VkFormatProperties2_host_to_win32(&pFormatProperties_host, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties));
38283     free_conversion_context(ctx);
38284     return STATUS_SUCCESS;
38285 }
38286
38287 #ifdef _WIN64
38288 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties2KHR(void *args)
38289 {
38290     struct vkGetPhysicalDeviceFormatProperties2KHR_params *params = args;
38291
38292     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
38293
38294     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
38295     return STATUS_SUCCESS;
38296 }
38297 #endif /* _WIN64 */
38298
38299 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2KHR(void *args)
38300 {
38301     struct
38302     {
38303         PTR32 physicalDevice;
38304         VkFormat format;
38305         PTR32 pFormatProperties;
38306     } *params = args;
38307     VkFormatProperties2 pFormatProperties_host;
38308     struct conversion_context local_ctx;
38309     struct conversion_context *ctx = &local_ctx;
38310
38311     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);
38312
38313     init_conversion_context(ctx);
38314     convert_VkFormatProperties2_win32_to_host(ctx, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties), &pFormatProperties_host);
38315     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);
38316     convert_VkFormatProperties2_host_to_win32(&pFormatProperties_host, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties));
38317     free_conversion_context(ctx);
38318     return STATUS_SUCCESS;
38319 }
38320
38321 #ifdef _WIN64
38322 static NTSTATUS thunk64_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
38323 {
38324     struct vkGetPhysicalDeviceFragmentShadingRatesKHR_params *params = args;
38325
38326     TRACE("%p, %p, %p\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
38327
38328     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);
38329     return STATUS_SUCCESS;
38330 }
38331 #endif /* _WIN64 */
38332
38333 static NTSTATUS thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
38334 {
38335     struct
38336     {
38337         PTR32 physicalDevice;
38338         PTR32 pFragmentShadingRateCount;
38339         PTR32 pFragmentShadingRates;
38340         VkResult result;
38341     } *params = args;
38342     VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates_host;
38343     struct conversion_context local_ctx;
38344     struct conversion_context *ctx = &local_ctx;
38345
38346     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
38347
38348     init_conversion_context(ctx);
38349     pFragmentShadingRates_host = convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(ctx, (VkPhysicalDeviceFragmentShadingRateKHR32 *)UlongToPtr(params->pFragmentShadingRates), *(uint32_t *)UlongToPtr(params->pFragmentShadingRateCount));
38350     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);
38351     convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(pFragmentShadingRates_host, (VkPhysicalDeviceFragmentShadingRateKHR32 *)UlongToPtr(params->pFragmentShadingRates), *(uint32_t *)UlongToPtr(params->pFragmentShadingRateCount));
38352     free_conversion_context(ctx);
38353     return STATUS_SUCCESS;
38354 }
38355
38356 #ifdef _WIN64
38357 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties(void *args)
38358 {
38359     struct vkGetPhysicalDeviceImageFormatProperties_params *params = args;
38360
38361     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
38362
38363     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);
38364     return STATUS_SUCCESS;
38365 }
38366 #endif /* _WIN64 */
38367
38368 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties(void *args)
38369 {
38370     struct
38371     {
38372         PTR32 physicalDevice;
38373         VkFormat format;
38374         VkImageType type;
38375         VkImageTiling tiling;
38376         VkImageUsageFlags usage;
38377         VkImageCreateFlags flags;
38378         PTR32 pImageFormatProperties;
38379         VkResult result;
38380     } *params = args;
38381     VkImageFormatProperties pImageFormatProperties_host;
38382
38383     TRACE("%#x, %#x, %#x, %#x, %#x, %#x, %#x\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
38384
38385     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);
38386     convert_VkImageFormatProperties_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties32 *)UlongToPtr(params->pImageFormatProperties));
38387     return STATUS_SUCCESS;
38388 }
38389
38390 #ifdef _WIN64
38391 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2(void *args)
38392 {
38393     struct vkGetPhysicalDeviceImageFormatProperties2_params *params = args;
38394
38395     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
38396
38397     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
38398     return STATUS_SUCCESS;
38399 }
38400 #endif /* _WIN64 */
38401
38402 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2(void *args)
38403 {
38404     struct
38405     {
38406         PTR32 physicalDevice;
38407         PTR32 pImageFormatInfo;
38408         PTR32 pImageFormatProperties;
38409         VkResult result;
38410     } *params = args;
38411     VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo_host;
38412     VkImageFormatProperties2 pImageFormatProperties_host;
38413     struct conversion_context local_ctx;
38414     struct conversion_context *ctx = &local_ctx;
38415
38416     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
38417
38418     init_conversion_context(ctx);
38419     convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(ctx, (const VkPhysicalDeviceImageFormatInfo232 *)UlongToPtr(params->pImageFormatInfo), &pImageFormatInfo_host);
38420     convert_VkImageFormatProperties2_win32_to_host(ctx, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties), &pImageFormatProperties_host);
38421     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pImageFormatInfo_host, &pImageFormatProperties_host);
38422     convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties));
38423     free_conversion_context(ctx);
38424     return STATUS_SUCCESS;
38425 }
38426
38427 #ifdef _WIN64
38428 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
38429 {
38430     struct vkGetPhysicalDeviceImageFormatProperties2KHR_params *params = args;
38431
38432     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
38433
38434     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
38435     return STATUS_SUCCESS;
38436 }
38437 #endif /* _WIN64 */
38438
38439 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
38440 {
38441     struct
38442     {
38443         PTR32 physicalDevice;
38444         PTR32 pImageFormatInfo;
38445         PTR32 pImageFormatProperties;
38446         VkResult result;
38447     } *params = args;
38448     VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo_host;
38449     VkImageFormatProperties2 pImageFormatProperties_host;
38450     struct conversion_context local_ctx;
38451     struct conversion_context *ctx = &local_ctx;
38452
38453     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
38454
38455     init_conversion_context(ctx);
38456     convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(ctx, (const VkPhysicalDeviceImageFormatInfo232 *)UlongToPtr(params->pImageFormatInfo), &pImageFormatInfo_host);
38457     convert_VkImageFormatProperties2_win32_to_host(ctx, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties), &pImageFormatProperties_host);
38458     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pImageFormatInfo_host, &pImageFormatProperties_host);
38459     convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties));
38460     free_conversion_context(ctx);
38461     return STATUS_SUCCESS;
38462 }
38463
38464 #ifdef _WIN64
38465 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties(void *args)
38466 {
38467     struct vkGetPhysicalDeviceMemoryProperties_params *params = args;
38468
38469     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
38470
38471     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
38472     return STATUS_SUCCESS;
38473 }
38474 #endif /* _WIN64 */
38475
38476 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties(void *args)
38477 {
38478     struct
38479     {
38480         PTR32 physicalDevice;
38481         PTR32 pMemoryProperties;
38482     } *params = args;
38483     VkPhysicalDeviceMemoryProperties pMemoryProperties_host;
38484
38485     TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);
38486
38487     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);
38488     convert_VkPhysicalDeviceMemoryProperties_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties32 *)UlongToPtr(params->pMemoryProperties));
38489     return STATUS_SUCCESS;
38490 }
38491
38492 #ifdef _WIN64
38493 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties2(void *args)
38494 {
38495     struct vkGetPhysicalDeviceMemoryProperties2_params *params = args;
38496
38497     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
38498
38499     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
38500     return STATUS_SUCCESS;
38501 }
38502 #endif /* _WIN64 */
38503
38504 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties2(void *args)
38505 {
38506     struct
38507     {
38508         PTR32 physicalDevice;
38509         PTR32 pMemoryProperties;
38510     } *params = args;
38511     VkPhysicalDeviceMemoryProperties2 pMemoryProperties_host;
38512     struct conversion_context local_ctx;
38513     struct conversion_context *ctx = &local_ctx;
38514
38515     TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);
38516
38517     init_conversion_context(ctx);
38518     convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(ctx, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties), &pMemoryProperties_host);
38519     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);
38520     convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties));
38521     free_conversion_context(ctx);
38522     return STATUS_SUCCESS;
38523 }
38524
38525 #ifdef _WIN64
38526 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties2KHR(void *args)
38527 {
38528     struct vkGetPhysicalDeviceMemoryProperties2KHR_params *params = args;
38529
38530     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
38531
38532     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
38533     return STATUS_SUCCESS;
38534 }
38535 #endif /* _WIN64 */
38536
38537 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties2KHR(void *args)
38538 {
38539     struct
38540     {
38541         PTR32 physicalDevice;
38542         PTR32 pMemoryProperties;
38543     } *params = args;
38544     VkPhysicalDeviceMemoryProperties2 pMemoryProperties_host;
38545     struct conversion_context local_ctx;
38546     struct conversion_context *ctx = &local_ctx;
38547
38548     TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);
38549
38550     init_conversion_context(ctx);
38551     convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(ctx, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties), &pMemoryProperties_host);
38552     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);
38553     convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties));
38554     free_conversion_context(ctx);
38555     return STATUS_SUCCESS;
38556 }
38557
38558 #ifdef _WIN64
38559 static NTSTATUS thunk64_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)
38560 {
38561     struct vkGetPhysicalDeviceMultisamplePropertiesEXT_params *params = args;
38562
38563     TRACE("%p, %#x, %p\n", params->physicalDevice, params->samples, params->pMultisampleProperties);
38564
38565     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->samples, params->pMultisampleProperties);
38566     return STATUS_SUCCESS;
38567 }
38568 #endif /* _WIN64 */
38569
38570 static NTSTATUS thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)
38571 {
38572     struct
38573     {
38574         PTR32 physicalDevice;
38575         VkSampleCountFlagBits samples;
38576         PTR32 pMultisampleProperties;
38577     } *params = args;
38578     VkMultisamplePropertiesEXT pMultisampleProperties_host;
38579
38580     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->samples, params->pMultisampleProperties);
38581
38582     convert_VkMultisamplePropertiesEXT_win32_to_host((VkMultisamplePropertiesEXT32 *)UlongToPtr(params->pMultisampleProperties), &pMultisampleProperties_host);
38583     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);
38584     convert_VkMultisamplePropertiesEXT_host_to_win32(&pMultisampleProperties_host, (VkMultisamplePropertiesEXT32 *)UlongToPtr(params->pMultisampleProperties));
38585     return STATUS_SUCCESS;
38586 }
38587
38588 #ifdef _WIN64
38589 static NTSTATUS thunk64_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
38590 {
38591     struct vkGetPhysicalDeviceOpticalFlowImageFormatsNV_params *params = args;
38592
38593     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
38594
38595     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);
38596     return STATUS_SUCCESS;
38597 }
38598 #endif /* _WIN64 */
38599
38600 static NTSTATUS thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
38601 {
38602     struct
38603     {
38604         PTR32 physicalDevice;
38605         PTR32 pOpticalFlowImageFormatInfo;
38606         PTR32 pFormatCount;
38607         PTR32 pImageFormatProperties;
38608         VkResult result;
38609     } *params = args;
38610     VkOpticalFlowImageFormatInfoNV pOpticalFlowImageFormatInfo_host;
38611     VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties_host;
38612     struct conversion_context local_ctx;
38613     struct conversion_context *ctx = &local_ctx;
38614
38615     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
38616
38617     init_conversion_context(ctx);
38618     convert_VkOpticalFlowImageFormatInfoNV_win32_to_host((const VkOpticalFlowImageFormatInfoNV32 *)UlongToPtr(params->pOpticalFlowImageFormatInfo), &pOpticalFlowImageFormatInfo_host);
38619     pImageFormatProperties_host = convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(ctx, (VkOpticalFlowImageFormatPropertiesNV32 *)UlongToPtr(params->pImageFormatProperties), *(uint32_t *)UlongToPtr(params->pFormatCount));
38620     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);
38621     convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(pImageFormatProperties_host, (VkOpticalFlowImageFormatPropertiesNV32 *)UlongToPtr(params->pImageFormatProperties), *(uint32_t *)UlongToPtr(params->pFormatCount));
38622     free_conversion_context(ctx);
38623     return STATUS_SUCCESS;
38624 }
38625
38626 #ifdef _WIN64
38627 static NTSTATUS thunk64_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
38628 {
38629     struct vkGetPhysicalDevicePresentRectanglesKHR_params *params = args;
38630
38631     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);
38632
38633     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);
38634     return STATUS_SUCCESS;
38635 }
38636 #endif /* _WIN64 */
38637
38638 static NTSTATUS thunk32_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
38639 {
38640     struct
38641     {
38642         PTR32 physicalDevice;
38643         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
38644         PTR32 pRectCount;
38645         PTR32 pRects;
38646         VkResult result;
38647     } *params = args;
38648
38649     TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);
38650
38651     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));
38652     return STATUS_SUCCESS;
38653 }
38654
38655 #ifdef _WIN64
38656 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties(void *args)
38657 {
38658     struct vkGetPhysicalDeviceProperties_params *params = args;
38659
38660     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
38661
38662     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
38663     return STATUS_SUCCESS;
38664 }
38665 #endif /* _WIN64 */
38666
38667 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties(void *args)
38668 {
38669     struct
38670     {
38671         PTR32 physicalDevice;
38672         PTR32 pProperties;
38673     } *params = args;
38674     VkPhysicalDeviceProperties pProperties_host;
38675
38676     TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);
38677
38678     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);
38679     convert_VkPhysicalDeviceProperties_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties32 *)UlongToPtr(params->pProperties));
38680     return STATUS_SUCCESS;
38681 }
38682
38683 #ifdef _WIN64
38684 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties2(void *args)
38685 {
38686     struct vkGetPhysicalDeviceProperties2_params *params = args;
38687
38688     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
38689
38690     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
38691     return STATUS_SUCCESS;
38692 }
38693 #endif /* _WIN64 */
38694
38695 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2(void *args)
38696 {
38697     struct
38698     {
38699         PTR32 physicalDevice;
38700         PTR32 pProperties;
38701     } *params = args;
38702     VkPhysicalDeviceProperties2 pProperties_host;
38703     struct conversion_context local_ctx;
38704     struct conversion_context *ctx = &local_ctx;
38705
38706     TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);
38707
38708     init_conversion_context(ctx);
38709     convert_VkPhysicalDeviceProperties2_win32_to_host(ctx, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties), &pProperties_host);
38710     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);
38711     convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties));
38712     free_conversion_context(ctx);
38713     return STATUS_SUCCESS;
38714 }
38715
38716 #ifdef _WIN64
38717 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties2KHR(void *args)
38718 {
38719     struct vkGetPhysicalDeviceProperties2KHR_params *params = args;
38720
38721     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
38722
38723     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
38724     return STATUS_SUCCESS;
38725 }
38726 #endif /* _WIN64 */
38727
38728 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2KHR(void *args)
38729 {
38730     struct
38731     {
38732         PTR32 physicalDevice;
38733         PTR32 pProperties;
38734     } *params = args;
38735     VkPhysicalDeviceProperties2 pProperties_host;
38736     struct conversion_context local_ctx;
38737     struct conversion_context *ctx = &local_ctx;
38738
38739     TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);
38740
38741     init_conversion_context(ctx);
38742     convert_VkPhysicalDeviceProperties2_win32_to_host(ctx, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties), &pProperties_host);
38743     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);
38744     convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties));
38745     free_conversion_context(ctx);
38746     return STATUS_SUCCESS;
38747 }
38748
38749 #ifdef _WIN64
38750 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(void *args)
38751 {
38752     struct vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_params *params = args;
38753
38754     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPerformanceQueryCreateInfo, params->pNumPasses);
38755
38756     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPerformanceQueryCreateInfo, params->pNumPasses);
38757     return STATUS_SUCCESS;
38758 }
38759 #endif /* _WIN64 */
38760
38761 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(void *args)
38762 {
38763     struct
38764     {
38765         PTR32 physicalDevice;
38766         PTR32 pPerformanceQueryCreateInfo;
38767         PTR32 pNumPasses;
38768     } *params = args;
38769     VkQueryPoolPerformanceCreateInfoKHR pPerformanceQueryCreateInfo_host;
38770
38771     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPerformanceQueryCreateInfo, params->pNumPasses);
38772
38773     convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host((const VkQueryPoolPerformanceCreateInfoKHR32 *)UlongToPtr(params->pPerformanceQueryCreateInfo), &pPerformanceQueryCreateInfo_host);
38774     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));
38775     return STATUS_SUCCESS;
38776 }
38777
38778 #ifdef _WIN64
38779 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties(void *args)
38780 {
38781     struct vkGetPhysicalDeviceQueueFamilyProperties_params *params = args;
38782
38783     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38784
38785     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38786     return STATUS_SUCCESS;
38787 }
38788 #endif /* _WIN64 */
38789
38790 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties(void *args)
38791 {
38792     struct
38793     {
38794         PTR32 physicalDevice;
38795         PTR32 pQueueFamilyPropertyCount;
38796         PTR32 pQueueFamilyProperties;
38797     } *params = args;
38798
38799     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38800
38801     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));
38802     return STATUS_SUCCESS;
38803 }
38804
38805 #ifdef _WIN64
38806 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties2(void *args)
38807 {
38808     struct vkGetPhysicalDeviceQueueFamilyProperties2_params *params = args;
38809
38810     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38811
38812     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38813     return STATUS_SUCCESS;
38814 }
38815 #endif /* _WIN64 */
38816
38817 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties2(void *args)
38818 {
38819     struct
38820     {
38821         PTR32 physicalDevice;
38822         PTR32 pQueueFamilyPropertyCount;
38823         PTR32 pQueueFamilyProperties;
38824     } *params = args;
38825     VkQueueFamilyProperties2 *pQueueFamilyProperties_host;
38826     struct conversion_context local_ctx;
38827     struct conversion_context *ctx = &local_ctx;
38828
38829     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38830
38831     init_conversion_context(ctx);
38832     pQueueFamilyProperties_host = convert_VkQueueFamilyProperties2_array_win32_to_host(ctx, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
38833     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);
38834     convert_VkQueueFamilyProperties2_array_host_to_win32(pQueueFamilyProperties_host, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
38835     free_conversion_context(ctx);
38836     return STATUS_SUCCESS;
38837 }
38838
38839 #ifdef _WIN64
38840 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties2KHR(void *args)
38841 {
38842     struct vkGetPhysicalDeviceQueueFamilyProperties2KHR_params *params = args;
38843
38844     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38845
38846     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38847     return STATUS_SUCCESS;
38848 }
38849 #endif /* _WIN64 */
38850
38851 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties2KHR(void *args)
38852 {
38853     struct
38854     {
38855         PTR32 physicalDevice;
38856         PTR32 pQueueFamilyPropertyCount;
38857         PTR32 pQueueFamilyProperties;
38858     } *params = args;
38859     VkQueueFamilyProperties2 *pQueueFamilyProperties_host;
38860     struct conversion_context local_ctx;
38861     struct conversion_context *ctx = &local_ctx;
38862
38863     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38864
38865     init_conversion_context(ctx);
38866     pQueueFamilyProperties_host = convert_VkQueueFamilyProperties2_array_win32_to_host(ctx, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
38867     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);
38868     convert_VkQueueFamilyProperties2_array_host_to_win32(pQueueFamilyProperties_host, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
38869     free_conversion_context(ctx);
38870     return STATUS_SUCCESS;
38871 }
38872
38873 #ifdef _WIN64
38874 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties(void *args)
38875 {
38876     struct vkGetPhysicalDeviceSparseImageFormatProperties_params *params = args;
38877
38878     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);
38879
38880     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);
38881     return STATUS_SUCCESS;
38882 }
38883 #endif /* _WIN64 */
38884
38885 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties(void *args)
38886 {
38887     struct
38888     {
38889         PTR32 physicalDevice;
38890         VkFormat format;
38891         VkImageType type;
38892         VkSampleCountFlagBits samples;
38893         VkImageUsageFlags usage;
38894         VkImageTiling tiling;
38895         PTR32 pPropertyCount;
38896         PTR32 pProperties;
38897     } *params = args;
38898
38899     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);
38900
38901     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));
38902     return STATUS_SUCCESS;
38903 }
38904
38905 #ifdef _WIN64
38906 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2(void *args)
38907 {
38908     struct vkGetPhysicalDeviceSparseImageFormatProperties2_params *params = args;
38909
38910     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38911
38912     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);
38913     return STATUS_SUCCESS;
38914 }
38915 #endif /* _WIN64 */
38916
38917 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2(void *args)
38918 {
38919     struct
38920     {
38921         PTR32 physicalDevice;
38922         PTR32 pFormatInfo;
38923         PTR32 pPropertyCount;
38924         PTR32 pProperties;
38925     } *params = args;
38926     VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo_host;
38927     VkSparseImageFormatProperties2 *pProperties_host;
38928     struct conversion_context local_ctx;
38929     struct conversion_context *ctx = &local_ctx;
38930
38931     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38932
38933     init_conversion_context(ctx);
38934     convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host((const VkPhysicalDeviceSparseImageFormatInfo232 *)UlongToPtr(params->pFormatInfo), &pFormatInfo_host);
38935     pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(ctx, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
38936     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);
38937     convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
38938     free_conversion_context(ctx);
38939     return STATUS_SUCCESS;
38940 }
38941
38942 #ifdef _WIN64
38943 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void *args)
38944 {
38945     struct vkGetPhysicalDeviceSparseImageFormatProperties2KHR_params *params = args;
38946
38947     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38948
38949     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);
38950     return STATUS_SUCCESS;
38951 }
38952 #endif /* _WIN64 */
38953
38954 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void *args)
38955 {
38956     struct
38957     {
38958         PTR32 physicalDevice;
38959         PTR32 pFormatInfo;
38960         PTR32 pPropertyCount;
38961         PTR32 pProperties;
38962     } *params = args;
38963     VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo_host;
38964     VkSparseImageFormatProperties2 *pProperties_host;
38965     struct conversion_context local_ctx;
38966     struct conversion_context *ctx = &local_ctx;
38967
38968     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38969
38970     init_conversion_context(ctx);
38971     convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host((const VkPhysicalDeviceSparseImageFormatInfo232 *)UlongToPtr(params->pFormatInfo), &pFormatInfo_host);
38972     pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(ctx, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
38973     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);
38974     convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
38975     free_conversion_context(ctx);
38976     return STATUS_SUCCESS;
38977 }
38978
38979 #ifdef _WIN64
38980 static NTSTATUS thunk64_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(void *args)
38981 {
38982     struct vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_params *params = args;
38983
38984     TRACE("%p, %p, %p\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);
38985
38986     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);
38987     return STATUS_SUCCESS;
38988 }
38989 #endif /* _WIN64 */
38990
38991 static NTSTATUS thunk32_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(void *args)
38992 {
38993     struct
38994     {
38995         PTR32 physicalDevice;
38996         PTR32 pCombinationCount;
38997         PTR32 pCombinations;
38998         VkResult result;
38999     } *params = args;
39000     VkFramebufferMixedSamplesCombinationNV *pCombinations_host;
39001     struct conversion_context local_ctx;
39002     struct conversion_context *ctx = &local_ctx;
39003
39004     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);
39005
39006     init_conversion_context(ctx);
39007     pCombinations_host = convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(ctx, (VkFramebufferMixedSamplesCombinationNV32 *)UlongToPtr(params->pCombinations), *(uint32_t *)UlongToPtr(params->pCombinationCount));
39008     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);
39009     convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(pCombinations_host, (VkFramebufferMixedSamplesCombinationNV32 *)UlongToPtr(params->pCombinations), *(uint32_t *)UlongToPtr(params->pCombinationCount));
39010     free_conversion_context(ctx);
39011     return STATUS_SUCCESS;
39012 }
39013
39014 #ifdef _WIN64
39015 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
39016 {
39017     struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params *params = args;
39018
39019     TRACE("%p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
39020
39021     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
39022     return STATUS_SUCCESS;
39023 }
39024 #endif /* _WIN64 */
39025
39026 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
39027 {
39028     struct
39029     {
39030         PTR32 physicalDevice;
39031         PTR32 pSurfaceInfo;
39032         PTR32 pSurfaceCapabilities;
39033         VkResult result;
39034     } *params = args;
39035     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
39036     VkSurfaceCapabilities2KHR pSurfaceCapabilities_host;
39037     struct conversion_context local_ctx;
39038     struct conversion_context *ctx = &local_ctx;
39039
39040     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
39041
39042     init_conversion_context(ctx);
39043     convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(ctx, (const VkPhysicalDeviceSurfaceInfo2KHR32 *)UlongToPtr(params->pSurfaceInfo), &pSurfaceInfo_host);
39044     convert_VkSurfaceCapabilities2KHR_win32_to_host(ctx, (VkSurfaceCapabilities2KHR32 *)UlongToPtr(params->pSurfaceCapabilities), &pSurfaceCapabilities_host);
39045     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pSurfaceInfo_host, &pSurfaceCapabilities_host);
39046     convert_VkSurfaceCapabilities2KHR_host_to_win32(&pSurfaceCapabilities_host, (VkSurfaceCapabilities2KHR32 *)UlongToPtr(params->pSurfaceCapabilities));
39047     free_conversion_context(ctx);
39048     return STATUS_SUCCESS;
39049 }
39050
39051 #ifdef _WIN64
39052 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
39053 {
39054     struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params *params = args;
39055
39056     TRACE("%p, 0x%s, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);
39057
39058     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(params->physicalDevice, params->surface, params->pSurfaceCapabilities);
39059     return STATUS_SUCCESS;
39060 }
39061 #endif /* _WIN64 */
39062
39063 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
39064 {
39065     struct
39066     {
39067         PTR32 physicalDevice;
39068         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
39069         PTR32 pSurfaceCapabilities;
39070         VkResult result;
39071     } *params = args;
39072
39073     TRACE("%#x, 0x%s, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);
39074
39075     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), params->surface, (VkSurfaceCapabilitiesKHR *)UlongToPtr(params->pSurfaceCapabilities));
39076     return STATUS_SUCCESS;
39077 }
39078
39079 #ifdef _WIN64
39080 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
39081 {
39082     struct vkGetPhysicalDeviceSurfaceFormats2KHR_params *params = args;
39083     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
39084
39085     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);
39086
39087     convert_VkPhysicalDeviceSurfaceInfo2KHR_win64_to_host(params->pSurfaceInfo, &pSurfaceInfo_host);
39088     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);
39089     return STATUS_SUCCESS;
39090 }
39091 #endif /* _WIN64 */
39092
39093 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
39094 {
39095     struct
39096     {
39097         PTR32 physicalDevice;
39098         PTR32 pSurfaceInfo;
39099         PTR32 pSurfaceFormatCount;
39100         PTR32 pSurfaceFormats;
39101         VkResult result;
39102     } *params = args;
39103     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
39104     VkSurfaceFormat2KHR *pSurfaceFormats_host;
39105     struct conversion_context local_ctx;
39106     struct conversion_context *ctx = &local_ctx;
39107
39108     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);
39109
39110     init_conversion_context(ctx);
39111     convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host(ctx, (const VkPhysicalDeviceSurfaceInfo2KHR32 *)UlongToPtr(params->pSurfaceInfo), &pSurfaceInfo_host);
39112     pSurfaceFormats_host = convert_VkSurfaceFormat2KHR_array_win32_to_host(ctx, (VkSurfaceFormat2KHR32 *)UlongToPtr(params->pSurfaceFormats), *(uint32_t *)UlongToPtr(params->pSurfaceFormatCount));
39113     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);
39114     convert_VkSurfaceFormat2KHR_array_host_to_win32(pSurfaceFormats_host, (VkSurfaceFormat2KHR32 *)UlongToPtr(params->pSurfaceFormats), *(uint32_t *)UlongToPtr(params->pSurfaceFormatCount));
39115     free_conversion_context(ctx);
39116     return STATUS_SUCCESS;
39117 }
39118
39119 #ifdef _WIN64
39120 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
39121 {
39122     struct vkGetPhysicalDeviceSurfaceFormatsKHR_params *params = args;
39123
39124     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);
39125
39126     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);
39127     return STATUS_SUCCESS;
39128 }
39129 #endif /* _WIN64 */
39130
39131 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
39132 {
39133     struct
39134     {
39135         PTR32 physicalDevice;
39136         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
39137         PTR32 pSurfaceFormatCount;
39138         PTR32 pSurfaceFormats;
39139         VkResult result;
39140     } *params = args;
39141
39142     TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);
39143
39144     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));
39145     return STATUS_SUCCESS;
39146 }
39147
39148 #ifdef _WIN64
39149 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
39150 {
39151     struct vkGetPhysicalDeviceSurfacePresentModesKHR_params *params = args;
39152
39153     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);
39154
39155     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);
39156     return STATUS_SUCCESS;
39157 }
39158 #endif /* _WIN64 */
39159
39160 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
39161 {
39162     struct
39163     {
39164         PTR32 physicalDevice;
39165         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
39166         PTR32 pPresentModeCount;
39167         PTR32 pPresentModes;
39168         VkResult result;
39169     } *params = args;
39170
39171     TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);
39172
39173     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));
39174     return STATUS_SUCCESS;
39175 }
39176
39177 #ifdef _WIN64
39178 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
39179 {
39180     struct vkGetPhysicalDeviceSurfaceSupportKHR_params *params = args;
39181
39182     TRACE("%p, %u, 0x%s, %p\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);
39183
39184     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);
39185     return STATUS_SUCCESS;
39186 }
39187 #endif /* _WIN64 */
39188
39189 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
39190 {
39191     struct
39192     {
39193         PTR32 physicalDevice;
39194         uint32_t queueFamilyIndex;
39195         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
39196         PTR32 pSupported;
39197         VkResult result;
39198     } *params = args;
39199
39200     TRACE("%#x, %u, 0x%s, %#x\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);
39201
39202     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));
39203     return STATUS_SUCCESS;
39204 }
39205
39206 #ifdef _WIN64
39207 static NTSTATUS thunk64_vkGetPhysicalDeviceToolProperties(void *args)
39208 {
39209     struct vkGetPhysicalDeviceToolProperties_params *params = args;
39210
39211     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
39212
39213     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);
39214     return STATUS_SUCCESS;
39215 }
39216 #endif /* _WIN64 */
39217
39218 static NTSTATUS thunk32_vkGetPhysicalDeviceToolProperties(void *args)
39219 {
39220     struct
39221     {
39222         PTR32 physicalDevice;
39223         PTR32 pToolCount;
39224         PTR32 pToolProperties;
39225         VkResult result;
39226     } *params = args;
39227     VkPhysicalDeviceToolProperties *pToolProperties_host;
39228     struct conversion_context local_ctx;
39229     struct conversion_context *ctx = &local_ctx;
39230
39231     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
39232
39233     init_conversion_context(ctx);
39234     pToolProperties_host = convert_VkPhysicalDeviceToolProperties_array_win32_to_host(ctx, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
39235     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);
39236     convert_VkPhysicalDeviceToolProperties_array_host_to_win32(pToolProperties_host, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
39237     free_conversion_context(ctx);
39238     return STATUS_SUCCESS;
39239 }
39240
39241 #ifdef _WIN64
39242 static NTSTATUS thunk64_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
39243 {
39244     struct vkGetPhysicalDeviceToolPropertiesEXT_params *params = args;
39245
39246     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
39247
39248     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);
39249     return STATUS_SUCCESS;
39250 }
39251 #endif /* _WIN64 */
39252
39253 static NTSTATUS thunk32_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
39254 {
39255     struct
39256     {
39257         PTR32 physicalDevice;
39258         PTR32 pToolCount;
39259         PTR32 pToolProperties;
39260         VkResult result;
39261     } *params = args;
39262     VkPhysicalDeviceToolProperties *pToolProperties_host;
39263     struct conversion_context local_ctx;
39264     struct conversion_context *ctx = &local_ctx;
39265
39266     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
39267
39268     init_conversion_context(ctx);
39269     pToolProperties_host = convert_VkPhysicalDeviceToolProperties_array_win32_to_host(ctx, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
39270     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);
39271     convert_VkPhysicalDeviceToolProperties_array_host_to_win32(pToolProperties_host, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
39272     free_conversion_context(ctx);
39273     return STATUS_SUCCESS;
39274 }
39275
39276 #ifdef _WIN64
39277 static NTSTATUS thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *args)
39278 {
39279     struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params *params = args;
39280
39281     TRACE("%p, %u\n", params->physicalDevice, params->queueFamilyIndex);
39282
39283     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex);
39284     return STATUS_SUCCESS;
39285 }
39286 #endif /* _WIN64 */
39287
39288 static NTSTATUS thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *args)
39289 {
39290     struct
39291     {
39292         PTR32 physicalDevice;
39293         uint32_t queueFamilyIndex;
39294         VkBool32 result;
39295     } *params = args;
39296
39297     TRACE("%#x, %u\n", params->physicalDevice, params->queueFamilyIndex);
39298
39299     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);
39300     return STATUS_SUCCESS;
39301 }
39302
39303 #ifdef _WIN64
39304 static NTSTATUS thunk64_vkGetPipelineCacheData(void *args)
39305 {
39306     struct vkGetPipelineCacheData_params *params = args;
39307
39308     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);
39309
39310     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineCacheData(wine_device_from_handle(params->device)->device, params->pipelineCache, params->pDataSize, params->pData);
39311     return STATUS_SUCCESS;
39312 }
39313 #endif /* _WIN64 */
39314
39315 static NTSTATUS thunk32_vkGetPipelineCacheData(void *args)
39316 {
39317     struct
39318     {
39319         PTR32 device;
39320         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
39321         PTR32 pDataSize;
39322         PTR32 pData;
39323         VkResult result;
39324     } *params = args;
39325     size_t pDataSize_host;
39326
39327     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);
39328
39329     pDataSize_host = *(PTR32 *)UlongToPtr(params->pDataSize);
39330     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));
39331     *(PTR32 *)UlongToPtr(params->pDataSize) = pDataSize_host;
39332     return STATUS_SUCCESS;
39333 }
39334
39335 #ifdef _WIN64
39336 static NTSTATUS thunk64_vkGetPipelineExecutableInternalRepresentationsKHR(void *args)
39337 {
39338     struct vkGetPipelineExecutableInternalRepresentationsKHR_params *params = args;
39339
39340     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
39341
39342     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
39343     return STATUS_SUCCESS;
39344 }
39345 #endif /* _WIN64 */
39346
39347 static NTSTATUS thunk32_vkGetPipelineExecutableInternalRepresentationsKHR(void *args)
39348 {
39349     struct
39350     {
39351         PTR32 device;
39352         PTR32 pExecutableInfo;
39353         PTR32 pInternalRepresentationCount;
39354         PTR32 pInternalRepresentations;
39355         VkResult result;
39356     } *params = args;
39357     VkPipelineExecutableInfoKHR pExecutableInfo_host;
39358     VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations_host;
39359     struct conversion_context local_ctx;
39360     struct conversion_context *ctx = &local_ctx;
39361
39362     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
39363
39364     init_conversion_context(ctx);
39365     convert_VkPipelineExecutableInfoKHR_win32_to_host((const VkPipelineExecutableInfoKHR32 *)UlongToPtr(params->pExecutableInfo), &pExecutableInfo_host);
39366     pInternalRepresentations_host = convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(ctx, (VkPipelineExecutableInternalRepresentationKHR32 *)UlongToPtr(params->pInternalRepresentations), *(uint32_t *)UlongToPtr(params->pInternalRepresentationCount));
39367     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);
39368     convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(pInternalRepresentations_host, (VkPipelineExecutableInternalRepresentationKHR32 *)UlongToPtr(params->pInternalRepresentations), *(uint32_t *)UlongToPtr(params->pInternalRepresentationCount));
39369     free_conversion_context(ctx);
39370     return STATUS_SUCCESS;
39371 }
39372
39373 #ifdef _WIN64
39374 static NTSTATUS thunk64_vkGetPipelineExecutablePropertiesKHR(void *args)
39375 {
39376     struct vkGetPipelineExecutablePropertiesKHR_params *params = args;
39377
39378     TRACE("%p, %p, %p, %p\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
39379
39380     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
39381     return STATUS_SUCCESS;
39382 }
39383 #endif /* _WIN64 */
39384
39385 static NTSTATUS thunk32_vkGetPipelineExecutablePropertiesKHR(void *args)
39386 {
39387     struct
39388     {
39389         PTR32 device;
39390         PTR32 pPipelineInfo;
39391         PTR32 pExecutableCount;
39392         PTR32 pProperties;
39393         VkResult result;
39394     } *params = args;
39395     VkPipelineInfoKHR pPipelineInfo_host;
39396     VkPipelineExecutablePropertiesKHR *pProperties_host;
39397     struct conversion_context local_ctx;
39398     struct conversion_context *ctx = &local_ctx;
39399
39400     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
39401
39402     init_conversion_context(ctx);
39403     convert_VkPipelineInfoKHR_win32_to_host((const VkPipelineInfoKHR32 *)UlongToPtr(params->pPipelineInfo), &pPipelineInfo_host);
39404     pProperties_host = convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(ctx, (VkPipelineExecutablePropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pExecutableCount));
39405     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);
39406     convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(pProperties_host, (VkPipelineExecutablePropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pExecutableCount));
39407     free_conversion_context(ctx);
39408     return STATUS_SUCCESS;
39409 }
39410
39411 #ifdef _WIN64
39412 static NTSTATUS thunk64_vkGetPipelineExecutableStatisticsKHR(void *args)
39413 {
39414     struct vkGetPipelineExecutableStatisticsKHR_params *params = args;
39415
39416     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
39417
39418     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
39419     return STATUS_SUCCESS;
39420 }
39421 #endif /* _WIN64 */
39422
39423 static NTSTATUS thunk32_vkGetPipelineExecutableStatisticsKHR(void *args)
39424 {
39425     struct
39426     {
39427         PTR32 device;
39428         PTR32 pExecutableInfo;
39429         PTR32 pStatisticCount;
39430         PTR32 pStatistics;
39431         VkResult result;
39432     } *params = args;
39433     VkPipelineExecutableInfoKHR pExecutableInfo_host;
39434     VkPipelineExecutableStatisticKHR *pStatistics_host;
39435     struct conversion_context local_ctx;
39436     struct conversion_context *ctx = &local_ctx;
39437
39438     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
39439
39440     init_conversion_context(ctx);
39441     convert_VkPipelineExecutableInfoKHR_win32_to_host((const VkPipelineExecutableInfoKHR32 *)UlongToPtr(params->pExecutableInfo), &pExecutableInfo_host);
39442     pStatistics_host = convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(ctx, (VkPipelineExecutableStatisticKHR32 *)UlongToPtr(params->pStatistics), *(uint32_t *)UlongToPtr(params->pStatisticCount));
39443     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);
39444     convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(pStatistics_host, (VkPipelineExecutableStatisticKHR32 *)UlongToPtr(params->pStatistics), *(uint32_t *)UlongToPtr(params->pStatisticCount));
39445     free_conversion_context(ctx);
39446     return STATUS_SUCCESS;
39447 }
39448
39449 #ifdef _WIN64
39450 static NTSTATUS thunk64_vkGetPipelinePropertiesEXT(void *args)
39451 {
39452     struct vkGetPipelinePropertiesEXT_params *params = args;
39453
39454     TRACE("%p, %p, %p\n", params->device, params->pPipelineInfo, params->pPipelineProperties);
39455
39456     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pPipelineProperties);
39457     return STATUS_SUCCESS;
39458 }
39459 #endif /* _WIN64 */
39460
39461 static NTSTATUS thunk32_vkGetPipelinePropertiesEXT(void *args)
39462 {
39463     struct
39464     {
39465         PTR32 device;
39466         PTR32 pPipelineInfo;
39467         PTR32 pPipelineProperties;
39468         VkResult result;
39469     } *params = args;
39470     VkPipelineInfoEXT pPipelineInfo_host;
39471
39472     TRACE("%#x, %#x, %#x\n", params->device, params->pPipelineInfo, params->pPipelineProperties);
39473
39474     convert_VkPipelineInfoEXT_win32_to_host((const VkPipelineInfoEXT32 *)UlongToPtr(params->pPipelineInfo), &pPipelineInfo_host);
39475     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));
39476     return STATUS_SUCCESS;
39477 }
39478
39479 #ifdef _WIN64
39480 static NTSTATUS thunk64_vkGetPrivateData(void *args)
39481 {
39482     struct vkGetPrivateData_params *params = args;
39483
39484     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);
39485
39486     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);
39487     return STATUS_SUCCESS;
39488 }
39489 #endif /* _WIN64 */
39490
39491 static NTSTATUS thunk32_vkGetPrivateData(void *args)
39492 {
39493     struct
39494     {
39495         PTR32 device;
39496         VkObjectType objectType;
39497         uint64_t DECLSPEC_ALIGN(8) objectHandle;
39498         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
39499         PTR32 pData;
39500     } *params = args;
39501
39502     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);
39503
39504     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));
39505     return STATUS_SUCCESS;
39506 }
39507
39508 #ifdef _WIN64
39509 static NTSTATUS thunk64_vkGetPrivateDataEXT(void *args)
39510 {
39511     struct vkGetPrivateDataEXT_params *params = args;
39512
39513     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);
39514
39515     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);
39516     return STATUS_SUCCESS;
39517 }
39518 #endif /* _WIN64 */
39519
39520 static NTSTATUS thunk32_vkGetPrivateDataEXT(void *args)
39521 {
39522     struct
39523     {
39524         PTR32 device;
39525         VkObjectType objectType;
39526         uint64_t DECLSPEC_ALIGN(8) objectHandle;
39527         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
39528         PTR32 pData;
39529     } *params = args;
39530
39531     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);
39532
39533     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));
39534     return STATUS_SUCCESS;
39535 }
39536
39537 #ifdef _WIN64
39538 static NTSTATUS thunk64_vkGetQueryPoolResults(void *args)
39539 {
39540     struct vkGetQueryPoolResults_params *params = args;
39541
39542     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);
39543
39544     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);
39545     return STATUS_SUCCESS;
39546 }
39547 #endif /* _WIN64 */
39548
39549 static NTSTATUS thunk32_vkGetQueryPoolResults(void *args)
39550 {
39551     struct
39552     {
39553         PTR32 device;
39554         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
39555         uint32_t firstQuery;
39556         uint32_t queryCount;
39557         PTR32 dataSize;
39558         PTR32 pData;
39559         VkDeviceSize DECLSPEC_ALIGN(8) stride;
39560         VkQueryResultFlags flags;
39561         VkResult result;
39562     } *params = args;
39563
39564     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);
39565
39566     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);
39567     return STATUS_SUCCESS;
39568 }
39569
39570 #ifdef _WIN64
39571 static NTSTATUS thunk64_vkGetQueueCheckpointData2NV(void *args)
39572 {
39573     struct vkGetQueueCheckpointData2NV_params *params = args;
39574
39575     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
39576
39577     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointData2NV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, params->pCheckpointData);
39578     return STATUS_SUCCESS;
39579 }
39580 #endif /* _WIN64 */
39581
39582 static NTSTATUS thunk32_vkGetQueueCheckpointData2NV(void *args)
39583 {
39584     struct
39585     {
39586         PTR32 queue;
39587         PTR32 pCheckpointDataCount;
39588         PTR32 pCheckpointData;
39589     } *params = args;
39590     VkCheckpointData2NV *pCheckpointData_host;
39591     struct conversion_context local_ctx;
39592     struct conversion_context *ctx = &local_ctx;
39593
39594     TRACE("%#x, %#x, %#x\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
39595
39596     init_conversion_context(ctx);
39597     pCheckpointData_host = convert_VkCheckpointData2NV_array_win32_to_host(ctx, (VkCheckpointData2NV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
39598     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);
39599     convert_VkCheckpointData2NV_array_host_to_win32(pCheckpointData_host, (VkCheckpointData2NV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
39600     free_conversion_context(ctx);
39601     return STATUS_SUCCESS;
39602 }
39603
39604 #ifdef _WIN64
39605 static NTSTATUS thunk64_vkGetQueueCheckpointDataNV(void *args)
39606 {
39607     struct vkGetQueueCheckpointDataNV_params *params = args;
39608
39609     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
39610
39611     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointDataNV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, params->pCheckpointData);
39612     return STATUS_SUCCESS;
39613 }
39614 #endif /* _WIN64 */
39615
39616 static NTSTATUS thunk32_vkGetQueueCheckpointDataNV(void *args)
39617 {
39618     struct
39619     {
39620         PTR32 queue;
39621         PTR32 pCheckpointDataCount;
39622         PTR32 pCheckpointData;
39623     } *params = args;
39624     VkCheckpointDataNV *pCheckpointData_host;
39625     struct conversion_context local_ctx;
39626     struct conversion_context *ctx = &local_ctx;
39627
39628     TRACE("%#x, %#x, %#x\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
39629
39630     init_conversion_context(ctx);
39631     pCheckpointData_host = convert_VkCheckpointDataNV_array_win32_to_host(ctx, (VkCheckpointDataNV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
39632     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);
39633     convert_VkCheckpointDataNV_array_host_to_win32(pCheckpointData_host, (VkCheckpointDataNV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
39634     free_conversion_context(ctx);
39635     return STATUS_SUCCESS;
39636 }
39637
39638 #ifdef _WIN64
39639 static NTSTATUS thunk64_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *args)
39640 {
39641     struct vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_params *params = args;
39642
39643     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);
39644
39645     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);
39646     return STATUS_SUCCESS;
39647 }
39648 #endif /* _WIN64 */
39649
39650 static NTSTATUS thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *args)
39651 {
39652     struct
39653     {
39654         PTR32 device;
39655         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39656         uint32_t firstGroup;
39657         uint32_t groupCount;
39658         PTR32 dataSize;
39659         PTR32 pData;
39660         VkResult result;
39661     } *params = args;
39662
39663     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);
39664
39665     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));
39666     return STATUS_SUCCESS;
39667 }
39668
39669 #ifdef _WIN64
39670 static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesKHR(void *args)
39671 {
39672     struct vkGetRayTracingShaderGroupHandlesKHR_params *params = args;
39673
39674     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);
39675
39676     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);
39677     return STATUS_SUCCESS;
39678 }
39679 #endif /* _WIN64 */
39680
39681 static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesKHR(void *args)
39682 {
39683     struct
39684     {
39685         PTR32 device;
39686         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39687         uint32_t firstGroup;
39688         uint32_t groupCount;
39689         PTR32 dataSize;
39690         PTR32 pData;
39691         VkResult result;
39692     } *params = args;
39693
39694     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);
39695
39696     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));
39697     return STATUS_SUCCESS;
39698 }
39699
39700 #ifdef _WIN64
39701 static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesNV(void *args)
39702 {
39703     struct vkGetRayTracingShaderGroupHandlesNV_params *params = args;
39704
39705     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);
39706
39707     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);
39708     return STATUS_SUCCESS;
39709 }
39710 #endif /* _WIN64 */
39711
39712 static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesNV(void *args)
39713 {
39714     struct
39715     {
39716         PTR32 device;
39717         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39718         uint32_t firstGroup;
39719         uint32_t groupCount;
39720         PTR32 dataSize;
39721         PTR32 pData;
39722         VkResult result;
39723     } *params = args;
39724
39725     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);
39726
39727     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));
39728     return STATUS_SUCCESS;
39729 }
39730
39731 #ifdef _WIN64
39732 static NTSTATUS thunk64_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
39733 {
39734     struct vkGetRayTracingShaderGroupStackSizeKHR_params *params = args;
39735
39736     TRACE("%p, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);
39737
39738     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->group, params->groupShader);
39739     return STATUS_SUCCESS;
39740 }
39741 #endif /* _WIN64 */
39742
39743 static NTSTATUS thunk32_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
39744 {
39745     struct
39746     {
39747         PTR32 device;
39748         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39749         uint32_t group;
39750         VkShaderGroupShaderKHR groupShader;
39751         VkDeviceSize result;
39752     } *params = args;
39753
39754     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);
39755
39756     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);
39757     return STATUS_SUCCESS;
39758 }
39759
39760 #ifdef _WIN64
39761 static NTSTATUS thunk64_vkGetRenderAreaGranularity(void *args)
39762 {
39763     struct vkGetRenderAreaGranularity_params *params = args;
39764
39765     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pGranularity);
39766
39767     wine_device_from_handle(params->device)->funcs.p_vkGetRenderAreaGranularity(wine_device_from_handle(params->device)->device, params->renderPass, params->pGranularity);
39768     return STATUS_SUCCESS;
39769 }
39770 #endif /* _WIN64 */
39771
39772 static NTSTATUS thunk32_vkGetRenderAreaGranularity(void *args)
39773 {
39774     struct
39775     {
39776         PTR32 device;
39777         VkRenderPass DECLSPEC_ALIGN(8) renderPass;
39778         PTR32 pGranularity;
39779     } *params = args;
39780
39781     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pGranularity);
39782
39783     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));
39784     return STATUS_SUCCESS;
39785 }
39786
39787 #ifdef _WIN64
39788 static NTSTATUS thunk64_vkGetSamplerOpaqueCaptureDescriptorDataEXT(void *args)
39789 {
39790     struct vkGetSamplerOpaqueCaptureDescriptorDataEXT_params *params = args;
39791
39792     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
39793
39794     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSamplerOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
39795     return STATUS_SUCCESS;
39796 }
39797 #endif /* _WIN64 */
39798
39799 static NTSTATUS thunk32_vkGetSamplerOpaqueCaptureDescriptorDataEXT(void *args)
39800 {
39801     struct
39802     {
39803         PTR32 device;
39804         PTR32 pInfo;
39805         PTR32 pData;
39806         VkResult result;
39807     } *params = args;
39808     VkSamplerCaptureDescriptorDataInfoEXT pInfo_host;
39809
39810     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
39811
39812     convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host((const VkSamplerCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
39813     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));
39814     return STATUS_SUCCESS;
39815 }
39816
39817 #ifdef _WIN64
39818 static NTSTATUS thunk64_vkGetSemaphoreCounterValue(void *args)
39819 {
39820     struct vkGetSemaphoreCounterValue_params *params = args;
39821
39822     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39823
39824     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
39825     return STATUS_SUCCESS;
39826 }
39827 #endif /* _WIN64 */
39828
39829 static NTSTATUS thunk32_vkGetSemaphoreCounterValue(void *args)
39830 {
39831     struct
39832     {
39833         PTR32 device;
39834         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
39835         PTR32 pValue;
39836         VkResult result;
39837     } *params = args;
39838
39839     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39840
39841     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));
39842     return STATUS_SUCCESS;
39843 }
39844
39845 #ifdef _WIN64
39846 static NTSTATUS thunk64_vkGetSemaphoreCounterValueKHR(void *args)
39847 {
39848     struct vkGetSemaphoreCounterValueKHR_params *params = args;
39849
39850     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39851
39852     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
39853     return STATUS_SUCCESS;
39854 }
39855 #endif /* _WIN64 */
39856
39857 static NTSTATUS thunk32_vkGetSemaphoreCounterValueKHR(void *args)
39858 {
39859     struct
39860     {
39861         PTR32 device;
39862         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
39863         PTR32 pValue;
39864         VkResult result;
39865     } *params = args;
39866
39867     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39868
39869     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));
39870     return STATUS_SUCCESS;
39871 }
39872
39873 #ifdef _WIN64
39874 static NTSTATUS thunk64_vkGetShaderBinaryDataEXT(void *args)
39875 {
39876     struct vkGetShaderBinaryDataEXT_params *params = args;
39877
39878     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->shader), params->pDataSize, params->pData);
39879
39880     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetShaderBinaryDataEXT(wine_device_from_handle(params->device)->device, params->shader, params->pDataSize, params->pData);
39881     return STATUS_SUCCESS;
39882 }
39883 #endif /* _WIN64 */
39884
39885 static NTSTATUS thunk32_vkGetShaderBinaryDataEXT(void *args)
39886 {
39887     struct
39888     {
39889         PTR32 device;
39890         VkShaderEXT DECLSPEC_ALIGN(8) shader;
39891         PTR32 pDataSize;
39892         PTR32 pData;
39893         VkResult result;
39894     } *params = args;
39895     size_t pDataSize_host;
39896
39897     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->shader), params->pDataSize, params->pData);
39898
39899     pDataSize_host = *(PTR32 *)UlongToPtr(params->pDataSize);
39900     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));
39901     *(PTR32 *)UlongToPtr(params->pDataSize) = pDataSize_host;
39902     return STATUS_SUCCESS;
39903 }
39904
39905 #ifdef _WIN64
39906 static NTSTATUS thunk64_vkGetShaderInfoAMD(void *args)
39907 {
39908     struct vkGetShaderInfoAMD_params *params = args;
39909
39910     TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
39911
39912     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);
39913     return STATUS_SUCCESS;
39914 }
39915 #endif /* _WIN64 */
39916
39917 static NTSTATUS thunk32_vkGetShaderInfoAMD(void *args)
39918 {
39919     struct
39920     {
39921         PTR32 device;
39922         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39923         VkShaderStageFlagBits shaderStage;
39924         VkShaderInfoTypeAMD infoType;
39925         PTR32 pInfoSize;
39926         PTR32 pInfo;
39927         VkResult result;
39928     } *params = args;
39929     size_t pInfoSize_host;
39930
39931     TRACE("%#x, 0x%s, %#x, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
39932
39933     pInfoSize_host = *(PTR32 *)UlongToPtr(params->pInfoSize);
39934     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));
39935     *(PTR32 *)UlongToPtr(params->pInfoSize) = pInfoSize_host;
39936     return STATUS_SUCCESS;
39937 }
39938
39939 #ifdef _WIN64
39940 static NTSTATUS thunk64_vkGetShaderModuleCreateInfoIdentifierEXT(void *args)
39941 {
39942     struct vkGetShaderModuleCreateInfoIdentifierEXT_params *params = args;
39943
39944     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pIdentifier);
39945
39946     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleCreateInfoIdentifierEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pIdentifier);
39947     return STATUS_SUCCESS;
39948 }
39949 #endif /* _WIN64 */
39950
39951 static NTSTATUS thunk32_vkGetShaderModuleCreateInfoIdentifierEXT(void *args)
39952 {
39953     struct
39954     {
39955         PTR32 device;
39956         PTR32 pCreateInfo;
39957         PTR32 pIdentifier;
39958     } *params = args;
39959     VkShaderModuleCreateInfo pCreateInfo_host;
39960     VkShaderModuleIdentifierEXT pIdentifier_host;
39961     struct conversion_context local_ctx;
39962     struct conversion_context *ctx = &local_ctx;
39963
39964     TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pIdentifier);
39965
39966     init_conversion_context(ctx);
39967     convert_VkShaderModuleCreateInfo_win32_to_host(ctx, (const VkShaderModuleCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
39968     convert_VkShaderModuleIdentifierEXT_win32_to_host((VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier), &pIdentifier_host);
39969     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetShaderModuleCreateInfoIdentifierEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pIdentifier_host);
39970     convert_VkShaderModuleIdentifierEXT_host_to_win32(&pIdentifier_host, (VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier));
39971     free_conversion_context(ctx);
39972     return STATUS_SUCCESS;
39973 }
39974
39975 #ifdef _WIN64
39976 static NTSTATUS thunk64_vkGetShaderModuleIdentifierEXT(void *args)
39977 {
39978     struct vkGetShaderModuleIdentifierEXT_params *params = args;
39979
39980     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pIdentifier);
39981
39982     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleIdentifierEXT(wine_device_from_handle(params->device)->device, params->shaderModule, params->pIdentifier);
39983     return STATUS_SUCCESS;
39984 }
39985 #endif /* _WIN64 */
39986
39987 static NTSTATUS thunk32_vkGetShaderModuleIdentifierEXT(void *args)
39988 {
39989     struct
39990     {
39991         PTR32 device;
39992         VkShaderModule DECLSPEC_ALIGN(8) shaderModule;
39993         PTR32 pIdentifier;
39994     } *params = args;
39995     VkShaderModuleIdentifierEXT pIdentifier_host;
39996
39997     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pIdentifier);
39998
39999     convert_VkShaderModuleIdentifierEXT_win32_to_host((VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier), &pIdentifier_host);
40000     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetShaderModuleIdentifierEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->shaderModule, &pIdentifier_host);
40001     convert_VkShaderModuleIdentifierEXT_host_to_win32(&pIdentifier_host, (VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier));
40002     return STATUS_SUCCESS;
40003 }
40004
40005 #ifdef _WIN64
40006 static NTSTATUS thunk64_vkGetSwapchainImagesKHR(void *args)
40007 {
40008     struct vkGetSwapchainImagesKHR_params *params = args;
40009
40010     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);
40011
40012     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->pSwapchainImageCount, params->pSwapchainImages);
40013     return STATUS_SUCCESS;
40014 }
40015 #endif /* _WIN64 */
40016
40017 static NTSTATUS thunk32_vkGetSwapchainImagesKHR(void *args)
40018 {
40019     struct
40020     {
40021         PTR32 device;
40022         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
40023         PTR32 pSwapchainImageCount;
40024         PTR32 pSwapchainImages;
40025         VkResult result;
40026     } *params = args;
40027
40028     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);
40029
40030     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));
40031     return STATUS_SUCCESS;
40032 }
40033
40034 #ifdef _WIN64
40035 static NTSTATUS thunk64_vkGetValidationCacheDataEXT(void *args)
40036 {
40037     struct vkGetValidationCacheDataEXT_params *params = args;
40038
40039     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);
40040
40041     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle(params->device)->device, params->validationCache, params->pDataSize, params->pData);
40042     return STATUS_SUCCESS;
40043 }
40044 #endif /* _WIN64 */
40045
40046 static NTSTATUS thunk32_vkGetValidationCacheDataEXT(void *args)
40047 {
40048     struct
40049     {
40050         PTR32 device;
40051         VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
40052         PTR32 pDataSize;
40053         PTR32 pData;
40054         VkResult result;
40055     } *params = args;
40056     size_t pDataSize_host;
40057
40058     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);
40059
40060     pDataSize_host = *(PTR32 *)UlongToPtr(params->pDataSize);
40061     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));
40062     *(PTR32 *)UlongToPtr(params->pDataSize) = pDataSize_host;
40063     return STATUS_SUCCESS;
40064 }
40065
40066 #ifdef _WIN64
40067 static NTSTATUS thunk64_vkInitializePerformanceApiINTEL(void *args)
40068 {
40069     struct vkInitializePerformanceApiINTEL_params *params = args;
40070
40071     TRACE("%p, %p\n", params->device, params->pInitializeInfo);
40072
40073     params->result = wine_device_from_handle(params->device)->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device, params->pInitializeInfo);
40074     return STATUS_SUCCESS;
40075 }
40076 #endif /* _WIN64 */
40077
40078 static NTSTATUS thunk32_vkInitializePerformanceApiINTEL(void *args)
40079 {
40080     struct
40081     {
40082         PTR32 device;
40083         PTR32 pInitializeInfo;
40084         VkResult result;
40085     } *params = args;
40086     VkInitializePerformanceApiInfoINTEL pInitializeInfo_host;
40087
40088     TRACE("%#x, %#x\n", params->device, params->pInitializeInfo);
40089
40090     convert_VkInitializePerformanceApiInfoINTEL_win32_to_host((const VkInitializePerformanceApiInfoINTEL32 *)UlongToPtr(params->pInitializeInfo), &pInitializeInfo_host);
40091     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInitializeInfo_host);
40092     return STATUS_SUCCESS;
40093 }
40094
40095 #ifdef _WIN64
40096 static NTSTATUS thunk64_vkInvalidateMappedMemoryRanges(void *args)
40097 {
40098     struct vkInvalidateMappedMemoryRanges_params *params = args;
40099     const VkMappedMemoryRange *pMemoryRanges_host;
40100     struct conversion_context local_ctx;
40101     struct conversion_context *ctx = &local_ctx;
40102
40103     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
40104
40105     init_conversion_context(ctx);
40106     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win64_to_host(ctx, params->pMemoryRanges, params->memoryRangeCount);
40107     params->result = wine_device_from_handle(params->device)->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
40108     free_conversion_context(ctx);
40109     return STATUS_SUCCESS;
40110 }
40111 #endif /* _WIN64 */
40112
40113 static NTSTATUS thunk32_vkInvalidateMappedMemoryRanges(void *args)
40114 {
40115     struct
40116     {
40117         PTR32 device;
40118         uint32_t memoryRangeCount;
40119         PTR32 pMemoryRanges;
40120         VkResult result;
40121     } *params = args;
40122     const VkMappedMemoryRange *pMemoryRanges_host;
40123     struct conversion_context local_ctx;
40124     struct conversion_context *ctx = &local_ctx;
40125
40126     TRACE("%#x, %u, %#x\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
40127
40128     init_conversion_context(ctx);
40129     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(ctx, (const VkMappedMemoryRange32 *)UlongToPtr(params->pMemoryRanges), params->memoryRangeCount);
40130     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);
40131     free_conversion_context(ctx);
40132     return STATUS_SUCCESS;
40133 }
40134
40135 #ifdef _WIN64
40136 static NTSTATUS thunk64_vkMapMemory(void *args)
40137 {
40138     struct vkMapMemory_params *params = args;
40139
40140     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);
40141
40142     params->result = wine_vkMapMemory(params->device, params->memory, params->offset, params->size, params->flags, params->ppData);
40143     return STATUS_SUCCESS;
40144 }
40145 #endif /* _WIN64 */
40146
40147 static NTSTATUS thunk32_vkMapMemory(void *args)
40148 {
40149     struct
40150     {
40151         PTR32 device;
40152         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
40153         VkDeviceSize DECLSPEC_ALIGN(8) offset;
40154         VkDeviceSize DECLSPEC_ALIGN(8) size;
40155         VkMemoryMapFlags flags;
40156         PTR32 ppData;
40157         VkResult result;
40158     } *params = args;
40159
40160     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);
40161
40162     params->result = wine_vkMapMemory((VkDevice)UlongToPtr(params->device), params->memory, params->offset, params->size, params->flags, (void **)UlongToPtr(params->ppData));
40163     return STATUS_SUCCESS;
40164 }
40165
40166 #ifdef _WIN64
40167 static NTSTATUS thunk64_vkMapMemory2KHR(void *args)
40168 {
40169     struct vkMapMemory2KHR_params *params = args;
40170
40171     TRACE("%p, %p, %p\n", params->device, params->pMemoryMapInfo, params->ppData);
40172
40173     params->result = wine_vkMapMemory2KHR(params->device, params->pMemoryMapInfo, params->ppData);
40174     return STATUS_SUCCESS;
40175 }
40176 #endif /* _WIN64 */
40177
40178 static NTSTATUS thunk32_vkMapMemory2KHR(void *args)
40179 {
40180     struct
40181     {
40182         PTR32 device;
40183         PTR32 pMemoryMapInfo;
40184         PTR32 ppData;
40185         VkResult result;
40186     } *params = args;
40187     VkMemoryMapInfoKHR pMemoryMapInfo_host;
40188
40189     TRACE("%#x, %#x, %#x\n", params->device, params->pMemoryMapInfo, params->ppData);
40190
40191     convert_VkMemoryMapInfoKHR_win32_to_unwrapped_host((const VkMemoryMapInfoKHR32 *)UlongToPtr(params->pMemoryMapInfo), &pMemoryMapInfo_host);
40192     params->result = wine_vkMapMemory2KHR((VkDevice)UlongToPtr(params->device), &pMemoryMapInfo_host, (void **)UlongToPtr(params->ppData));
40193     return STATUS_SUCCESS;
40194 }
40195
40196 #ifdef _WIN64
40197 static NTSTATUS thunk64_vkMergePipelineCaches(void *args)
40198 {
40199     struct vkMergePipelineCaches_params *params = args;
40200
40201     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
40202
40203     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergePipelineCaches(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
40204     return STATUS_SUCCESS;
40205 }
40206 #endif /* _WIN64 */
40207
40208 static NTSTATUS thunk32_vkMergePipelineCaches(void *args)
40209 {
40210     struct
40211     {
40212         PTR32 device;
40213         VkPipelineCache DECLSPEC_ALIGN(8) dstCache;
40214         uint32_t srcCacheCount;
40215         PTR32 pSrcCaches;
40216         VkResult result;
40217     } *params = args;
40218
40219     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
40220
40221     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));
40222     return STATUS_SUCCESS;
40223 }
40224
40225 #ifdef _WIN64
40226 static NTSTATUS thunk64_vkMergeValidationCachesEXT(void *args)
40227 {
40228     struct vkMergeValidationCachesEXT_params *params = args;
40229
40230     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
40231
40232     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
40233     return STATUS_SUCCESS;
40234 }
40235 #endif /* _WIN64 */
40236
40237 static NTSTATUS thunk32_vkMergeValidationCachesEXT(void *args)
40238 {
40239     struct
40240     {
40241         PTR32 device;
40242         VkValidationCacheEXT DECLSPEC_ALIGN(8) dstCache;
40243         uint32_t srcCacheCount;
40244         PTR32 pSrcCaches;
40245         VkResult result;
40246     } *params = args;
40247
40248     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
40249
40250     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));
40251     return STATUS_SUCCESS;
40252 }
40253
40254 #ifdef _WIN64
40255 static NTSTATUS thunk64_vkQueueBeginDebugUtilsLabelEXT(void *args)
40256 {
40257     struct vkQueueBeginDebugUtilsLabelEXT_params *params = args;
40258
40259     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
40260
40261     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, params->pLabelInfo);
40262     return STATUS_SUCCESS;
40263 }
40264 #endif /* _WIN64 */
40265
40266 static NTSTATUS thunk32_vkQueueBeginDebugUtilsLabelEXT(void *args)
40267 {
40268     struct
40269     {
40270         PTR32 queue;
40271         PTR32 pLabelInfo;
40272     } *params = args;
40273     VkDebugUtilsLabelEXT pLabelInfo_host;
40274
40275     TRACE("%#x, %#x\n", params->queue, params->pLabelInfo);
40276
40277     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
40278     wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, &pLabelInfo_host);
40279     return STATUS_SUCCESS;
40280 }
40281
40282 #ifdef _WIN64
40283 static NTSTATUS thunk64_vkQueueBindSparse(void *args)
40284 {
40285     struct vkQueueBindSparse_params *params = args;
40286     const VkBindSparseInfo *pBindInfo_host;
40287     struct conversion_context local_ctx;
40288     struct conversion_context *ctx = &local_ctx;
40289
40290     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));
40291
40292     init_conversion_context(ctx);
40293     pBindInfo_host = convert_VkBindSparseInfo_array_win64_to_host(ctx, params->pBindInfo, params->bindInfoCount);
40294     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);
40295     free_conversion_context(ctx);
40296     return STATUS_SUCCESS;
40297 }
40298 #endif /* _WIN64 */
40299
40300 static NTSTATUS thunk32_vkQueueBindSparse(void *args)
40301 {
40302     struct
40303     {
40304         PTR32 queue;
40305         uint32_t bindInfoCount;
40306         PTR32 pBindInfo;
40307         VkFence DECLSPEC_ALIGN(8) fence;
40308         VkResult result;
40309     } *params = args;
40310     const VkBindSparseInfo *pBindInfo_host;
40311     struct conversion_context local_ctx;
40312     struct conversion_context *ctx = &local_ctx;
40313
40314     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));
40315
40316     init_conversion_context(ctx);
40317     pBindInfo_host = convert_VkBindSparseInfo_array_win32_to_host(ctx, (const VkBindSparseInfo32 *)UlongToPtr(params->pBindInfo), params->bindInfoCount);
40318     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);
40319     free_conversion_context(ctx);
40320     return STATUS_SUCCESS;
40321 }
40322
40323 #ifdef _WIN64
40324 static NTSTATUS thunk64_vkQueueEndDebugUtilsLabelEXT(void *args)
40325 {
40326     struct vkQueueEndDebugUtilsLabelEXT_params *params = args;
40327
40328     TRACE("%p\n", params->queue);
40329
40330     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue);
40331     return STATUS_SUCCESS;
40332 }
40333 #endif /* _WIN64 */
40334
40335 static NTSTATUS thunk32_vkQueueEndDebugUtilsLabelEXT(void *args)
40336 {
40337     struct
40338     {
40339         PTR32 queue;
40340     } *params = args;
40341
40342     TRACE("%#x\n", params->queue);
40343
40344     wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue);
40345     return STATUS_SUCCESS;
40346 }
40347
40348 #ifdef _WIN64
40349 static NTSTATUS thunk64_vkQueueInsertDebugUtilsLabelEXT(void *args)
40350 {
40351     struct vkQueueInsertDebugUtilsLabelEXT_params *params = args;
40352
40353     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
40354
40355     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, params->pLabelInfo);
40356     return STATUS_SUCCESS;
40357 }
40358 #endif /* _WIN64 */
40359
40360 static NTSTATUS thunk32_vkQueueInsertDebugUtilsLabelEXT(void *args)
40361 {
40362     struct
40363     {
40364         PTR32 queue;
40365         PTR32 pLabelInfo;
40366     } *params = args;
40367     VkDebugUtilsLabelEXT pLabelInfo_host;
40368
40369     TRACE("%#x, %#x\n", params->queue, params->pLabelInfo);
40370
40371     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
40372     wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, &pLabelInfo_host);
40373     return STATUS_SUCCESS;
40374 }
40375
40376 #ifdef _WIN64
40377 static NTSTATUS thunk64_vkQueuePresentKHR(void *args)
40378 {
40379     struct vkQueuePresentKHR_params *params = args;
40380
40381     TRACE("%p, %p\n", params->queue, params->pPresentInfo);
40382
40383     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle(params->queue)->queue, params->pPresentInfo);
40384     return STATUS_SUCCESS;
40385 }
40386 #endif /* _WIN64 */
40387
40388 static NTSTATUS thunk32_vkQueuePresentKHR(void *args)
40389 {
40390     struct
40391     {
40392         PTR32 queue;
40393         PTR32 pPresentInfo;
40394         VkResult result;
40395     } *params = args;
40396     VkPresentInfoKHR pPresentInfo_host;
40397     struct conversion_context local_ctx;
40398     struct conversion_context *ctx = &local_ctx;
40399
40400     TRACE("%#x, %#x\n", params->queue, params->pPresentInfo);
40401
40402     init_conversion_context(ctx);
40403     convert_VkPresentInfoKHR_win32_to_host(ctx, (const VkPresentInfoKHR32 *)UlongToPtr(params->pPresentInfo), &pPresentInfo_host);
40404     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);
40405     free_conversion_context(ctx);
40406     return STATUS_SUCCESS;
40407 }
40408
40409 #ifdef _WIN64
40410 static NTSTATUS thunk64_vkQueueSetPerformanceConfigurationINTEL(void *args)
40411 {
40412     struct vkQueueSetPerformanceConfigurationINTEL_params *params = args;
40413
40414     TRACE("%p, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));
40415
40416     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle(params->queue)->queue, params->configuration);
40417     return STATUS_SUCCESS;
40418 }
40419 #endif /* _WIN64 */
40420
40421 static NTSTATUS thunk32_vkQueueSetPerformanceConfigurationINTEL(void *args)
40422 {
40423     struct
40424     {
40425         PTR32 queue;
40426         VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
40427         VkResult result;
40428     } *params = args;
40429
40430     TRACE("%#x, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));
40431
40432     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);
40433     return STATUS_SUCCESS;
40434 }
40435
40436 #ifdef _WIN64
40437 static NTSTATUS thunk64_vkQueueSubmit(void *args)
40438 {
40439     struct vkQueueSubmit_params *params = args;
40440     const VkSubmitInfo *pSubmits_host;
40441     struct conversion_context local_ctx;
40442     struct conversion_context *ctx = &local_ctx;
40443
40444     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40445
40446     init_conversion_context(ctx);
40447     pSubmits_host = convert_VkSubmitInfo_array_win64_to_host(ctx, params->pSubmits, params->submitCount);
40448     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);
40449     free_conversion_context(ctx);
40450     return STATUS_SUCCESS;
40451 }
40452 #endif /* _WIN64 */
40453
40454 static NTSTATUS thunk32_vkQueueSubmit(void *args)
40455 {
40456     struct
40457     {
40458         PTR32 queue;
40459         uint32_t submitCount;
40460         PTR32 pSubmits;
40461         VkFence DECLSPEC_ALIGN(8) fence;
40462         VkResult result;
40463     } *params = args;
40464     const VkSubmitInfo *pSubmits_host;
40465     struct conversion_context local_ctx;
40466     struct conversion_context *ctx = &local_ctx;
40467
40468     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40469
40470     init_conversion_context(ctx);
40471     pSubmits_host = convert_VkSubmitInfo_array_win32_to_host(ctx, (const VkSubmitInfo32 *)UlongToPtr(params->pSubmits), params->submitCount);
40472     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);
40473     free_conversion_context(ctx);
40474     return STATUS_SUCCESS;
40475 }
40476
40477 #ifdef _WIN64
40478 static NTSTATUS thunk64_vkQueueSubmit2(void *args)
40479 {
40480     struct vkQueueSubmit2_params *params = args;
40481     const VkSubmitInfo2 *pSubmits_host;
40482     struct conversion_context local_ctx;
40483     struct conversion_context *ctx = &local_ctx;
40484
40485     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40486
40487     init_conversion_context(ctx);
40488     pSubmits_host = convert_VkSubmitInfo2_array_win64_to_host(ctx, params->pSubmits, params->submitCount);
40489     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);
40490     free_conversion_context(ctx);
40491     return STATUS_SUCCESS;
40492 }
40493 #endif /* _WIN64 */
40494
40495 static NTSTATUS thunk32_vkQueueSubmit2(void *args)
40496 {
40497     struct
40498     {
40499         PTR32 queue;
40500         uint32_t submitCount;
40501         PTR32 pSubmits;
40502         VkFence DECLSPEC_ALIGN(8) fence;
40503         VkResult result;
40504     } *params = args;
40505     const VkSubmitInfo2 *pSubmits_host;
40506     struct conversion_context local_ctx;
40507     struct conversion_context *ctx = &local_ctx;
40508
40509     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40510
40511     init_conversion_context(ctx);
40512     pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(ctx, (const VkSubmitInfo232 *)UlongToPtr(params->pSubmits), params->submitCount);
40513     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);
40514     free_conversion_context(ctx);
40515     return STATUS_SUCCESS;
40516 }
40517
40518 #ifdef _WIN64
40519 static NTSTATUS thunk64_vkQueueSubmit2KHR(void *args)
40520 {
40521     struct vkQueueSubmit2KHR_params *params = args;
40522     const VkSubmitInfo2 *pSubmits_host;
40523     struct conversion_context local_ctx;
40524     struct conversion_context *ctx = &local_ctx;
40525
40526     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40527
40528     init_conversion_context(ctx);
40529     pSubmits_host = convert_VkSubmitInfo2_array_win64_to_host(ctx, params->pSubmits, params->submitCount);
40530     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);
40531     free_conversion_context(ctx);
40532     return STATUS_SUCCESS;
40533 }
40534 #endif /* _WIN64 */
40535
40536 static NTSTATUS thunk32_vkQueueSubmit2KHR(void *args)
40537 {
40538     struct
40539     {
40540         PTR32 queue;
40541         uint32_t submitCount;
40542         PTR32 pSubmits;
40543         VkFence DECLSPEC_ALIGN(8) fence;
40544         VkResult result;
40545     } *params = args;
40546     const VkSubmitInfo2 *pSubmits_host;
40547     struct conversion_context local_ctx;
40548     struct conversion_context *ctx = &local_ctx;
40549
40550     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
40551
40552     init_conversion_context(ctx);
40553     pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(ctx, (const VkSubmitInfo232 *)UlongToPtr(params->pSubmits), params->submitCount);
40554     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);
40555     free_conversion_context(ctx);
40556     return STATUS_SUCCESS;
40557 }
40558
40559 #ifdef _WIN64
40560 static NTSTATUS thunk64_vkQueueWaitIdle(void *args)
40561 {
40562     struct vkQueueWaitIdle_params *params = args;
40563
40564     TRACE("%p\n", params->queue);
40565
40566     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle(params->queue)->queue);
40567     return STATUS_SUCCESS;
40568 }
40569 #endif /* _WIN64 */
40570
40571 static NTSTATUS thunk32_vkQueueWaitIdle(void *args)
40572 {
40573     struct
40574     {
40575         PTR32 queue;
40576         VkResult result;
40577     } *params = args;
40578
40579     TRACE("%#x\n", params->queue);
40580
40581     params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue);
40582     return STATUS_SUCCESS;
40583 }
40584
40585 #ifdef _WIN64
40586 static NTSTATUS thunk64_vkReleasePerformanceConfigurationINTEL(void *args)
40587 {
40588     struct vkReleasePerformanceConfigurationINTEL_params *params = args;
40589
40590     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));
40591
40592     params->result = wine_device_from_handle(params->device)->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->configuration);
40593     return STATUS_SUCCESS;
40594 }
40595 #endif /* _WIN64 */
40596
40597 static NTSTATUS thunk32_vkReleasePerformanceConfigurationINTEL(void *args)
40598 {
40599     struct
40600     {
40601         PTR32 device;
40602         VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
40603         VkResult result;
40604     } *params = args;
40605
40606     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));
40607
40608     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->configuration);
40609     return STATUS_SUCCESS;
40610 }
40611
40612 #ifdef _WIN64
40613 static NTSTATUS thunk64_vkReleaseProfilingLockKHR(void *args)
40614 {
40615     struct vkReleaseProfilingLockKHR_params *params = args;
40616
40617     TRACE("%p\n", params->device);
40618
40619     wine_device_from_handle(params->device)->funcs.p_vkReleaseProfilingLockKHR(wine_device_from_handle(params->device)->device);
40620     return STATUS_SUCCESS;
40621 }
40622 #endif /* _WIN64 */
40623
40624 static NTSTATUS thunk32_vkReleaseProfilingLockKHR(void *args)
40625 {
40626     struct
40627     {
40628         PTR32 device;
40629     } *params = args;
40630
40631     TRACE("%#x\n", params->device);
40632
40633     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkReleaseProfilingLockKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
40634     return STATUS_SUCCESS;
40635 }
40636
40637 #ifdef _WIN64
40638 static NTSTATUS thunk64_vkReleaseSwapchainImagesEXT(void *args)
40639 {
40640     struct vkReleaseSwapchainImagesEXT_params *params = args;
40641
40642     TRACE("%p, %p\n", params->device, params->pReleaseInfo);
40643
40644     params->result = wine_device_from_handle(params->device)->funcs.p_vkReleaseSwapchainImagesEXT(wine_device_from_handle(params->device)->device, params->pReleaseInfo);
40645     return STATUS_SUCCESS;
40646 }
40647 #endif /* _WIN64 */
40648
40649 static NTSTATUS thunk32_vkReleaseSwapchainImagesEXT(void *args)
40650 {
40651     struct
40652     {
40653         PTR32 device;
40654         PTR32 pReleaseInfo;
40655         VkResult result;
40656     } *params = args;
40657     VkReleaseSwapchainImagesInfoEXT pReleaseInfo_host;
40658
40659     TRACE("%#x, %#x\n", params->device, params->pReleaseInfo);
40660
40661     convert_VkReleaseSwapchainImagesInfoEXT_win32_to_host((const VkReleaseSwapchainImagesInfoEXT32 *)UlongToPtr(params->pReleaseInfo), &pReleaseInfo_host);
40662     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkReleaseSwapchainImagesEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pReleaseInfo_host);
40663     return STATUS_SUCCESS;
40664 }
40665
40666 #ifdef _WIN64
40667 static NTSTATUS thunk64_vkResetCommandBuffer(void *args)
40668 {
40669     struct vkResetCommandBuffer_params *params = args;
40670
40671     TRACE("%p, %#x\n", params->commandBuffer, params->flags);
40672
40673     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->flags);
40674     return STATUS_SUCCESS;
40675 }
40676 #endif /* _WIN64 */
40677
40678 static NTSTATUS thunk32_vkResetCommandBuffer(void *args)
40679 {
40680     struct
40681     {
40682         PTR32 commandBuffer;
40683         VkCommandBufferResetFlags flags;
40684         VkResult result;
40685     } *params = args;
40686
40687     TRACE("%#x, %#x\n", params->commandBuffer, params->flags);
40688
40689     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);
40690     return STATUS_SUCCESS;
40691 }
40692
40693 #ifdef _WIN64
40694 static NTSTATUS thunk64_vkResetCommandPool(void *args)
40695 {
40696     struct vkResetCommandPool_params *params = args;
40697
40698     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
40699
40700     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);
40701     return STATUS_SUCCESS;
40702 }
40703 #endif /* _WIN64 */
40704
40705 static NTSTATUS thunk32_vkResetCommandPool(void *args)
40706 {
40707     struct
40708     {
40709         PTR32 device;
40710         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
40711         VkCommandPoolResetFlags flags;
40712         VkResult result;
40713     } *params = args;
40714
40715     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
40716
40717     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);
40718     return STATUS_SUCCESS;
40719 }
40720
40721 #ifdef _WIN64
40722 static NTSTATUS thunk64_vkResetDescriptorPool(void *args)
40723 {
40724     struct vkResetDescriptorPool_params *params = args;
40725
40726     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);
40727
40728     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, params->flags);
40729     return STATUS_SUCCESS;
40730 }
40731 #endif /* _WIN64 */
40732
40733 static NTSTATUS thunk32_vkResetDescriptorPool(void *args)
40734 {
40735     struct
40736     {
40737         PTR32 device;
40738         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
40739         VkDescriptorPoolResetFlags flags;
40740         VkResult result;
40741     } *params = args;
40742
40743     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);
40744
40745     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);
40746     return STATUS_SUCCESS;
40747 }
40748
40749 #ifdef _WIN64
40750 static NTSTATUS thunk64_vkResetEvent(void *args)
40751 {
40752     struct vkResetEvent_params *params = args;
40753
40754     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
40755
40756     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetEvent(wine_device_from_handle(params->device)->device, params->event);
40757     return STATUS_SUCCESS;
40758 }
40759 #endif /* _WIN64 */
40760
40761 static NTSTATUS thunk32_vkResetEvent(void *args)
40762 {
40763     struct
40764     {
40765         PTR32 device;
40766         VkEvent DECLSPEC_ALIGN(8) event;
40767         VkResult result;
40768     } *params = args;
40769
40770     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
40771
40772     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
40773     return STATUS_SUCCESS;
40774 }
40775
40776 #ifdef _WIN64
40777 static NTSTATUS thunk64_vkResetFences(void *args)
40778 {
40779     struct vkResetFences_params *params = args;
40780
40781     TRACE("%p, %u, %p\n", params->device, params->fenceCount, params->pFences);
40782
40783     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences);
40784     return STATUS_SUCCESS;
40785 }
40786 #endif /* _WIN64 */
40787
40788 static NTSTATUS thunk32_vkResetFences(void *args)
40789 {
40790     struct
40791     {
40792         PTR32 device;
40793         uint32_t fenceCount;
40794         PTR32 pFences;
40795         VkResult result;
40796     } *params = args;
40797
40798     TRACE("%#x, %u, %#x\n", params->device, params->fenceCount, params->pFences);
40799
40800     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));
40801     return STATUS_SUCCESS;
40802 }
40803
40804 #ifdef _WIN64
40805 static NTSTATUS thunk64_vkResetQueryPool(void *args)
40806 {
40807     struct vkResetQueryPool_params *params = args;
40808
40809     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
40810
40811     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
40812     return STATUS_SUCCESS;
40813 }
40814 #endif /* _WIN64 */
40815
40816 static NTSTATUS thunk32_vkResetQueryPool(void *args)
40817 {
40818     struct
40819     {
40820         PTR32 device;
40821         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
40822         uint32_t firstQuery;
40823         uint32_t queryCount;
40824     } *params = args;
40825
40826     TRACE("%#x, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
40827
40828     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);
40829     return STATUS_SUCCESS;
40830 }
40831
40832 #ifdef _WIN64
40833 static NTSTATUS thunk64_vkResetQueryPoolEXT(void *args)
40834 {
40835     struct vkResetQueryPoolEXT_params *params = args;
40836
40837     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
40838
40839     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPoolEXT(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
40840     return STATUS_SUCCESS;
40841 }
40842 #endif /* _WIN64 */
40843
40844 static NTSTATUS thunk32_vkResetQueryPoolEXT(void *args)
40845 {
40846     struct
40847     {
40848         PTR32 device;
40849         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
40850         uint32_t firstQuery;
40851         uint32_t queryCount;
40852     } *params = args;
40853
40854     TRACE("%#x, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
40855
40856     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);
40857     return STATUS_SUCCESS;
40858 }
40859
40860 #ifdef _WIN64
40861 static NTSTATUS thunk64_vkSetDebugUtilsObjectNameEXT(void *args)
40862 {
40863     struct vkSetDebugUtilsObjectNameEXT_params *params = args;
40864     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;
40865
40866     TRACE("%p, %p\n", params->device, params->pNameInfo);
40867
40868     convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(params->pNameInfo, &pNameInfo_host);
40869     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
40870     return STATUS_SUCCESS;
40871 }
40872 #endif /* _WIN64 */
40873
40874 static NTSTATUS thunk32_vkSetDebugUtilsObjectNameEXT(void *args)
40875 {
40876     struct
40877     {
40878         PTR32 device;
40879         PTR32 pNameInfo;
40880         VkResult result;
40881     } *params = args;
40882     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;
40883
40884     TRACE("%#x, %#x\n", params->device, params->pNameInfo);
40885
40886     convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host((const VkDebugUtilsObjectNameInfoEXT32 *)UlongToPtr(params->pNameInfo), &pNameInfo_host);
40887     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pNameInfo_host);
40888     return STATUS_SUCCESS;
40889 }
40890
40891 #ifdef _WIN64
40892 static NTSTATUS thunk64_vkSetDebugUtilsObjectTagEXT(void *args)
40893 {
40894     struct vkSetDebugUtilsObjectTagEXT_params *params = args;
40895     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;
40896
40897     TRACE("%p, %p\n", params->device, params->pTagInfo);
40898
40899     convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(params->pTagInfo, &pTagInfo_host);
40900     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
40901     return STATUS_SUCCESS;
40902 }
40903 #endif /* _WIN64 */
40904
40905 static NTSTATUS thunk32_vkSetDebugUtilsObjectTagEXT(void *args)
40906 {
40907     struct
40908     {
40909         PTR32 device;
40910         PTR32 pTagInfo;
40911         VkResult result;
40912     } *params = args;
40913     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;
40914
40915     TRACE("%#x, %#x\n", params->device, params->pTagInfo);
40916
40917     convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host((const VkDebugUtilsObjectTagInfoEXT32 *)UlongToPtr(params->pTagInfo), &pTagInfo_host);
40918     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pTagInfo_host);
40919     return STATUS_SUCCESS;
40920 }
40921
40922 #ifdef _WIN64
40923 static NTSTATUS thunk64_vkSetDeviceMemoryPriorityEXT(void *args)
40924 {
40925     struct vkSetDeviceMemoryPriorityEXT_params *params = args;
40926
40927     TRACE("%p, 0x%s, %f\n", params->device, wine_dbgstr_longlong(params->memory), params->priority);
40928
40929     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);
40930     return STATUS_SUCCESS;
40931 }
40932 #endif /* _WIN64 */
40933
40934 static NTSTATUS thunk32_vkSetDeviceMemoryPriorityEXT(void *args)
40935 {
40936     struct
40937     {
40938         PTR32 device;
40939         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
40940         float priority;
40941     } *params = args;
40942
40943     TRACE("%#x, 0x%s, %f\n", params->device, wine_dbgstr_longlong(params->memory), params->priority);
40944
40945     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);
40946     return STATUS_SUCCESS;
40947 }
40948
40949 #ifdef _WIN64
40950 static NTSTATUS thunk64_vkSetEvent(void *args)
40951 {
40952     struct vkSetEvent_params *params = args;
40953
40954     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
40955
40956     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetEvent(wine_device_from_handle(params->device)->device, params->event);
40957     return STATUS_SUCCESS;
40958 }
40959 #endif /* _WIN64 */
40960
40961 static NTSTATUS thunk32_vkSetEvent(void *args)
40962 {
40963     struct
40964     {
40965         PTR32 device;
40966         VkEvent DECLSPEC_ALIGN(8) event;
40967         VkResult result;
40968     } *params = args;
40969
40970     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
40971
40972     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
40973     return STATUS_SUCCESS;
40974 }
40975
40976 #ifdef _WIN64
40977 static NTSTATUS thunk64_vkSetHdrMetadataEXT(void *args)
40978 {
40979     struct vkSetHdrMetadataEXT_params *params = args;
40980
40981     TRACE("%p, %u, %p, %p\n", params->device, params->swapchainCount, params->pSwapchains, params->pMetadata);
40982
40983     wine_device_from_handle(params->device)->funcs.p_vkSetHdrMetadataEXT(wine_device_from_handle(params->device)->device, params->swapchainCount, params->pSwapchains, params->pMetadata);
40984     return STATUS_SUCCESS;
40985 }
40986 #endif /* _WIN64 */
40987
40988 static NTSTATUS thunk32_vkSetHdrMetadataEXT(void *args)
40989 {
40990     struct
40991     {
40992         PTR32 device;
40993         uint32_t swapchainCount;
40994         PTR32 pSwapchains;
40995         PTR32 pMetadata;
40996     } *params = args;
40997     const VkHdrMetadataEXT *pMetadata_host;
40998     struct conversion_context local_ctx;
40999     struct conversion_context *ctx = &local_ctx;
41000
41001     TRACE("%#x, %u, %#x, %#x\n", params->device, params->swapchainCount, params->pSwapchains, params->pMetadata);
41002
41003     init_conversion_context(ctx);
41004     pMetadata_host = convert_VkHdrMetadataEXT_array_win32_to_host(ctx, (const VkHdrMetadataEXT32 *)UlongToPtr(params->pMetadata), params->swapchainCount);
41005     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);
41006     free_conversion_context(ctx);
41007     return STATUS_SUCCESS;
41008 }
41009
41010 #ifdef _WIN64
41011 static NTSTATUS thunk64_vkSetPrivateData(void *args)
41012 {
41013     struct vkSetPrivateData_params *params = args;
41014
41015     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));
41016
41017     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);
41018     return STATUS_SUCCESS;
41019 }
41020 #endif /* _WIN64 */
41021
41022 static NTSTATUS thunk32_vkSetPrivateData(void *args)
41023 {
41024     struct
41025     {
41026         PTR32 device;
41027         VkObjectType objectType;
41028         uint64_t DECLSPEC_ALIGN(8) objectHandle;
41029         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
41030         uint64_t DECLSPEC_ALIGN(8) data;
41031         VkResult result;
41032     } *params = args;
41033
41034     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));
41035
41036     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);
41037     return STATUS_SUCCESS;
41038 }
41039
41040 #ifdef _WIN64
41041 static NTSTATUS thunk64_vkSetPrivateDataEXT(void *args)
41042 {
41043     struct vkSetPrivateDataEXT_params *params = args;
41044
41045     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));
41046
41047     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);
41048     return STATUS_SUCCESS;
41049 }
41050 #endif /* _WIN64 */
41051
41052 static NTSTATUS thunk32_vkSetPrivateDataEXT(void *args)
41053 {
41054     struct
41055     {
41056         PTR32 device;
41057         VkObjectType objectType;
41058         uint64_t DECLSPEC_ALIGN(8) objectHandle;
41059         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
41060         uint64_t DECLSPEC_ALIGN(8) data;
41061         VkResult result;
41062     } *params = args;
41063
41064     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));
41065
41066     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);
41067     return STATUS_SUCCESS;
41068 }
41069
41070 #ifdef _WIN64
41071 static NTSTATUS thunk64_vkSignalSemaphore(void *args)
41072 {
41073     struct vkSignalSemaphore_params *params = args;
41074
41075     TRACE("%p, %p\n", params->device, params->pSignalInfo);
41076
41077     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphore(wine_device_from_handle(params->device)->device, params->pSignalInfo);
41078     return STATUS_SUCCESS;
41079 }
41080 #endif /* _WIN64 */
41081
41082 static NTSTATUS thunk32_vkSignalSemaphore(void *args)
41083 {
41084     struct
41085     {
41086         PTR32 device;
41087         PTR32 pSignalInfo;
41088         VkResult result;
41089     } *params = args;
41090     VkSemaphoreSignalInfo pSignalInfo_host;
41091
41092     TRACE("%#x, %#x\n", params->device, params->pSignalInfo);
41093
41094     convert_VkSemaphoreSignalInfo_win32_to_host((const VkSemaphoreSignalInfo32 *)UlongToPtr(params->pSignalInfo), &pSignalInfo_host);
41095     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSignalSemaphore(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pSignalInfo_host);
41096     return STATUS_SUCCESS;
41097 }
41098
41099 #ifdef _WIN64
41100 static NTSTATUS thunk64_vkSignalSemaphoreKHR(void *args)
41101 {
41102     struct vkSignalSemaphoreKHR_params *params = args;
41103
41104     TRACE("%p, %p\n", params->device, params->pSignalInfo);
41105
41106     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle(params->device)->device, params->pSignalInfo);
41107     return STATUS_SUCCESS;
41108 }
41109 #endif /* _WIN64 */
41110
41111 static NTSTATUS thunk32_vkSignalSemaphoreKHR(void *args)
41112 {
41113     struct
41114     {
41115         PTR32 device;
41116         PTR32 pSignalInfo;
41117         VkResult result;
41118     } *params = args;
41119     VkSemaphoreSignalInfo pSignalInfo_host;
41120
41121     TRACE("%#x, %#x\n", params->device, params->pSignalInfo);
41122
41123     convert_VkSemaphoreSignalInfo_win32_to_host((const VkSemaphoreSignalInfo32 *)UlongToPtr(params->pSignalInfo), &pSignalInfo_host);
41124     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pSignalInfo_host);
41125     return STATUS_SUCCESS;
41126 }
41127
41128 #ifdef _WIN64
41129 static NTSTATUS thunk64_vkSubmitDebugUtilsMessageEXT(void *args)
41130 {
41131     struct vkSubmitDebugUtilsMessageEXT_params *params = args;
41132     VkDebugUtilsMessengerCallbackDataEXT pCallbackData_host;
41133     struct conversion_context local_ctx;
41134     struct conversion_context *ctx = &local_ctx;
41135
41136     TRACE("%p, %#x, %#x, %p\n", params->instance, params->messageSeverity, params->messageTypes, params->pCallbackData);
41137
41138     init_conversion_context(ctx);
41139     convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(ctx, params->pCallbackData, &pCallbackData_host);
41140     wine_instance_from_handle(params->instance)->funcs.p_vkSubmitDebugUtilsMessageEXT(wine_instance_from_handle(params->instance)->instance, params->messageSeverity, params->messageTypes, &pCallbackData_host);
41141     free_conversion_context(ctx);
41142     return STATUS_SUCCESS;
41143 }
41144 #endif /* _WIN64 */
41145
41146 static NTSTATUS thunk32_vkSubmitDebugUtilsMessageEXT(void *args)
41147 {
41148     struct
41149     {
41150         PTR32 instance;
41151         VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity;
41152         VkDebugUtilsMessageTypeFlagsEXT messageTypes;
41153         PTR32 pCallbackData;
41154     } *params = args;
41155     VkDebugUtilsMessengerCallbackDataEXT pCallbackData_host;
41156     struct conversion_context local_ctx;
41157     struct conversion_context *ctx = &local_ctx;
41158
41159     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->messageSeverity, params->messageTypes, params->pCallbackData);
41160
41161     init_conversion_context(ctx);
41162     convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(ctx, (const VkDebugUtilsMessengerCallbackDataEXT32 *)UlongToPtr(params->pCallbackData), &pCallbackData_host);
41163     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);
41164     free_conversion_context(ctx);
41165     return STATUS_SUCCESS;
41166 }
41167
41168 #ifdef _WIN64
41169 static NTSTATUS thunk64_vkTrimCommandPool(void *args)
41170 {
41171     struct vkTrimCommandPool_params *params = args;
41172
41173     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
41174
41175     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);
41176     return STATUS_SUCCESS;
41177 }
41178 #endif /* _WIN64 */
41179
41180 static NTSTATUS thunk32_vkTrimCommandPool(void *args)
41181 {
41182     struct
41183     {
41184         PTR32 device;
41185         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
41186         VkCommandPoolTrimFlags flags;
41187     } *params = args;
41188
41189     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
41190
41191     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);
41192     return STATUS_SUCCESS;
41193 }
41194
41195 #ifdef _WIN64
41196 static NTSTATUS thunk64_vkTrimCommandPoolKHR(void *args)
41197 {
41198     struct vkTrimCommandPoolKHR_params *params = args;
41199
41200     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
41201
41202     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);
41203     return STATUS_SUCCESS;
41204 }
41205 #endif /* _WIN64 */
41206
41207 static NTSTATUS thunk32_vkTrimCommandPoolKHR(void *args)
41208 {
41209     struct
41210     {
41211         PTR32 device;
41212         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
41213         VkCommandPoolTrimFlags flags;
41214     } *params = args;
41215
41216     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
41217
41218     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);
41219     return STATUS_SUCCESS;
41220 }
41221
41222 #ifdef _WIN64
41223 static NTSTATUS thunk64_vkUninitializePerformanceApiINTEL(void *args)
41224 {
41225     struct vkUninitializePerformanceApiINTEL_params *params = args;
41226
41227     TRACE("%p\n", params->device);
41228
41229     wine_device_from_handle(params->device)->funcs.p_vkUninitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device);
41230     return STATUS_SUCCESS;
41231 }
41232 #endif /* _WIN64 */
41233
41234 static NTSTATUS thunk32_vkUninitializePerformanceApiINTEL(void *args)
41235 {
41236     struct
41237     {
41238         PTR32 device;
41239     } *params = args;
41240
41241     TRACE("%#x\n", params->device);
41242
41243     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUninitializePerformanceApiINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
41244     return STATUS_SUCCESS;
41245 }
41246
41247 #ifdef _WIN64
41248 static NTSTATUS thunk64_vkUnmapMemory(void *args)
41249 {
41250     struct vkUnmapMemory_params *params = args;
41251
41252     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->memory));
41253
41254     wine_vkUnmapMemory(params->device, params->memory);
41255     return STATUS_SUCCESS;
41256 }
41257 #endif /* _WIN64 */
41258
41259 static NTSTATUS thunk32_vkUnmapMemory(void *args)
41260 {
41261     struct
41262     {
41263         PTR32 device;
41264         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
41265     } *params = args;
41266
41267     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->memory));
41268
41269     wine_vkUnmapMemory((VkDevice)UlongToPtr(params->device), params->memory);
41270     return STATUS_SUCCESS;
41271 }
41272
41273 #ifdef _WIN64
41274 static NTSTATUS thunk64_vkUnmapMemory2KHR(void *args)
41275 {
41276     struct vkUnmapMemory2KHR_params *params = args;
41277
41278     TRACE("%p, %p\n", params->device, params->pMemoryUnmapInfo);
41279
41280     params->result = wine_vkUnmapMemory2KHR(params->device, params->pMemoryUnmapInfo);
41281     return STATUS_SUCCESS;
41282 }
41283 #endif /* _WIN64 */
41284
41285 static NTSTATUS thunk32_vkUnmapMemory2KHR(void *args)
41286 {
41287     struct
41288     {
41289         PTR32 device;
41290         PTR32 pMemoryUnmapInfo;
41291         VkResult result;
41292     } *params = args;
41293     VkMemoryUnmapInfoKHR pMemoryUnmapInfo_host;
41294
41295     TRACE("%#x, %#x\n", params->device, params->pMemoryUnmapInfo);
41296
41297     convert_VkMemoryUnmapInfoKHR_win32_to_unwrapped_host((const VkMemoryUnmapInfoKHR32 *)UlongToPtr(params->pMemoryUnmapInfo), &pMemoryUnmapInfo_host);
41298     params->result = wine_vkUnmapMemory2KHR((VkDevice)UlongToPtr(params->device), &pMemoryUnmapInfo_host);
41299     return STATUS_SUCCESS;
41300 }
41301
41302 #ifdef _WIN64
41303 static void thunk64_vkUpdateDescriptorSetWithTemplate(void *args)
41304 {
41305     struct vkUpdateDescriptorSetWithTemplate_params *params = args;
41306
41307     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
41308 }
41309 #endif /* _WIN64 */
41310
41311 static void thunk32_vkUpdateDescriptorSetWithTemplate(void *args)
41312 {
41313     struct
41314     {
41315         PTR32 device;
41316         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
41317         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
41318         PTR32 pData;
41319     } *params = args;
41320
41321     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));
41322 }
41323
41324 #ifdef _WIN64
41325 static NTSTATUS thunk64_vkUpdateDescriptorSetWithTemplateKHR(void *args)
41326 {
41327     struct vkUpdateDescriptorSetWithTemplateKHR_params *params = args;
41328
41329     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
41330
41331     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
41332     return STATUS_SUCCESS;
41333 }
41334 #endif /* _WIN64 */
41335
41336 static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplateKHR(void *args)
41337 {
41338     struct
41339     {
41340         PTR32 device;
41341         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
41342         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
41343         PTR32 pData;
41344     } *params = args;
41345
41346     TRACE("%#x, 0x%s, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
41347
41348     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));
41349     return STATUS_SUCCESS;
41350 }
41351
41352 #ifdef _WIN64
41353 static void thunk64_vkUpdateDescriptorSets(void *args)
41354 {
41355     struct vkUpdateDescriptorSets_params *params = args;
41356
41357     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
41358 }
41359 #endif /* _WIN64 */
41360
41361 static void thunk32_vkUpdateDescriptorSets(void *args)
41362 {
41363     struct
41364     {
41365         PTR32 device;
41366         uint32_t descriptorWriteCount;
41367         PTR32 pDescriptorWrites;
41368         uint32_t descriptorCopyCount;
41369         PTR32 pDescriptorCopies;
41370     } *params = args;
41371     const VkWriteDescriptorSet *pDescriptorWrites_host;
41372     const VkCopyDescriptorSet *pDescriptorCopies_host;
41373     struct conversion_context local_ctx;
41374     struct conversion_context *ctx = &local_ctx;
41375
41376     init_conversion_context(ctx);
41377     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(ctx, (const VkWriteDescriptorSet32 *)UlongToPtr(params->pDescriptorWrites), params->descriptorWriteCount);
41378     pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win32_to_host(ctx, (const VkCopyDescriptorSet32 *)UlongToPtr(params->pDescriptorCopies), params->descriptorCopyCount);
41379     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);
41380     free_conversion_context(ctx);
41381 }
41382
41383 #ifdef _WIN64
41384 static NTSTATUS thunk64_vkWaitForFences(void *args)
41385 {
41386     struct vkWaitForFences_params *params = args;
41387
41388     TRACE("%p, %u, %p, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));
41389
41390     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);
41391     return STATUS_SUCCESS;
41392 }
41393 #endif /* _WIN64 */
41394
41395 static NTSTATUS thunk32_vkWaitForFences(void *args)
41396 {
41397     struct
41398     {
41399         PTR32 device;
41400         uint32_t fenceCount;
41401         PTR32 pFences;
41402         VkBool32 waitAll;
41403         uint64_t DECLSPEC_ALIGN(8) timeout;
41404         VkResult result;
41405     } *params = args;
41406
41407     TRACE("%#x, %u, %#x, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));
41408
41409     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);
41410     return STATUS_SUCCESS;
41411 }
41412
41413 #ifdef _WIN64
41414 static NTSTATUS thunk64_vkWaitForPresentKHR(void *args)
41415 {
41416     struct vkWaitForPresentKHR_params *params = args;
41417
41418     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));
41419
41420     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForPresentKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->presentId, params->timeout);
41421     return STATUS_SUCCESS;
41422 }
41423 #endif /* _WIN64 */
41424
41425 static NTSTATUS thunk32_vkWaitForPresentKHR(void *args)
41426 {
41427     struct
41428     {
41429         PTR32 device;
41430         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
41431         uint64_t DECLSPEC_ALIGN(8) presentId;
41432         uint64_t DECLSPEC_ALIGN(8) timeout;
41433         VkResult result;
41434     } *params = args;
41435
41436     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));
41437
41438     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);
41439     return STATUS_SUCCESS;
41440 }
41441
41442 #ifdef _WIN64
41443 static NTSTATUS thunk64_vkWaitSemaphores(void *args)
41444 {
41445     struct vkWaitSemaphores_params *params = args;
41446
41447     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
41448
41449     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphores(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
41450     return STATUS_SUCCESS;
41451 }
41452 #endif /* _WIN64 */
41453
41454 static NTSTATUS thunk32_vkWaitSemaphores(void *args)
41455 {
41456     struct
41457     {
41458         PTR32 device;
41459         PTR32 pWaitInfo;
41460         uint64_t DECLSPEC_ALIGN(8) timeout;
41461         VkResult result;
41462     } *params = args;
41463     VkSemaphoreWaitInfo pWaitInfo_host;
41464
41465     TRACE("%#x, %#x, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
41466
41467     convert_VkSemaphoreWaitInfo_win32_to_host((const VkSemaphoreWaitInfo32 *)UlongToPtr(params->pWaitInfo), &pWaitInfo_host);
41468     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);
41469     return STATUS_SUCCESS;
41470 }
41471
41472 #ifdef _WIN64
41473 static NTSTATUS thunk64_vkWaitSemaphoresKHR(void *args)
41474 {
41475     struct vkWaitSemaphoresKHR_params *params = args;
41476
41477     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
41478
41479     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
41480     return STATUS_SUCCESS;
41481 }
41482 #endif /* _WIN64 */
41483
41484 static NTSTATUS thunk32_vkWaitSemaphoresKHR(void *args)
41485 {
41486     struct
41487     {
41488         PTR32 device;
41489         PTR32 pWaitInfo;
41490         uint64_t DECLSPEC_ALIGN(8) timeout;
41491         VkResult result;
41492     } *params = args;
41493     VkSemaphoreWaitInfo pWaitInfo_host;
41494
41495     TRACE("%#x, %#x, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
41496
41497     convert_VkSemaphoreWaitInfo_win32_to_host((const VkSemaphoreWaitInfo32 *)UlongToPtr(params->pWaitInfo), &pWaitInfo_host);
41498     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);
41499     return STATUS_SUCCESS;
41500 }
41501
41502 #ifdef _WIN64
41503 static NTSTATUS thunk64_vkWriteAccelerationStructuresPropertiesKHR(void *args)
41504 {
41505     struct vkWriteAccelerationStructuresPropertiesKHR_params *params = args;
41506
41507     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));
41508
41509     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);
41510     return STATUS_SUCCESS;
41511 }
41512 #endif /* _WIN64 */
41513
41514 static NTSTATUS thunk32_vkWriteAccelerationStructuresPropertiesKHR(void *args)
41515 {
41516     struct
41517     {
41518         PTR32 device;
41519         uint32_t accelerationStructureCount;
41520         PTR32 pAccelerationStructures;
41521         VkQueryType queryType;
41522         PTR32 dataSize;
41523         PTR32 pData;
41524         PTR32 stride;
41525         VkResult result;
41526     } *params = args;
41527
41528     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));
41529
41530     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);
41531     return STATUS_SUCCESS;
41532 }
41533
41534 #ifdef _WIN64
41535 static NTSTATUS thunk64_vkWriteMicromapsPropertiesEXT(void *args)
41536 {
41537     struct vkWriteMicromapsPropertiesEXT_params *params = args;
41538
41539     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));
41540
41541     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);
41542     return STATUS_SUCCESS;
41543 }
41544 #endif /* _WIN64 */
41545
41546 static NTSTATUS thunk32_vkWriteMicromapsPropertiesEXT(void *args)
41547 {
41548     struct
41549     {
41550         PTR32 device;
41551         uint32_t micromapCount;
41552         PTR32 pMicromaps;
41553         VkQueryType queryType;
41554         PTR32 dataSize;
41555         PTR32 pData;
41556         PTR32 stride;
41557         VkResult result;
41558     } *params = args;
41559
41560     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));
41561
41562     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);
41563     return STATUS_SUCCESS;
41564 }
41565
41566 static const char * const vk_device_extensions[] =
41567 {
41568     "VK_AMD_buffer_marker",
41569     "VK_AMD_device_coherent_memory",
41570     "VK_AMD_draw_indirect_count",
41571     "VK_AMD_gcn_shader",
41572     "VK_AMD_gpu_shader_half_float",
41573     "VK_AMD_gpu_shader_int16",
41574     "VK_AMD_memory_overallocation_behavior",
41575     "VK_AMD_mixed_attachment_samples",
41576     "VK_AMD_negative_viewport_height",
41577     "VK_AMD_pipeline_compiler_control",
41578     "VK_AMD_rasterization_order",
41579     "VK_AMD_shader_ballot",
41580     "VK_AMD_shader_core_properties",
41581     "VK_AMD_shader_core_properties2",
41582     "VK_AMD_shader_early_and_late_fragment_tests",
41583     "VK_AMD_shader_explicit_vertex_parameter",
41584     "VK_AMD_shader_fragment_mask",
41585     "VK_AMD_shader_image_load_store_lod",
41586     "VK_AMD_shader_info",
41587     "VK_AMD_shader_trinary_minmax",
41588     "VK_AMD_texture_gather_bias_lod",
41589     "VK_ARM_rasterization_order_attachment_access",
41590     "VK_ARM_shader_core_builtins",
41591     "VK_ARM_shader_core_properties",
41592     "VK_EXT_4444_formats",
41593     "VK_EXT_astc_decode_mode",
41594     "VK_EXT_attachment_feedback_loop_dynamic_state",
41595     "VK_EXT_attachment_feedback_loop_layout",
41596     "VK_EXT_blend_operation_advanced",
41597     "VK_EXT_border_color_swizzle",
41598     "VK_EXT_buffer_device_address",
41599     "VK_EXT_calibrated_timestamps",
41600     "VK_EXT_color_write_enable",
41601     "VK_EXT_conditional_rendering",
41602     "VK_EXT_conservative_rasterization",
41603     "VK_EXT_custom_border_color",
41604     "VK_EXT_debug_marker",
41605     "VK_EXT_depth_bias_control",
41606     "VK_EXT_depth_clamp_zero_one",
41607     "VK_EXT_depth_clip_control",
41608     "VK_EXT_depth_clip_enable",
41609     "VK_EXT_depth_range_unrestricted",
41610     "VK_EXT_descriptor_buffer",
41611     "VK_EXT_descriptor_indexing",
41612     "VK_EXT_device_address_binding_report",
41613     "VK_EXT_device_fault",
41614     "VK_EXT_discard_rectangles",
41615     "VK_EXT_dynamic_rendering_unused_attachments",
41616     "VK_EXT_extended_dynamic_state",
41617     "VK_EXT_extended_dynamic_state2",
41618     "VK_EXT_extended_dynamic_state3",
41619     "VK_EXT_external_memory_acquire_unmodified",
41620     "VK_EXT_external_memory_host",
41621     "VK_EXT_filter_cubic",
41622     "VK_EXT_fragment_density_map",
41623     "VK_EXT_fragment_density_map2",
41624     "VK_EXT_fragment_shader_interlock",
41625     "VK_EXT_global_priority",
41626     "VK_EXT_global_priority_query",
41627     "VK_EXT_graphics_pipeline_library",
41628     "VK_EXT_hdr_metadata",
41629     "VK_EXT_host_query_reset",
41630     "VK_EXT_image_2d_view_of_3d",
41631     "VK_EXT_image_compression_control",
41632     "VK_EXT_image_compression_control_swapchain",
41633     "VK_EXT_image_robustness",
41634     "VK_EXT_image_sliced_view_of_3d",
41635     "VK_EXT_image_view_min_lod",
41636     "VK_EXT_index_type_uint8",
41637     "VK_EXT_inline_uniform_block",
41638     "VK_EXT_legacy_dithering",
41639     "VK_EXT_line_rasterization",
41640     "VK_EXT_load_store_op_none",
41641     "VK_EXT_memory_budget",
41642     "VK_EXT_memory_priority",
41643     "VK_EXT_mesh_shader",
41644     "VK_EXT_multi_draw",
41645     "VK_EXT_multisampled_render_to_single_sampled",
41646     "VK_EXT_mutable_descriptor_type",
41647     "VK_EXT_non_seamless_cube_map",
41648     "VK_EXT_opacity_micromap",
41649     "VK_EXT_pageable_device_local_memory",
41650     "VK_EXT_pci_bus_info",
41651     "VK_EXT_pipeline_creation_cache_control",
41652     "VK_EXT_pipeline_creation_feedback",
41653     "VK_EXT_pipeline_library_group_handles",
41654     "VK_EXT_pipeline_properties",
41655     "VK_EXT_pipeline_protected_access",
41656     "VK_EXT_pipeline_robustness",
41657     "VK_EXT_post_depth_coverage",
41658     "VK_EXT_primitive_topology_list_restart",
41659     "VK_EXT_primitives_generated_query",
41660     "VK_EXT_private_data",
41661     "VK_EXT_provoking_vertex",
41662     "VK_EXT_queue_family_foreign",
41663     "VK_EXT_rasterization_order_attachment_access",
41664     "VK_EXT_rgba10x6_formats",
41665     "VK_EXT_robustness2",
41666     "VK_EXT_sample_locations",
41667     "VK_EXT_sampler_filter_minmax",
41668     "VK_EXT_scalar_block_layout",
41669     "VK_EXT_separate_stencil_usage",
41670     "VK_EXT_shader_atomic_float",
41671     "VK_EXT_shader_atomic_float2",
41672     "VK_EXT_shader_demote_to_helper_invocation",
41673     "VK_EXT_shader_image_atomic_int64",
41674     "VK_EXT_shader_module_identifier",
41675     "VK_EXT_shader_object",
41676     "VK_EXT_shader_stencil_export",
41677     "VK_EXT_shader_subgroup_ballot",
41678     "VK_EXT_shader_subgroup_vote",
41679     "VK_EXT_shader_tile_image",
41680     "VK_EXT_shader_viewport_index_layer",
41681     "VK_EXT_subgroup_size_control",
41682     "VK_EXT_subpass_merge_feedback",
41683     "VK_EXT_swapchain_maintenance1",
41684     "VK_EXT_texel_buffer_alignment",
41685     "VK_EXT_texture_compression_astc_hdr",
41686     "VK_EXT_tooling_info",
41687     "VK_EXT_transform_feedback",
41688     "VK_EXT_validation_cache",
41689     "VK_EXT_vertex_attribute_divisor",
41690     "VK_EXT_vertex_input_dynamic_state",
41691     "VK_EXT_ycbcr_2plane_444_formats",
41692     "VK_EXT_ycbcr_image_arrays",
41693     "VK_GOOGLE_decorate_string",
41694     "VK_GOOGLE_hlsl_functionality1",
41695     "VK_GOOGLE_user_type",
41696     "VK_HUAWEI_cluster_culling_shader",
41697     "VK_HUAWEI_invocation_mask",
41698     "VK_HUAWEI_subpass_shading",
41699     "VK_IMG_filter_cubic",
41700     "VK_IMG_format_pvrtc",
41701     "VK_INTEL_performance_query",
41702     "VK_INTEL_shader_integer_functions2",
41703     "VK_KHR_16bit_storage",
41704     "VK_KHR_8bit_storage",
41705     "VK_KHR_acceleration_structure",
41706     "VK_KHR_bind_memory2",
41707     "VK_KHR_buffer_device_address",
41708     "VK_KHR_copy_commands2",
41709     "VK_KHR_create_renderpass2",
41710     "VK_KHR_dedicated_allocation",
41711     "VK_KHR_deferred_host_operations",
41712     "VK_KHR_depth_stencil_resolve",
41713     "VK_KHR_descriptor_update_template",
41714     "VK_KHR_device_group",
41715     "VK_KHR_draw_indirect_count",
41716     "VK_KHR_driver_properties",
41717     "VK_KHR_dynamic_rendering",
41718     "VK_KHR_external_fence",
41719     "VK_KHR_external_memory",
41720     "VK_KHR_external_semaphore",
41721     "VK_KHR_format_feature_flags2",
41722     "VK_KHR_fragment_shader_barycentric",
41723     "VK_KHR_fragment_shading_rate",
41724     "VK_KHR_get_memory_requirements2",
41725     "VK_KHR_global_priority",
41726     "VK_KHR_image_format_list",
41727     "VK_KHR_imageless_framebuffer",
41728     "VK_KHR_incremental_present",
41729     "VK_KHR_maintenance1",
41730     "VK_KHR_maintenance2",
41731     "VK_KHR_maintenance3",
41732     "VK_KHR_maintenance4",
41733     "VK_KHR_map_memory2",
41734     "VK_KHR_multiview",
41735     "VK_KHR_performance_query",
41736     "VK_KHR_pipeline_executable_properties",
41737     "VK_KHR_pipeline_library",
41738     "VK_KHR_present_id",
41739     "VK_KHR_present_wait",
41740     "VK_KHR_push_descriptor",
41741     "VK_KHR_ray_query",
41742     "VK_KHR_ray_tracing_maintenance1",
41743     "VK_KHR_ray_tracing_pipeline",
41744     "VK_KHR_ray_tracing_position_fetch",
41745     "VK_KHR_relaxed_block_layout",
41746     "VK_KHR_sampler_mirror_clamp_to_edge",
41747     "VK_KHR_sampler_ycbcr_conversion",
41748     "VK_KHR_separate_depth_stencil_layouts",
41749     "VK_KHR_shader_atomic_int64",
41750     "VK_KHR_shader_clock",
41751     "VK_KHR_shader_draw_parameters",
41752     "VK_KHR_shader_float16_int8",
41753     "VK_KHR_shader_float_controls",
41754     "VK_KHR_shader_integer_dot_product",
41755     "VK_KHR_shader_non_semantic_info",
41756     "VK_KHR_shader_subgroup_extended_types",
41757     "VK_KHR_shader_subgroup_uniform_control_flow",
41758     "VK_KHR_shader_terminate_invocation",
41759     "VK_KHR_spirv_1_4",
41760     "VK_KHR_storage_buffer_storage_class",
41761     "VK_KHR_swapchain",
41762     "VK_KHR_swapchain_mutable_format",
41763     "VK_KHR_synchronization2",
41764     "VK_KHR_timeline_semaphore",
41765     "VK_KHR_uniform_buffer_standard_layout",
41766     "VK_KHR_variable_pointers",
41767     "VK_KHR_vulkan_memory_model",
41768     "VK_KHR_workgroup_memory_explicit_layout",
41769     "VK_KHR_zero_initialize_workgroup_memory",
41770     "VK_NVX_binary_import",
41771     "VK_NVX_image_view_handle",
41772     "VK_NV_clip_space_w_scaling",
41773     "VK_NV_compute_shader_derivatives",
41774     "VK_NV_cooperative_matrix",
41775     "VK_NV_copy_memory_indirect",
41776     "VK_NV_corner_sampled_image",
41777     "VK_NV_coverage_reduction_mode",
41778     "VK_NV_dedicated_allocation",
41779     "VK_NV_dedicated_allocation_image_aliasing",
41780     "VK_NV_device_diagnostic_checkpoints",
41781     "VK_NV_device_diagnostics_config",
41782     "VK_NV_device_generated_commands",
41783     "VK_NV_fill_rectangle",
41784     "VK_NV_fragment_coverage_to_color",
41785     "VK_NV_fragment_shader_barycentric",
41786     "VK_NV_fragment_shading_rate_enums",
41787     "VK_NV_framebuffer_mixed_samples",
41788     "VK_NV_geometry_shader_passthrough",
41789     "VK_NV_glsl_shader",
41790     "VK_NV_inherited_viewport_scissor",
41791     "VK_NV_linear_color_attachment",
41792     "VK_NV_low_latency",
41793     "VK_NV_memory_decompression",
41794     "VK_NV_mesh_shader",
41795     "VK_NV_optical_flow",
41796     "VK_NV_present_barrier",
41797     "VK_NV_ray_tracing",
41798     "VK_NV_ray_tracing_invocation_reorder",
41799     "VK_NV_ray_tracing_motion_blur",
41800     "VK_NV_representative_fragment_test",
41801     "VK_NV_sample_mask_override_coverage",
41802     "VK_NV_scissor_exclusive",
41803     "VK_NV_shader_image_footprint",
41804     "VK_NV_shader_sm_builtins",
41805     "VK_NV_shader_subgroup_partitioned",
41806     "VK_NV_shading_rate_image",
41807     "VK_NV_viewport_array2",
41808     "VK_NV_viewport_swizzle",
41809     "VK_QCOM_fragment_density_map_offset",
41810     "VK_QCOM_image_processing",
41811     "VK_QCOM_multiview_per_view_render_areas",
41812     "VK_QCOM_multiview_per_view_viewports",
41813     "VK_QCOM_render_pass_shader_resolve",
41814     "VK_QCOM_render_pass_store_ops",
41815     "VK_QCOM_render_pass_transform",
41816     "VK_QCOM_rotated_copy_commands",
41817     "VK_QCOM_tile_properties",
41818     "VK_VALVE_descriptor_set_host_mapping",
41819     "VK_VALVE_mutable_descriptor_type",
41820 };
41821
41822 static const char * const vk_instance_extensions[] =
41823 {
41824     "VK_EXT_debug_report",
41825     "VK_EXT_debug_utils",
41826     "VK_EXT_surface_maintenance1",
41827     "VK_EXT_swapchain_colorspace",
41828     "VK_EXT_validation_features",
41829     "VK_EXT_validation_flags",
41830     "VK_KHR_device_group_creation",
41831     "VK_KHR_external_fence_capabilities",
41832     "VK_KHR_external_memory_capabilities",
41833     "VK_KHR_external_semaphore_capabilities",
41834     "VK_KHR_get_physical_device_properties2",
41835     "VK_KHR_get_surface_capabilities2",
41836     "VK_KHR_portability_enumeration",
41837     "VK_KHR_surface",
41838     "VK_KHR_win32_surface",
41839 };
41840
41841 BOOL wine_vk_device_extension_supported(const char *name)
41842 {
41843     unsigned int i;
41844     for (i = 0; i < ARRAY_SIZE(vk_device_extensions); i++)
41845     {
41846         if (strcmp(vk_device_extensions[i], name) == 0)
41847             return TRUE;
41848     }
41849     return FALSE;
41850 }
41851
41852 BOOL wine_vk_instance_extension_supported(const char *name)
41853 {
41854     unsigned int i;
41855     for (i = 0; i < ARRAY_SIZE(vk_instance_extensions); i++)
41856     {
41857         if (strcmp(vk_instance_extensions[i], name) == 0)
41858             return TRUE;
41859     }
41860     return FALSE;
41861 }
41862
41863 BOOL wine_vk_is_type_wrapped(VkObjectType type)
41864 {
41865     return FALSE ||
41866         type == VK_OBJECT_TYPE_COMMAND_BUFFER ||
41867         type == VK_OBJECT_TYPE_COMMAND_POOL ||
41868         type == VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT ||
41869         type == VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT ||
41870         type == VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR ||
41871         type == VK_OBJECT_TYPE_DEVICE ||
41872         type == VK_OBJECT_TYPE_DEVICE_MEMORY ||
41873         type == VK_OBJECT_TYPE_INSTANCE ||
41874         type == VK_OBJECT_TYPE_PHYSICAL_DEVICE ||
41875         type == VK_OBJECT_TYPE_QUEUE ||
41876         type == VK_OBJECT_TYPE_SURFACE_KHR;
41877 }
41878
41879 #ifdef _WIN64
41880
41881 const unixlib_entry_t __wine_unix_call_funcs[] =
41882 {
41883     init_vulkan,
41884     vk_is_available_instance_function,
41885     vk_is_available_device_function,
41886     thunk64_vkAcquireNextImage2KHR,
41887     thunk64_vkAcquireNextImageKHR,
41888     thunk64_vkAcquirePerformanceConfigurationINTEL,
41889     thunk64_vkAcquireProfilingLockKHR,
41890     thunk64_vkAllocateCommandBuffers,
41891     thunk64_vkAllocateDescriptorSets,
41892     thunk64_vkAllocateMemory,
41893     thunk64_vkBeginCommandBuffer,
41894     thunk64_vkBindAccelerationStructureMemoryNV,
41895     thunk64_vkBindBufferMemory,
41896     thunk64_vkBindBufferMemory2,
41897     thunk64_vkBindBufferMemory2KHR,
41898     thunk64_vkBindImageMemory,
41899     thunk64_vkBindImageMemory2,
41900     thunk64_vkBindImageMemory2KHR,
41901     thunk64_vkBindOpticalFlowSessionImageNV,
41902     thunk64_vkBuildAccelerationStructuresKHR,
41903     thunk64_vkBuildMicromapsEXT,
41904     (void *)thunk64_vkCmdBeginConditionalRenderingEXT,
41905     (void *)thunk64_vkCmdBeginDebugUtilsLabelEXT,
41906     (void *)thunk64_vkCmdBeginQuery,
41907     (void *)thunk64_vkCmdBeginQueryIndexedEXT,
41908     (void *)thunk64_vkCmdBeginRenderPass,
41909     (void *)thunk64_vkCmdBeginRenderPass2,
41910     (void *)thunk64_vkCmdBeginRenderPass2KHR,
41911     (void *)thunk64_vkCmdBeginRendering,
41912     (void *)thunk64_vkCmdBeginRenderingKHR,
41913     (void *)thunk64_vkCmdBeginTransformFeedbackEXT,
41914     (void *)thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
41915     (void *)thunk64_vkCmdBindDescriptorBuffersEXT,
41916     (void *)thunk64_vkCmdBindDescriptorSets,
41917     (void *)thunk64_vkCmdBindIndexBuffer,
41918     (void *)thunk64_vkCmdBindInvocationMaskHUAWEI,
41919     (void *)thunk64_vkCmdBindPipeline,
41920     (void *)thunk64_vkCmdBindPipelineShaderGroupNV,
41921     (void *)thunk64_vkCmdBindShadersEXT,
41922     (void *)thunk64_vkCmdBindShadingRateImageNV,
41923     (void *)thunk64_vkCmdBindTransformFeedbackBuffersEXT,
41924     (void *)thunk64_vkCmdBindVertexBuffers,
41925     (void *)thunk64_vkCmdBindVertexBuffers2,
41926     (void *)thunk64_vkCmdBindVertexBuffers2EXT,
41927     (void *)thunk64_vkCmdBlitImage,
41928     (void *)thunk64_vkCmdBlitImage2,
41929     (void *)thunk64_vkCmdBlitImage2KHR,
41930     (void *)thunk64_vkCmdBuildAccelerationStructureNV,
41931     (void *)thunk64_vkCmdBuildAccelerationStructuresIndirectKHR,
41932     (void *)thunk64_vkCmdBuildAccelerationStructuresKHR,
41933     (void *)thunk64_vkCmdBuildMicromapsEXT,
41934     (void *)thunk64_vkCmdClearAttachments,
41935     (void *)thunk64_vkCmdClearColorImage,
41936     (void *)thunk64_vkCmdClearDepthStencilImage,
41937     (void *)thunk64_vkCmdCopyAccelerationStructureKHR,
41938     (void *)thunk64_vkCmdCopyAccelerationStructureNV,
41939     (void *)thunk64_vkCmdCopyAccelerationStructureToMemoryKHR,
41940     (void *)thunk64_vkCmdCopyBuffer,
41941     (void *)thunk64_vkCmdCopyBuffer2,
41942     (void *)thunk64_vkCmdCopyBuffer2KHR,
41943     (void *)thunk64_vkCmdCopyBufferToImage,
41944     (void *)thunk64_vkCmdCopyBufferToImage2,
41945     (void *)thunk64_vkCmdCopyBufferToImage2KHR,
41946     (void *)thunk64_vkCmdCopyImage,
41947     (void *)thunk64_vkCmdCopyImage2,
41948     (void *)thunk64_vkCmdCopyImage2KHR,
41949     (void *)thunk64_vkCmdCopyImageToBuffer,
41950     (void *)thunk64_vkCmdCopyImageToBuffer2,
41951     (void *)thunk64_vkCmdCopyImageToBuffer2KHR,
41952     (void *)thunk64_vkCmdCopyMemoryIndirectNV,
41953     (void *)thunk64_vkCmdCopyMemoryToAccelerationStructureKHR,
41954     (void *)thunk64_vkCmdCopyMemoryToImageIndirectNV,
41955     (void *)thunk64_vkCmdCopyMemoryToMicromapEXT,
41956     (void *)thunk64_vkCmdCopyMicromapEXT,
41957     (void *)thunk64_vkCmdCopyMicromapToMemoryEXT,
41958     (void *)thunk64_vkCmdCopyQueryPoolResults,
41959     (void *)thunk64_vkCmdCuLaunchKernelNVX,
41960     (void *)thunk64_vkCmdDebugMarkerBeginEXT,
41961     (void *)thunk64_vkCmdDebugMarkerEndEXT,
41962     (void *)thunk64_vkCmdDebugMarkerInsertEXT,
41963     (void *)thunk64_vkCmdDecompressMemoryIndirectCountNV,
41964     (void *)thunk64_vkCmdDecompressMemoryNV,
41965     (void *)thunk64_vkCmdDispatch,
41966     (void *)thunk64_vkCmdDispatchBase,
41967     (void *)thunk64_vkCmdDispatchBaseKHR,
41968     (void *)thunk64_vkCmdDispatchIndirect,
41969     (void *)thunk64_vkCmdDraw,
41970     (void *)thunk64_vkCmdDrawClusterHUAWEI,
41971     (void *)thunk64_vkCmdDrawClusterIndirectHUAWEI,
41972     (void *)thunk64_vkCmdDrawIndexed,
41973     (void *)thunk64_vkCmdDrawIndexedIndirect,
41974     (void *)thunk64_vkCmdDrawIndexedIndirectCount,
41975     (void *)thunk64_vkCmdDrawIndexedIndirectCountAMD,
41976     (void *)thunk64_vkCmdDrawIndexedIndirectCountKHR,
41977     (void *)thunk64_vkCmdDrawIndirect,
41978     (void *)thunk64_vkCmdDrawIndirectByteCountEXT,
41979     (void *)thunk64_vkCmdDrawIndirectCount,
41980     (void *)thunk64_vkCmdDrawIndirectCountAMD,
41981     (void *)thunk64_vkCmdDrawIndirectCountKHR,
41982     (void *)thunk64_vkCmdDrawMeshTasksEXT,
41983     (void *)thunk64_vkCmdDrawMeshTasksIndirectCountEXT,
41984     (void *)thunk64_vkCmdDrawMeshTasksIndirectCountNV,
41985     (void *)thunk64_vkCmdDrawMeshTasksIndirectEXT,
41986     (void *)thunk64_vkCmdDrawMeshTasksIndirectNV,
41987     (void *)thunk64_vkCmdDrawMeshTasksNV,
41988     (void *)thunk64_vkCmdDrawMultiEXT,
41989     (void *)thunk64_vkCmdDrawMultiIndexedEXT,
41990     (void *)thunk64_vkCmdEndConditionalRenderingEXT,
41991     (void *)thunk64_vkCmdEndDebugUtilsLabelEXT,
41992     (void *)thunk64_vkCmdEndQuery,
41993     (void *)thunk64_vkCmdEndQueryIndexedEXT,
41994     (void *)thunk64_vkCmdEndRenderPass,
41995     (void *)thunk64_vkCmdEndRenderPass2,
41996     (void *)thunk64_vkCmdEndRenderPass2KHR,
41997     (void *)thunk64_vkCmdEndRendering,
41998     (void *)thunk64_vkCmdEndRenderingKHR,
41999     (void *)thunk64_vkCmdEndTransformFeedbackEXT,
42000     (void *)thunk64_vkCmdExecuteCommands,
42001     (void *)thunk64_vkCmdExecuteGeneratedCommandsNV,
42002     (void *)thunk64_vkCmdFillBuffer,
42003     (void *)thunk64_vkCmdInsertDebugUtilsLabelEXT,
42004     (void *)thunk64_vkCmdNextSubpass,
42005     (void *)thunk64_vkCmdNextSubpass2,
42006     (void *)thunk64_vkCmdNextSubpass2KHR,
42007     (void *)thunk64_vkCmdOpticalFlowExecuteNV,
42008     (void *)thunk64_vkCmdPipelineBarrier,
42009     (void *)thunk64_vkCmdPipelineBarrier2,
42010     (void *)thunk64_vkCmdPipelineBarrier2KHR,
42011     (void *)thunk64_vkCmdPreprocessGeneratedCommandsNV,
42012     (void *)thunk64_vkCmdPushConstants,
42013     (void *)thunk64_vkCmdPushDescriptorSetKHR,
42014     (void *)thunk64_vkCmdPushDescriptorSetWithTemplateKHR,
42015     (void *)thunk64_vkCmdResetEvent,
42016     (void *)thunk64_vkCmdResetEvent2,
42017     (void *)thunk64_vkCmdResetEvent2KHR,
42018     (void *)thunk64_vkCmdResetQueryPool,
42019     (void *)thunk64_vkCmdResolveImage,
42020     (void *)thunk64_vkCmdResolveImage2,
42021     (void *)thunk64_vkCmdResolveImage2KHR,
42022     (void *)thunk64_vkCmdSetAlphaToCoverageEnableEXT,
42023     (void *)thunk64_vkCmdSetAlphaToOneEnableEXT,
42024     (void *)thunk64_vkCmdSetAttachmentFeedbackLoopEnableEXT,
42025     (void *)thunk64_vkCmdSetBlendConstants,
42026     (void *)thunk64_vkCmdSetCheckpointNV,
42027     (void *)thunk64_vkCmdSetCoarseSampleOrderNV,
42028     (void *)thunk64_vkCmdSetColorBlendAdvancedEXT,
42029     (void *)thunk64_vkCmdSetColorBlendEnableEXT,
42030     (void *)thunk64_vkCmdSetColorBlendEquationEXT,
42031     (void *)thunk64_vkCmdSetColorWriteEnableEXT,
42032     (void *)thunk64_vkCmdSetColorWriteMaskEXT,
42033     (void *)thunk64_vkCmdSetConservativeRasterizationModeEXT,
42034     (void *)thunk64_vkCmdSetCoverageModulationModeNV,
42035     (void *)thunk64_vkCmdSetCoverageModulationTableEnableNV,
42036     (void *)thunk64_vkCmdSetCoverageModulationTableNV,
42037     (void *)thunk64_vkCmdSetCoverageReductionModeNV,
42038     (void *)thunk64_vkCmdSetCoverageToColorEnableNV,
42039     (void *)thunk64_vkCmdSetCoverageToColorLocationNV,
42040     (void *)thunk64_vkCmdSetCullMode,
42041     (void *)thunk64_vkCmdSetCullModeEXT,
42042     (void *)thunk64_vkCmdSetDepthBias,
42043     (void *)thunk64_vkCmdSetDepthBias2EXT,
42044     (void *)thunk64_vkCmdSetDepthBiasEnable,
42045     (void *)thunk64_vkCmdSetDepthBiasEnableEXT,
42046     (void *)thunk64_vkCmdSetDepthBounds,
42047     (void *)thunk64_vkCmdSetDepthBoundsTestEnable,
42048     (void *)thunk64_vkCmdSetDepthBoundsTestEnableEXT,
42049     (void *)thunk64_vkCmdSetDepthClampEnableEXT,
42050     (void *)thunk64_vkCmdSetDepthClipEnableEXT,
42051     (void *)thunk64_vkCmdSetDepthClipNegativeOneToOneEXT,
42052     (void *)thunk64_vkCmdSetDepthCompareOp,
42053     (void *)thunk64_vkCmdSetDepthCompareOpEXT,
42054     (void *)thunk64_vkCmdSetDepthTestEnable,
42055     (void *)thunk64_vkCmdSetDepthTestEnableEXT,
42056     (void *)thunk64_vkCmdSetDepthWriteEnable,
42057     (void *)thunk64_vkCmdSetDepthWriteEnableEXT,
42058     (void *)thunk64_vkCmdSetDescriptorBufferOffsetsEXT,
42059     (void *)thunk64_vkCmdSetDeviceMask,
42060     (void *)thunk64_vkCmdSetDeviceMaskKHR,
42061     (void *)thunk64_vkCmdSetDiscardRectangleEXT,
42062     (void *)thunk64_vkCmdSetDiscardRectangleEnableEXT,
42063     (void *)thunk64_vkCmdSetDiscardRectangleModeEXT,
42064     (void *)thunk64_vkCmdSetEvent,
42065     (void *)thunk64_vkCmdSetEvent2,
42066     (void *)thunk64_vkCmdSetEvent2KHR,
42067     (void *)thunk64_vkCmdSetExclusiveScissorEnableNV,
42068     (void *)thunk64_vkCmdSetExclusiveScissorNV,
42069     (void *)thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
42070     (void *)thunk64_vkCmdSetFragmentShadingRateEnumNV,
42071     (void *)thunk64_vkCmdSetFragmentShadingRateKHR,
42072     (void *)thunk64_vkCmdSetFrontFace,
42073     (void *)thunk64_vkCmdSetFrontFaceEXT,
42074     (void *)thunk64_vkCmdSetLineRasterizationModeEXT,
42075     (void *)thunk64_vkCmdSetLineStippleEXT,
42076     (void *)thunk64_vkCmdSetLineStippleEnableEXT,
42077     (void *)thunk64_vkCmdSetLineWidth,
42078     (void *)thunk64_vkCmdSetLogicOpEXT,
42079     (void *)thunk64_vkCmdSetLogicOpEnableEXT,
42080     (void *)thunk64_vkCmdSetPatchControlPointsEXT,
42081     thunk64_vkCmdSetPerformanceMarkerINTEL,
42082     thunk64_vkCmdSetPerformanceOverrideINTEL,
42083     thunk64_vkCmdSetPerformanceStreamMarkerINTEL,
42084     (void *)thunk64_vkCmdSetPolygonModeEXT,
42085     (void *)thunk64_vkCmdSetPrimitiveRestartEnable,
42086     (void *)thunk64_vkCmdSetPrimitiveRestartEnableEXT,
42087     (void *)thunk64_vkCmdSetPrimitiveTopology,
42088     (void *)thunk64_vkCmdSetPrimitiveTopologyEXT,
42089     (void *)thunk64_vkCmdSetProvokingVertexModeEXT,
42090     (void *)thunk64_vkCmdSetRasterizationSamplesEXT,
42091     (void *)thunk64_vkCmdSetRasterizationStreamEXT,
42092     (void *)thunk64_vkCmdSetRasterizerDiscardEnable,
42093     (void *)thunk64_vkCmdSetRasterizerDiscardEnableEXT,
42094     (void *)thunk64_vkCmdSetRayTracingPipelineStackSizeKHR,
42095     (void *)thunk64_vkCmdSetRepresentativeFragmentTestEnableNV,
42096     (void *)thunk64_vkCmdSetSampleLocationsEXT,
42097     (void *)thunk64_vkCmdSetSampleLocationsEnableEXT,
42098     (void *)thunk64_vkCmdSetSampleMaskEXT,
42099     (void *)thunk64_vkCmdSetScissor,
42100     (void *)thunk64_vkCmdSetScissorWithCount,
42101     (void *)thunk64_vkCmdSetScissorWithCountEXT,
42102     (void *)thunk64_vkCmdSetShadingRateImageEnableNV,
42103     (void *)thunk64_vkCmdSetStencilCompareMask,
42104     (void *)thunk64_vkCmdSetStencilOp,
42105     (void *)thunk64_vkCmdSetStencilOpEXT,
42106     (void *)thunk64_vkCmdSetStencilReference,
42107     (void *)thunk64_vkCmdSetStencilTestEnable,
42108     (void *)thunk64_vkCmdSetStencilTestEnableEXT,
42109     (void *)thunk64_vkCmdSetStencilWriteMask,
42110     (void *)thunk64_vkCmdSetTessellationDomainOriginEXT,
42111     (void *)thunk64_vkCmdSetVertexInputEXT,
42112     (void *)thunk64_vkCmdSetViewport,
42113     (void *)thunk64_vkCmdSetViewportShadingRatePaletteNV,
42114     (void *)thunk64_vkCmdSetViewportSwizzleNV,
42115     (void *)thunk64_vkCmdSetViewportWScalingEnableNV,
42116     (void *)thunk64_vkCmdSetViewportWScalingNV,
42117     (void *)thunk64_vkCmdSetViewportWithCount,
42118     (void *)thunk64_vkCmdSetViewportWithCountEXT,
42119     (void *)thunk64_vkCmdSubpassShadingHUAWEI,
42120     (void *)thunk64_vkCmdTraceRaysIndirect2KHR,
42121     (void *)thunk64_vkCmdTraceRaysIndirectKHR,
42122     (void *)thunk64_vkCmdTraceRaysKHR,
42123     (void *)thunk64_vkCmdTraceRaysNV,
42124     (void *)thunk64_vkCmdUpdateBuffer,
42125     (void *)thunk64_vkCmdWaitEvents,
42126     (void *)thunk64_vkCmdWaitEvents2,
42127     (void *)thunk64_vkCmdWaitEvents2KHR,
42128     (void *)thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR,
42129     (void *)thunk64_vkCmdWriteAccelerationStructuresPropertiesNV,
42130     (void *)thunk64_vkCmdWriteBufferMarker2AMD,
42131     (void *)thunk64_vkCmdWriteBufferMarkerAMD,
42132     (void *)thunk64_vkCmdWriteMicromapsPropertiesEXT,
42133     (void *)thunk64_vkCmdWriteTimestamp,
42134     (void *)thunk64_vkCmdWriteTimestamp2,
42135     (void *)thunk64_vkCmdWriteTimestamp2KHR,
42136     thunk64_vkCompileDeferredNV,
42137     thunk64_vkCopyAccelerationStructureKHR,
42138     thunk64_vkCopyAccelerationStructureToMemoryKHR,
42139     thunk64_vkCopyMemoryToAccelerationStructureKHR,
42140     thunk64_vkCopyMemoryToMicromapEXT,
42141     thunk64_vkCopyMicromapEXT,
42142     thunk64_vkCopyMicromapToMemoryEXT,
42143     thunk64_vkCreateAccelerationStructureKHR,
42144     thunk64_vkCreateAccelerationStructureNV,
42145     thunk64_vkCreateBuffer,
42146     thunk64_vkCreateBufferView,
42147     thunk64_vkCreateCommandPool,
42148     thunk64_vkCreateComputePipelines,
42149     thunk64_vkCreateCuFunctionNVX,
42150     thunk64_vkCreateCuModuleNVX,
42151     thunk64_vkCreateDebugReportCallbackEXT,
42152     thunk64_vkCreateDebugUtilsMessengerEXT,
42153     thunk64_vkCreateDeferredOperationKHR,
42154     thunk64_vkCreateDescriptorPool,
42155     thunk64_vkCreateDescriptorSetLayout,
42156     thunk64_vkCreateDescriptorUpdateTemplate,
42157     thunk64_vkCreateDescriptorUpdateTemplateKHR,
42158     thunk64_vkCreateDevice,
42159     thunk64_vkCreateEvent,
42160     thunk64_vkCreateFence,
42161     thunk64_vkCreateFramebuffer,
42162     thunk64_vkCreateGraphicsPipelines,
42163     thunk64_vkCreateImage,
42164     thunk64_vkCreateImageView,
42165     thunk64_vkCreateIndirectCommandsLayoutNV,
42166     thunk64_vkCreateInstance,
42167     thunk64_vkCreateMicromapEXT,
42168     thunk64_vkCreateOpticalFlowSessionNV,
42169     thunk64_vkCreatePipelineCache,
42170     thunk64_vkCreatePipelineLayout,
42171     thunk64_vkCreatePrivateDataSlot,
42172     thunk64_vkCreatePrivateDataSlotEXT,
42173     thunk64_vkCreateQueryPool,
42174     thunk64_vkCreateRayTracingPipelinesKHR,
42175     thunk64_vkCreateRayTracingPipelinesNV,
42176     thunk64_vkCreateRenderPass,
42177     thunk64_vkCreateRenderPass2,
42178     thunk64_vkCreateRenderPass2KHR,
42179     thunk64_vkCreateSampler,
42180     thunk64_vkCreateSamplerYcbcrConversion,
42181     thunk64_vkCreateSamplerYcbcrConversionKHR,
42182     thunk64_vkCreateSemaphore,
42183     thunk64_vkCreateShaderModule,
42184     thunk64_vkCreateShadersEXT,
42185     thunk64_vkCreateSwapchainKHR,
42186     thunk64_vkCreateValidationCacheEXT,
42187     thunk64_vkCreateWin32SurfaceKHR,
42188     thunk64_vkDebugMarkerSetObjectNameEXT,
42189     thunk64_vkDebugMarkerSetObjectTagEXT,
42190     thunk64_vkDebugReportMessageEXT,
42191     thunk64_vkDeferredOperationJoinKHR,
42192     thunk64_vkDestroyAccelerationStructureKHR,
42193     thunk64_vkDestroyAccelerationStructureNV,
42194     thunk64_vkDestroyBuffer,
42195     thunk64_vkDestroyBufferView,
42196     thunk64_vkDestroyCommandPool,
42197     thunk64_vkDestroyCuFunctionNVX,
42198     thunk64_vkDestroyCuModuleNVX,
42199     thunk64_vkDestroyDebugReportCallbackEXT,
42200     thunk64_vkDestroyDebugUtilsMessengerEXT,
42201     thunk64_vkDestroyDeferredOperationKHR,
42202     thunk64_vkDestroyDescriptorPool,
42203     thunk64_vkDestroyDescriptorSetLayout,
42204     thunk64_vkDestroyDescriptorUpdateTemplate,
42205     thunk64_vkDestroyDescriptorUpdateTemplateKHR,
42206     thunk64_vkDestroyDevice,
42207     thunk64_vkDestroyEvent,
42208     thunk64_vkDestroyFence,
42209     thunk64_vkDestroyFramebuffer,
42210     thunk64_vkDestroyImage,
42211     thunk64_vkDestroyImageView,
42212     thunk64_vkDestroyIndirectCommandsLayoutNV,
42213     thunk64_vkDestroyInstance,
42214     thunk64_vkDestroyMicromapEXT,
42215     thunk64_vkDestroyOpticalFlowSessionNV,
42216     thunk64_vkDestroyPipeline,
42217     thunk64_vkDestroyPipelineCache,
42218     thunk64_vkDestroyPipelineLayout,
42219     thunk64_vkDestroyPrivateDataSlot,
42220     thunk64_vkDestroyPrivateDataSlotEXT,
42221     thunk64_vkDestroyQueryPool,
42222     thunk64_vkDestroyRenderPass,
42223     thunk64_vkDestroySampler,
42224     thunk64_vkDestroySamplerYcbcrConversion,
42225     thunk64_vkDestroySamplerYcbcrConversionKHR,
42226     thunk64_vkDestroySemaphore,
42227     thunk64_vkDestroyShaderEXT,
42228     thunk64_vkDestroyShaderModule,
42229     thunk64_vkDestroySurfaceKHR,
42230     thunk64_vkDestroySwapchainKHR,
42231     thunk64_vkDestroyValidationCacheEXT,
42232     thunk64_vkDeviceWaitIdle,
42233     thunk64_vkEndCommandBuffer,
42234     thunk64_vkEnumerateDeviceExtensionProperties,
42235     thunk64_vkEnumerateDeviceLayerProperties,
42236     thunk64_vkEnumerateInstanceExtensionProperties,
42237     thunk64_vkEnumerateInstanceVersion,
42238     thunk64_vkEnumeratePhysicalDeviceGroups,
42239     thunk64_vkEnumeratePhysicalDeviceGroupsKHR,
42240     thunk64_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
42241     thunk64_vkEnumeratePhysicalDevices,
42242     thunk64_vkFlushMappedMemoryRanges,
42243     thunk64_vkFreeCommandBuffers,
42244     thunk64_vkFreeDescriptorSets,
42245     thunk64_vkFreeMemory,
42246     thunk64_vkGetAccelerationStructureBuildSizesKHR,
42247     thunk64_vkGetAccelerationStructureDeviceAddressKHR,
42248     thunk64_vkGetAccelerationStructureHandleNV,
42249     thunk64_vkGetAccelerationStructureMemoryRequirementsNV,
42250     thunk64_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
42251     thunk64_vkGetBufferDeviceAddress,
42252     thunk64_vkGetBufferDeviceAddressEXT,
42253     thunk64_vkGetBufferDeviceAddressKHR,
42254     thunk64_vkGetBufferMemoryRequirements,
42255     thunk64_vkGetBufferMemoryRequirements2,
42256     thunk64_vkGetBufferMemoryRequirements2KHR,
42257     thunk64_vkGetBufferOpaqueCaptureAddress,
42258     thunk64_vkGetBufferOpaqueCaptureAddressKHR,
42259     thunk64_vkGetBufferOpaqueCaptureDescriptorDataEXT,
42260     thunk64_vkGetCalibratedTimestampsEXT,
42261     thunk64_vkGetDeferredOperationMaxConcurrencyKHR,
42262     thunk64_vkGetDeferredOperationResultKHR,
42263     (void *)thunk64_vkGetDescriptorEXT,
42264     thunk64_vkGetDescriptorSetHostMappingVALVE,
42265     thunk64_vkGetDescriptorSetLayoutBindingOffsetEXT,
42266     thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
42267     thunk64_vkGetDescriptorSetLayoutSizeEXT,
42268     thunk64_vkGetDescriptorSetLayoutSupport,
42269     thunk64_vkGetDescriptorSetLayoutSupportKHR,
42270     thunk64_vkGetDeviceAccelerationStructureCompatibilityKHR,
42271     thunk64_vkGetDeviceBufferMemoryRequirements,
42272     thunk64_vkGetDeviceBufferMemoryRequirementsKHR,
42273     thunk64_vkGetDeviceFaultInfoEXT,
42274     thunk64_vkGetDeviceGroupPeerMemoryFeatures,
42275     thunk64_vkGetDeviceGroupPeerMemoryFeaturesKHR,
42276     thunk64_vkGetDeviceGroupPresentCapabilitiesKHR,
42277     thunk64_vkGetDeviceGroupSurfacePresentModesKHR,
42278     thunk64_vkGetDeviceImageMemoryRequirements,
42279     thunk64_vkGetDeviceImageMemoryRequirementsKHR,
42280     thunk64_vkGetDeviceImageSparseMemoryRequirements,
42281     thunk64_vkGetDeviceImageSparseMemoryRequirementsKHR,
42282     thunk64_vkGetDeviceMemoryCommitment,
42283     thunk64_vkGetDeviceMemoryOpaqueCaptureAddress,
42284     thunk64_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
42285     thunk64_vkGetDeviceMicromapCompatibilityEXT,
42286     thunk64_vkGetDeviceQueue,
42287     thunk64_vkGetDeviceQueue2,
42288     thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
42289     thunk64_vkGetDynamicRenderingTilePropertiesQCOM,
42290     thunk64_vkGetEventStatus,
42291     thunk64_vkGetFenceStatus,
42292     thunk64_vkGetFramebufferTilePropertiesQCOM,
42293     thunk64_vkGetGeneratedCommandsMemoryRequirementsNV,
42294     thunk64_vkGetImageMemoryRequirements,
42295     thunk64_vkGetImageMemoryRequirements2,
42296     thunk64_vkGetImageMemoryRequirements2KHR,
42297     thunk64_vkGetImageOpaqueCaptureDescriptorDataEXT,
42298     thunk64_vkGetImageSparseMemoryRequirements,
42299     thunk64_vkGetImageSparseMemoryRequirements2,
42300     thunk64_vkGetImageSparseMemoryRequirements2KHR,
42301     thunk64_vkGetImageSubresourceLayout,
42302     thunk64_vkGetImageSubresourceLayout2EXT,
42303     thunk64_vkGetImageViewAddressNVX,
42304     thunk64_vkGetImageViewHandleNVX,
42305     thunk64_vkGetImageViewOpaqueCaptureDescriptorDataEXT,
42306     thunk64_vkGetMemoryHostPointerPropertiesEXT,
42307     thunk64_vkGetMicromapBuildSizesEXT,
42308     thunk64_vkGetPerformanceParameterINTEL,
42309     thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
42310     thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
42311     thunk64_vkGetPhysicalDeviceExternalBufferProperties,
42312     thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
42313     thunk64_vkGetPhysicalDeviceExternalFenceProperties,
42314     thunk64_vkGetPhysicalDeviceExternalFencePropertiesKHR,
42315     thunk64_vkGetPhysicalDeviceExternalSemaphoreProperties,
42316     thunk64_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
42317     thunk64_vkGetPhysicalDeviceFeatures,
42318     thunk64_vkGetPhysicalDeviceFeatures2,
42319     thunk64_vkGetPhysicalDeviceFeatures2KHR,
42320     thunk64_vkGetPhysicalDeviceFormatProperties,
42321     thunk64_vkGetPhysicalDeviceFormatProperties2,
42322     thunk64_vkGetPhysicalDeviceFormatProperties2KHR,
42323     thunk64_vkGetPhysicalDeviceFragmentShadingRatesKHR,
42324     thunk64_vkGetPhysicalDeviceImageFormatProperties,
42325     thunk64_vkGetPhysicalDeviceImageFormatProperties2,
42326     thunk64_vkGetPhysicalDeviceImageFormatProperties2KHR,
42327     thunk64_vkGetPhysicalDeviceMemoryProperties,
42328     thunk64_vkGetPhysicalDeviceMemoryProperties2,
42329     thunk64_vkGetPhysicalDeviceMemoryProperties2KHR,
42330     thunk64_vkGetPhysicalDeviceMultisamplePropertiesEXT,
42331     thunk64_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
42332     thunk64_vkGetPhysicalDevicePresentRectanglesKHR,
42333     thunk64_vkGetPhysicalDeviceProperties,
42334     thunk64_vkGetPhysicalDeviceProperties2,
42335     thunk64_vkGetPhysicalDeviceProperties2KHR,
42336     thunk64_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
42337     thunk64_vkGetPhysicalDeviceQueueFamilyProperties,
42338     thunk64_vkGetPhysicalDeviceQueueFamilyProperties2,
42339     thunk64_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
42340     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties,
42341     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2,
42342     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
42343     thunk64_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
42344     thunk64_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
42345     thunk64_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
42346     thunk64_vkGetPhysicalDeviceSurfaceFormats2KHR,
42347     thunk64_vkGetPhysicalDeviceSurfaceFormatsKHR,
42348     thunk64_vkGetPhysicalDeviceSurfacePresentModesKHR,
42349     thunk64_vkGetPhysicalDeviceSurfaceSupportKHR,
42350     thunk64_vkGetPhysicalDeviceToolProperties,
42351     thunk64_vkGetPhysicalDeviceToolPropertiesEXT,
42352     thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR,
42353     thunk64_vkGetPipelineCacheData,
42354     thunk64_vkGetPipelineExecutableInternalRepresentationsKHR,
42355     thunk64_vkGetPipelineExecutablePropertiesKHR,
42356     thunk64_vkGetPipelineExecutableStatisticsKHR,
42357     thunk64_vkGetPipelinePropertiesEXT,
42358     thunk64_vkGetPrivateData,
42359     thunk64_vkGetPrivateDataEXT,
42360     thunk64_vkGetQueryPoolResults,
42361     thunk64_vkGetQueueCheckpointData2NV,
42362     thunk64_vkGetQueueCheckpointDataNV,
42363     thunk64_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
42364     thunk64_vkGetRayTracingShaderGroupHandlesKHR,
42365     thunk64_vkGetRayTracingShaderGroupHandlesNV,
42366     thunk64_vkGetRayTracingShaderGroupStackSizeKHR,
42367     thunk64_vkGetRenderAreaGranularity,
42368     thunk64_vkGetSamplerOpaqueCaptureDescriptorDataEXT,
42369     thunk64_vkGetSemaphoreCounterValue,
42370     thunk64_vkGetSemaphoreCounterValueKHR,
42371     thunk64_vkGetShaderBinaryDataEXT,
42372     thunk64_vkGetShaderInfoAMD,
42373     thunk64_vkGetShaderModuleCreateInfoIdentifierEXT,
42374     thunk64_vkGetShaderModuleIdentifierEXT,
42375     thunk64_vkGetSwapchainImagesKHR,
42376     thunk64_vkGetValidationCacheDataEXT,
42377     thunk64_vkInitializePerformanceApiINTEL,
42378     thunk64_vkInvalidateMappedMemoryRanges,
42379     thunk64_vkMapMemory,
42380     thunk64_vkMapMemory2KHR,
42381     thunk64_vkMergePipelineCaches,
42382     thunk64_vkMergeValidationCachesEXT,
42383     thunk64_vkQueueBeginDebugUtilsLabelEXT,
42384     thunk64_vkQueueBindSparse,
42385     thunk64_vkQueueEndDebugUtilsLabelEXT,
42386     thunk64_vkQueueInsertDebugUtilsLabelEXT,
42387     thunk64_vkQueuePresentKHR,
42388     thunk64_vkQueueSetPerformanceConfigurationINTEL,
42389     thunk64_vkQueueSubmit,
42390     thunk64_vkQueueSubmit2,
42391     thunk64_vkQueueSubmit2KHR,
42392     thunk64_vkQueueWaitIdle,
42393     thunk64_vkReleasePerformanceConfigurationINTEL,
42394     thunk64_vkReleaseProfilingLockKHR,
42395     thunk64_vkReleaseSwapchainImagesEXT,
42396     thunk64_vkResetCommandBuffer,
42397     thunk64_vkResetCommandPool,
42398     thunk64_vkResetDescriptorPool,
42399     thunk64_vkResetEvent,
42400     thunk64_vkResetFences,
42401     thunk64_vkResetQueryPool,
42402     thunk64_vkResetQueryPoolEXT,
42403     thunk64_vkSetDebugUtilsObjectNameEXT,
42404     thunk64_vkSetDebugUtilsObjectTagEXT,
42405     thunk64_vkSetDeviceMemoryPriorityEXT,
42406     thunk64_vkSetEvent,
42407     thunk64_vkSetHdrMetadataEXT,
42408     thunk64_vkSetPrivateData,
42409     thunk64_vkSetPrivateDataEXT,
42410     thunk64_vkSignalSemaphore,
42411     thunk64_vkSignalSemaphoreKHR,
42412     thunk64_vkSubmitDebugUtilsMessageEXT,
42413     thunk64_vkTrimCommandPool,
42414     thunk64_vkTrimCommandPoolKHR,
42415     thunk64_vkUninitializePerformanceApiINTEL,
42416     thunk64_vkUnmapMemory,
42417     thunk64_vkUnmapMemory2KHR,
42418     (void *)thunk64_vkUpdateDescriptorSetWithTemplate,
42419     thunk64_vkUpdateDescriptorSetWithTemplateKHR,
42420     (void *)thunk64_vkUpdateDescriptorSets,
42421     thunk64_vkWaitForFences,
42422     thunk64_vkWaitForPresentKHR,
42423     thunk64_vkWaitSemaphores,
42424     thunk64_vkWaitSemaphoresKHR,
42425     thunk64_vkWriteAccelerationStructuresPropertiesKHR,
42426     thunk64_vkWriteMicromapsPropertiesEXT,
42427 };
42428 C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);
42429
42430 #endif /* _WIN64 */
42431
42432 #ifdef _WIN64
42433 const unixlib_entry_t __wine_unix_call_wow64_funcs[] =
42434 #else
42435 const unixlib_entry_t __wine_unix_call_funcs[] =
42436 #endif
42437 {
42438     init_vulkan,
42439     vk_is_available_instance_function32,
42440     vk_is_available_device_function32,
42441     thunk32_vkAcquireNextImage2KHR,
42442     thunk32_vkAcquireNextImageKHR,
42443     thunk32_vkAcquirePerformanceConfigurationINTEL,
42444     thunk32_vkAcquireProfilingLockKHR,
42445     thunk32_vkAllocateCommandBuffers,
42446     thunk32_vkAllocateDescriptorSets,
42447     thunk32_vkAllocateMemory,
42448     thunk32_vkBeginCommandBuffer,
42449     thunk32_vkBindAccelerationStructureMemoryNV,
42450     thunk32_vkBindBufferMemory,
42451     thunk32_vkBindBufferMemory2,
42452     thunk32_vkBindBufferMemory2KHR,
42453     thunk32_vkBindImageMemory,
42454     thunk32_vkBindImageMemory2,
42455     thunk32_vkBindImageMemory2KHR,
42456     thunk32_vkBindOpticalFlowSessionImageNV,
42457     thunk32_vkBuildAccelerationStructuresKHR,
42458     thunk32_vkBuildMicromapsEXT,
42459     (void *)thunk32_vkCmdBeginConditionalRenderingEXT,
42460     (void *)thunk32_vkCmdBeginDebugUtilsLabelEXT,
42461     (void *)thunk32_vkCmdBeginQuery,
42462     (void *)thunk32_vkCmdBeginQueryIndexedEXT,
42463     (void *)thunk32_vkCmdBeginRenderPass,
42464     (void *)thunk32_vkCmdBeginRenderPass2,
42465     (void *)thunk32_vkCmdBeginRenderPass2KHR,
42466     (void *)thunk32_vkCmdBeginRendering,
42467     (void *)thunk32_vkCmdBeginRenderingKHR,
42468     (void *)thunk32_vkCmdBeginTransformFeedbackEXT,
42469     (void *)thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
42470     (void *)thunk32_vkCmdBindDescriptorBuffersEXT,
42471     (void *)thunk32_vkCmdBindDescriptorSets,
42472     (void *)thunk32_vkCmdBindIndexBuffer,
42473     (void *)thunk32_vkCmdBindInvocationMaskHUAWEI,
42474     (void *)thunk32_vkCmdBindPipeline,
42475     (void *)thunk32_vkCmdBindPipelineShaderGroupNV,
42476     (void *)thunk32_vkCmdBindShadersEXT,
42477     (void *)thunk32_vkCmdBindShadingRateImageNV,
42478     (void *)thunk32_vkCmdBindTransformFeedbackBuffersEXT,
42479     (void *)thunk32_vkCmdBindVertexBuffers,
42480     (void *)thunk32_vkCmdBindVertexBuffers2,
42481     (void *)thunk32_vkCmdBindVertexBuffers2EXT,
42482     (void *)thunk32_vkCmdBlitImage,
42483     (void *)thunk32_vkCmdBlitImage2,
42484     (void *)thunk32_vkCmdBlitImage2KHR,
42485     (void *)thunk32_vkCmdBuildAccelerationStructureNV,
42486     (void *)thunk32_vkCmdBuildAccelerationStructuresIndirectKHR,
42487     (void *)thunk32_vkCmdBuildAccelerationStructuresKHR,
42488     (void *)thunk32_vkCmdBuildMicromapsEXT,
42489     (void *)thunk32_vkCmdClearAttachments,
42490     (void *)thunk32_vkCmdClearColorImage,
42491     (void *)thunk32_vkCmdClearDepthStencilImage,
42492     (void *)thunk32_vkCmdCopyAccelerationStructureKHR,
42493     (void *)thunk32_vkCmdCopyAccelerationStructureNV,
42494     (void *)thunk32_vkCmdCopyAccelerationStructureToMemoryKHR,
42495     (void *)thunk32_vkCmdCopyBuffer,
42496     (void *)thunk32_vkCmdCopyBuffer2,
42497     (void *)thunk32_vkCmdCopyBuffer2KHR,
42498     (void *)thunk32_vkCmdCopyBufferToImage,
42499     (void *)thunk32_vkCmdCopyBufferToImage2,
42500     (void *)thunk32_vkCmdCopyBufferToImage2KHR,
42501     (void *)thunk32_vkCmdCopyImage,
42502     (void *)thunk32_vkCmdCopyImage2,
42503     (void *)thunk32_vkCmdCopyImage2KHR,
42504     (void *)thunk32_vkCmdCopyImageToBuffer,
42505     (void *)thunk32_vkCmdCopyImageToBuffer2,
42506     (void *)thunk32_vkCmdCopyImageToBuffer2KHR,
42507     (void *)thunk32_vkCmdCopyMemoryIndirectNV,
42508     (void *)thunk32_vkCmdCopyMemoryToAccelerationStructureKHR,
42509     (void *)thunk32_vkCmdCopyMemoryToImageIndirectNV,
42510     (void *)thunk32_vkCmdCopyMemoryToMicromapEXT,
42511     (void *)thunk32_vkCmdCopyMicromapEXT,
42512     (void *)thunk32_vkCmdCopyMicromapToMemoryEXT,
42513     (void *)thunk32_vkCmdCopyQueryPoolResults,
42514     (void *)thunk32_vkCmdCuLaunchKernelNVX,
42515     (void *)thunk32_vkCmdDebugMarkerBeginEXT,
42516     (void *)thunk32_vkCmdDebugMarkerEndEXT,
42517     (void *)thunk32_vkCmdDebugMarkerInsertEXT,
42518     (void *)thunk32_vkCmdDecompressMemoryIndirectCountNV,
42519     (void *)thunk32_vkCmdDecompressMemoryNV,
42520     (void *)thunk32_vkCmdDispatch,
42521     (void *)thunk32_vkCmdDispatchBase,
42522     (void *)thunk32_vkCmdDispatchBaseKHR,
42523     (void *)thunk32_vkCmdDispatchIndirect,
42524     (void *)thunk32_vkCmdDraw,
42525     (void *)thunk32_vkCmdDrawClusterHUAWEI,
42526     (void *)thunk32_vkCmdDrawClusterIndirectHUAWEI,
42527     (void *)thunk32_vkCmdDrawIndexed,
42528     (void *)thunk32_vkCmdDrawIndexedIndirect,
42529     (void *)thunk32_vkCmdDrawIndexedIndirectCount,
42530     (void *)thunk32_vkCmdDrawIndexedIndirectCountAMD,
42531     (void *)thunk32_vkCmdDrawIndexedIndirectCountKHR,
42532     (void *)thunk32_vkCmdDrawIndirect,
42533     (void *)thunk32_vkCmdDrawIndirectByteCountEXT,
42534     (void *)thunk32_vkCmdDrawIndirectCount,
42535     (void *)thunk32_vkCmdDrawIndirectCountAMD,
42536     (void *)thunk32_vkCmdDrawIndirectCountKHR,
42537     (void *)thunk32_vkCmdDrawMeshTasksEXT,
42538     (void *)thunk32_vkCmdDrawMeshTasksIndirectCountEXT,
42539     (void *)thunk32_vkCmdDrawMeshTasksIndirectCountNV,
42540     (void *)thunk32_vkCmdDrawMeshTasksIndirectEXT,
42541     (void *)thunk32_vkCmdDrawMeshTasksIndirectNV,
42542     (void *)thunk32_vkCmdDrawMeshTasksNV,
42543     (void *)thunk32_vkCmdDrawMultiEXT,
42544     (void *)thunk32_vkCmdDrawMultiIndexedEXT,
42545     (void *)thunk32_vkCmdEndConditionalRenderingEXT,
42546     (void *)thunk32_vkCmdEndDebugUtilsLabelEXT,
42547     (void *)thunk32_vkCmdEndQuery,
42548     (void *)thunk32_vkCmdEndQueryIndexedEXT,
42549     (void *)thunk32_vkCmdEndRenderPass,
42550     (void *)thunk32_vkCmdEndRenderPass2,
42551     (void *)thunk32_vkCmdEndRenderPass2KHR,
42552     (void *)thunk32_vkCmdEndRendering,
42553     (void *)thunk32_vkCmdEndRenderingKHR,
42554     (void *)thunk32_vkCmdEndTransformFeedbackEXT,
42555     (void *)thunk32_vkCmdExecuteCommands,
42556     (void *)thunk32_vkCmdExecuteGeneratedCommandsNV,
42557     (void *)thunk32_vkCmdFillBuffer,
42558     (void *)thunk32_vkCmdInsertDebugUtilsLabelEXT,
42559     (void *)thunk32_vkCmdNextSubpass,
42560     (void *)thunk32_vkCmdNextSubpass2,
42561     (void *)thunk32_vkCmdNextSubpass2KHR,
42562     (void *)thunk32_vkCmdOpticalFlowExecuteNV,
42563     (void *)thunk32_vkCmdPipelineBarrier,
42564     (void *)thunk32_vkCmdPipelineBarrier2,
42565     (void *)thunk32_vkCmdPipelineBarrier2KHR,
42566     (void *)thunk32_vkCmdPreprocessGeneratedCommandsNV,
42567     (void *)thunk32_vkCmdPushConstants,
42568     (void *)thunk32_vkCmdPushDescriptorSetKHR,
42569     (void *)thunk32_vkCmdPushDescriptorSetWithTemplateKHR,
42570     (void *)thunk32_vkCmdResetEvent,
42571     (void *)thunk32_vkCmdResetEvent2,
42572     (void *)thunk32_vkCmdResetEvent2KHR,
42573     (void *)thunk32_vkCmdResetQueryPool,
42574     (void *)thunk32_vkCmdResolveImage,
42575     (void *)thunk32_vkCmdResolveImage2,
42576     (void *)thunk32_vkCmdResolveImage2KHR,
42577     (void *)thunk32_vkCmdSetAlphaToCoverageEnableEXT,
42578     (void *)thunk32_vkCmdSetAlphaToOneEnableEXT,
42579     (void *)thunk32_vkCmdSetAttachmentFeedbackLoopEnableEXT,
42580     (void *)thunk32_vkCmdSetBlendConstants,
42581     (void *)thunk32_vkCmdSetCheckpointNV,
42582     (void *)thunk32_vkCmdSetCoarseSampleOrderNV,
42583     (void *)thunk32_vkCmdSetColorBlendAdvancedEXT,
42584     (void *)thunk32_vkCmdSetColorBlendEnableEXT,
42585     (void *)thunk32_vkCmdSetColorBlendEquationEXT,
42586     (void *)thunk32_vkCmdSetColorWriteEnableEXT,
42587     (void *)thunk32_vkCmdSetColorWriteMaskEXT,
42588     (void *)thunk32_vkCmdSetConservativeRasterizationModeEXT,
42589     (void *)thunk32_vkCmdSetCoverageModulationModeNV,
42590     (void *)thunk32_vkCmdSetCoverageModulationTableEnableNV,
42591     (void *)thunk32_vkCmdSetCoverageModulationTableNV,
42592     (void *)thunk32_vkCmdSetCoverageReductionModeNV,
42593     (void *)thunk32_vkCmdSetCoverageToColorEnableNV,
42594     (void *)thunk32_vkCmdSetCoverageToColorLocationNV,
42595     (void *)thunk32_vkCmdSetCullMode,
42596     (void *)thunk32_vkCmdSetCullModeEXT,
42597     (void *)thunk32_vkCmdSetDepthBias,
42598     (void *)thunk32_vkCmdSetDepthBias2EXT,
42599     (void *)thunk32_vkCmdSetDepthBiasEnable,
42600     (void *)thunk32_vkCmdSetDepthBiasEnableEXT,
42601     (void *)thunk32_vkCmdSetDepthBounds,
42602     (void *)thunk32_vkCmdSetDepthBoundsTestEnable,
42603     (void *)thunk32_vkCmdSetDepthBoundsTestEnableEXT,
42604     (void *)thunk32_vkCmdSetDepthClampEnableEXT,
42605     (void *)thunk32_vkCmdSetDepthClipEnableEXT,
42606     (void *)thunk32_vkCmdSetDepthClipNegativeOneToOneEXT,
42607     (void *)thunk32_vkCmdSetDepthCompareOp,
42608     (void *)thunk32_vkCmdSetDepthCompareOpEXT,
42609     (void *)thunk32_vkCmdSetDepthTestEnable,
42610     (void *)thunk32_vkCmdSetDepthTestEnableEXT,
42611     (void *)thunk32_vkCmdSetDepthWriteEnable,
42612     (void *)thunk32_vkCmdSetDepthWriteEnableEXT,
42613     (void *)thunk32_vkCmdSetDescriptorBufferOffsetsEXT,
42614     (void *)thunk32_vkCmdSetDeviceMask,
42615     (void *)thunk32_vkCmdSetDeviceMaskKHR,
42616     (void *)thunk32_vkCmdSetDiscardRectangleEXT,
42617     (void *)thunk32_vkCmdSetDiscardRectangleEnableEXT,
42618     (void *)thunk32_vkCmdSetDiscardRectangleModeEXT,
42619     (void *)thunk32_vkCmdSetEvent,
42620     (void *)thunk32_vkCmdSetEvent2,
42621     (void *)thunk32_vkCmdSetEvent2KHR,
42622     (void *)thunk32_vkCmdSetExclusiveScissorEnableNV,
42623     (void *)thunk32_vkCmdSetExclusiveScissorNV,
42624     (void *)thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
42625     (void *)thunk32_vkCmdSetFragmentShadingRateEnumNV,
42626     (void *)thunk32_vkCmdSetFragmentShadingRateKHR,
42627     (void *)thunk32_vkCmdSetFrontFace,
42628     (void *)thunk32_vkCmdSetFrontFaceEXT,
42629     (void *)thunk32_vkCmdSetLineRasterizationModeEXT,
42630     (void *)thunk32_vkCmdSetLineStippleEXT,
42631     (void *)thunk32_vkCmdSetLineStippleEnableEXT,
42632     (void *)thunk32_vkCmdSetLineWidth,
42633     (void *)thunk32_vkCmdSetLogicOpEXT,
42634     (void *)thunk32_vkCmdSetLogicOpEnableEXT,
42635     (void *)thunk32_vkCmdSetPatchControlPointsEXT,
42636     thunk32_vkCmdSetPerformanceMarkerINTEL,
42637     thunk32_vkCmdSetPerformanceOverrideINTEL,
42638     thunk32_vkCmdSetPerformanceStreamMarkerINTEL,
42639     (void *)thunk32_vkCmdSetPolygonModeEXT,
42640     (void *)thunk32_vkCmdSetPrimitiveRestartEnable,
42641     (void *)thunk32_vkCmdSetPrimitiveRestartEnableEXT,
42642     (void *)thunk32_vkCmdSetPrimitiveTopology,
42643     (void *)thunk32_vkCmdSetPrimitiveTopologyEXT,
42644     (void *)thunk32_vkCmdSetProvokingVertexModeEXT,
42645     (void *)thunk32_vkCmdSetRasterizationSamplesEXT,
42646     (void *)thunk32_vkCmdSetRasterizationStreamEXT,
42647     (void *)thunk32_vkCmdSetRasterizerDiscardEnable,
42648     (void *)thunk32_vkCmdSetRasterizerDiscardEnableEXT,
42649     (void *)thunk32_vkCmdSetRayTracingPipelineStackSizeKHR,
42650     (void *)thunk32_vkCmdSetRepresentativeFragmentTestEnableNV,
42651     (void *)thunk32_vkCmdSetSampleLocationsEXT,
42652     (void *)thunk32_vkCmdSetSampleLocationsEnableEXT,
42653     (void *)thunk32_vkCmdSetSampleMaskEXT,
42654     (void *)thunk32_vkCmdSetScissor,
42655     (void *)thunk32_vkCmdSetScissorWithCount,
42656     (void *)thunk32_vkCmdSetScissorWithCountEXT,
42657     (void *)thunk32_vkCmdSetShadingRateImageEnableNV,
42658     (void *)thunk32_vkCmdSetStencilCompareMask,
42659     (void *)thunk32_vkCmdSetStencilOp,
42660     (void *)thunk32_vkCmdSetStencilOpEXT,
42661     (void *)thunk32_vkCmdSetStencilReference,
42662     (void *)thunk32_vkCmdSetStencilTestEnable,
42663     (void *)thunk32_vkCmdSetStencilTestEnableEXT,
42664     (void *)thunk32_vkCmdSetStencilWriteMask,
42665     (void *)thunk32_vkCmdSetTessellationDomainOriginEXT,
42666     (void *)thunk32_vkCmdSetVertexInputEXT,
42667     (void *)thunk32_vkCmdSetViewport,
42668     (void *)thunk32_vkCmdSetViewportShadingRatePaletteNV,
42669     (void *)thunk32_vkCmdSetViewportSwizzleNV,
42670     (void *)thunk32_vkCmdSetViewportWScalingEnableNV,
42671     (void *)thunk32_vkCmdSetViewportWScalingNV,
42672     (void *)thunk32_vkCmdSetViewportWithCount,
42673     (void *)thunk32_vkCmdSetViewportWithCountEXT,
42674     (void *)thunk32_vkCmdSubpassShadingHUAWEI,
42675     (void *)thunk32_vkCmdTraceRaysIndirect2KHR,
42676     (void *)thunk32_vkCmdTraceRaysIndirectKHR,
42677     (void *)thunk32_vkCmdTraceRaysKHR,
42678     (void *)thunk32_vkCmdTraceRaysNV,
42679     (void *)thunk32_vkCmdUpdateBuffer,
42680     (void *)thunk32_vkCmdWaitEvents,
42681     (void *)thunk32_vkCmdWaitEvents2,
42682     (void *)thunk32_vkCmdWaitEvents2KHR,
42683     (void *)thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR,
42684     (void *)thunk32_vkCmdWriteAccelerationStructuresPropertiesNV,
42685     (void *)thunk32_vkCmdWriteBufferMarker2AMD,
42686     (void *)thunk32_vkCmdWriteBufferMarkerAMD,
42687     (void *)thunk32_vkCmdWriteMicromapsPropertiesEXT,
42688     (void *)thunk32_vkCmdWriteTimestamp,
42689     (void *)thunk32_vkCmdWriteTimestamp2,
42690     (void *)thunk32_vkCmdWriteTimestamp2KHR,
42691     thunk32_vkCompileDeferredNV,
42692     thunk32_vkCopyAccelerationStructureKHR,
42693     thunk32_vkCopyAccelerationStructureToMemoryKHR,
42694     thunk32_vkCopyMemoryToAccelerationStructureKHR,
42695     thunk32_vkCopyMemoryToMicromapEXT,
42696     thunk32_vkCopyMicromapEXT,
42697     thunk32_vkCopyMicromapToMemoryEXT,
42698     thunk32_vkCreateAccelerationStructureKHR,
42699     thunk32_vkCreateAccelerationStructureNV,
42700     thunk32_vkCreateBuffer,
42701     thunk32_vkCreateBufferView,
42702     thunk32_vkCreateCommandPool,
42703     thunk32_vkCreateComputePipelines,
42704     thunk32_vkCreateCuFunctionNVX,
42705     thunk32_vkCreateCuModuleNVX,
42706     thunk32_vkCreateDebugReportCallbackEXT,
42707     thunk32_vkCreateDebugUtilsMessengerEXT,
42708     thunk32_vkCreateDeferredOperationKHR,
42709     thunk32_vkCreateDescriptorPool,
42710     thunk32_vkCreateDescriptorSetLayout,
42711     thunk32_vkCreateDescriptorUpdateTemplate,
42712     thunk32_vkCreateDescriptorUpdateTemplateKHR,
42713     thunk32_vkCreateDevice,
42714     thunk32_vkCreateEvent,
42715     thunk32_vkCreateFence,
42716     thunk32_vkCreateFramebuffer,
42717     thunk32_vkCreateGraphicsPipelines,
42718     thunk32_vkCreateImage,
42719     thunk32_vkCreateImageView,
42720     thunk32_vkCreateIndirectCommandsLayoutNV,
42721     thunk32_vkCreateInstance,
42722     thunk32_vkCreateMicromapEXT,
42723     thunk32_vkCreateOpticalFlowSessionNV,
42724     thunk32_vkCreatePipelineCache,
42725     thunk32_vkCreatePipelineLayout,
42726     thunk32_vkCreatePrivateDataSlot,
42727     thunk32_vkCreatePrivateDataSlotEXT,
42728     thunk32_vkCreateQueryPool,
42729     thunk32_vkCreateRayTracingPipelinesKHR,
42730     thunk32_vkCreateRayTracingPipelinesNV,
42731     thunk32_vkCreateRenderPass,
42732     thunk32_vkCreateRenderPass2,
42733     thunk32_vkCreateRenderPass2KHR,
42734     thunk32_vkCreateSampler,
42735     thunk32_vkCreateSamplerYcbcrConversion,
42736     thunk32_vkCreateSamplerYcbcrConversionKHR,
42737     thunk32_vkCreateSemaphore,
42738     thunk32_vkCreateShaderModule,
42739     thunk32_vkCreateShadersEXT,
42740     thunk32_vkCreateSwapchainKHR,
42741     thunk32_vkCreateValidationCacheEXT,
42742     thunk32_vkCreateWin32SurfaceKHR,
42743     thunk32_vkDebugMarkerSetObjectNameEXT,
42744     thunk32_vkDebugMarkerSetObjectTagEXT,
42745     thunk32_vkDebugReportMessageEXT,
42746     thunk32_vkDeferredOperationJoinKHR,
42747     thunk32_vkDestroyAccelerationStructureKHR,
42748     thunk32_vkDestroyAccelerationStructureNV,
42749     thunk32_vkDestroyBuffer,
42750     thunk32_vkDestroyBufferView,
42751     thunk32_vkDestroyCommandPool,
42752     thunk32_vkDestroyCuFunctionNVX,
42753     thunk32_vkDestroyCuModuleNVX,
42754     thunk32_vkDestroyDebugReportCallbackEXT,
42755     thunk32_vkDestroyDebugUtilsMessengerEXT,
42756     thunk32_vkDestroyDeferredOperationKHR,
42757     thunk32_vkDestroyDescriptorPool,
42758     thunk32_vkDestroyDescriptorSetLayout,
42759     thunk32_vkDestroyDescriptorUpdateTemplate,
42760     thunk32_vkDestroyDescriptorUpdateTemplateKHR,
42761     thunk32_vkDestroyDevice,
42762     thunk32_vkDestroyEvent,
42763     thunk32_vkDestroyFence,
42764     thunk32_vkDestroyFramebuffer,
42765     thunk32_vkDestroyImage,
42766     thunk32_vkDestroyImageView,
42767     thunk32_vkDestroyIndirectCommandsLayoutNV,
42768     thunk32_vkDestroyInstance,
42769     thunk32_vkDestroyMicromapEXT,
42770     thunk32_vkDestroyOpticalFlowSessionNV,
42771     thunk32_vkDestroyPipeline,
42772     thunk32_vkDestroyPipelineCache,
42773     thunk32_vkDestroyPipelineLayout,
42774     thunk32_vkDestroyPrivateDataSlot,
42775     thunk32_vkDestroyPrivateDataSlotEXT,
42776     thunk32_vkDestroyQueryPool,
42777     thunk32_vkDestroyRenderPass,
42778     thunk32_vkDestroySampler,
42779     thunk32_vkDestroySamplerYcbcrConversion,
42780     thunk32_vkDestroySamplerYcbcrConversionKHR,
42781     thunk32_vkDestroySemaphore,
42782     thunk32_vkDestroyShaderEXT,
42783     thunk32_vkDestroyShaderModule,
42784     thunk32_vkDestroySurfaceKHR,
42785     thunk32_vkDestroySwapchainKHR,
42786     thunk32_vkDestroyValidationCacheEXT,
42787     thunk32_vkDeviceWaitIdle,
42788     thunk32_vkEndCommandBuffer,
42789     thunk32_vkEnumerateDeviceExtensionProperties,
42790     thunk32_vkEnumerateDeviceLayerProperties,
42791     thunk32_vkEnumerateInstanceExtensionProperties,
42792     thunk32_vkEnumerateInstanceVersion,
42793     thunk32_vkEnumeratePhysicalDeviceGroups,
42794     thunk32_vkEnumeratePhysicalDeviceGroupsKHR,
42795     thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
42796     thunk32_vkEnumeratePhysicalDevices,
42797     thunk32_vkFlushMappedMemoryRanges,
42798     thunk32_vkFreeCommandBuffers,
42799     thunk32_vkFreeDescriptorSets,
42800     thunk32_vkFreeMemory,
42801     thunk32_vkGetAccelerationStructureBuildSizesKHR,
42802     thunk32_vkGetAccelerationStructureDeviceAddressKHR,
42803     thunk32_vkGetAccelerationStructureHandleNV,
42804     thunk32_vkGetAccelerationStructureMemoryRequirementsNV,
42805     thunk32_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
42806     thunk32_vkGetBufferDeviceAddress,
42807     thunk32_vkGetBufferDeviceAddressEXT,
42808     thunk32_vkGetBufferDeviceAddressKHR,
42809     thunk32_vkGetBufferMemoryRequirements,
42810     thunk32_vkGetBufferMemoryRequirements2,
42811     thunk32_vkGetBufferMemoryRequirements2KHR,
42812     thunk32_vkGetBufferOpaqueCaptureAddress,
42813     thunk32_vkGetBufferOpaqueCaptureAddressKHR,
42814     thunk32_vkGetBufferOpaqueCaptureDescriptorDataEXT,
42815     thunk32_vkGetCalibratedTimestampsEXT,
42816     thunk32_vkGetDeferredOperationMaxConcurrencyKHR,
42817     thunk32_vkGetDeferredOperationResultKHR,
42818     (void *)thunk32_vkGetDescriptorEXT,
42819     thunk32_vkGetDescriptorSetHostMappingVALVE,
42820     thunk32_vkGetDescriptorSetLayoutBindingOffsetEXT,
42821     thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
42822     thunk32_vkGetDescriptorSetLayoutSizeEXT,
42823     thunk32_vkGetDescriptorSetLayoutSupport,
42824     thunk32_vkGetDescriptorSetLayoutSupportKHR,
42825     thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR,
42826     thunk32_vkGetDeviceBufferMemoryRequirements,
42827     thunk32_vkGetDeviceBufferMemoryRequirementsKHR,
42828     thunk32_vkGetDeviceFaultInfoEXT,
42829     thunk32_vkGetDeviceGroupPeerMemoryFeatures,
42830     thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR,
42831     thunk32_vkGetDeviceGroupPresentCapabilitiesKHR,
42832     thunk32_vkGetDeviceGroupSurfacePresentModesKHR,
42833     thunk32_vkGetDeviceImageMemoryRequirements,
42834     thunk32_vkGetDeviceImageMemoryRequirementsKHR,
42835     thunk32_vkGetDeviceImageSparseMemoryRequirements,
42836     thunk32_vkGetDeviceImageSparseMemoryRequirementsKHR,
42837     thunk32_vkGetDeviceMemoryCommitment,
42838     thunk32_vkGetDeviceMemoryOpaqueCaptureAddress,
42839     thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
42840     thunk32_vkGetDeviceMicromapCompatibilityEXT,
42841     thunk32_vkGetDeviceQueue,
42842     thunk32_vkGetDeviceQueue2,
42843     thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
42844     thunk32_vkGetDynamicRenderingTilePropertiesQCOM,
42845     thunk32_vkGetEventStatus,
42846     thunk32_vkGetFenceStatus,
42847     thunk32_vkGetFramebufferTilePropertiesQCOM,
42848     thunk32_vkGetGeneratedCommandsMemoryRequirementsNV,
42849     thunk32_vkGetImageMemoryRequirements,
42850     thunk32_vkGetImageMemoryRequirements2,
42851     thunk32_vkGetImageMemoryRequirements2KHR,
42852     thunk32_vkGetImageOpaqueCaptureDescriptorDataEXT,
42853     thunk32_vkGetImageSparseMemoryRequirements,
42854     thunk32_vkGetImageSparseMemoryRequirements2,
42855     thunk32_vkGetImageSparseMemoryRequirements2KHR,
42856     thunk32_vkGetImageSubresourceLayout,
42857     thunk32_vkGetImageSubresourceLayout2EXT,
42858     thunk32_vkGetImageViewAddressNVX,
42859     thunk32_vkGetImageViewHandleNVX,
42860     thunk32_vkGetImageViewOpaqueCaptureDescriptorDataEXT,
42861     thunk32_vkGetMemoryHostPointerPropertiesEXT,
42862     thunk32_vkGetMicromapBuildSizesEXT,
42863     thunk32_vkGetPerformanceParameterINTEL,
42864     thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
42865     thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
42866     thunk32_vkGetPhysicalDeviceExternalBufferProperties,
42867     thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
42868     thunk32_vkGetPhysicalDeviceExternalFenceProperties,
42869     thunk32_vkGetPhysicalDeviceExternalFencePropertiesKHR,
42870     thunk32_vkGetPhysicalDeviceExternalSemaphoreProperties,
42871     thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
42872     thunk32_vkGetPhysicalDeviceFeatures,
42873     thunk32_vkGetPhysicalDeviceFeatures2,
42874     thunk32_vkGetPhysicalDeviceFeatures2KHR,
42875     thunk32_vkGetPhysicalDeviceFormatProperties,
42876     thunk32_vkGetPhysicalDeviceFormatProperties2,
42877     thunk32_vkGetPhysicalDeviceFormatProperties2KHR,
42878     thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR,
42879     thunk32_vkGetPhysicalDeviceImageFormatProperties,
42880     thunk32_vkGetPhysicalDeviceImageFormatProperties2,
42881     thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR,
42882     thunk32_vkGetPhysicalDeviceMemoryProperties,
42883     thunk32_vkGetPhysicalDeviceMemoryProperties2,
42884     thunk32_vkGetPhysicalDeviceMemoryProperties2KHR,
42885     thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT,
42886     thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
42887     thunk32_vkGetPhysicalDevicePresentRectanglesKHR,
42888     thunk32_vkGetPhysicalDeviceProperties,
42889     thunk32_vkGetPhysicalDeviceProperties2,
42890     thunk32_vkGetPhysicalDeviceProperties2KHR,
42891     thunk32_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
42892     thunk32_vkGetPhysicalDeviceQueueFamilyProperties,
42893     thunk32_vkGetPhysicalDeviceQueueFamilyProperties2,
42894     thunk32_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
42895     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties,
42896     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2,
42897     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
42898     thunk32_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
42899     thunk32_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
42900     thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
42901     thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR,
42902     thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR,
42903     thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR,
42904     thunk32_vkGetPhysicalDeviceSurfaceSupportKHR,
42905     thunk32_vkGetPhysicalDeviceToolProperties,
42906     thunk32_vkGetPhysicalDeviceToolPropertiesEXT,
42907     thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR,
42908     thunk32_vkGetPipelineCacheData,
42909     thunk32_vkGetPipelineExecutableInternalRepresentationsKHR,
42910     thunk32_vkGetPipelineExecutablePropertiesKHR,
42911     thunk32_vkGetPipelineExecutableStatisticsKHR,
42912     thunk32_vkGetPipelinePropertiesEXT,
42913     thunk32_vkGetPrivateData,
42914     thunk32_vkGetPrivateDataEXT,
42915     thunk32_vkGetQueryPoolResults,
42916     thunk32_vkGetQueueCheckpointData2NV,
42917     thunk32_vkGetQueueCheckpointDataNV,
42918     thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
42919     thunk32_vkGetRayTracingShaderGroupHandlesKHR,
42920     thunk32_vkGetRayTracingShaderGroupHandlesNV,
42921     thunk32_vkGetRayTracingShaderGroupStackSizeKHR,
42922     thunk32_vkGetRenderAreaGranularity,
42923     thunk32_vkGetSamplerOpaqueCaptureDescriptorDataEXT,
42924     thunk32_vkGetSemaphoreCounterValue,
42925     thunk32_vkGetSemaphoreCounterValueKHR,
42926     thunk32_vkGetShaderBinaryDataEXT,
42927     thunk32_vkGetShaderInfoAMD,
42928     thunk32_vkGetShaderModuleCreateInfoIdentifierEXT,
42929     thunk32_vkGetShaderModuleIdentifierEXT,
42930     thunk32_vkGetSwapchainImagesKHR,
42931     thunk32_vkGetValidationCacheDataEXT,
42932     thunk32_vkInitializePerformanceApiINTEL,
42933     thunk32_vkInvalidateMappedMemoryRanges,
42934     thunk32_vkMapMemory,
42935     thunk32_vkMapMemory2KHR,
42936     thunk32_vkMergePipelineCaches,
42937     thunk32_vkMergeValidationCachesEXT,
42938     thunk32_vkQueueBeginDebugUtilsLabelEXT,
42939     thunk32_vkQueueBindSparse,
42940     thunk32_vkQueueEndDebugUtilsLabelEXT,
42941     thunk32_vkQueueInsertDebugUtilsLabelEXT,
42942     thunk32_vkQueuePresentKHR,
42943     thunk32_vkQueueSetPerformanceConfigurationINTEL,
42944     thunk32_vkQueueSubmit,
42945     thunk32_vkQueueSubmit2,
42946     thunk32_vkQueueSubmit2KHR,
42947     thunk32_vkQueueWaitIdle,
42948     thunk32_vkReleasePerformanceConfigurationINTEL,
42949     thunk32_vkReleaseProfilingLockKHR,
42950     thunk32_vkReleaseSwapchainImagesEXT,
42951     thunk32_vkResetCommandBuffer,
42952     thunk32_vkResetCommandPool,
42953     thunk32_vkResetDescriptorPool,
42954     thunk32_vkResetEvent,
42955     thunk32_vkResetFences,
42956     thunk32_vkResetQueryPool,
42957     thunk32_vkResetQueryPoolEXT,
42958     thunk32_vkSetDebugUtilsObjectNameEXT,
42959     thunk32_vkSetDebugUtilsObjectTagEXT,
42960     thunk32_vkSetDeviceMemoryPriorityEXT,
42961     thunk32_vkSetEvent,
42962     thunk32_vkSetHdrMetadataEXT,
42963     thunk32_vkSetPrivateData,
42964     thunk32_vkSetPrivateDataEXT,
42965     thunk32_vkSignalSemaphore,
42966     thunk32_vkSignalSemaphoreKHR,
42967     thunk32_vkSubmitDebugUtilsMessageEXT,
42968     thunk32_vkTrimCommandPool,
42969     thunk32_vkTrimCommandPoolKHR,
42970     thunk32_vkUninitializePerformanceApiINTEL,
42971     thunk32_vkUnmapMemory,
42972     thunk32_vkUnmapMemory2KHR,
42973     (void *)thunk32_vkUpdateDescriptorSetWithTemplate,
42974     thunk32_vkUpdateDescriptorSetWithTemplateKHR,
42975     (void *)thunk32_vkUpdateDescriptorSets,
42976     thunk32_vkWaitForFences,
42977     thunk32_vkWaitForPresentKHR,
42978     thunk32_vkWaitSemaphores,
42979     thunk32_vkWaitSemaphoresKHR,
42980     thunk32_vkWriteAccelerationStructuresPropertiesKHR,
42981     thunk32_vkWriteMicromapsPropertiesEXT,
42982 };
42983 C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);