dlls/winevulkan/vulkan_thunks.c

   1 /* Automatically generated from Vulkan vk.xml; DO NOT EDIT!
   2  *
   3  * This file is generated from Vulkan vk.xml file covered
   4  * by the following copyright and permission notice:
   5  *
   6  * Copyright 2015-2022 The Khronos Group Inc.
   7  *
   8  * SPDX-License-Identifier: Apache-2.0 OR MIT
   9  *
  10  */
  11
  12 #if 0
  13 #pragma makedep unix
  14 #endif
  15
  16 #include "config.h"
  17
  18 #include <stdlib.h>
  19
  20 #include "vulkan_private.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
  23
  24 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 VkRenderPassBeginInfo32
 485 {
 486     VkStructureType sType;
 487     PTR32 pNext;
 488     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
 489     VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
 490     VkRect2D renderArea;
 491     uint32_t clearValueCount;
 492     PTR32 pClearValues;
 493 } VkRenderPassBeginInfo32;
 494
 495 typedef struct VkSubpassBeginInfo32
 496 {
 497     VkStructureType sType;
 498     PTR32 pNext;
 499     VkSubpassContents contents;
 500 } VkSubpassBeginInfo32;
 501 typedef VkSubpassBeginInfo32 VkSubpassBeginInfoKHR32;
 502
 503 typedef struct VkRenderingAttachmentInfo32
 504 {
 505     VkStructureType sType;
 506     PTR32 pNext;
 507     VkImageView DECLSPEC_ALIGN(8) imageView;
 508     VkImageLayout imageLayout;
 509     VkResolveModeFlagBits resolveMode;
 510     VkImageView DECLSPEC_ALIGN(8) resolveImageView;
 511     VkImageLayout resolveImageLayout;
 512     VkAttachmentLoadOp loadOp;
 513     VkAttachmentStoreOp storeOp;
 514     VkClearValue clearValue;
 515 } VkRenderingAttachmentInfo32;
 516 typedef VkRenderingAttachmentInfo32 VkRenderingAttachmentInfoKHR32;
 517
 518 typedef struct VkMultisampledRenderToSingleSampledInfoEXT32
 519 {
 520     VkStructureType sType;
 521     PTR32 pNext;
 522     VkBool32 multisampledRenderToSingleSampledEnable;
 523     VkSampleCountFlagBits rasterizationSamples;
 524 } VkMultisampledRenderToSingleSampledInfoEXT32;
 525
 526 typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR32
 527 {
 528     VkStructureType sType;
 529     PTR32 pNext;
 530     VkImageView DECLSPEC_ALIGN(8) imageView;
 531     VkImageLayout imageLayout;
 532     VkExtent2D shadingRateAttachmentTexelSize;
 533 } VkRenderingFragmentShadingRateAttachmentInfoKHR32;
 534
 535 typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT32
 536 {
 537     VkStructureType sType;
 538     PTR32 pNext;
 539     VkImageView DECLSPEC_ALIGN(8) imageView;
 540     VkImageLayout imageLayout;
 541 } VkRenderingFragmentDensityMapAttachmentInfoEXT32;
 542
 543 typedef struct VkRenderingInfo32
 544 {
 545     VkStructureType sType;
 546     PTR32 pNext;
 547     VkRenderingFlags flags;
 548     VkRect2D renderArea;
 549     uint32_t layerCount;
 550     uint32_t viewMask;
 551     uint32_t colorAttachmentCount;
 552     PTR32 pColorAttachments;
 553     PTR32 pDepthAttachment;
 554     PTR32 pStencilAttachment;
 555 } VkRenderingInfo32;
 556 typedef VkRenderingInfo32 VkRenderingInfoKHR32;
 557
 558 typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32
 559 {
 560     VkStructureType sType;
 561     PTR32 pNext;
 562     VkBuffer DECLSPEC_ALIGN(8) buffer;
 563 } VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32;
 564
 565 typedef struct VkDescriptorBufferBindingInfoEXT32
 566 {
 567     VkStructureType sType;
 568     PTR32 pNext;
 569     VkDeviceAddress DECLSPEC_ALIGN(8) address;
 570     VkBufferUsageFlags usage;
 571 } VkDescriptorBufferBindingInfoEXT32;
 572
 573 typedef struct VkCopyCommandTransformInfoQCOM32
 574 {
 575     VkStructureType sType;
 576     PTR32 pNext;
 577     VkSurfaceTransformFlagBitsKHR transform;
 578 } VkCopyCommandTransformInfoQCOM32;
 579
 580 typedef struct VkImageBlit232
 581 {
 582     VkStructureType sType;
 583     PTR32 pNext;
 584     VkImageSubresourceLayers srcSubresource;
 585     VkOffset3D srcOffsets[2];
 586     VkImageSubresourceLayers dstSubresource;
 587     VkOffset3D dstOffsets[2];
 588 } VkImageBlit232;
 589 typedef VkImageBlit232 VkImageBlit2KHR32;
 590
 591 typedef struct VkBlitImageInfo232
 592 {
 593     VkStructureType sType;
 594     PTR32 pNext;
 595     VkImage DECLSPEC_ALIGN(8) srcImage;
 596     VkImageLayout srcImageLayout;
 597     VkImage DECLSPEC_ALIGN(8) dstImage;
 598     VkImageLayout dstImageLayout;
 599     uint32_t regionCount;
 600     PTR32 pRegions;
 601     VkFilter filter;
 602 } VkBlitImageInfo232;
 603 typedef VkBlitImageInfo232 VkBlitImageInfo2KHR32;
 604
 605 typedef struct VkGeometryTrianglesNV32
 606 {
 607     VkStructureType sType;
 608     PTR32 pNext;
 609     VkBuffer DECLSPEC_ALIGN(8) vertexData;
 610     VkDeviceSize DECLSPEC_ALIGN(8) vertexOffset;
 611     uint32_t vertexCount;
 612     VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
 613     VkFormat vertexFormat;
 614     VkBuffer DECLSPEC_ALIGN(8) indexData;
 615     VkDeviceSize DECLSPEC_ALIGN(8) indexOffset;
 616     uint32_t indexCount;
 617     VkIndexType indexType;
 618     VkBuffer DECLSPEC_ALIGN(8) transformData;
 619     VkDeviceSize DECLSPEC_ALIGN(8) transformOffset;
 620 } VkGeometryTrianglesNV32;
 621
 622 typedef struct VkGeometryAABBNV32
 623 {
 624     VkStructureType sType;
 625     PTR32 pNext;
 626     VkBuffer DECLSPEC_ALIGN(8) aabbData;
 627     uint32_t numAABBs;
 628     uint32_t stride;
 629     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 630 } VkGeometryAABBNV32;
 631
 632 typedef struct VkGeometryDataNV32
 633 {
 634     VkGeometryTrianglesNV32 DECLSPEC_ALIGN(8) triangles;
 635     VkGeometryAABBNV32 DECLSPEC_ALIGN(8) aabbs;
 636 } VkGeometryDataNV32;
 637
 638 typedef struct VkGeometryNV32
 639 {
 640     VkStructureType sType;
 641     PTR32 pNext;
 642     VkGeometryTypeKHR geometryType;
 643     VkGeometryDataNV32 DECLSPEC_ALIGN(8) geometry;
 644     VkGeometryFlagsKHR flags;
 645 } VkGeometryNV32;
 646
 647 typedef struct VkAccelerationStructureInfoNV32
 648 {
 649     VkStructureType sType;
 650     PTR32 pNext;
 651     VkAccelerationStructureTypeNV type;
 652     VkBuildAccelerationStructureFlagsNV flags;
 653     uint32_t instanceCount;
 654     uint32_t geometryCount;
 655     PTR32 pGeometries;
 656 } VkAccelerationStructureInfoNV32;
 657
 658 typedef struct VkCopyAccelerationStructureInfoKHR32
 659 {
 660     VkStructureType sType;
 661     PTR32 pNext;
 662     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
 663     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
 664     VkCopyAccelerationStructureModeKHR mode;
 665 } VkCopyAccelerationStructureInfoKHR32;
 666
 667 typedef struct VkCopyAccelerationStructureToMemoryInfoKHR32
 668 {
 669     VkStructureType sType;
 670     PTR32 pNext;
 671     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
 672     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
 673     VkCopyAccelerationStructureModeKHR mode;
 674 } VkCopyAccelerationStructureToMemoryInfoKHR32;
 675
 676 typedef struct VkBufferCopy32
 677 {
 678     VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
 679     VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
 680     VkDeviceSize DECLSPEC_ALIGN(8) size;
 681 } VkBufferCopy32;
 682
 683 typedef struct VkBufferCopy232
 684 {
 685     VkStructureType sType;
 686     PTR32 pNext;
 687     VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
 688     VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
 689     VkDeviceSize DECLSPEC_ALIGN(8) size;
 690 } VkBufferCopy232;
 691 typedef VkBufferCopy232 VkBufferCopy2KHR32;
 692
 693 typedef struct VkCopyBufferInfo232
 694 {
 695     VkStructureType sType;
 696     PTR32 pNext;
 697     VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
 698     VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
 699     uint32_t regionCount;
 700     PTR32 pRegions;
 701 } VkCopyBufferInfo232;
 702 typedef VkCopyBufferInfo232 VkCopyBufferInfo2KHR32;
 703
 704 typedef struct VkBufferImageCopy32
 705 {
 706     VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
 707     uint32_t bufferRowLength;
 708     uint32_t bufferImageHeight;
 709     VkImageSubresourceLayers imageSubresource;
 710     VkOffset3D imageOffset;
 711     VkExtent3D imageExtent;
 712 } VkBufferImageCopy32;
 713
 714 typedef struct VkBufferImageCopy232
 715 {
 716     VkStructureType sType;
 717     PTR32 pNext;
 718     VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
 719     uint32_t bufferRowLength;
 720     uint32_t bufferImageHeight;
 721     VkImageSubresourceLayers imageSubresource;
 722     VkOffset3D imageOffset;
 723     VkExtent3D imageExtent;
 724 } VkBufferImageCopy232;
 725 typedef VkBufferImageCopy232 VkBufferImageCopy2KHR32;
 726
 727 typedef struct VkCopyBufferToImageInfo232
 728 {
 729     VkStructureType sType;
 730     PTR32 pNext;
 731     VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
 732     VkImage DECLSPEC_ALIGN(8) dstImage;
 733     VkImageLayout dstImageLayout;
 734     uint32_t regionCount;
 735     PTR32 pRegions;
 736 } VkCopyBufferToImageInfo232;
 737 typedef VkCopyBufferToImageInfo232 VkCopyBufferToImageInfo2KHR32;
 738
 739 typedef struct VkImageCopy232
 740 {
 741     VkStructureType sType;
 742     PTR32 pNext;
 743     VkImageSubresourceLayers srcSubresource;
 744     VkOffset3D srcOffset;
 745     VkImageSubresourceLayers dstSubresource;
 746     VkOffset3D dstOffset;
 747     VkExtent3D extent;
 748 } VkImageCopy232;
 749 typedef VkImageCopy232 VkImageCopy2KHR32;
 750
 751 typedef struct VkCopyImageInfo232
 752 {
 753     VkStructureType sType;
 754     PTR32 pNext;
 755     VkImage DECLSPEC_ALIGN(8) srcImage;
 756     VkImageLayout srcImageLayout;
 757     VkImage DECLSPEC_ALIGN(8) dstImage;
 758     VkImageLayout dstImageLayout;
 759     uint32_t regionCount;
 760     PTR32 pRegions;
 761 } VkCopyImageInfo232;
 762 typedef VkCopyImageInfo232 VkCopyImageInfo2KHR32;
 763
 764 typedef struct VkCopyImageToBufferInfo232
 765 {
 766     VkStructureType sType;
 767     PTR32 pNext;
 768     VkImage DECLSPEC_ALIGN(8) srcImage;
 769     VkImageLayout srcImageLayout;
 770     VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
 771     uint32_t regionCount;
 772     PTR32 pRegions;
 773 } VkCopyImageToBufferInfo232;
 774 typedef VkCopyImageToBufferInfo232 VkCopyImageToBufferInfo2KHR32;
 775
 776 typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32
 777 {
 778     VkStructureType sType;
 779     PTR32 pNext;
 780     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
 781     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
 782     VkCopyAccelerationStructureModeKHR mode;
 783 } VkCopyMemoryToAccelerationStructureInfoKHR32;
 784
 785 typedef struct VkCopyMemoryToMicromapInfoEXT32
 786 {
 787     VkStructureType sType;
 788     PTR32 pNext;
 789     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
 790     VkMicromapEXT DECLSPEC_ALIGN(8) dst;
 791     VkCopyMicromapModeEXT mode;
 792 } VkCopyMemoryToMicromapInfoEXT32;
 793
 794 typedef struct VkCopyMicromapInfoEXT32
 795 {
 796     VkStructureType sType;
 797     PTR32 pNext;
 798     VkMicromapEXT DECLSPEC_ALIGN(8) src;
 799     VkMicromapEXT DECLSPEC_ALIGN(8) dst;
 800     VkCopyMicromapModeEXT mode;
 801 } VkCopyMicromapInfoEXT32;
 802
 803 typedef struct VkCopyMicromapToMemoryInfoEXT32
 804 {
 805     VkStructureType sType;
 806     PTR32 pNext;
 807     VkMicromapEXT DECLSPEC_ALIGN(8) src;
 808     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
 809     VkCopyMicromapModeEXT mode;
 810 } VkCopyMicromapToMemoryInfoEXT32;
 811
 812 typedef struct VkCuLaunchInfoNVX32
 813 {
 814     VkStructureType sType;
 815     PTR32 pNext;
 816     VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
 817     uint32_t gridDimX;
 818     uint32_t gridDimY;
 819     uint32_t gridDimZ;
 820     uint32_t blockDimX;
 821     uint32_t blockDimY;
 822     uint32_t blockDimZ;
 823     uint32_t sharedMemBytes;
 824     PTR32 paramCount;
 825     PTR32 pParams;
 826     PTR32 extraCount;
 827     PTR32 pExtras;
 828 } VkCuLaunchInfoNVX32;
 829
 830 typedef struct VkDebugMarkerMarkerInfoEXT32
 831 {
 832     VkStructureType sType;
 833     PTR32 pNext;
 834     PTR32 pMarkerName;
 835     float color[4];
 836 } VkDebugMarkerMarkerInfoEXT32;
 837
 838 typedef struct VkDecompressMemoryRegionNV32
 839 {
 840     VkDeviceAddress DECLSPEC_ALIGN(8) srcAddress;
 841     VkDeviceAddress DECLSPEC_ALIGN(8) dstAddress;
 842     VkDeviceSize DECLSPEC_ALIGN(8) compressedSize;
 843     VkDeviceSize DECLSPEC_ALIGN(8) decompressedSize;
 844     VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethod;
 845 } VkDecompressMemoryRegionNV32;
 846
 847 typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM32
 848 {
 849     VkStructureType sType;
 850     PTR32 pNext;
 851     uint32_t fragmentDensityOffsetCount;
 852     PTR32 pFragmentDensityOffsets;
 853 } VkSubpassFragmentDensityMapOffsetEndInfoQCOM32;
 854
 855 typedef struct VkSubpassEndInfo32
 856 {
 857     VkStructureType sType;
 858     PTR32 pNext;
 859 } VkSubpassEndInfo32;
 860 typedef VkSubpassEndInfo32 VkSubpassEndInfoKHR32;
 861
 862 typedef struct VkIndirectCommandsStreamNV32
 863 {
 864     VkBuffer DECLSPEC_ALIGN(8) buffer;
 865     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 866 } VkIndirectCommandsStreamNV32;
 867
 868 typedef struct VkGeneratedCommandsInfoNV32
 869 {
 870     VkStructureType sType;
 871     PTR32 pNext;
 872     VkPipelineBindPoint pipelineBindPoint;
 873     VkPipeline DECLSPEC_ALIGN(8) pipeline;
 874     VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
 875     uint32_t streamCount;
 876     PTR32 pStreams;
 877     uint32_t sequencesCount;
 878     VkBuffer DECLSPEC_ALIGN(8) preprocessBuffer;
 879     VkDeviceSize DECLSPEC_ALIGN(8) preprocessOffset;
 880     VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize;
 881     VkBuffer DECLSPEC_ALIGN(8) sequencesCountBuffer;
 882     VkDeviceSize DECLSPEC_ALIGN(8) sequencesCountOffset;
 883     VkBuffer DECLSPEC_ALIGN(8) sequencesIndexBuffer;
 884     VkDeviceSize DECLSPEC_ALIGN(8) sequencesIndexOffset;
 885 } VkGeneratedCommandsInfoNV32;
 886
 887 typedef struct VkOpticalFlowExecuteInfoNV32
 888 {
 889     VkStructureType sType;
 890     PTR32 pNext;
 891     VkOpticalFlowExecuteFlagsNV flags;
 892     uint32_t regionCount;
 893     PTR32 pRegions;
 894 } VkOpticalFlowExecuteInfoNV32;
 895
 896 typedef struct VkMemoryBarrier32
 897 {
 898     VkStructureType sType;
 899     PTR32 pNext;
 900     VkAccessFlags srcAccessMask;
 901     VkAccessFlags dstAccessMask;
 902 } VkMemoryBarrier32;
 903
 904 typedef struct VkBufferMemoryBarrier32
 905 {
 906     VkStructureType sType;
 907     PTR32 pNext;
 908     VkAccessFlags srcAccessMask;
 909     VkAccessFlags dstAccessMask;
 910     uint32_t srcQueueFamilyIndex;
 911     uint32_t dstQueueFamilyIndex;
 912     VkBuffer DECLSPEC_ALIGN(8) buffer;
 913     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 914     VkDeviceSize DECLSPEC_ALIGN(8) size;
 915 } VkBufferMemoryBarrier32;
 916
 917 typedef struct VkImageMemoryBarrier32
 918 {
 919     VkStructureType sType;
 920     PTR32 pNext;
 921     VkAccessFlags srcAccessMask;
 922     VkAccessFlags dstAccessMask;
 923     VkImageLayout oldLayout;
 924     VkImageLayout newLayout;
 925     uint32_t srcQueueFamilyIndex;
 926     uint32_t dstQueueFamilyIndex;
 927     VkImage DECLSPEC_ALIGN(8) image;
 928     VkImageSubresourceRange subresourceRange;
 929 } VkImageMemoryBarrier32;
 930
 931 typedef struct VkMemoryBarrier232
 932 {
 933     VkStructureType sType;
 934     PTR32 pNext;
 935     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 936     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 937     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 938     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 939 } VkMemoryBarrier232;
 940 typedef VkMemoryBarrier232 VkMemoryBarrier2KHR32;
 941
 942 typedef struct VkBufferMemoryBarrier232
 943 {
 944     VkStructureType sType;
 945     PTR32 pNext;
 946     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 947     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 948     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 949     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 950     uint32_t srcQueueFamilyIndex;
 951     uint32_t dstQueueFamilyIndex;
 952     VkBuffer DECLSPEC_ALIGN(8) buffer;
 953     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 954     VkDeviceSize DECLSPEC_ALIGN(8) size;
 955 } VkBufferMemoryBarrier232;
 956 typedef VkBufferMemoryBarrier232 VkBufferMemoryBarrier2KHR32;
 957
 958 typedef struct VkImageMemoryBarrier232
 959 {
 960     VkStructureType sType;
 961     PTR32 pNext;
 962     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
 963     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
 964     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
 965     VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask;
 966     VkImageLayout oldLayout;
 967     VkImageLayout newLayout;
 968     uint32_t srcQueueFamilyIndex;
 969     uint32_t dstQueueFamilyIndex;
 970     VkImage DECLSPEC_ALIGN(8) image;
 971     VkImageSubresourceRange subresourceRange;
 972 } VkImageMemoryBarrier232;
 973 typedef VkImageMemoryBarrier232 VkImageMemoryBarrier2KHR32;
 974
 975 typedef struct VkDependencyInfo32
 976 {
 977     VkStructureType sType;
 978     PTR32 pNext;
 979     VkDependencyFlags dependencyFlags;
 980     uint32_t memoryBarrierCount;
 981     PTR32 pMemoryBarriers;
 982     uint32_t bufferMemoryBarrierCount;
 983     PTR32 pBufferMemoryBarriers;
 984     uint32_t imageMemoryBarrierCount;
 985     PTR32 pImageMemoryBarriers;
 986 } VkDependencyInfo32;
 987 typedef VkDependencyInfo32 VkDependencyInfoKHR32;
 988
 989 typedef struct VkDescriptorImageInfo32
 990 {
 991     VkSampler DECLSPEC_ALIGN(8) sampler;
 992     VkImageView DECLSPEC_ALIGN(8) imageView;
 993     VkImageLayout imageLayout;
 994 } VkDescriptorImageInfo32;
 995
 996 typedef struct VkDescriptorBufferInfo32
 997 {
 998     VkBuffer DECLSPEC_ALIGN(8) buffer;
 999     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1000     VkDeviceSize DECLSPEC_ALIGN(8) range;
1001 } VkDescriptorBufferInfo32;
1002
1003 typedef struct VkWriteDescriptorSetInlineUniformBlock32
1004 {
1005     VkStructureType sType;
1006     PTR32 pNext;
1007     uint32_t dataSize;
1008     PTR32 pData;
1009 } VkWriteDescriptorSetInlineUniformBlock32;
1010 typedef VkWriteDescriptorSetInlineUniformBlock32 VkWriteDescriptorSetInlineUniformBlockEXT32;
1011
1012 typedef struct VkWriteDescriptorSetAccelerationStructureKHR32
1013 {
1014     VkStructureType sType;
1015     PTR32 pNext;
1016     uint32_t accelerationStructureCount;
1017     PTR32 pAccelerationStructures;
1018 } VkWriteDescriptorSetAccelerationStructureKHR32;
1019
1020 typedef struct VkWriteDescriptorSetAccelerationStructureNV32
1021 {
1022     VkStructureType sType;
1023     PTR32 pNext;
1024     uint32_t accelerationStructureCount;
1025     PTR32 pAccelerationStructures;
1026 } VkWriteDescriptorSetAccelerationStructureNV32;
1027
1028 typedef struct VkWriteDescriptorSet32
1029 {
1030     VkStructureType sType;
1031     PTR32 pNext;
1032     VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
1033     uint32_t dstBinding;
1034     uint32_t dstArrayElement;
1035     uint32_t descriptorCount;
1036     VkDescriptorType descriptorType;
1037     PTR32 pImageInfo;
1038     PTR32 pBufferInfo;
1039     PTR32 pTexelBufferView;
1040 } VkWriteDescriptorSet32;
1041
1042 typedef struct VkImageResolve232
1043 {
1044     VkStructureType sType;
1045     PTR32 pNext;
1046     VkImageSubresourceLayers srcSubresource;
1047     VkOffset3D srcOffset;
1048     VkImageSubresourceLayers dstSubresource;
1049     VkOffset3D dstOffset;
1050     VkExtent3D extent;
1051 } VkImageResolve232;
1052 typedef VkImageResolve232 VkImageResolve2KHR32;
1053
1054 typedef struct VkResolveImageInfo232
1055 {
1056     VkStructureType sType;
1057     PTR32 pNext;
1058     VkImage DECLSPEC_ALIGN(8) srcImage;
1059     VkImageLayout srcImageLayout;
1060     VkImage DECLSPEC_ALIGN(8) dstImage;
1061     VkImageLayout dstImageLayout;
1062     uint32_t regionCount;
1063     PTR32 pRegions;
1064 } VkResolveImageInfo232;
1065 typedef VkResolveImageInfo232 VkResolveImageInfo2KHR32;
1066
1067 typedef struct VkCoarseSampleOrderCustomNV32
1068 {
1069     VkShadingRatePaletteEntryNV shadingRate;
1070     uint32_t sampleCount;
1071     uint32_t sampleLocationCount;
1072     PTR32 pSampleLocations;
1073 } VkCoarseSampleOrderCustomNV32;
1074
1075 typedef struct VkPerformanceMarkerInfoINTEL32
1076 {
1077     VkStructureType sType;
1078     PTR32 pNext;
1079     uint64_t DECLSPEC_ALIGN(8) marker;
1080 } VkPerformanceMarkerInfoINTEL32;
1081
1082 typedef struct VkPerformanceOverrideInfoINTEL32
1083 {
1084     VkStructureType sType;
1085     PTR32 pNext;
1086     VkPerformanceOverrideTypeINTEL type;
1087     VkBool32 enable;
1088     uint64_t DECLSPEC_ALIGN(8) parameter;
1089 } VkPerformanceOverrideInfoINTEL32;
1090
1091 typedef struct VkPerformanceStreamMarkerInfoINTEL32
1092 {
1093     VkStructureType sType;
1094     PTR32 pNext;
1095     uint32_t marker;
1096 } VkPerformanceStreamMarkerInfoINTEL32;
1097
1098 typedef struct VkVertexInputBindingDescription2EXT32
1099 {
1100     VkStructureType sType;
1101     PTR32 pNext;
1102     uint32_t binding;
1103     uint32_t stride;
1104     VkVertexInputRate inputRate;
1105     uint32_t divisor;
1106 } VkVertexInputBindingDescription2EXT32;
1107
1108 typedef struct VkVertexInputAttributeDescription2EXT32
1109 {
1110     VkStructureType sType;
1111     PTR32 pNext;
1112     uint32_t location;
1113     uint32_t binding;
1114     VkFormat format;
1115     uint32_t offset;
1116 } VkVertexInputAttributeDescription2EXT32;
1117
1118 typedef struct VkShadingRatePaletteNV32
1119 {
1120     uint32_t shadingRatePaletteEntryCount;
1121     PTR32 pShadingRatePaletteEntries;
1122 } VkShadingRatePaletteNV32;
1123
1124 typedef struct VkStridedDeviceAddressRegionKHR32
1125 {
1126     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1127     VkDeviceSize DECLSPEC_ALIGN(8) stride;
1128     VkDeviceSize DECLSPEC_ALIGN(8) size;
1129 } VkStridedDeviceAddressRegionKHR32;
1130
1131 typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT32
1132 {
1133     VkStructureType sType;
1134     PTR32 pNext;
1135     PTR32 opaqueCaptureDescriptorData;
1136 } VkOpaqueCaptureDescriptorDataCreateInfoEXT32;
1137
1138 typedef struct VkAccelerationStructureMotionInfoNV32
1139 {
1140     VkStructureType sType;
1141     PTR32 pNext;
1142     uint32_t maxInstances;
1143     VkAccelerationStructureMotionInfoFlagsNV flags;
1144 } VkAccelerationStructureMotionInfoNV32;
1145
1146 typedef struct VkAccelerationStructureCreateInfoKHR32
1147 {
1148     VkStructureType sType;
1149     PTR32 pNext;
1150     VkAccelerationStructureCreateFlagsKHR createFlags;
1151     VkBuffer DECLSPEC_ALIGN(8) buffer;
1152     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1153     VkDeviceSize DECLSPEC_ALIGN(8) size;
1154     VkAccelerationStructureTypeKHR type;
1155     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1156 } VkAccelerationStructureCreateInfoKHR32;
1157
1158 typedef struct VkAccelerationStructureCreateInfoNV32
1159 {
1160     VkStructureType sType;
1161     PTR32 pNext;
1162     VkDeviceSize DECLSPEC_ALIGN(8) compactedSize;
1163     VkAccelerationStructureInfoNV32 info;
1164 } VkAccelerationStructureCreateInfoNV32;
1165
1166 typedef struct VkDedicatedAllocationBufferCreateInfoNV32
1167 {
1168     VkStructureType sType;
1169     PTR32 pNext;
1170     VkBool32 dedicatedAllocation;
1171 } VkDedicatedAllocationBufferCreateInfoNV32;
1172
1173 typedef struct VkExternalMemoryBufferCreateInfo32
1174 {
1175     VkStructureType sType;
1176     PTR32 pNext;
1177     VkExternalMemoryHandleTypeFlags handleTypes;
1178 } VkExternalMemoryBufferCreateInfo32;
1179 typedef VkExternalMemoryBufferCreateInfo32 VkExternalMemoryBufferCreateInfoKHR32;
1180
1181 typedef struct VkBufferOpaqueCaptureAddressCreateInfo32
1182 {
1183     VkStructureType sType;
1184     PTR32 pNext;
1185     uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
1186 } VkBufferOpaqueCaptureAddressCreateInfo32;
1187 typedef VkBufferOpaqueCaptureAddressCreateInfo32 VkBufferOpaqueCaptureAddressCreateInfoKHR32;
1188
1189 typedef struct VkBufferDeviceAddressCreateInfoEXT32
1190 {
1191     VkStructureType sType;
1192     PTR32 pNext;
1193     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1194 } VkBufferDeviceAddressCreateInfoEXT32;
1195
1196 typedef struct VkBufferCreateInfo32
1197 {
1198     VkStructureType sType;
1199     PTR32 pNext;
1200     VkBufferCreateFlags flags;
1201     VkDeviceSize DECLSPEC_ALIGN(8) size;
1202     VkBufferUsageFlags usage;
1203     VkSharingMode sharingMode;
1204     uint32_t queueFamilyIndexCount;
1205     PTR32 pQueueFamilyIndices;
1206 } VkBufferCreateInfo32;
1207
1208 typedef struct VkBufferViewCreateInfo32
1209 {
1210     VkStructureType sType;
1211     PTR32 pNext;
1212     VkBufferViewCreateFlags flags;
1213     VkBuffer DECLSPEC_ALIGN(8) buffer;
1214     VkFormat format;
1215     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1216     VkDeviceSize DECLSPEC_ALIGN(8) range;
1217 } VkBufferViewCreateInfo32;
1218
1219 typedef struct VkCommandPoolCreateInfo32
1220 {
1221     VkStructureType sType;
1222     PTR32 pNext;
1223     VkCommandPoolCreateFlags flags;
1224     uint32_t queueFamilyIndex;
1225 } VkCommandPoolCreateInfo32;
1226
1227 typedef struct VkPipelineCreationFeedback32
1228 {
1229     VkPipelineCreationFeedbackFlags flags;
1230     uint64_t DECLSPEC_ALIGN(8) duration;
1231 } VkPipelineCreationFeedback32;
1232 typedef VkPipelineCreationFeedback32 VkPipelineCreationFeedbackEXT32;
1233
1234 typedef struct VkSpecializationMapEntry32
1235 {
1236     uint32_t constantID;
1237     uint32_t offset;
1238     PTR32 size;
1239 } VkSpecializationMapEntry32;
1240
1241 typedef struct VkSpecializationInfo32
1242 {
1243     uint32_t mapEntryCount;
1244     PTR32 pMapEntries;
1245     PTR32 dataSize;
1246     PTR32 pData;
1247 } VkSpecializationInfo32;
1248
1249 typedef struct VkShaderModuleCreateInfo32
1250 {
1251     VkStructureType sType;
1252     PTR32 pNext;
1253     VkShaderModuleCreateFlags flags;
1254     PTR32 codeSize;
1255     PTR32 pCode;
1256 } VkShaderModuleCreateInfo32;
1257
1258 typedef struct VkShaderModuleValidationCacheCreateInfoEXT32
1259 {
1260     VkStructureType sType;
1261     PTR32 pNext;
1262     VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
1263 } VkShaderModuleValidationCacheCreateInfoEXT32;
1264
1265 typedef struct VkDebugUtilsObjectNameInfoEXT32
1266 {
1267     VkStructureType sType;
1268     PTR32 pNext;
1269     VkObjectType objectType;
1270     uint64_t DECLSPEC_ALIGN(8) objectHandle;
1271     PTR32 pObjectName;
1272 } VkDebugUtilsObjectNameInfoEXT32;
1273
1274 typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32
1275 {
1276     VkStructureType sType;
1277     PTR32 pNext;
1278     uint32_t requiredSubgroupSize;
1279 } VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32;
1280 typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT32;
1281
1282 typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT32
1283 {
1284     VkStructureType sType;
1285     PTR32 pNext;
1286     uint32_t identifierSize;
1287     PTR32 pIdentifier;
1288 } VkPipelineShaderStageModuleIdentifierCreateInfoEXT32;
1289
1290 typedef struct VkPipelineRobustnessCreateInfoEXT32
1291 {
1292     VkStructureType sType;
1293     PTR32 pNext;
1294     VkPipelineRobustnessBufferBehaviorEXT storageBuffers;
1295     VkPipelineRobustnessBufferBehaviorEXT uniformBuffers;
1296     VkPipelineRobustnessBufferBehaviorEXT vertexInputs;
1297     VkPipelineRobustnessImageBehaviorEXT images;
1298 } VkPipelineRobustnessCreateInfoEXT32;
1299
1300 typedef struct VkPipelineShaderStageCreateInfo32
1301 {
1302     VkStructureType sType;
1303     PTR32 pNext;
1304     VkPipelineShaderStageCreateFlags flags;
1305     VkShaderStageFlagBits stage;
1306     VkShaderModule DECLSPEC_ALIGN(8) module;
1307     PTR32 pName;
1308     PTR32 pSpecializationInfo;
1309 } VkPipelineShaderStageCreateInfo32;
1310
1311 typedef struct VkPipelineCreationFeedbackCreateInfo32
1312 {
1313     VkStructureType sType;
1314     PTR32 pNext;
1315     PTR32 pPipelineCreationFeedback;
1316     uint32_t pipelineStageCreationFeedbackCount;
1317     PTR32 pPipelineStageCreationFeedbacks;
1318 } VkPipelineCreationFeedbackCreateInfo32;
1319 typedef VkPipelineCreationFeedbackCreateInfo32 VkPipelineCreationFeedbackCreateInfoEXT32;
1320
1321 typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI32
1322 {
1323     VkStructureType sType;
1324     PTR32 pNext;
1325     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
1326     uint32_t subpass;
1327 } VkSubpassShadingPipelineCreateInfoHUAWEI32;
1328
1329 typedef struct VkPipelineCompilerControlCreateInfoAMD32
1330 {
1331     VkStructureType sType;
1332     PTR32 pNext;
1333     VkPipelineCompilerControlFlagsAMD compilerControlFlags;
1334 } VkPipelineCompilerControlCreateInfoAMD32;
1335
1336 typedef struct VkComputePipelineCreateInfo32
1337 {
1338     VkStructureType sType;
1339     PTR32 pNext;
1340     VkPipelineCreateFlags flags;
1341     VkPipelineShaderStageCreateInfo32 DECLSPEC_ALIGN(8) stage;
1342     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
1343     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
1344     int32_t basePipelineIndex;
1345 } VkComputePipelineCreateInfo32;
1346
1347 typedef struct VkCuFunctionCreateInfoNVX32
1348 {
1349     VkStructureType sType;
1350     PTR32 pNext;
1351     VkCuModuleNVX DECLSPEC_ALIGN(8) module;
1352     PTR32 pName;
1353 } VkCuFunctionCreateInfoNVX32;
1354
1355 typedef struct VkCuModuleCreateInfoNVX32
1356 {
1357     VkStructureType sType;
1358     PTR32 pNext;
1359     PTR32 dataSize;
1360     PTR32 pData;
1361 } VkCuModuleCreateInfoNVX32;
1362
1363 typedef struct VkDebugReportCallbackCreateInfoEXT32
1364 {
1365     VkStructureType sType;
1366     PTR32 pNext;
1367     VkDebugReportFlagsEXT flags;
1368     PFN_vkDebugReportCallbackEXT pfnCallback;
1369     PTR32 pUserData;
1370 } VkDebugReportCallbackCreateInfoEXT32;
1371
1372 typedef struct VkDebugUtilsMessengerCreateInfoEXT32
1373 {
1374     VkStructureType sType;
1375     PTR32 pNext;
1376     VkDebugUtilsMessengerCreateFlagsEXT flags;
1377     VkDebugUtilsMessageSeverityFlagsEXT messageSeverity;
1378     VkDebugUtilsMessageTypeFlagsEXT messageType;
1379     PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
1380     PTR32 pUserData;
1381 } VkDebugUtilsMessengerCreateInfoEXT32;
1382
1383 typedef struct VkMutableDescriptorTypeListEXT32
1384 {
1385     uint32_t descriptorTypeCount;
1386     PTR32 pDescriptorTypes;
1387 } VkMutableDescriptorTypeListEXT32;
1388 typedef VkMutableDescriptorTypeListEXT32 VkMutableDescriptorTypeListVALVE32;
1389
1390 typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo32
1391 {
1392     VkStructureType sType;
1393     PTR32 pNext;
1394     uint32_t maxInlineUniformBlockBindings;
1395 } VkDescriptorPoolInlineUniformBlockCreateInfo32;
1396 typedef VkDescriptorPoolInlineUniformBlockCreateInfo32 VkDescriptorPoolInlineUniformBlockCreateInfoEXT32;
1397
1398 typedef struct VkMutableDescriptorTypeCreateInfoEXT32
1399 {
1400     VkStructureType sType;
1401     PTR32 pNext;
1402     uint32_t mutableDescriptorTypeListCount;
1403     PTR32 pMutableDescriptorTypeLists;
1404 } VkMutableDescriptorTypeCreateInfoEXT32;
1405 typedef VkMutableDescriptorTypeCreateInfoEXT32 VkMutableDescriptorTypeCreateInfoVALVE32;
1406
1407 typedef struct VkDescriptorPoolCreateInfo32
1408 {
1409     VkStructureType sType;
1410     PTR32 pNext;
1411     VkDescriptorPoolCreateFlags flags;
1412     uint32_t maxSets;
1413     uint32_t poolSizeCount;
1414     PTR32 pPoolSizes;
1415 } VkDescriptorPoolCreateInfo32;
1416
1417 typedef struct VkDescriptorSetLayoutBinding32
1418 {
1419     uint32_t binding;
1420     VkDescriptorType descriptorType;
1421     uint32_t descriptorCount;
1422     VkShaderStageFlags stageFlags;
1423     PTR32 pImmutableSamplers;
1424 } VkDescriptorSetLayoutBinding32;
1425
1426 typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo32
1427 {
1428     VkStructureType sType;
1429     PTR32 pNext;
1430     uint32_t bindingCount;
1431     PTR32 pBindingFlags;
1432 } VkDescriptorSetLayoutBindingFlagsCreateInfo32;
1433 typedef VkDescriptorSetLayoutBindingFlagsCreateInfo32 VkDescriptorSetLayoutBindingFlagsCreateInfoEXT32;
1434
1435 typedef struct VkDescriptorSetLayoutCreateInfo32
1436 {
1437     VkStructureType sType;
1438     PTR32 pNext;
1439     VkDescriptorSetLayoutCreateFlags flags;
1440     uint32_t bindingCount;
1441     PTR32 pBindings;
1442 } VkDescriptorSetLayoutCreateInfo32;
1443
1444 typedef struct VkDescriptorUpdateTemplateEntry32
1445 {
1446     uint32_t dstBinding;
1447     uint32_t dstArrayElement;
1448     uint32_t descriptorCount;
1449     VkDescriptorType descriptorType;
1450     PTR32 offset;
1451     PTR32 stride;
1452 } VkDescriptorUpdateTemplateEntry32;
1453 typedef VkDescriptorUpdateTemplateEntry32 VkDescriptorUpdateTemplateEntryKHR32;
1454
1455 typedef struct VkDescriptorUpdateTemplateCreateInfo32
1456 {
1457     VkStructureType sType;
1458     PTR32 pNext;
1459     VkDescriptorUpdateTemplateCreateFlags flags;
1460     uint32_t descriptorUpdateEntryCount;
1461     PTR32 pDescriptorUpdateEntries;
1462     VkDescriptorUpdateTemplateType templateType;
1463     VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
1464     VkPipelineBindPoint pipelineBindPoint;
1465     VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
1466     uint32_t set;
1467 } VkDescriptorUpdateTemplateCreateInfo32;
1468 typedef VkDescriptorUpdateTemplateCreateInfo32 VkDescriptorUpdateTemplateCreateInfoKHR32;
1469
1470 typedef struct VkDeviceQueueGlobalPriorityCreateInfoKHR32
1471 {
1472     VkStructureType sType;
1473     PTR32 pNext;
1474     VkQueueGlobalPriorityKHR globalPriority;
1475 } VkDeviceQueueGlobalPriorityCreateInfoKHR32;
1476 typedef VkDeviceQueueGlobalPriorityCreateInfoKHR32 VkDeviceQueueGlobalPriorityCreateInfoEXT32;
1477
1478 typedef struct VkDeviceQueueCreateInfo32
1479 {
1480     VkStructureType sType;
1481     PTR32 pNext;
1482     VkDeviceQueueCreateFlags flags;
1483     uint32_t queueFamilyIndex;
1484     uint32_t queueCount;
1485     PTR32 pQueuePriorities;
1486 } VkDeviceQueueCreateInfo32;
1487
1488 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32
1489 {
1490     VkStructureType sType;
1491     PTR32 pNext;
1492     VkBool32 deviceGeneratedCommands;
1493 } VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32;
1494
1495 typedef struct VkDevicePrivateDataCreateInfo32
1496 {
1497     VkStructureType sType;
1498     PTR32 pNext;
1499     uint32_t privateDataSlotRequestCount;
1500 } VkDevicePrivateDataCreateInfo32;
1501 typedef VkDevicePrivateDataCreateInfo32 VkDevicePrivateDataCreateInfoEXT32;
1502
1503 typedef struct VkPhysicalDevicePrivateDataFeatures32
1504 {
1505     VkStructureType sType;
1506     PTR32 pNext;
1507     VkBool32 privateData;
1508 } VkPhysicalDevicePrivateDataFeatures32;
1509 typedef VkPhysicalDevicePrivateDataFeatures32 VkPhysicalDevicePrivateDataFeaturesEXT32;
1510
1511 typedef struct VkPhysicalDeviceFeatures232
1512 {
1513     VkStructureType sType;
1514     PTR32 pNext;
1515     VkPhysicalDeviceFeatures features;
1516 } VkPhysicalDeviceFeatures232;
1517 typedef VkPhysicalDeviceFeatures232 VkPhysicalDeviceFeatures2KHR32;
1518
1519 typedef struct VkPhysicalDeviceVariablePointersFeatures32
1520 {
1521     VkStructureType sType;
1522     PTR32 pNext;
1523     VkBool32 variablePointersStorageBuffer;
1524     VkBool32 variablePointers;
1525 } VkPhysicalDeviceVariablePointersFeatures32;
1526 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointersFeaturesKHR32;
1527 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeaturesKHR32;
1528 typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeatures32;
1529
1530 typedef struct VkPhysicalDeviceMultiviewFeatures32
1531 {
1532     VkStructureType sType;
1533     PTR32 pNext;
1534     VkBool32 multiview;
1535     VkBool32 multiviewGeometryShader;
1536     VkBool32 multiviewTessellationShader;
1537 } VkPhysicalDeviceMultiviewFeatures32;
1538 typedef VkPhysicalDeviceMultiviewFeatures32 VkPhysicalDeviceMultiviewFeaturesKHR32;
1539
1540 typedef struct VkDeviceGroupDeviceCreateInfo32
1541 {
1542     VkStructureType sType;
1543     PTR32 pNext;
1544     uint32_t physicalDeviceCount;
1545     PTR32 pPhysicalDevices;
1546 } VkDeviceGroupDeviceCreateInfo32;
1547 typedef VkDeviceGroupDeviceCreateInfo32 VkDeviceGroupDeviceCreateInfoKHR32;
1548
1549 typedef struct VkPhysicalDevicePresentIdFeaturesKHR32
1550 {
1551     VkStructureType sType;
1552     PTR32 pNext;
1553     VkBool32 presentId;
1554 } VkPhysicalDevicePresentIdFeaturesKHR32;
1555
1556 typedef struct VkPhysicalDevicePresentWaitFeaturesKHR32
1557 {
1558     VkStructureType sType;
1559     PTR32 pNext;
1560     VkBool32 presentWait;
1561 } VkPhysicalDevicePresentWaitFeaturesKHR32;
1562
1563 typedef struct VkPhysicalDevice16BitStorageFeatures32
1564 {
1565     VkStructureType sType;
1566     PTR32 pNext;
1567     VkBool32 storageBuffer16BitAccess;
1568     VkBool32 uniformAndStorageBuffer16BitAccess;
1569     VkBool32 storagePushConstant16;
1570     VkBool32 storageInputOutput16;
1571 } VkPhysicalDevice16BitStorageFeatures32;
1572 typedef VkPhysicalDevice16BitStorageFeatures32 VkPhysicalDevice16BitStorageFeaturesKHR32;
1573
1574 typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32
1575 {
1576     VkStructureType sType;
1577     PTR32 pNext;
1578     VkBool32 shaderSubgroupExtendedTypes;
1579 } VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32;
1580 typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR32;
1581
1582 typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures32
1583 {
1584     VkStructureType sType;
1585     PTR32 pNext;
1586     VkBool32 samplerYcbcrConversion;
1587 } VkPhysicalDeviceSamplerYcbcrConversionFeatures32;
1588 typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures32 VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR32;
1589
1590 typedef struct VkPhysicalDeviceProtectedMemoryFeatures32
1591 {
1592     VkStructureType sType;
1593     PTR32 pNext;
1594     VkBool32 protectedMemory;
1595 } VkPhysicalDeviceProtectedMemoryFeatures32;
1596
1597 typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32
1598 {
1599     VkStructureType sType;
1600     PTR32 pNext;
1601     VkBool32 advancedBlendCoherentOperations;
1602 } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32;
1603
1604 typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT32
1605 {
1606     VkStructureType sType;
1607     PTR32 pNext;
1608     VkBool32 multiDraw;
1609 } VkPhysicalDeviceMultiDrawFeaturesEXT32;
1610
1611 typedef struct VkPhysicalDeviceInlineUniformBlockFeatures32
1612 {
1613     VkStructureType sType;
1614     PTR32 pNext;
1615     VkBool32 inlineUniformBlock;
1616     VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
1617 } VkPhysicalDeviceInlineUniformBlockFeatures32;
1618 typedef VkPhysicalDeviceInlineUniformBlockFeatures32 VkPhysicalDeviceInlineUniformBlockFeaturesEXT32;
1619
1620 typedef struct VkPhysicalDeviceMaintenance4Features32
1621 {
1622     VkStructureType sType;
1623     PTR32 pNext;
1624     VkBool32 maintenance4;
1625 } VkPhysicalDeviceMaintenance4Features32;
1626 typedef VkPhysicalDeviceMaintenance4Features32 VkPhysicalDeviceMaintenance4FeaturesKHR32;
1627
1628 typedef struct VkPhysicalDeviceShaderDrawParametersFeatures32
1629 {
1630     VkStructureType sType;
1631     PTR32 pNext;
1632     VkBool32 shaderDrawParameters;
1633 } VkPhysicalDeviceShaderDrawParametersFeatures32;
1634 typedef VkPhysicalDeviceShaderDrawParametersFeatures32 VkPhysicalDeviceShaderDrawParameterFeatures32;
1635
1636 typedef struct VkPhysicalDeviceShaderFloat16Int8Features32
1637 {
1638     VkStructureType sType;
1639     PTR32 pNext;
1640     VkBool32 shaderFloat16;
1641     VkBool32 shaderInt8;
1642 } VkPhysicalDeviceShaderFloat16Int8Features32;
1643 typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceShaderFloat16Int8FeaturesKHR32;
1644 typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceFloat16Int8FeaturesKHR32;
1645
1646 typedef struct VkPhysicalDeviceHostQueryResetFeatures32
1647 {
1648     VkStructureType sType;
1649     PTR32 pNext;
1650     VkBool32 hostQueryReset;
1651 } VkPhysicalDeviceHostQueryResetFeatures32;
1652 typedef VkPhysicalDeviceHostQueryResetFeatures32 VkPhysicalDeviceHostQueryResetFeaturesEXT32;
1653
1654 typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32
1655 {
1656     VkStructureType sType;
1657     PTR32 pNext;
1658     VkBool32 globalPriorityQuery;
1659 } VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32;
1660 typedef VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT32;
1661
1662 typedef struct VkPhysicalDeviceDescriptorIndexingFeatures32
1663 {
1664     VkStructureType sType;
1665     PTR32 pNext;
1666     VkBool32 shaderInputAttachmentArrayDynamicIndexing;
1667     VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
1668     VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
1669     VkBool32 shaderUniformBufferArrayNonUniformIndexing;
1670     VkBool32 shaderSampledImageArrayNonUniformIndexing;
1671     VkBool32 shaderStorageBufferArrayNonUniformIndexing;
1672     VkBool32 shaderStorageImageArrayNonUniformIndexing;
1673     VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
1674     VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
1675     VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
1676     VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
1677     VkBool32 descriptorBindingSampledImageUpdateAfterBind;
1678     VkBool32 descriptorBindingStorageImageUpdateAfterBind;
1679     VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
1680     VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
1681     VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
1682     VkBool32 descriptorBindingUpdateUnusedWhilePending;
1683     VkBool32 descriptorBindingPartiallyBound;
1684     VkBool32 descriptorBindingVariableDescriptorCount;
1685     VkBool32 runtimeDescriptorArray;
1686 } VkPhysicalDeviceDescriptorIndexingFeatures32;
1687 typedef VkPhysicalDeviceDescriptorIndexingFeatures32 VkPhysicalDeviceDescriptorIndexingFeaturesEXT32;
1688
1689 typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures32
1690 {
1691     VkStructureType sType;
1692     PTR32 pNext;
1693     VkBool32 timelineSemaphore;
1694 } VkPhysicalDeviceTimelineSemaphoreFeatures32;
1695 typedef VkPhysicalDeviceTimelineSemaphoreFeatures32 VkPhysicalDeviceTimelineSemaphoreFeaturesKHR32;
1696
1697 typedef struct VkPhysicalDevice8BitStorageFeatures32
1698 {
1699     VkStructureType sType;
1700     PTR32 pNext;
1701     VkBool32 storageBuffer8BitAccess;
1702     VkBool32 uniformAndStorageBuffer8BitAccess;
1703     VkBool32 storagePushConstant8;
1704 } VkPhysicalDevice8BitStorageFeatures32;
1705 typedef VkPhysicalDevice8BitStorageFeatures32 VkPhysicalDevice8BitStorageFeaturesKHR32;
1706
1707 typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT32
1708 {
1709     VkStructureType sType;
1710     PTR32 pNext;
1711     VkBool32 conditionalRendering;
1712     VkBool32 inheritedConditionalRendering;
1713 } VkPhysicalDeviceConditionalRenderingFeaturesEXT32;
1714
1715 typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures32
1716 {
1717     VkStructureType sType;
1718     PTR32 pNext;
1719     VkBool32 vulkanMemoryModel;
1720     VkBool32 vulkanMemoryModelDeviceScope;
1721     VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
1722 } VkPhysicalDeviceVulkanMemoryModelFeatures32;
1723 typedef VkPhysicalDeviceVulkanMemoryModelFeatures32 VkPhysicalDeviceVulkanMemoryModelFeaturesKHR32;
1724
1725 typedef struct VkPhysicalDeviceShaderAtomicInt64Features32
1726 {
1727     VkStructureType sType;
1728     PTR32 pNext;
1729     VkBool32 shaderBufferInt64Atomics;
1730     VkBool32 shaderSharedInt64Atomics;
1731 } VkPhysicalDeviceShaderAtomicInt64Features32;
1732 typedef VkPhysicalDeviceShaderAtomicInt64Features32 VkPhysicalDeviceShaderAtomicInt64FeaturesKHR32;
1733
1734 typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32
1735 {
1736     VkStructureType sType;
1737     PTR32 pNext;
1738     VkBool32 shaderBufferFloat32Atomics;
1739     VkBool32 shaderBufferFloat32AtomicAdd;
1740     VkBool32 shaderBufferFloat64Atomics;
1741     VkBool32 shaderBufferFloat64AtomicAdd;
1742     VkBool32 shaderSharedFloat32Atomics;
1743     VkBool32 shaderSharedFloat32AtomicAdd;
1744     VkBool32 shaderSharedFloat64Atomics;
1745     VkBool32 shaderSharedFloat64AtomicAdd;
1746     VkBool32 shaderImageFloat32Atomics;
1747     VkBool32 shaderImageFloat32AtomicAdd;
1748     VkBool32 sparseImageFloat32Atomics;
1749     VkBool32 sparseImageFloat32AtomicAdd;
1750 } VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32;
1751
1752 typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32
1753 {
1754     VkStructureType sType;
1755     PTR32 pNext;
1756     VkBool32 shaderBufferFloat16Atomics;
1757     VkBool32 shaderBufferFloat16AtomicAdd;
1758     VkBool32 shaderBufferFloat16AtomicMinMax;
1759     VkBool32 shaderBufferFloat32AtomicMinMax;
1760     VkBool32 shaderBufferFloat64AtomicMinMax;
1761     VkBool32 shaderSharedFloat16Atomics;
1762     VkBool32 shaderSharedFloat16AtomicAdd;
1763     VkBool32 shaderSharedFloat16AtomicMinMax;
1764     VkBool32 shaderSharedFloat32AtomicMinMax;
1765     VkBool32 shaderSharedFloat64AtomicMinMax;
1766     VkBool32 shaderImageFloat32AtomicMinMax;
1767     VkBool32 sparseImageFloat32AtomicMinMax;
1768 } VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32;
1769
1770 typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32
1771 {
1772     VkStructureType sType;
1773     PTR32 pNext;
1774     VkBool32 vertexAttributeInstanceRateDivisor;
1775     VkBool32 vertexAttributeInstanceRateZeroDivisor;
1776 } VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32;
1777
1778 typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT32
1779 {
1780     VkStructureType sType;
1781     PTR32 pNext;
1782     VkBool32 decodeModeSharedExponent;
1783 } VkPhysicalDeviceASTCDecodeFeaturesEXT32;
1784
1785 typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT32
1786 {
1787     VkStructureType sType;
1788     PTR32 pNext;
1789     VkBool32 transformFeedback;
1790     VkBool32 geometryStreams;
1791 } VkPhysicalDeviceTransformFeedbackFeaturesEXT32;
1792
1793 typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32
1794 {
1795     VkStructureType sType;
1796     PTR32 pNext;
1797     VkBool32 representativeFragmentTest;
1798 } VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32;
1799
1800 typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV32
1801 {
1802     VkStructureType sType;
1803     PTR32 pNext;
1804     VkBool32 exclusiveScissor;
1805 } VkPhysicalDeviceExclusiveScissorFeaturesNV32;
1806
1807 typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV32
1808 {
1809     VkStructureType sType;
1810     PTR32 pNext;
1811     VkBool32 cornerSampledImage;
1812 } VkPhysicalDeviceCornerSampledImageFeaturesNV32;
1813
1814 typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32
1815 {
1816     VkStructureType sType;
1817     PTR32 pNext;
1818     VkBool32 computeDerivativeGroupQuads;
1819     VkBool32 computeDerivativeGroupLinear;
1820 } VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32;
1821
1822 typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV32
1823 {
1824     VkStructureType sType;
1825     PTR32 pNext;
1826     VkBool32 imageFootprint;
1827 } VkPhysicalDeviceShaderImageFootprintFeaturesNV32;
1828
1829 typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32
1830 {
1831     VkStructureType sType;
1832     PTR32 pNext;
1833     VkBool32 dedicatedAllocationImageAliasing;
1834 } VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32;
1835
1836 typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32
1837 {
1838     VkStructureType sType;
1839     PTR32 pNext;
1840     VkBool32 indirectCopy;
1841 } VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32;
1842
1843 typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV32
1844 {
1845     VkStructureType sType;
1846     PTR32 pNext;
1847     VkBool32 memoryDecompression;
1848 } VkPhysicalDeviceMemoryDecompressionFeaturesNV32;
1849
1850 typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV32
1851 {
1852     VkStructureType sType;
1853     PTR32 pNext;
1854     VkBool32 shadingRateImage;
1855     VkBool32 shadingRateCoarseSampleOrder;
1856 } VkPhysicalDeviceShadingRateImageFeaturesNV32;
1857
1858 typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32
1859 {
1860     VkStructureType sType;
1861     PTR32 pNext;
1862     VkBool32 invocationMask;
1863 } VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32;
1864
1865 typedef struct VkPhysicalDeviceMeshShaderFeaturesNV32
1866 {
1867     VkStructureType sType;
1868     PTR32 pNext;
1869     VkBool32 taskShader;
1870     VkBool32 meshShader;
1871 } VkPhysicalDeviceMeshShaderFeaturesNV32;
1872
1873 typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT32
1874 {
1875     VkStructureType sType;
1876     PTR32 pNext;
1877     VkBool32 taskShader;
1878     VkBool32 meshShader;
1879     VkBool32 multiviewMeshShader;
1880     VkBool32 primitiveFragmentShadingRateMeshShader;
1881     VkBool32 meshShaderQueries;
1882 } VkPhysicalDeviceMeshShaderFeaturesEXT32;
1883
1884 typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR32
1885 {
1886     VkStructureType sType;
1887     PTR32 pNext;
1888     VkBool32 accelerationStructure;
1889     VkBool32 accelerationStructureCaptureReplay;
1890     VkBool32 accelerationStructureIndirectBuild;
1891     VkBool32 accelerationStructureHostCommands;
1892     VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind;
1893 } VkPhysicalDeviceAccelerationStructureFeaturesKHR32;
1894
1895 typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR32
1896 {
1897     VkStructureType sType;
1898     PTR32 pNext;
1899     VkBool32 rayTracingPipeline;
1900     VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay;
1901     VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
1902     VkBool32 rayTracingPipelineTraceRaysIndirect;
1903     VkBool32 rayTraversalPrimitiveCulling;
1904 } VkPhysicalDeviceRayTracingPipelineFeaturesKHR32;
1905
1906 typedef struct VkPhysicalDeviceRayQueryFeaturesKHR32
1907 {
1908     VkStructureType sType;
1909     PTR32 pNext;
1910     VkBool32 rayQuery;
1911 } VkPhysicalDeviceRayQueryFeaturesKHR32;
1912
1913 typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32
1914 {
1915     VkStructureType sType;
1916     PTR32 pNext;
1917     VkBool32 rayTracingMaintenance1;
1918     VkBool32 rayTracingPipelineTraceRaysIndirect2;
1919 } VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32;
1920
1921 typedef struct VkDeviceMemoryOverallocationCreateInfoAMD32
1922 {
1923     VkStructureType sType;
1924     PTR32 pNext;
1925     VkMemoryOverallocationBehaviorAMD overallocationBehavior;
1926 } VkDeviceMemoryOverallocationCreateInfoAMD32;
1927
1928 typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT32
1929 {
1930     VkStructureType sType;
1931     PTR32 pNext;
1932     VkBool32 fragmentDensityMap;
1933     VkBool32 fragmentDensityMapDynamic;
1934     VkBool32 fragmentDensityMapNonSubsampledImages;
1935 } VkPhysicalDeviceFragmentDensityMapFeaturesEXT32;
1936
1937 typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32
1938 {
1939     VkStructureType sType;
1940     PTR32 pNext;
1941     VkBool32 fragmentDensityMapDeferred;
1942 } VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32;
1943
1944 typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32
1945 {
1946     VkStructureType sType;
1947     PTR32 pNext;
1948     VkBool32 fragmentDensityMapOffset;
1949 } VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32;
1950
1951 typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures32
1952 {
1953     VkStructureType sType;
1954     PTR32 pNext;
1955     VkBool32 scalarBlockLayout;
1956 } VkPhysicalDeviceScalarBlockLayoutFeatures32;
1957 typedef VkPhysicalDeviceScalarBlockLayoutFeatures32 VkPhysicalDeviceScalarBlockLayoutFeaturesEXT32;
1958
1959 typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures32
1960 {
1961     VkStructureType sType;
1962     PTR32 pNext;
1963     VkBool32 uniformBufferStandardLayout;
1964 } VkPhysicalDeviceUniformBufferStandardLayoutFeatures32;
1965 typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR32;
1966
1967 typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT32
1968 {
1969     VkStructureType sType;
1970     PTR32 pNext;
1971     VkBool32 depthClipEnable;
1972 } VkPhysicalDeviceDepthClipEnableFeaturesEXT32;
1973
1974 typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT32
1975 {
1976     VkStructureType sType;
1977     PTR32 pNext;
1978     VkBool32 memoryPriority;
1979 } VkPhysicalDeviceMemoryPriorityFeaturesEXT32;
1980
1981 typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32
1982 {
1983     VkStructureType sType;
1984     PTR32 pNext;
1985     VkBool32 pageableDeviceLocalMemory;
1986 } VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32;
1987
1988 typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures32
1989 {
1990     VkStructureType sType;
1991     PTR32 pNext;
1992     VkBool32 bufferDeviceAddress;
1993     VkBool32 bufferDeviceAddressCaptureReplay;
1994     VkBool32 bufferDeviceAddressMultiDevice;
1995 } VkPhysicalDeviceBufferDeviceAddressFeatures32;
1996 typedef VkPhysicalDeviceBufferDeviceAddressFeatures32 VkPhysicalDeviceBufferDeviceAddressFeaturesKHR32;
1997
1998 typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32
1999 {
2000     VkStructureType sType;
2001     PTR32 pNext;
2002     VkBool32 bufferDeviceAddress;
2003     VkBool32 bufferDeviceAddressCaptureReplay;
2004     VkBool32 bufferDeviceAddressMultiDevice;
2005 } VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32;
2006 typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 VkPhysicalDeviceBufferAddressFeaturesEXT32;
2007
2008 typedef struct VkPhysicalDeviceImagelessFramebufferFeatures32
2009 {
2010     VkStructureType sType;
2011     PTR32 pNext;
2012     VkBool32 imagelessFramebuffer;
2013 } VkPhysicalDeviceImagelessFramebufferFeatures32;
2014 typedef VkPhysicalDeviceImagelessFramebufferFeatures32 VkPhysicalDeviceImagelessFramebufferFeaturesKHR32;
2015
2016 typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures32
2017 {
2018     VkStructureType sType;
2019     PTR32 pNext;
2020     VkBool32 textureCompressionASTC_HDR;
2021 } VkPhysicalDeviceTextureCompressionASTCHDRFeatures32;
2022 typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT32;
2023
2024 typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV32
2025 {
2026     VkStructureType sType;
2027     PTR32 pNext;
2028     VkBool32 cooperativeMatrix;
2029     VkBool32 cooperativeMatrixRobustBufferAccess;
2030 } VkPhysicalDeviceCooperativeMatrixFeaturesNV32;
2031
2032 typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32
2033 {
2034     VkStructureType sType;
2035     PTR32 pNext;
2036     VkBool32 ycbcrImageArrays;
2037 } VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32;
2038
2039 typedef struct VkPhysicalDevicePresentBarrierFeaturesNV32
2040 {
2041     VkStructureType sType;
2042     PTR32 pNext;
2043     VkBool32 presentBarrier;
2044 } VkPhysicalDevicePresentBarrierFeaturesNV32;
2045
2046 typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR32
2047 {
2048     VkStructureType sType;
2049     PTR32 pNext;
2050     VkBool32 performanceCounterQueryPools;
2051     VkBool32 performanceCounterMultipleQueryPools;
2052 } VkPhysicalDevicePerformanceQueryFeaturesKHR32;
2053
2054 typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV32
2055 {
2056     VkStructureType sType;
2057     PTR32 pNext;
2058     VkBool32 coverageReductionMode;
2059 } VkPhysicalDeviceCoverageReductionModeFeaturesNV32;
2060
2061 typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32
2062 {
2063     VkStructureType sType;
2064     PTR32 pNext;
2065     VkBool32 shaderIntegerFunctions2;
2066 } VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32;
2067
2068 typedef struct VkPhysicalDeviceShaderClockFeaturesKHR32
2069 {
2070     VkStructureType sType;
2071     PTR32 pNext;
2072     VkBool32 shaderSubgroupClock;
2073     VkBool32 shaderDeviceClock;
2074 } VkPhysicalDeviceShaderClockFeaturesKHR32;
2075
2076 typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT32
2077 {
2078     VkStructureType sType;
2079     PTR32 pNext;
2080     VkBool32 indexTypeUint8;
2081 } VkPhysicalDeviceIndexTypeUint8FeaturesEXT32;
2082
2083 typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32
2084 {
2085     VkStructureType sType;
2086     PTR32 pNext;
2087     VkBool32 shaderSMBuiltins;
2088 } VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32;
2089
2090 typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32
2091 {
2092     VkStructureType sType;
2093     PTR32 pNext;
2094     VkBool32 fragmentShaderSampleInterlock;
2095     VkBool32 fragmentShaderPixelInterlock;
2096     VkBool32 fragmentShaderShadingRateInterlock;
2097 } VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32;
2098
2099 typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32
2100 {
2101     VkStructureType sType;
2102     PTR32 pNext;
2103     VkBool32 separateDepthStencilLayouts;
2104 } VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32;
2105 typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR32;
2106
2107 typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32
2108 {
2109     VkStructureType sType;
2110     PTR32 pNext;
2111     VkBool32 primitiveTopologyListRestart;
2112     VkBool32 primitiveTopologyPatchListRestart;
2113 } VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32;
2114
2115 typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32
2116 {
2117     VkStructureType sType;
2118     PTR32 pNext;
2119     VkBool32 pipelineExecutableInfo;
2120 } VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32;
2121
2122 typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32
2123 {
2124     VkStructureType sType;
2125     PTR32 pNext;
2126     VkBool32 shaderDemoteToHelperInvocation;
2127 } VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32;
2128 typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT32;
2129
2130 typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32
2131 {
2132     VkStructureType sType;
2133     PTR32 pNext;
2134     VkBool32 texelBufferAlignment;
2135 } VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32;
2136
2137 typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures32
2138 {
2139     VkStructureType sType;
2140     PTR32 pNext;
2141     VkBool32 subgroupSizeControl;
2142     VkBool32 computeFullSubgroups;
2143 } VkPhysicalDeviceSubgroupSizeControlFeatures32;
2144 typedef VkPhysicalDeviceSubgroupSizeControlFeatures32 VkPhysicalDeviceSubgroupSizeControlFeaturesEXT32;
2145
2146 typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT32
2147 {
2148     VkStructureType sType;
2149     PTR32 pNext;
2150     VkBool32 rectangularLines;
2151     VkBool32 bresenhamLines;
2152     VkBool32 smoothLines;
2153     VkBool32 stippledRectangularLines;
2154     VkBool32 stippledBresenhamLines;
2155     VkBool32 stippledSmoothLines;
2156 } VkPhysicalDeviceLineRasterizationFeaturesEXT32;
2157
2158 typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures32
2159 {
2160     VkStructureType sType;
2161     PTR32 pNext;
2162     VkBool32 pipelineCreationCacheControl;
2163 } VkPhysicalDevicePipelineCreationCacheControlFeatures32;
2164 typedef VkPhysicalDevicePipelineCreationCacheControlFeatures32 VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT32;
2165
2166 typedef struct VkPhysicalDeviceVulkan11Features32
2167 {
2168     VkStructureType sType;
2169     PTR32 pNext;
2170     VkBool32 storageBuffer16BitAccess;
2171     VkBool32 uniformAndStorageBuffer16BitAccess;
2172     VkBool32 storagePushConstant16;
2173     VkBool32 storageInputOutput16;
2174     VkBool32 multiview;
2175     VkBool32 multiviewGeometryShader;
2176     VkBool32 multiviewTessellationShader;
2177     VkBool32 variablePointersStorageBuffer;
2178     VkBool32 variablePointers;
2179     VkBool32 protectedMemory;
2180     VkBool32 samplerYcbcrConversion;
2181     VkBool32 shaderDrawParameters;
2182 } VkPhysicalDeviceVulkan11Features32;
2183
2184 typedef struct VkPhysicalDeviceVulkan12Features32
2185 {
2186     VkStructureType sType;
2187     PTR32 pNext;
2188     VkBool32 samplerMirrorClampToEdge;
2189     VkBool32 drawIndirectCount;
2190     VkBool32 storageBuffer8BitAccess;
2191     VkBool32 uniformAndStorageBuffer8BitAccess;
2192     VkBool32 storagePushConstant8;
2193     VkBool32 shaderBufferInt64Atomics;
2194     VkBool32 shaderSharedInt64Atomics;
2195     VkBool32 shaderFloat16;
2196     VkBool32 shaderInt8;
2197     VkBool32 descriptorIndexing;
2198     VkBool32 shaderInputAttachmentArrayDynamicIndexing;
2199     VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
2200     VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
2201     VkBool32 shaderUniformBufferArrayNonUniformIndexing;
2202     VkBool32 shaderSampledImageArrayNonUniformIndexing;
2203     VkBool32 shaderStorageBufferArrayNonUniformIndexing;
2204     VkBool32 shaderStorageImageArrayNonUniformIndexing;
2205     VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
2206     VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
2207     VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
2208     VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
2209     VkBool32 descriptorBindingSampledImageUpdateAfterBind;
2210     VkBool32 descriptorBindingStorageImageUpdateAfterBind;
2211     VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
2212     VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
2213     VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
2214     VkBool32 descriptorBindingUpdateUnusedWhilePending;
2215     VkBool32 descriptorBindingPartiallyBound;
2216     VkBool32 descriptorBindingVariableDescriptorCount;
2217     VkBool32 runtimeDescriptorArray;
2218     VkBool32 samplerFilterMinmax;
2219     VkBool32 scalarBlockLayout;
2220     VkBool32 imagelessFramebuffer;
2221     VkBool32 uniformBufferStandardLayout;
2222     VkBool32 shaderSubgroupExtendedTypes;
2223     VkBool32 separateDepthStencilLayouts;
2224     VkBool32 hostQueryReset;
2225     VkBool32 timelineSemaphore;
2226     VkBool32 bufferDeviceAddress;
2227     VkBool32 bufferDeviceAddressCaptureReplay;
2228     VkBool32 bufferDeviceAddressMultiDevice;
2229     VkBool32 vulkanMemoryModel;
2230     VkBool32 vulkanMemoryModelDeviceScope;
2231     VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
2232     VkBool32 shaderOutputViewportIndex;
2233     VkBool32 shaderOutputLayer;
2234     VkBool32 subgroupBroadcastDynamicId;
2235 } VkPhysicalDeviceVulkan12Features32;
2236
2237 typedef struct VkPhysicalDeviceVulkan13Features32
2238 {
2239     VkStructureType sType;
2240     PTR32 pNext;
2241     VkBool32 robustImageAccess;
2242     VkBool32 inlineUniformBlock;
2243     VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
2244     VkBool32 pipelineCreationCacheControl;
2245     VkBool32 privateData;
2246     VkBool32 shaderDemoteToHelperInvocation;
2247     VkBool32 shaderTerminateInvocation;
2248     VkBool32 subgroupSizeControl;
2249     VkBool32 computeFullSubgroups;
2250     VkBool32 synchronization2;
2251     VkBool32 textureCompressionASTC_HDR;
2252     VkBool32 shaderZeroInitializeWorkgroupMemory;
2253     VkBool32 dynamicRendering;
2254     VkBool32 shaderIntegerDotProduct;
2255     VkBool32 maintenance4;
2256 } VkPhysicalDeviceVulkan13Features32;
2257
2258 typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD32
2259 {
2260     VkStructureType sType;
2261     PTR32 pNext;
2262     VkBool32 deviceCoherentMemory;
2263 } VkPhysicalDeviceCoherentMemoryFeaturesAMD32;
2264
2265 typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT32
2266 {
2267     VkStructureType sType;
2268     PTR32 pNext;
2269     VkBool32 customBorderColors;
2270     VkBool32 customBorderColorWithoutFormat;
2271 } VkPhysicalDeviceCustomBorderColorFeaturesEXT32;
2272
2273 typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32
2274 {
2275     VkStructureType sType;
2276     PTR32 pNext;
2277     VkBool32 borderColorSwizzle;
2278     VkBool32 borderColorSwizzleFromImage;
2279 } VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32;
2280
2281 typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32
2282 {
2283     VkStructureType sType;
2284     PTR32 pNext;
2285     VkBool32 extendedDynamicState;
2286 } VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32;
2287
2288 typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32
2289 {
2290     VkStructureType sType;
2291     PTR32 pNext;
2292     VkBool32 extendedDynamicState2;
2293     VkBool32 extendedDynamicState2LogicOp;
2294     VkBool32 extendedDynamicState2PatchControlPoints;
2295 } VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32;
2296
2297 typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32
2298 {
2299     VkStructureType sType;
2300     PTR32 pNext;
2301     VkBool32 extendedDynamicState3TessellationDomainOrigin;
2302     VkBool32 extendedDynamicState3DepthClampEnable;
2303     VkBool32 extendedDynamicState3PolygonMode;
2304     VkBool32 extendedDynamicState3RasterizationSamples;
2305     VkBool32 extendedDynamicState3SampleMask;
2306     VkBool32 extendedDynamicState3AlphaToCoverageEnable;
2307     VkBool32 extendedDynamicState3AlphaToOneEnable;
2308     VkBool32 extendedDynamicState3LogicOpEnable;
2309     VkBool32 extendedDynamicState3ColorBlendEnable;
2310     VkBool32 extendedDynamicState3ColorBlendEquation;
2311     VkBool32 extendedDynamicState3ColorWriteMask;
2312     VkBool32 extendedDynamicState3RasterizationStream;
2313     VkBool32 extendedDynamicState3ConservativeRasterizationMode;
2314     VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize;
2315     VkBool32 extendedDynamicState3DepthClipEnable;
2316     VkBool32 extendedDynamicState3SampleLocationsEnable;
2317     VkBool32 extendedDynamicState3ColorBlendAdvanced;
2318     VkBool32 extendedDynamicState3ProvokingVertexMode;
2319     VkBool32 extendedDynamicState3LineRasterizationMode;
2320     VkBool32 extendedDynamicState3LineStippleEnable;
2321     VkBool32 extendedDynamicState3DepthClipNegativeOneToOne;
2322     VkBool32 extendedDynamicState3ViewportWScalingEnable;
2323     VkBool32 extendedDynamicState3ViewportSwizzle;
2324     VkBool32 extendedDynamicState3CoverageToColorEnable;
2325     VkBool32 extendedDynamicState3CoverageToColorLocation;
2326     VkBool32 extendedDynamicState3CoverageModulationMode;
2327     VkBool32 extendedDynamicState3CoverageModulationTableEnable;
2328     VkBool32 extendedDynamicState3CoverageModulationTable;
2329     VkBool32 extendedDynamicState3CoverageReductionMode;
2330     VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable;
2331     VkBool32 extendedDynamicState3ShadingRateImageEnable;
2332 } VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32;
2333
2334 typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV32
2335 {
2336     VkStructureType sType;
2337     PTR32 pNext;
2338     VkBool32 diagnosticsConfig;
2339 } VkPhysicalDeviceDiagnosticsConfigFeaturesNV32;
2340
2341 typedef struct VkDeviceDiagnosticsConfigCreateInfoNV32
2342 {
2343     VkStructureType sType;
2344     PTR32 pNext;
2345     VkDeviceDiagnosticsConfigFlagsNV flags;
2346 } VkDeviceDiagnosticsConfigCreateInfoNV32;
2347
2348 typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32
2349 {
2350     VkStructureType sType;
2351     PTR32 pNext;
2352     VkBool32 shaderZeroInitializeWorkgroupMemory;
2353 } VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32;
2354 typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR32;
2355
2356 typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32
2357 {
2358     VkStructureType sType;
2359     PTR32 pNext;
2360     VkBool32 shaderSubgroupUniformControlFlow;
2361 } VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32;
2362
2363 typedef struct VkPhysicalDeviceRobustness2FeaturesEXT32
2364 {
2365     VkStructureType sType;
2366     PTR32 pNext;
2367     VkBool32 robustBufferAccess2;
2368     VkBool32 robustImageAccess2;
2369     VkBool32 nullDescriptor;
2370 } VkPhysicalDeviceRobustness2FeaturesEXT32;
2371
2372 typedef struct VkPhysicalDeviceImageRobustnessFeatures32
2373 {
2374     VkStructureType sType;
2375     PTR32 pNext;
2376     VkBool32 robustImageAccess;
2377 } VkPhysicalDeviceImageRobustnessFeatures32;
2378 typedef VkPhysicalDeviceImageRobustnessFeatures32 VkPhysicalDeviceImageRobustnessFeaturesEXT32;
2379
2380 typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32
2381 {
2382     VkStructureType sType;
2383     PTR32 pNext;
2384     VkBool32 workgroupMemoryExplicitLayout;
2385     VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout;
2386     VkBool32 workgroupMemoryExplicitLayout8BitAccess;
2387     VkBool32 workgroupMemoryExplicitLayout16BitAccess;
2388 } VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32;
2389
2390 typedef struct VkPhysicalDevice4444FormatsFeaturesEXT32
2391 {
2392     VkStructureType sType;
2393     PTR32 pNext;
2394     VkBool32 formatA4R4G4B4;
2395     VkBool32 formatA4B4G4R4;
2396 } VkPhysicalDevice4444FormatsFeaturesEXT32;
2397
2398 typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32
2399 {
2400     VkStructureType sType;
2401     PTR32 pNext;
2402     VkBool32 subpassShading;
2403 } VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32;
2404
2405 typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32
2406 {
2407     VkStructureType sType;
2408     PTR32 pNext;
2409     VkBool32 shaderImageInt64Atomics;
2410     VkBool32 sparseImageInt64Atomics;
2411 } VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32;
2412
2413 typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR32
2414 {
2415     VkStructureType sType;
2416     PTR32 pNext;
2417     VkBool32 pipelineFragmentShadingRate;
2418     VkBool32 primitiveFragmentShadingRate;
2419     VkBool32 attachmentFragmentShadingRate;
2420 } VkPhysicalDeviceFragmentShadingRateFeaturesKHR32;
2421
2422 typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures32
2423 {
2424     VkStructureType sType;
2425     PTR32 pNext;
2426     VkBool32 shaderTerminateInvocation;
2427 } VkPhysicalDeviceShaderTerminateInvocationFeatures32;
2428 typedef VkPhysicalDeviceShaderTerminateInvocationFeatures32 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR32;
2429
2430 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32
2431 {
2432     VkStructureType sType;
2433     PTR32 pNext;
2434     VkBool32 fragmentShadingRateEnums;
2435     VkBool32 supersampleFragmentShadingRates;
2436     VkBool32 noInvocationFragmentShadingRates;
2437 } VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32;
2438
2439 typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32
2440 {
2441     VkStructureType sType;
2442     PTR32 pNext;
2443     VkBool32 image2DViewOf3D;
2444     VkBool32 sampler2DViewOf3D;
2445 } VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32;
2446
2447 typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32
2448 {
2449     VkStructureType sType;
2450     PTR32 pNext;
2451     VkBool32 mutableDescriptorType;
2452 } VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32;
2453 typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE32;
2454
2455 typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT32
2456 {
2457     VkStructureType sType;
2458     PTR32 pNext;
2459     VkBool32 depthClipControl;
2460 } VkPhysicalDeviceDepthClipControlFeaturesEXT32;
2461
2462 typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32
2463 {
2464     VkStructureType sType;
2465     PTR32 pNext;
2466     VkBool32 vertexInputDynamicState;
2467 } VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32;
2468
2469 typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT32
2470 {
2471     VkStructureType sType;
2472     PTR32 pNext;
2473     VkBool32 colorWriteEnable;
2474 } VkPhysicalDeviceColorWriteEnableFeaturesEXT32;
2475
2476 typedef struct VkPhysicalDeviceSynchronization2Features32
2477 {
2478     VkStructureType sType;
2479     PTR32 pNext;
2480     VkBool32 synchronization2;
2481 } VkPhysicalDeviceSynchronization2Features32;
2482 typedef VkPhysicalDeviceSynchronization2Features32 VkPhysicalDeviceSynchronization2FeaturesKHR32;
2483
2484 typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32
2485 {
2486     VkStructureType sType;
2487     PTR32 pNext;
2488     VkBool32 primitivesGeneratedQuery;
2489     VkBool32 primitivesGeneratedQueryWithRasterizerDiscard;
2490     VkBool32 primitivesGeneratedQueryWithNonZeroStreams;
2491 } VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32;
2492
2493 typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT32
2494 {
2495     VkStructureType sType;
2496     PTR32 pNext;
2497     VkBool32 legacyDithering;
2498 } VkPhysicalDeviceLegacyDitheringFeaturesEXT32;
2499
2500 typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32
2501 {
2502     VkStructureType sType;
2503     PTR32 pNext;
2504     VkBool32 multisampledRenderToSingleSampled;
2505 } VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32;
2506
2507 typedef struct VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32
2508 {
2509     VkStructureType sType;
2510     PTR32 pNext;
2511     VkBool32 pipelineProtectedAccess;
2512 } VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32;
2513
2514 typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV32
2515 {
2516     VkStructureType sType;
2517     PTR32 pNext;
2518     VkBool32 inheritedViewportScissor2D;
2519 } VkPhysicalDeviceInheritedViewportScissorFeaturesNV32;
2520
2521 typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32
2522 {
2523     VkStructureType sType;
2524     PTR32 pNext;
2525     VkBool32 ycbcr2plane444Formats;
2526 } VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32;
2527
2528 typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT32
2529 {
2530     VkStructureType sType;
2531     PTR32 pNext;
2532     VkBool32 provokingVertexLast;
2533     VkBool32 transformFeedbackPreservesProvokingVertex;
2534 } VkPhysicalDeviceProvokingVertexFeaturesEXT32;
2535
2536 typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT32
2537 {
2538     VkStructureType sType;
2539     PTR32 pNext;
2540     VkBool32 descriptorBuffer;
2541     VkBool32 descriptorBufferCaptureReplay;
2542     VkBool32 descriptorBufferImageLayoutIgnored;
2543     VkBool32 descriptorBufferPushDescriptors;
2544 } VkPhysicalDeviceDescriptorBufferFeaturesEXT32;
2545
2546 typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures32
2547 {
2548     VkStructureType sType;
2549     PTR32 pNext;
2550     VkBool32 shaderIntegerDotProduct;
2551 } VkPhysicalDeviceShaderIntegerDotProductFeatures32;
2552 typedef VkPhysicalDeviceShaderIntegerDotProductFeatures32 VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR32;
2553
2554 typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32
2555 {
2556     VkStructureType sType;
2557     PTR32 pNext;
2558     VkBool32 fragmentShaderBarycentric;
2559 } VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32;
2560 typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV32;
2561
2562 typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32
2563 {
2564     VkStructureType sType;
2565     PTR32 pNext;
2566     VkBool32 rayTracingMotionBlur;
2567     VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect;
2568 } VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32;
2569
2570 typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32
2571 {
2572     VkStructureType sType;
2573     PTR32 pNext;
2574     VkBool32 formatRgba10x6WithoutYCbCrSampler;
2575 } VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32;
2576
2577 typedef struct VkPhysicalDeviceDynamicRenderingFeatures32
2578 {
2579     VkStructureType sType;
2580     PTR32 pNext;
2581     VkBool32 dynamicRendering;
2582 } VkPhysicalDeviceDynamicRenderingFeatures32;
2583 typedef VkPhysicalDeviceDynamicRenderingFeatures32 VkPhysicalDeviceDynamicRenderingFeaturesKHR32;
2584
2585 typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT32
2586 {
2587     VkStructureType sType;
2588     PTR32 pNext;
2589     VkBool32 minLod;
2590 } VkPhysicalDeviceImageViewMinLodFeaturesEXT32;
2591
2592 typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32
2593 {
2594     VkStructureType sType;
2595     PTR32 pNext;
2596     VkBool32 rasterizationOrderColorAttachmentAccess;
2597     VkBool32 rasterizationOrderDepthAttachmentAccess;
2598     VkBool32 rasterizationOrderStencilAttachmentAccess;
2599 } VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32;
2600 typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM32;
2601
2602 typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV32
2603 {
2604     VkStructureType sType;
2605     PTR32 pNext;
2606     VkBool32 linearColorAttachment;
2607 } VkPhysicalDeviceLinearColorAttachmentFeaturesNV32;
2608
2609 typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32
2610 {
2611     VkStructureType sType;
2612     PTR32 pNext;
2613     VkBool32 graphicsPipelineLibrary;
2614 } VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32;
2615
2616 typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32
2617 {
2618     VkStructureType sType;
2619     PTR32 pNext;
2620     VkBool32 descriptorSetHostMapping;
2621 } VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32;
2622
2623 typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32
2624 {
2625     VkStructureType sType;
2626     PTR32 pNext;
2627     VkBool32 shaderModuleIdentifier;
2628 } VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32;
2629
2630 typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT32
2631 {
2632     VkStructureType sType;
2633     PTR32 pNext;
2634     VkBool32 imageCompressionControl;
2635 } VkPhysicalDeviceImageCompressionControlFeaturesEXT32;
2636
2637 typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32
2638 {
2639     VkStructureType sType;
2640     PTR32 pNext;
2641     VkBool32 imageCompressionControlSwapchain;
2642 } VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32;
2643
2644 typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32
2645 {
2646     VkStructureType sType;
2647     PTR32 pNext;
2648     VkBool32 subpassMergeFeedback;
2649 } VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32;
2650
2651 typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT32
2652 {
2653     VkStructureType sType;
2654     PTR32 pNext;
2655     VkBool32 micromap;
2656     VkBool32 micromapCaptureReplay;
2657     VkBool32 micromapHostCommands;
2658 } VkPhysicalDeviceOpacityMicromapFeaturesEXT32;
2659
2660 typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT32
2661 {
2662     VkStructureType sType;
2663     PTR32 pNext;
2664     VkBool32 pipelinePropertiesIdentifier;
2665 } VkPhysicalDevicePipelinePropertiesFeaturesEXT32;
2666
2667 typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32
2668 {
2669     VkStructureType sType;
2670     PTR32 pNext;
2671     VkBool32 shaderEarlyAndLateFragmentTests;
2672 } VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32;
2673
2674 typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32
2675 {
2676     VkStructureType sType;
2677     PTR32 pNext;
2678     VkBool32 nonSeamlessCubeMap;
2679 } VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32;
2680
2681 typedef struct VkPhysicalDevicePipelineRobustnessFeaturesEXT32
2682 {
2683     VkStructureType sType;
2684     PTR32 pNext;
2685     VkBool32 pipelineRobustness;
2686 } VkPhysicalDevicePipelineRobustnessFeaturesEXT32;
2687
2688 typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM32
2689 {
2690     VkStructureType sType;
2691     PTR32 pNext;
2692     VkBool32 textureSampleWeighted;
2693     VkBool32 textureBoxFilter;
2694     VkBool32 textureBlockMatch;
2695 } VkPhysicalDeviceImageProcessingFeaturesQCOM32;
2696
2697 typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM32
2698 {
2699     VkStructureType sType;
2700     PTR32 pNext;
2701     VkBool32 tileProperties;
2702 } VkPhysicalDeviceTilePropertiesFeaturesQCOM32;
2703
2704 typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32
2705 {
2706     VkStructureType sType;
2707     PTR32 pNext;
2708     VkBool32 attachmentFeedbackLoopLayout;
2709 } VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32;
2710
2711 typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32
2712 {
2713     VkStructureType sType;
2714     PTR32 pNext;
2715     VkBool32 depthClampZeroOne;
2716 } VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32;
2717
2718 typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT32
2719 {
2720     VkStructureType sType;
2721     PTR32 pNext;
2722     VkBool32 reportAddressBinding;
2723 } VkPhysicalDeviceAddressBindingReportFeaturesEXT32;
2724
2725 typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV32
2726 {
2727     VkStructureType sType;
2728     PTR32 pNext;
2729     VkBool32 opticalFlow;
2730 } VkPhysicalDeviceOpticalFlowFeaturesNV32;
2731
2732 typedef struct VkPhysicalDeviceFaultFeaturesEXT32
2733 {
2734     VkStructureType sType;
2735     PTR32 pNext;
2736     VkBool32 deviceFault;
2737     VkBool32 deviceFaultVendorBinary;
2738 } VkPhysicalDeviceFaultFeaturesEXT32;
2739
2740 typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32
2741 {
2742     VkStructureType sType;
2743     PTR32 pNext;
2744     VkBool32 shaderCoreBuiltins;
2745 } VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32;
2746
2747 typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32
2748 {
2749     VkStructureType sType;
2750     PTR32 pNext;
2751     VkBool32 rayTracingInvocationReorder;
2752 } VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32;
2753
2754 typedef struct VkDeviceCreateInfo32
2755 {
2756     VkStructureType sType;
2757     PTR32 pNext;
2758     VkDeviceCreateFlags flags;
2759     uint32_t queueCreateInfoCount;
2760     PTR32 pQueueCreateInfos;
2761     uint32_t enabledLayerCount;
2762     PTR32 ppEnabledLayerNames;
2763     uint32_t enabledExtensionCount;
2764     PTR32 ppEnabledExtensionNames;
2765     PTR32 pEnabledFeatures;
2766 } VkDeviceCreateInfo32;
2767
2768 typedef struct VkEventCreateInfo32
2769 {
2770     VkStructureType sType;
2771     PTR32 pNext;
2772     VkEventCreateFlags flags;
2773 } VkEventCreateInfo32;
2774
2775 typedef struct VkExportFenceCreateInfo32
2776 {
2777     VkStructureType sType;
2778     PTR32 pNext;
2779     VkExternalFenceHandleTypeFlags handleTypes;
2780 } VkExportFenceCreateInfo32;
2781 typedef VkExportFenceCreateInfo32 VkExportFenceCreateInfoKHR32;
2782
2783 typedef struct VkFenceCreateInfo32
2784 {
2785     VkStructureType sType;
2786     PTR32 pNext;
2787     VkFenceCreateFlags flags;
2788 } VkFenceCreateInfo32;
2789
2790 typedef struct VkFramebufferAttachmentImageInfo32
2791 {
2792     VkStructureType sType;
2793     PTR32 pNext;
2794     VkImageCreateFlags flags;
2795     VkImageUsageFlags usage;
2796     uint32_t width;
2797     uint32_t height;
2798     uint32_t layerCount;
2799     uint32_t viewFormatCount;
2800     PTR32 pViewFormats;
2801 } VkFramebufferAttachmentImageInfo32;
2802 typedef VkFramebufferAttachmentImageInfo32 VkFramebufferAttachmentImageInfoKHR32;
2803
2804 typedef struct VkFramebufferAttachmentsCreateInfo32
2805 {
2806     VkStructureType sType;
2807     PTR32 pNext;
2808     uint32_t attachmentImageInfoCount;
2809     PTR32 pAttachmentImageInfos;
2810 } VkFramebufferAttachmentsCreateInfo32;
2811 typedef VkFramebufferAttachmentsCreateInfo32 VkFramebufferAttachmentsCreateInfoKHR32;
2812
2813 typedef struct VkFramebufferCreateInfo32
2814 {
2815     VkStructureType sType;
2816     PTR32 pNext;
2817     VkFramebufferCreateFlags flags;
2818     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
2819     uint32_t attachmentCount;
2820     PTR32 pAttachments;
2821     uint32_t width;
2822     uint32_t height;
2823     uint32_t layers;
2824 } VkFramebufferCreateInfo32;
2825
2826 typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT32
2827 {
2828     VkStructureType sType;
2829     PTR32 pNext;
2830     uint32_t vertexBindingDivisorCount;
2831     PTR32 pVertexBindingDivisors;
2832 } VkPipelineVertexInputDivisorStateCreateInfoEXT32;
2833
2834 typedef struct VkPipelineVertexInputStateCreateInfo32
2835 {
2836     VkStructureType sType;
2837     PTR32 pNext;
2838     VkPipelineVertexInputStateCreateFlags flags;
2839     uint32_t vertexBindingDescriptionCount;
2840     PTR32 pVertexBindingDescriptions;
2841     uint32_t vertexAttributeDescriptionCount;
2842     PTR32 pVertexAttributeDescriptions;
2843 } VkPipelineVertexInputStateCreateInfo32;
2844
2845 typedef struct VkPipelineTessellationDomainOriginStateCreateInfo32
2846 {
2847     VkStructureType sType;
2848     PTR32 pNext;
2849     VkTessellationDomainOrigin domainOrigin;
2850 } VkPipelineTessellationDomainOriginStateCreateInfo32;
2851 typedef VkPipelineTessellationDomainOriginStateCreateInfo32 VkPipelineTessellationDomainOriginStateCreateInfoKHR32;
2852
2853 typedef struct VkPipelineTessellationStateCreateInfo32
2854 {
2855     VkStructureType sType;
2856     PTR32 pNext;
2857     VkPipelineTessellationStateCreateFlags flags;
2858     uint32_t patchControlPoints;
2859 } VkPipelineTessellationStateCreateInfo32;
2860
2861 typedef struct VkGraphicsShaderGroupCreateInfoNV32
2862 {
2863     VkStructureType sType;
2864     PTR32 pNext;
2865     uint32_t stageCount;
2866     PTR32 pStages;
2867     PTR32 pVertexInputState;
2868     PTR32 pTessellationState;
2869 } VkGraphicsShaderGroupCreateInfoNV32;
2870
2871 typedef struct VkPipelineInputAssemblyStateCreateInfo32
2872 {
2873     VkStructureType sType;
2874     PTR32 pNext;
2875     VkPipelineInputAssemblyStateCreateFlags flags;
2876     VkPrimitiveTopology topology;
2877     VkBool32 primitiveRestartEnable;
2878 } VkPipelineInputAssemblyStateCreateInfo32;
2879
2880 typedef struct VkPipelineViewportWScalingStateCreateInfoNV32
2881 {
2882     VkStructureType sType;
2883     PTR32 pNext;
2884     VkBool32 viewportWScalingEnable;
2885     uint32_t viewportCount;
2886     PTR32 pViewportWScalings;
2887 } VkPipelineViewportWScalingStateCreateInfoNV32;
2888
2889 typedef struct VkPipelineViewportSwizzleStateCreateInfoNV32
2890 {
2891     VkStructureType sType;
2892     PTR32 pNext;
2893     VkPipelineViewportSwizzleStateCreateFlagsNV flags;
2894     uint32_t viewportCount;
2895     PTR32 pViewportSwizzles;
2896 } VkPipelineViewportSwizzleStateCreateInfoNV32;
2897
2898 typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV32
2899 {
2900     VkStructureType sType;
2901     PTR32 pNext;
2902     uint32_t exclusiveScissorCount;
2903     PTR32 pExclusiveScissors;
2904 } VkPipelineViewportExclusiveScissorStateCreateInfoNV32;
2905
2906 typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV32
2907 {
2908     VkStructureType sType;
2909     PTR32 pNext;
2910     VkBool32 shadingRateImageEnable;
2911     uint32_t viewportCount;
2912     PTR32 pShadingRatePalettes;
2913 } VkPipelineViewportShadingRateImageStateCreateInfoNV32;
2914
2915 typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32
2916 {
2917     VkStructureType sType;
2918     PTR32 pNext;
2919     VkCoarseSampleOrderTypeNV sampleOrderType;
2920     uint32_t customSampleOrderCount;
2921     PTR32 pCustomSampleOrders;
2922 } VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32;
2923
2924 typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT32
2925 {
2926     VkStructureType sType;
2927     PTR32 pNext;
2928     VkBool32 negativeOneToOne;
2929 } VkPipelineViewportDepthClipControlCreateInfoEXT32;
2930
2931 typedef struct VkPipelineViewportStateCreateInfo32
2932 {
2933     VkStructureType sType;
2934     PTR32 pNext;
2935     VkPipelineViewportStateCreateFlags flags;
2936     uint32_t viewportCount;
2937     PTR32 pViewports;
2938     uint32_t scissorCount;
2939     PTR32 pScissors;
2940 } VkPipelineViewportStateCreateInfo32;
2941
2942 typedef struct VkPipelineRasterizationStateRasterizationOrderAMD32
2943 {
2944     VkStructureType sType;
2945     PTR32 pNext;
2946     VkRasterizationOrderAMD rasterizationOrder;
2947 } VkPipelineRasterizationStateRasterizationOrderAMD32;
2948
2949 typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT32
2950 {
2951     VkStructureType sType;
2952     PTR32 pNext;
2953     VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
2954     VkConservativeRasterizationModeEXT conservativeRasterizationMode;
2955     float extraPrimitiveOverestimationSize;
2956 } VkPipelineRasterizationConservativeStateCreateInfoEXT32;
2957
2958 typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT32
2959 {
2960     VkStructureType sType;
2961     PTR32 pNext;
2962     VkPipelineRasterizationStateStreamCreateFlagsEXT flags;
2963     uint32_t rasterizationStream;
2964 } VkPipelineRasterizationStateStreamCreateInfoEXT32;
2965
2966 typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT32
2967 {
2968     VkStructureType sType;
2969     PTR32 pNext;
2970     VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags;
2971     VkBool32 depthClipEnable;
2972 } VkPipelineRasterizationDepthClipStateCreateInfoEXT32;
2973
2974 typedef struct VkPipelineRasterizationLineStateCreateInfoEXT32
2975 {
2976     VkStructureType sType;
2977     PTR32 pNext;
2978     VkLineRasterizationModeEXT lineRasterizationMode;
2979     VkBool32 stippledLineEnable;
2980     uint32_t lineStippleFactor;
2981     uint16_t lineStipplePattern;
2982 } VkPipelineRasterizationLineStateCreateInfoEXT32;
2983
2984 typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32
2985 {
2986     VkStructureType sType;
2987     PTR32 pNext;
2988     VkProvokingVertexModeEXT provokingVertexMode;
2989 } VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32;
2990
2991 typedef struct VkPipelineRasterizationStateCreateInfo32
2992 {
2993     VkStructureType sType;
2994     PTR32 pNext;
2995     VkPipelineRasterizationStateCreateFlags flags;
2996     VkBool32 depthClampEnable;
2997     VkBool32 rasterizerDiscardEnable;
2998     VkPolygonMode polygonMode;
2999     VkCullModeFlags cullMode;
3000     VkFrontFace frontFace;
3001     VkBool32 depthBiasEnable;
3002     float depthBiasConstantFactor;
3003     float depthBiasClamp;
3004     float depthBiasSlopeFactor;
3005     float lineWidth;
3006 } VkPipelineRasterizationStateCreateInfo32;
3007
3008 typedef struct VkPipelineCoverageToColorStateCreateInfoNV32
3009 {
3010     VkStructureType sType;
3011     PTR32 pNext;
3012     VkPipelineCoverageToColorStateCreateFlagsNV flags;
3013     VkBool32 coverageToColorEnable;
3014     uint32_t coverageToColorLocation;
3015 } VkPipelineCoverageToColorStateCreateInfoNV32;
3016
3017 typedef struct VkPipelineSampleLocationsStateCreateInfoEXT32
3018 {
3019     VkStructureType sType;
3020     PTR32 pNext;
3021     VkBool32 sampleLocationsEnable;
3022     VkSampleLocationsInfoEXT32 sampleLocationsInfo;
3023 } VkPipelineSampleLocationsStateCreateInfoEXT32;
3024
3025 typedef struct VkPipelineCoverageModulationStateCreateInfoNV32
3026 {
3027     VkStructureType sType;
3028     PTR32 pNext;
3029     VkPipelineCoverageModulationStateCreateFlagsNV flags;
3030     VkCoverageModulationModeNV coverageModulationMode;
3031     VkBool32 coverageModulationTableEnable;
3032     uint32_t coverageModulationTableCount;
3033     PTR32 pCoverageModulationTable;
3034 } VkPipelineCoverageModulationStateCreateInfoNV32;
3035
3036 typedef struct VkPipelineCoverageReductionStateCreateInfoNV32
3037 {
3038     VkStructureType sType;
3039     PTR32 pNext;
3040     VkPipelineCoverageReductionStateCreateFlagsNV flags;
3041     VkCoverageReductionModeNV coverageReductionMode;
3042 } VkPipelineCoverageReductionStateCreateInfoNV32;
3043
3044 typedef struct VkPipelineMultisampleStateCreateInfo32
3045 {
3046     VkStructureType sType;
3047     PTR32 pNext;
3048     VkPipelineMultisampleStateCreateFlags flags;
3049     VkSampleCountFlagBits rasterizationSamples;
3050     VkBool32 sampleShadingEnable;
3051     float minSampleShading;
3052     PTR32 pSampleMask;
3053     VkBool32 alphaToCoverageEnable;
3054     VkBool32 alphaToOneEnable;
3055 } VkPipelineMultisampleStateCreateInfo32;
3056
3057 typedef struct VkPipelineDepthStencilStateCreateInfo32
3058 {
3059     VkStructureType sType;
3060     PTR32 pNext;
3061     VkPipelineDepthStencilStateCreateFlags flags;
3062     VkBool32 depthTestEnable;
3063     VkBool32 depthWriteEnable;
3064     VkCompareOp depthCompareOp;
3065     VkBool32 depthBoundsTestEnable;
3066     VkBool32 stencilTestEnable;
3067     VkStencilOpState front;
3068     VkStencilOpState back;
3069     float minDepthBounds;
3070     float maxDepthBounds;
3071 } VkPipelineDepthStencilStateCreateInfo32;
3072
3073 typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT32
3074 {
3075     VkStructureType sType;
3076     PTR32 pNext;
3077     VkBool32 srcPremultiplied;
3078     VkBool32 dstPremultiplied;
3079     VkBlendOverlapEXT blendOverlap;
3080 } VkPipelineColorBlendAdvancedStateCreateInfoEXT32;
3081
3082 typedef struct VkPipelineColorWriteCreateInfoEXT32
3083 {
3084     VkStructureType sType;
3085     PTR32 pNext;
3086     uint32_t attachmentCount;
3087     PTR32 pColorWriteEnables;
3088 } VkPipelineColorWriteCreateInfoEXT32;
3089
3090 typedef struct VkPipelineColorBlendStateCreateInfo32
3091 {
3092     VkStructureType sType;
3093     PTR32 pNext;
3094     VkPipelineColorBlendStateCreateFlags flags;
3095     VkBool32 logicOpEnable;
3096     VkLogicOp logicOp;
3097     uint32_t attachmentCount;
3098     PTR32 pAttachments;
3099     float blendConstants[4];
3100 } VkPipelineColorBlendStateCreateInfo32;
3101
3102 typedef struct VkPipelineDynamicStateCreateInfo32
3103 {
3104     VkStructureType sType;
3105     PTR32 pNext;
3106     VkPipelineDynamicStateCreateFlags flags;
3107     uint32_t dynamicStateCount;
3108     PTR32 pDynamicStates;
3109 } VkPipelineDynamicStateCreateInfo32;
3110
3111 typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV32
3112 {
3113     VkStructureType sType;
3114     PTR32 pNext;
3115     uint32_t groupCount;
3116     PTR32 pGroups;
3117     uint32_t pipelineCount;
3118     PTR32 pPipelines;
3119 } VkGraphicsPipelineShaderGroupsCreateInfoNV32;
3120
3121 typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT32
3122 {
3123     VkStructureType sType;
3124     PTR32 pNext;
3125     VkPipelineDiscardRectangleStateCreateFlagsEXT flags;
3126     VkDiscardRectangleModeEXT discardRectangleMode;
3127     uint32_t discardRectangleCount;
3128     PTR32 pDiscardRectangles;
3129 } VkPipelineDiscardRectangleStateCreateInfoEXT32;
3130
3131 typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV32
3132 {
3133     VkStructureType sType;
3134     PTR32 pNext;
3135     VkBool32 representativeFragmentTestEnable;
3136 } VkPipelineRepresentativeFragmentTestStateCreateInfoNV32;
3137
3138 typedef struct VkPipelineLibraryCreateInfoKHR32
3139 {
3140     VkStructureType sType;
3141     PTR32 pNext;
3142     uint32_t libraryCount;
3143     PTR32 pLibraries;
3144 } VkPipelineLibraryCreateInfoKHR32;
3145
3146 typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR32
3147 {
3148     VkStructureType sType;
3149     PTR32 pNext;
3150     VkExtent2D fragmentSize;
3151     VkFragmentShadingRateCombinerOpKHR combinerOps[2];
3152 } VkPipelineFragmentShadingRateStateCreateInfoKHR32;
3153
3154 typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV32
3155 {
3156     VkStructureType sType;
3157     PTR32 pNext;
3158     VkFragmentShadingRateTypeNV shadingRateType;
3159     VkFragmentShadingRateNV shadingRate;
3160     VkFragmentShadingRateCombinerOpKHR combinerOps[2];
3161 } VkPipelineFragmentShadingRateEnumStateCreateInfoNV32;
3162
3163 typedef struct VkPipelineRenderingCreateInfo32
3164 {
3165     VkStructureType sType;
3166     PTR32 pNext;
3167     uint32_t viewMask;
3168     uint32_t colorAttachmentCount;
3169     PTR32 pColorAttachmentFormats;
3170     VkFormat depthAttachmentFormat;
3171     VkFormat stencilAttachmentFormat;
3172 } VkPipelineRenderingCreateInfo32;
3173 typedef VkPipelineRenderingCreateInfo32 VkPipelineRenderingCreateInfoKHR32;
3174
3175 typedef struct VkGraphicsPipelineLibraryCreateInfoEXT32
3176 {
3177     VkStructureType sType;
3178     PTR32 pNext;
3179     VkGraphicsPipelineLibraryFlagsEXT flags;
3180 } VkGraphicsPipelineLibraryCreateInfoEXT32;
3181
3182 typedef struct VkGraphicsPipelineCreateInfo32
3183 {
3184     VkStructureType sType;
3185     PTR32 pNext;
3186     VkPipelineCreateFlags flags;
3187     uint32_t stageCount;
3188     PTR32 pStages;
3189     PTR32 pVertexInputState;
3190     PTR32 pInputAssemblyState;
3191     PTR32 pTessellationState;
3192     PTR32 pViewportState;
3193     PTR32 pRasterizationState;
3194     PTR32 pMultisampleState;
3195     PTR32 pDepthStencilState;
3196     PTR32 pColorBlendState;
3197     PTR32 pDynamicState;
3198     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3199     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
3200     uint32_t subpass;
3201     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3202     int32_t basePipelineIndex;
3203 } VkGraphicsPipelineCreateInfo32;
3204
3205 typedef struct VkDedicatedAllocationImageCreateInfoNV32
3206 {
3207     VkStructureType sType;
3208     PTR32 pNext;
3209     VkBool32 dedicatedAllocation;
3210 } VkDedicatedAllocationImageCreateInfoNV32;
3211
3212 typedef struct VkExternalMemoryImageCreateInfo32
3213 {
3214     VkStructureType sType;
3215     PTR32 pNext;
3216     VkExternalMemoryHandleTypeFlags handleTypes;
3217 } VkExternalMemoryImageCreateInfo32;
3218 typedef VkExternalMemoryImageCreateInfo32 VkExternalMemoryImageCreateInfoKHR32;
3219
3220 typedef struct VkImageSwapchainCreateInfoKHR32
3221 {
3222     VkStructureType sType;
3223     PTR32 pNext;
3224     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
3225 } VkImageSwapchainCreateInfoKHR32;
3226
3227 typedef struct VkImageFormatListCreateInfo32
3228 {
3229     VkStructureType sType;
3230     PTR32 pNext;
3231     uint32_t viewFormatCount;
3232     PTR32 pViewFormats;
3233 } VkImageFormatListCreateInfo32;
3234 typedef VkImageFormatListCreateInfo32 VkImageFormatListCreateInfoKHR32;
3235
3236 typedef struct VkImageStencilUsageCreateInfo32
3237 {
3238     VkStructureType sType;
3239     PTR32 pNext;
3240     VkImageUsageFlags stencilUsage;
3241 } VkImageStencilUsageCreateInfo32;
3242 typedef VkImageStencilUsageCreateInfo32 VkImageStencilUsageCreateInfoEXT32;
3243
3244 typedef struct VkImageCompressionControlEXT32
3245 {
3246     VkStructureType sType;
3247     PTR32 pNext;
3248     VkImageCompressionFlagsEXT flags;
3249     uint32_t compressionControlPlaneCount;
3250     PTR32 pFixedRateFlags;
3251 } VkImageCompressionControlEXT32;
3252
3253 typedef struct VkOpticalFlowImageFormatInfoNV32
3254 {
3255     VkStructureType sType;
3256     PTR32 pNext;
3257     VkOpticalFlowUsageFlagsNV usage;
3258 } VkOpticalFlowImageFormatInfoNV32;
3259
3260 typedef struct VkImageCreateInfo32
3261 {
3262     VkStructureType sType;
3263     PTR32 pNext;
3264     VkImageCreateFlags flags;
3265     VkImageType imageType;
3266     VkFormat format;
3267     VkExtent3D extent;
3268     uint32_t mipLevels;
3269     uint32_t arrayLayers;
3270     VkSampleCountFlagBits samples;
3271     VkImageTiling tiling;
3272     VkImageUsageFlags usage;
3273     VkSharingMode sharingMode;
3274     uint32_t queueFamilyIndexCount;
3275     PTR32 pQueueFamilyIndices;
3276     VkImageLayout initialLayout;
3277 } VkImageCreateInfo32;
3278
3279 typedef struct VkImageViewUsageCreateInfo32
3280 {
3281     VkStructureType sType;
3282     PTR32 pNext;
3283     VkImageUsageFlags usage;
3284 } VkImageViewUsageCreateInfo32;
3285 typedef VkImageViewUsageCreateInfo32 VkImageViewUsageCreateInfoKHR32;
3286
3287 typedef struct VkSamplerYcbcrConversionInfo32
3288 {
3289     VkStructureType sType;
3290     PTR32 pNext;
3291     VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) conversion;
3292 } VkSamplerYcbcrConversionInfo32;
3293 typedef VkSamplerYcbcrConversionInfo32 VkSamplerYcbcrConversionInfoKHR32;
3294
3295 typedef struct VkImageViewASTCDecodeModeEXT32
3296 {
3297     VkStructureType sType;
3298     PTR32 pNext;
3299     VkFormat decodeMode;
3300 } VkImageViewASTCDecodeModeEXT32;
3301
3302 typedef struct VkImageViewMinLodCreateInfoEXT32
3303 {
3304     VkStructureType sType;
3305     PTR32 pNext;
3306     float minLod;
3307 } VkImageViewMinLodCreateInfoEXT32;
3308
3309 typedef struct VkImageViewSampleWeightCreateInfoQCOM32
3310 {
3311     VkStructureType sType;
3312     PTR32 pNext;
3313     VkOffset2D filterCenter;
3314     VkExtent2D filterSize;
3315     uint32_t numPhases;
3316 } VkImageViewSampleWeightCreateInfoQCOM32;
3317
3318 typedef struct VkImageViewCreateInfo32
3319 {
3320     VkStructureType sType;
3321     PTR32 pNext;
3322     VkImageViewCreateFlags flags;
3323     VkImage DECLSPEC_ALIGN(8) image;
3324     VkImageViewType viewType;
3325     VkFormat format;
3326     VkComponentMapping components;
3327     VkImageSubresourceRange subresourceRange;
3328 } VkImageViewCreateInfo32;
3329
3330 typedef struct VkIndirectCommandsLayoutTokenNV32
3331 {
3332     VkStructureType sType;
3333     PTR32 pNext;
3334     VkIndirectCommandsTokenTypeNV tokenType;
3335     uint32_t stream;
3336     uint32_t offset;
3337     uint32_t vertexBindingUnit;
3338     VkBool32 vertexDynamicStride;
3339     VkPipelineLayout DECLSPEC_ALIGN(8) pushconstantPipelineLayout;
3340     VkShaderStageFlags pushconstantShaderStageFlags;
3341     uint32_t pushconstantOffset;
3342     uint32_t pushconstantSize;
3343     VkIndirectStateFlagsNV indirectStateFlags;
3344     uint32_t indexTypeCount;
3345     PTR32 pIndexTypes;
3346     PTR32 pIndexTypeValues;
3347 } VkIndirectCommandsLayoutTokenNV32;
3348
3349 typedef struct VkIndirectCommandsLayoutCreateInfoNV32
3350 {
3351     VkStructureType sType;
3352     PTR32 pNext;
3353     VkIndirectCommandsLayoutUsageFlagsNV flags;
3354     VkPipelineBindPoint pipelineBindPoint;
3355     uint32_t tokenCount;
3356     PTR32 pTokens;
3357     uint32_t streamCount;
3358     PTR32 pStreamStrides;
3359 } VkIndirectCommandsLayoutCreateInfoNV32;
3360
3361 typedef struct VkApplicationInfo32
3362 {
3363     VkStructureType sType;
3364     PTR32 pNext;
3365     PTR32 pApplicationName;
3366     uint32_t applicationVersion;
3367     PTR32 pEngineName;
3368     uint32_t engineVersion;
3369     uint32_t apiVersion;
3370 } VkApplicationInfo32;
3371
3372 typedef struct VkValidationFlagsEXT32
3373 {
3374     VkStructureType sType;
3375     PTR32 pNext;
3376     uint32_t disabledValidationCheckCount;
3377     PTR32 pDisabledValidationChecks;
3378 } VkValidationFlagsEXT32;
3379
3380 typedef struct VkValidationFeaturesEXT32
3381 {
3382     VkStructureType sType;
3383     PTR32 pNext;
3384     uint32_t enabledValidationFeatureCount;
3385     PTR32 pEnabledValidationFeatures;
3386     uint32_t disabledValidationFeatureCount;
3387     PTR32 pDisabledValidationFeatures;
3388 } VkValidationFeaturesEXT32;
3389
3390 typedef struct VkInstanceCreateInfo32
3391 {
3392     VkStructureType sType;
3393     PTR32 pNext;
3394     VkInstanceCreateFlags flags;
3395     PTR32 pApplicationInfo;
3396     uint32_t enabledLayerCount;
3397     PTR32 ppEnabledLayerNames;
3398     uint32_t enabledExtensionCount;
3399     PTR32 ppEnabledExtensionNames;
3400 } VkInstanceCreateInfo32;
3401
3402 typedef struct VkMicromapCreateInfoEXT32
3403 {
3404     VkStructureType sType;
3405     PTR32 pNext;
3406     VkMicromapCreateFlagsEXT createFlags;
3407     VkBuffer DECLSPEC_ALIGN(8) buffer;
3408     VkDeviceSize DECLSPEC_ALIGN(8) offset;
3409     VkDeviceSize DECLSPEC_ALIGN(8) size;
3410     VkMicromapTypeEXT type;
3411     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
3412 } VkMicromapCreateInfoEXT32;
3413
3414 typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV32
3415 {
3416     VkStructureType sType;
3417     PTR32 pNext;
3418     uint32_t id;
3419     uint32_t size;
3420     PTR32 pPrivateData;
3421 } VkOpticalFlowSessionCreatePrivateDataInfoNV32;
3422
3423 typedef struct VkOpticalFlowSessionCreateInfoNV32
3424 {
3425     VkStructureType sType;
3426     PTR32 pNext;
3427     uint32_t width;
3428     uint32_t height;
3429     VkFormat imageFormat;
3430     VkFormat flowVectorFormat;
3431     VkFormat costFormat;
3432     VkOpticalFlowGridSizeFlagsNV outputGridSize;
3433     VkOpticalFlowGridSizeFlagsNV hintGridSize;
3434     VkOpticalFlowPerformanceLevelNV performanceLevel;
3435     VkOpticalFlowSessionCreateFlagsNV flags;
3436 } VkOpticalFlowSessionCreateInfoNV32;
3437
3438 typedef struct VkPipelineCacheCreateInfo32
3439 {
3440     VkStructureType sType;
3441     PTR32 pNext;
3442     VkPipelineCacheCreateFlags flags;
3443     PTR32 initialDataSize;
3444     PTR32 pInitialData;
3445 } VkPipelineCacheCreateInfo32;
3446
3447 typedef struct VkPipelineLayoutCreateInfo32
3448 {
3449     VkStructureType sType;
3450     PTR32 pNext;
3451     VkPipelineLayoutCreateFlags flags;
3452     uint32_t setLayoutCount;
3453     PTR32 pSetLayouts;
3454     uint32_t pushConstantRangeCount;
3455     PTR32 pPushConstantRanges;
3456 } VkPipelineLayoutCreateInfo32;
3457
3458 typedef struct VkPrivateDataSlotCreateInfo32
3459 {
3460     VkStructureType sType;
3461     PTR32 pNext;
3462     VkPrivateDataSlotCreateFlags flags;
3463 } VkPrivateDataSlotCreateInfo32;
3464 typedef VkPrivateDataSlotCreateInfo32 VkPrivateDataSlotCreateInfoEXT32;
3465
3466 typedef struct VkQueryPoolPerformanceCreateInfoKHR32
3467 {
3468     VkStructureType sType;
3469     PTR32 pNext;
3470     uint32_t queueFamilyIndex;
3471     uint32_t counterIndexCount;
3472     PTR32 pCounterIndices;
3473 } VkQueryPoolPerformanceCreateInfoKHR32;
3474
3475 typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL32
3476 {
3477     VkStructureType sType;
3478     PTR32 pNext;
3479     VkQueryPoolSamplingModeINTEL performanceCountersSampling;
3480 } VkQueryPoolPerformanceQueryCreateInfoINTEL32;
3481 typedef VkQueryPoolPerformanceQueryCreateInfoINTEL32 VkQueryPoolCreateInfoINTEL32;
3482
3483 typedef struct VkQueryPoolCreateInfo32
3484 {
3485     VkStructureType sType;
3486     PTR32 pNext;
3487     VkQueryPoolCreateFlags flags;
3488     VkQueryType queryType;
3489     uint32_t queryCount;
3490     VkQueryPipelineStatisticFlags pipelineStatistics;
3491 } VkQueryPoolCreateInfo32;
3492
3493 typedef struct VkRayTracingShaderGroupCreateInfoKHR32
3494 {
3495     VkStructureType sType;
3496     PTR32 pNext;
3497     VkRayTracingShaderGroupTypeKHR type;
3498     uint32_t generalShader;
3499     uint32_t closestHitShader;
3500     uint32_t anyHitShader;
3501     uint32_t intersectionShader;
3502     PTR32 pShaderGroupCaptureReplayHandle;
3503 } VkRayTracingShaderGroupCreateInfoKHR32;
3504
3505 typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR32
3506 {
3507     VkStructureType sType;
3508     PTR32 pNext;
3509     uint32_t maxPipelineRayPayloadSize;
3510     uint32_t maxPipelineRayHitAttributeSize;
3511 } VkRayTracingPipelineInterfaceCreateInfoKHR32;
3512
3513 typedef struct VkRayTracingPipelineCreateInfoKHR32
3514 {
3515     VkStructureType sType;
3516     PTR32 pNext;
3517     VkPipelineCreateFlags flags;
3518     uint32_t stageCount;
3519     PTR32 pStages;
3520     uint32_t groupCount;
3521     PTR32 pGroups;
3522     uint32_t maxPipelineRayRecursionDepth;
3523     PTR32 pLibraryInfo;
3524     PTR32 pLibraryInterface;
3525     PTR32 pDynamicState;
3526     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3527     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3528     int32_t basePipelineIndex;
3529 } VkRayTracingPipelineCreateInfoKHR32;
3530
3531 typedef struct VkRayTracingShaderGroupCreateInfoNV32
3532 {
3533     VkStructureType sType;
3534     PTR32 pNext;
3535     VkRayTracingShaderGroupTypeKHR type;
3536     uint32_t generalShader;
3537     uint32_t closestHitShader;
3538     uint32_t anyHitShader;
3539     uint32_t intersectionShader;
3540 } VkRayTracingShaderGroupCreateInfoNV32;
3541
3542 typedef struct VkRayTracingPipelineCreateInfoNV32
3543 {
3544     VkStructureType sType;
3545     PTR32 pNext;
3546     VkPipelineCreateFlags flags;
3547     uint32_t stageCount;
3548     PTR32 pStages;
3549     uint32_t groupCount;
3550     PTR32 pGroups;
3551     uint32_t maxRecursionDepth;
3552     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
3553     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
3554     int32_t basePipelineIndex;
3555 } VkRayTracingPipelineCreateInfoNV32;
3556
3557 typedef struct VkSubpassDescription32
3558 {
3559     VkSubpassDescriptionFlags flags;
3560     VkPipelineBindPoint pipelineBindPoint;
3561     uint32_t inputAttachmentCount;
3562     PTR32 pInputAttachments;
3563     uint32_t colorAttachmentCount;
3564     PTR32 pColorAttachments;
3565     PTR32 pResolveAttachments;
3566     PTR32 pDepthStencilAttachment;
3567     uint32_t preserveAttachmentCount;
3568     PTR32 pPreserveAttachments;
3569 } VkSubpassDescription32;
3570
3571 typedef struct VkRenderPassMultiviewCreateInfo32
3572 {
3573     VkStructureType sType;
3574     PTR32 pNext;
3575     uint32_t subpassCount;
3576     PTR32 pViewMasks;
3577     uint32_t dependencyCount;
3578     PTR32 pViewOffsets;
3579     uint32_t correlationMaskCount;
3580     PTR32 pCorrelationMasks;
3581 } VkRenderPassMultiviewCreateInfo32;
3582 typedef VkRenderPassMultiviewCreateInfo32 VkRenderPassMultiviewCreateInfoKHR32;
3583
3584 typedef struct VkRenderPassInputAttachmentAspectCreateInfo32
3585 {
3586     VkStructureType sType;
3587     PTR32 pNext;
3588     uint32_t aspectReferenceCount;
3589     PTR32 pAspectReferences;
3590 } VkRenderPassInputAttachmentAspectCreateInfo32;
3591 typedef VkRenderPassInputAttachmentAspectCreateInfo32 VkRenderPassInputAttachmentAspectCreateInfoKHR32;
3592
3593 typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT32
3594 {
3595     VkStructureType sType;
3596     PTR32 pNext;
3597     VkAttachmentReference fragmentDensityMapAttachment;
3598 } VkRenderPassFragmentDensityMapCreateInfoEXT32;
3599
3600 typedef struct VkRenderPassCreateInfo32
3601 {
3602     VkStructureType sType;
3603     PTR32 pNext;
3604     VkRenderPassCreateFlags flags;
3605     uint32_t attachmentCount;
3606     PTR32 pAttachments;
3607     uint32_t subpassCount;
3608     PTR32 pSubpasses;
3609     uint32_t dependencyCount;
3610     PTR32 pDependencies;
3611 } VkRenderPassCreateInfo32;
3612
3613 typedef struct VkAttachmentDescriptionStencilLayout32
3614 {
3615     VkStructureType sType;
3616     PTR32 pNext;
3617     VkImageLayout stencilInitialLayout;
3618     VkImageLayout stencilFinalLayout;
3619 } VkAttachmentDescriptionStencilLayout32;
3620 typedef VkAttachmentDescriptionStencilLayout32 VkAttachmentDescriptionStencilLayoutKHR32;
3621
3622 typedef struct VkAttachmentDescription232
3623 {
3624     VkStructureType sType;
3625     PTR32 pNext;
3626     VkAttachmentDescriptionFlags flags;
3627     VkFormat format;
3628     VkSampleCountFlagBits samples;
3629     VkAttachmentLoadOp loadOp;
3630     VkAttachmentStoreOp storeOp;
3631     VkAttachmentLoadOp stencilLoadOp;
3632     VkAttachmentStoreOp stencilStoreOp;
3633     VkImageLayout initialLayout;
3634     VkImageLayout finalLayout;
3635 } VkAttachmentDescription232;
3636 typedef VkAttachmentDescription232 VkAttachmentDescription2KHR32;
3637
3638 typedef struct VkAttachmentReferenceStencilLayout32
3639 {
3640     VkStructureType sType;
3641     PTR32 pNext;
3642     VkImageLayout stencilLayout;
3643 } VkAttachmentReferenceStencilLayout32;
3644 typedef VkAttachmentReferenceStencilLayout32 VkAttachmentReferenceStencilLayoutKHR32;
3645
3646 typedef struct VkAttachmentReference232
3647 {
3648     VkStructureType sType;
3649     PTR32 pNext;
3650     uint32_t attachment;
3651     VkImageLayout layout;
3652     VkImageAspectFlags aspectMask;
3653 } VkAttachmentReference232;
3654 typedef VkAttachmentReference232 VkAttachmentReference2KHR32;
3655
3656 typedef struct VkSubpassDescriptionDepthStencilResolve32
3657 {
3658     VkStructureType sType;
3659     PTR32 pNext;
3660     VkResolveModeFlagBits depthResolveMode;
3661     VkResolveModeFlagBits stencilResolveMode;
3662     PTR32 pDepthStencilResolveAttachment;
3663 } VkSubpassDescriptionDepthStencilResolve32;
3664 typedef VkSubpassDescriptionDepthStencilResolve32 VkSubpassDescriptionDepthStencilResolveKHR32;
3665
3666 typedef struct VkFragmentShadingRateAttachmentInfoKHR32
3667 {
3668     VkStructureType sType;
3669     PTR32 pNext;
3670     PTR32 pFragmentShadingRateAttachment;
3671     VkExtent2D shadingRateAttachmentTexelSize;
3672 } VkFragmentShadingRateAttachmentInfoKHR32;
3673
3674 typedef struct VkRenderPassCreationControlEXT32
3675 {
3676     VkStructureType sType;
3677     PTR32 pNext;
3678     VkBool32 disallowMerging;
3679 } VkRenderPassCreationControlEXT32;
3680
3681 typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT32
3682 {
3683     VkStructureType sType;
3684     PTR32 pNext;
3685     PTR32 pSubpassFeedback;
3686 } VkRenderPassSubpassFeedbackCreateInfoEXT32;
3687
3688 typedef struct VkSubpassDescription232
3689 {
3690     VkStructureType sType;
3691     PTR32 pNext;
3692     VkSubpassDescriptionFlags flags;
3693     VkPipelineBindPoint pipelineBindPoint;
3694     uint32_t viewMask;
3695     uint32_t inputAttachmentCount;
3696     PTR32 pInputAttachments;
3697     uint32_t colorAttachmentCount;
3698     PTR32 pColorAttachments;
3699     PTR32 pResolveAttachments;
3700     PTR32 pDepthStencilAttachment;
3701     uint32_t preserveAttachmentCount;
3702     PTR32 pPreserveAttachments;
3703 } VkSubpassDescription232;
3704 typedef VkSubpassDescription232 VkSubpassDescription2KHR32;
3705
3706 typedef struct VkSubpassDependency232
3707 {
3708     VkStructureType sType;
3709     PTR32 pNext;
3710     uint32_t srcSubpass;
3711     uint32_t dstSubpass;
3712     VkPipelineStageFlags srcStageMask;
3713     VkPipelineStageFlags dstStageMask;
3714     VkAccessFlags srcAccessMask;
3715     VkAccessFlags dstAccessMask;
3716     VkDependencyFlags dependencyFlags;
3717     int32_t viewOffset;
3718 } VkSubpassDependency232;
3719 typedef VkSubpassDependency232 VkSubpassDependency2KHR32;
3720
3721 typedef struct VkRenderPassCreationFeedbackCreateInfoEXT32
3722 {
3723     VkStructureType sType;
3724     PTR32 pNext;
3725     PTR32 pRenderPassFeedback;
3726 } VkRenderPassCreationFeedbackCreateInfoEXT32;
3727
3728 typedef struct VkRenderPassCreateInfo232
3729 {
3730     VkStructureType sType;
3731     PTR32 pNext;
3732     VkRenderPassCreateFlags flags;
3733     uint32_t attachmentCount;
3734     PTR32 pAttachments;
3735     uint32_t subpassCount;
3736     PTR32 pSubpasses;
3737     uint32_t dependencyCount;
3738     PTR32 pDependencies;
3739     uint32_t correlatedViewMaskCount;
3740     PTR32 pCorrelatedViewMasks;
3741 } VkRenderPassCreateInfo232;
3742 typedef VkRenderPassCreateInfo232 VkRenderPassCreateInfo2KHR32;
3743
3744 typedef struct VkSamplerReductionModeCreateInfo32
3745 {
3746     VkStructureType sType;
3747     PTR32 pNext;
3748     VkSamplerReductionMode reductionMode;
3749 } VkSamplerReductionModeCreateInfo32;
3750 typedef VkSamplerReductionModeCreateInfo32 VkSamplerReductionModeCreateInfoEXT32;
3751
3752 typedef struct VkSamplerCustomBorderColorCreateInfoEXT32
3753 {
3754     VkStructureType sType;
3755     PTR32 pNext;
3756     VkClearColorValue customBorderColor;
3757     VkFormat format;
3758 } VkSamplerCustomBorderColorCreateInfoEXT32;
3759
3760 typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT32
3761 {
3762     VkStructureType sType;
3763     PTR32 pNext;
3764     VkComponentMapping components;
3765     VkBool32 srgb;
3766 } VkSamplerBorderColorComponentMappingCreateInfoEXT32;
3767
3768 typedef struct VkSamplerCreateInfo32
3769 {
3770     VkStructureType sType;
3771     PTR32 pNext;
3772     VkSamplerCreateFlags flags;
3773     VkFilter magFilter;
3774     VkFilter minFilter;
3775     VkSamplerMipmapMode mipmapMode;
3776     VkSamplerAddressMode addressModeU;
3777     VkSamplerAddressMode addressModeV;
3778     VkSamplerAddressMode addressModeW;
3779     float mipLodBias;
3780     VkBool32 anisotropyEnable;
3781     float maxAnisotropy;
3782     VkBool32 compareEnable;
3783     VkCompareOp compareOp;
3784     float minLod;
3785     float maxLod;
3786     VkBorderColor borderColor;
3787     VkBool32 unnormalizedCoordinates;
3788 } VkSamplerCreateInfo32;
3789
3790 typedef struct VkSamplerYcbcrConversionCreateInfo32
3791 {
3792     VkStructureType sType;
3793     PTR32 pNext;
3794     VkFormat format;
3795     VkSamplerYcbcrModelConversion ycbcrModel;
3796     VkSamplerYcbcrRange ycbcrRange;
3797     VkComponentMapping components;
3798     VkChromaLocation xChromaOffset;
3799     VkChromaLocation yChromaOffset;
3800     VkFilter chromaFilter;
3801     VkBool32 forceExplicitReconstruction;
3802 } VkSamplerYcbcrConversionCreateInfo32;
3803 typedef VkSamplerYcbcrConversionCreateInfo32 VkSamplerYcbcrConversionCreateInfoKHR32;
3804
3805 typedef struct VkExportSemaphoreCreateInfo32
3806 {
3807     VkStructureType sType;
3808     PTR32 pNext;
3809     VkExternalSemaphoreHandleTypeFlags handleTypes;
3810 } VkExportSemaphoreCreateInfo32;
3811 typedef VkExportSemaphoreCreateInfo32 VkExportSemaphoreCreateInfoKHR32;
3812
3813 typedef struct VkSemaphoreTypeCreateInfo32
3814 {
3815     VkStructureType sType;
3816     PTR32 pNext;
3817     VkSemaphoreType semaphoreType;
3818     uint64_t DECLSPEC_ALIGN(8) initialValue;
3819 } VkSemaphoreTypeCreateInfo32;
3820 typedef VkSemaphoreTypeCreateInfo32 VkSemaphoreTypeCreateInfoKHR32;
3821
3822 typedef struct VkSemaphoreCreateInfo32
3823 {
3824     VkStructureType sType;
3825     PTR32 pNext;
3826     VkSemaphoreCreateFlags flags;
3827 } VkSemaphoreCreateInfo32;
3828
3829 typedef struct VkDeviceGroupSwapchainCreateInfoKHR32
3830 {
3831     VkStructureType sType;
3832     PTR32 pNext;
3833     VkDeviceGroupPresentModeFlagsKHR modes;
3834 } VkDeviceGroupSwapchainCreateInfoKHR32;
3835
3836 typedef struct VkSwapchainPresentBarrierCreateInfoNV32
3837 {
3838     VkStructureType sType;
3839     PTR32 pNext;
3840     VkBool32 presentBarrierEnable;
3841 } VkSwapchainPresentBarrierCreateInfoNV32;
3842
3843 typedef struct VkSwapchainCreateInfoKHR32
3844 {
3845     VkStructureType sType;
3846     PTR32 pNext;
3847     VkSwapchainCreateFlagsKHR flags;
3848     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
3849     uint32_t minImageCount;
3850     VkFormat imageFormat;
3851     VkColorSpaceKHR imageColorSpace;
3852     VkExtent2D imageExtent;
3853     uint32_t imageArrayLayers;
3854     VkImageUsageFlags imageUsage;
3855     VkSharingMode imageSharingMode;
3856     uint32_t queueFamilyIndexCount;
3857     PTR32 pQueueFamilyIndices;
3858     VkSurfaceTransformFlagBitsKHR preTransform;
3859     VkCompositeAlphaFlagBitsKHR compositeAlpha;
3860     VkPresentModeKHR presentMode;
3861     VkBool32 clipped;
3862     VkSwapchainKHR DECLSPEC_ALIGN(8) oldSwapchain;
3863 } VkSwapchainCreateInfoKHR32;
3864
3865 typedef struct VkValidationCacheCreateInfoEXT32
3866 {
3867     VkStructureType sType;
3868     PTR32 pNext;
3869     VkValidationCacheCreateFlagsEXT flags;
3870     PTR32 initialDataSize;
3871     PTR32 pInitialData;
3872 } VkValidationCacheCreateInfoEXT32;
3873
3874 typedef struct VkWin32SurfaceCreateInfoKHR32
3875 {
3876     VkStructureType sType;
3877     PTR32 pNext;
3878     VkWin32SurfaceCreateFlagsKHR flags;
3879     PTR32 hinstance;
3880     PTR32 hwnd;
3881 } VkWin32SurfaceCreateInfoKHR32;
3882
3883 typedef struct VkDebugMarkerObjectNameInfoEXT32
3884 {
3885     VkStructureType sType;
3886     PTR32 pNext;
3887     VkDebugReportObjectTypeEXT objectType;
3888     uint64_t DECLSPEC_ALIGN(8) object;
3889     PTR32 pObjectName;
3890 } VkDebugMarkerObjectNameInfoEXT32;
3891
3892 typedef struct VkDebugMarkerObjectTagInfoEXT32
3893 {
3894     VkStructureType sType;
3895     PTR32 pNext;
3896     VkDebugReportObjectTypeEXT objectType;
3897     uint64_t DECLSPEC_ALIGN(8) object;
3898     uint64_t DECLSPEC_ALIGN(8) tagName;
3899     PTR32 tagSize;
3900     PTR32 pTag;
3901 } VkDebugMarkerObjectTagInfoEXT32;
3902
3903 typedef struct VkPhysicalDeviceGroupProperties32
3904 {
3905     VkStructureType sType;
3906     PTR32 pNext;
3907     uint32_t physicalDeviceCount;
3908     PTR32 physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
3909     VkBool32 subsetAllocation;
3910 } VkPhysicalDeviceGroupProperties32;
3911 typedef VkPhysicalDeviceGroupProperties32 VkPhysicalDeviceGroupPropertiesKHR32;
3912
3913 typedef struct VkPerformanceCounterKHR32
3914 {
3915     VkStructureType sType;
3916     PTR32 pNext;
3917     VkPerformanceCounterUnitKHR unit;
3918     VkPerformanceCounterScopeKHR scope;
3919     VkPerformanceCounterStorageKHR storage;
3920     uint8_t uuid[VK_UUID_SIZE];
3921 } VkPerformanceCounterKHR32;
3922
3923 typedef struct VkPerformanceCounterDescriptionKHR32
3924 {
3925     VkStructureType sType;
3926     PTR32 pNext;
3927     VkPerformanceCounterDescriptionFlagsKHR flags;
3928     char name[VK_MAX_DESCRIPTION_SIZE];
3929     char category[VK_MAX_DESCRIPTION_SIZE];
3930     char description[VK_MAX_DESCRIPTION_SIZE];
3931 } VkPerformanceCounterDescriptionKHR32;
3932
3933 typedef struct VkMappedMemoryRange32
3934 {
3935     VkStructureType sType;
3936     PTR32 pNext;
3937     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
3938     VkDeviceSize DECLSPEC_ALIGN(8) offset;
3939     VkDeviceSize DECLSPEC_ALIGN(8) size;
3940 } VkMappedMemoryRange32;
3941
3942 typedef struct VkAccelerationStructureBuildSizesInfoKHR32
3943 {
3944     VkStructureType sType;
3945     PTR32 pNext;
3946     VkDeviceSize DECLSPEC_ALIGN(8) accelerationStructureSize;
3947     VkDeviceSize DECLSPEC_ALIGN(8) updateScratchSize;
3948     VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
3949 } VkAccelerationStructureBuildSizesInfoKHR32;
3950
3951 typedef struct VkAccelerationStructureDeviceAddressInfoKHR32
3952 {
3953     VkStructureType sType;
3954     PTR32 pNext;
3955     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
3956 } VkAccelerationStructureDeviceAddressInfoKHR32;
3957
3958 typedef struct VkAccelerationStructureMemoryRequirementsInfoNV32
3959 {
3960     VkStructureType sType;
3961     PTR32 pNext;
3962     VkAccelerationStructureMemoryRequirementsTypeNV type;
3963     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
3964 } VkAccelerationStructureMemoryRequirementsInfoNV32;
3965
3966 typedef struct VkMemoryRequirements32
3967 {
3968     VkDeviceSize DECLSPEC_ALIGN(8) size;
3969     VkDeviceSize DECLSPEC_ALIGN(8) alignment;
3970     uint32_t memoryTypeBits;
3971 } VkMemoryRequirements32;
3972
3973
3974 typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT32
3975 {
3976     VkStructureType sType;
3977     PTR32 pNext;
3978     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
3979     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructureNV;
3980 } VkAccelerationStructureCaptureDescriptorDataInfoEXT32;
3981
3982 typedef struct VkBufferDeviceAddressInfo32
3983 {
3984     VkStructureType sType;
3985     PTR32 pNext;
3986     VkBuffer DECLSPEC_ALIGN(8) buffer;
3987 } VkBufferDeviceAddressInfo32;
3988 typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoKHR32;
3989 typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoEXT32;
3990
3991 typedef struct VkBufferMemoryRequirementsInfo232
3992 {
3993     VkStructureType sType;
3994     PTR32 pNext;
3995     VkBuffer DECLSPEC_ALIGN(8) buffer;
3996 } VkBufferMemoryRequirementsInfo232;
3997 typedef VkBufferMemoryRequirementsInfo232 VkBufferMemoryRequirementsInfo2KHR32;
3998
3999 typedef struct VkMemoryDedicatedRequirements32
4000 {
4001     VkStructureType sType;
4002     PTR32 pNext;
4003     VkBool32 prefersDedicatedAllocation;
4004     VkBool32 requiresDedicatedAllocation;
4005 } VkMemoryDedicatedRequirements32;
4006 typedef VkMemoryDedicatedRequirements32 VkMemoryDedicatedRequirementsKHR32;
4007
4008 typedef struct VkMemoryRequirements232
4009 {
4010     VkStructureType sType;
4011     PTR32 pNext;
4012     VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
4013 } VkMemoryRequirements232;
4014 typedef VkMemoryRequirements232 VkMemoryRequirements2KHR32;
4015
4016 typedef struct VkBufferCaptureDescriptorDataInfoEXT32
4017 {
4018     VkStructureType sType;
4019     PTR32 pNext;
4020     VkBuffer DECLSPEC_ALIGN(8) buffer;
4021 } VkBufferCaptureDescriptorDataInfoEXT32;
4022
4023 typedef struct VkCalibratedTimestampInfoEXT32
4024 {
4025     VkStructureType sType;
4026     PTR32 pNext;
4027     VkTimeDomainEXT timeDomain;
4028 } VkCalibratedTimestampInfoEXT32;
4029
4030 typedef struct VkDescriptorAddressInfoEXT32
4031 {
4032     VkStructureType sType;
4033     PTR32 pNext;
4034     VkDeviceAddress DECLSPEC_ALIGN(8) address;
4035     VkDeviceSize DECLSPEC_ALIGN(8) range;
4036     VkFormat format;
4037 } VkDescriptorAddressInfoEXT32;
4038
4039 typedef union VkDescriptorDataEXT32
4040 {
4041     PTR32 pSampler;
4042     PTR32 pCombinedImageSampler;
4043     PTR32 pInputAttachmentImage;
4044     PTR32 pSampledImage;
4045     PTR32 pStorageImage;
4046     PTR32 pUniformTexelBuffer;
4047     PTR32 pStorageTexelBuffer;
4048     PTR32 pUniformBuffer;
4049     PTR32 pStorageBuffer;
4050     VkDeviceAddress DECLSPEC_ALIGN(8) accelerationStructure;
4051 } VkDescriptorDataEXT32;
4052
4053 typedef struct VkDescriptorGetInfoEXT32
4054 {
4055     VkStructureType sType;
4056     PTR32 pNext;
4057     VkDescriptorType type;
4058     VkDescriptorDataEXT32 DECLSPEC_ALIGN(8) data;
4059 } VkDescriptorGetInfoEXT32;
4060
4061 typedef struct VkDescriptorSetBindingReferenceVALVE32
4062 {
4063     VkStructureType sType;
4064     PTR32 pNext;
4065     VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
4066     uint32_t binding;
4067 } VkDescriptorSetBindingReferenceVALVE32;
4068
4069 typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE32
4070 {
4071     VkStructureType sType;
4072     PTR32 pNext;
4073     PTR32 descriptorOffset;
4074     uint32_t descriptorSize;
4075 } VkDescriptorSetLayoutHostMappingInfoVALVE32;
4076
4077 typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport32
4078 {
4079     VkStructureType sType;
4080     PTR32 pNext;
4081     uint32_t maxVariableDescriptorCount;
4082 } VkDescriptorSetVariableDescriptorCountLayoutSupport32;
4083 typedef VkDescriptorSetVariableDescriptorCountLayoutSupport32 VkDescriptorSetVariableDescriptorCountLayoutSupportEXT32;
4084
4085 typedef struct VkDescriptorSetLayoutSupport32
4086 {
4087     VkStructureType sType;
4088     PTR32 pNext;
4089     VkBool32 supported;
4090 } VkDescriptorSetLayoutSupport32;
4091 typedef VkDescriptorSetLayoutSupport32 VkDescriptorSetLayoutSupportKHR32;
4092
4093 typedef struct VkAccelerationStructureVersionInfoKHR32
4094 {
4095     VkStructureType sType;
4096     PTR32 pNext;
4097     PTR32 pVersionData;
4098 } VkAccelerationStructureVersionInfoKHR32;
4099
4100 typedef struct VkDeviceBufferMemoryRequirements32
4101 {
4102     VkStructureType sType;
4103     PTR32 pNext;
4104     PTR32 pCreateInfo;
4105 } VkDeviceBufferMemoryRequirements32;
4106 typedef VkDeviceBufferMemoryRequirements32 VkDeviceBufferMemoryRequirementsKHR32;
4107
4108 typedef struct VkDeviceFaultCountsEXT32
4109 {
4110     VkStructureType sType;
4111     PTR32 pNext;
4112     uint32_t addressInfoCount;
4113     uint32_t vendorInfoCount;
4114     VkDeviceSize DECLSPEC_ALIGN(8) vendorBinarySize;
4115 } VkDeviceFaultCountsEXT32;
4116
4117 typedef struct VkDeviceFaultAddressInfoEXT32
4118 {
4119     VkDeviceFaultAddressTypeEXT addressType;
4120     VkDeviceAddress DECLSPEC_ALIGN(8) reportedAddress;
4121     VkDeviceSize DECLSPEC_ALIGN(8) addressPrecision;
4122 } VkDeviceFaultAddressInfoEXT32;
4123
4124 typedef struct VkDeviceFaultVendorInfoEXT32
4125 {
4126     char description[VK_MAX_DESCRIPTION_SIZE];
4127     uint64_t DECLSPEC_ALIGN(8) vendorFaultCode;
4128     uint64_t DECLSPEC_ALIGN(8) vendorFaultData;
4129 } VkDeviceFaultVendorInfoEXT32;
4130
4131 typedef struct VkDeviceFaultInfoEXT32
4132 {
4133     VkStructureType sType;
4134     PTR32 pNext;
4135     char description[VK_MAX_DESCRIPTION_SIZE];
4136     PTR32 pAddressInfos;
4137     PTR32 pVendorInfos;
4138     PTR32 pVendorBinaryData;
4139 } VkDeviceFaultInfoEXT32;
4140
4141 typedef struct VkDeviceGroupPresentCapabilitiesKHR32
4142 {
4143     VkStructureType sType;
4144     PTR32 pNext;
4145     uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
4146     VkDeviceGroupPresentModeFlagsKHR modes;
4147 } VkDeviceGroupPresentCapabilitiesKHR32;
4148
4149 typedef struct VkDeviceImageMemoryRequirements32
4150 {
4151     VkStructureType sType;
4152     PTR32 pNext;
4153     PTR32 pCreateInfo;
4154     VkImageAspectFlagBits planeAspect;
4155 } VkDeviceImageMemoryRequirements32;
4156 typedef VkDeviceImageMemoryRequirements32 VkDeviceImageMemoryRequirementsKHR32;
4157
4158 typedef struct VkSparseImageMemoryRequirements32
4159 {
4160     VkSparseImageFormatProperties formatProperties;
4161     uint32_t imageMipTailFirstLod;
4162     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailSize;
4163     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailOffset;
4164     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailStride;
4165 } VkSparseImageMemoryRequirements32;
4166
4167 typedef struct VkSparseImageMemoryRequirements232
4168 {
4169     VkStructureType sType;
4170     PTR32 pNext;
4171     VkSparseImageMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
4172 } VkSparseImageMemoryRequirements232;
4173 typedef VkSparseImageMemoryRequirements232 VkSparseImageMemoryRequirements2KHR32;
4174
4175 typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo32
4176 {
4177     VkStructureType sType;
4178     PTR32 pNext;
4179     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
4180 } VkDeviceMemoryOpaqueCaptureAddressInfo32;
4181 typedef VkDeviceMemoryOpaqueCaptureAddressInfo32 VkDeviceMemoryOpaqueCaptureAddressInfoKHR32;
4182
4183 typedef struct VkMicromapVersionInfoEXT32
4184 {
4185     VkStructureType sType;
4186     PTR32 pNext;
4187     PTR32 pVersionData;
4188 } VkMicromapVersionInfoEXT32;
4189
4190 typedef struct VkDeviceQueueInfo232
4191 {
4192     VkStructureType sType;
4193     PTR32 pNext;
4194     VkDeviceQueueCreateFlags flags;
4195     uint32_t queueFamilyIndex;
4196     uint32_t queueIndex;
4197 } VkDeviceQueueInfo232;
4198
4199 typedef struct VkTilePropertiesQCOM32
4200 {
4201     VkStructureType sType;
4202     PTR32 pNext;
4203     VkExtent3D tileSize;
4204     VkExtent2D apronSize;
4205     VkOffset2D origin;
4206 } VkTilePropertiesQCOM32;
4207
4208 typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV32
4209 {
4210     VkStructureType sType;
4211     PTR32 pNext;
4212     VkPipelineBindPoint pipelineBindPoint;
4213     VkPipeline DECLSPEC_ALIGN(8) pipeline;
4214     VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
4215     uint32_t maxSequencesCount;
4216 } VkGeneratedCommandsMemoryRequirementsInfoNV32;
4217
4218 typedef struct VkImagePlaneMemoryRequirementsInfo32
4219 {
4220     VkStructureType sType;
4221     PTR32 pNext;
4222     VkImageAspectFlagBits planeAspect;
4223 } VkImagePlaneMemoryRequirementsInfo32;
4224 typedef VkImagePlaneMemoryRequirementsInfo32 VkImagePlaneMemoryRequirementsInfoKHR32;
4225
4226 typedef struct VkImageMemoryRequirementsInfo232
4227 {
4228     VkStructureType sType;
4229     PTR32 pNext;
4230     VkImage DECLSPEC_ALIGN(8) image;
4231 } VkImageMemoryRequirementsInfo232;
4232 typedef VkImageMemoryRequirementsInfo232 VkImageMemoryRequirementsInfo2KHR32;
4233
4234 typedef struct VkImageCaptureDescriptorDataInfoEXT32
4235 {
4236     VkStructureType sType;
4237     PTR32 pNext;
4238     VkImage DECLSPEC_ALIGN(8) image;
4239 } VkImageCaptureDescriptorDataInfoEXT32;
4240
4241 typedef struct VkImageSparseMemoryRequirementsInfo232
4242 {
4243     VkStructureType sType;
4244     PTR32 pNext;
4245     VkImage DECLSPEC_ALIGN(8) image;
4246 } VkImageSparseMemoryRequirementsInfo232;
4247 typedef VkImageSparseMemoryRequirementsInfo232 VkImageSparseMemoryRequirementsInfo2KHR32;
4248
4249 typedef struct VkSubresourceLayout32
4250 {
4251     VkDeviceSize DECLSPEC_ALIGN(8) offset;
4252     VkDeviceSize DECLSPEC_ALIGN(8) size;
4253     VkDeviceSize DECLSPEC_ALIGN(8) rowPitch;
4254     VkDeviceSize DECLSPEC_ALIGN(8) arrayPitch;
4255     VkDeviceSize DECLSPEC_ALIGN(8) depthPitch;
4256 } VkSubresourceLayout32;
4257
4258 typedef struct VkImageSubresource2EXT32
4259 {
4260     VkStructureType sType;
4261     PTR32 pNext;
4262     VkImageSubresource imageSubresource;
4263 } VkImageSubresource2EXT32;
4264
4265 typedef struct VkImageCompressionPropertiesEXT32
4266 {
4267     VkStructureType sType;
4268     PTR32 pNext;
4269     VkImageCompressionFlagsEXT imageCompressionFlags;
4270     VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags;
4271 } VkImageCompressionPropertiesEXT32;
4272
4273 typedef struct VkSubresourceLayout2EXT32
4274 {
4275     VkStructureType sType;
4276     PTR32 pNext;
4277     VkSubresourceLayout32 DECLSPEC_ALIGN(8) subresourceLayout;
4278 } VkSubresourceLayout2EXT32;
4279
4280 typedef struct VkImageViewAddressPropertiesNVX32
4281 {
4282     VkStructureType sType;
4283     PTR32 pNext;
4284     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
4285     VkDeviceSize DECLSPEC_ALIGN(8) size;
4286 } VkImageViewAddressPropertiesNVX32;
4287
4288 typedef struct VkImageViewHandleInfoNVX32
4289 {
4290     VkStructureType sType;
4291     PTR32 pNext;
4292     VkImageView DECLSPEC_ALIGN(8) imageView;
4293     VkDescriptorType descriptorType;
4294     VkSampler DECLSPEC_ALIGN(8) sampler;
4295 } VkImageViewHandleInfoNVX32;
4296
4297 typedef struct VkImageViewCaptureDescriptorDataInfoEXT32
4298 {
4299     VkStructureType sType;
4300     PTR32 pNext;
4301     VkImageView DECLSPEC_ALIGN(8) imageView;
4302 } VkImageViewCaptureDescriptorDataInfoEXT32;
4303
4304 typedef struct VkMemoryHostPointerPropertiesEXT32
4305 {
4306     VkStructureType sType;
4307     PTR32 pNext;
4308     uint32_t memoryTypeBits;
4309 } VkMemoryHostPointerPropertiesEXT32;
4310
4311 typedef struct VkMicromapBuildSizesInfoEXT32
4312 {
4313     VkStructureType sType;
4314     PTR32 pNext;
4315     VkDeviceSize DECLSPEC_ALIGN(8) micromapSize;
4316     VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
4317     VkBool32 discardable;
4318 } VkMicromapBuildSizesInfoEXT32;
4319
4320 typedef union VkPerformanceValueDataINTEL32
4321 {
4322     uint32_t value32;
4323     uint64_t DECLSPEC_ALIGN(8) value64;
4324     float valueFloat;
4325     VkBool32 valueBool;
4326     PTR32 valueString;
4327 } VkPerformanceValueDataINTEL32;
4328
4329 typedef struct VkPerformanceValueINTEL32
4330 {
4331     VkPerformanceValueTypeINTEL type;
4332     VkPerformanceValueDataINTEL32 DECLSPEC_ALIGN(8) data;
4333 } VkPerformanceValueINTEL32;
4334
4335 typedef struct VkCooperativeMatrixPropertiesNV32
4336 {
4337     VkStructureType sType;
4338     PTR32 pNext;
4339     uint32_t MSize;
4340     uint32_t NSize;
4341     uint32_t KSize;
4342     VkComponentTypeNV AType;
4343     VkComponentTypeNV BType;
4344     VkComponentTypeNV CType;
4345     VkComponentTypeNV DType;
4346     VkScopeNV scope;
4347 } VkCooperativeMatrixPropertiesNV32;
4348
4349 typedef struct VkPhysicalDeviceExternalBufferInfo32
4350 {
4351     VkStructureType sType;
4352     PTR32 pNext;
4353     VkBufferCreateFlags flags;
4354     VkBufferUsageFlags usage;
4355     VkExternalMemoryHandleTypeFlagBits handleType;
4356 } VkPhysicalDeviceExternalBufferInfo32;
4357 typedef VkPhysicalDeviceExternalBufferInfo32 VkPhysicalDeviceExternalBufferInfoKHR32;
4358
4359 typedef struct VkExternalBufferProperties32
4360 {
4361     VkStructureType sType;
4362     PTR32 pNext;
4363     VkExternalMemoryProperties externalMemoryProperties;
4364 } VkExternalBufferProperties32;
4365 typedef VkExternalBufferProperties32 VkExternalBufferPropertiesKHR32;
4366
4367 typedef struct VkPhysicalDeviceExternalFenceInfo32
4368 {
4369     VkStructureType sType;
4370     PTR32 pNext;
4371     VkExternalFenceHandleTypeFlagBits handleType;
4372 } VkPhysicalDeviceExternalFenceInfo32;
4373 typedef VkPhysicalDeviceExternalFenceInfo32 VkPhysicalDeviceExternalFenceInfoKHR32;
4374
4375 typedef struct VkExternalFenceProperties32
4376 {
4377     VkStructureType sType;
4378     PTR32 pNext;
4379     VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
4380     VkExternalFenceHandleTypeFlags compatibleHandleTypes;
4381     VkExternalFenceFeatureFlags externalFenceFeatures;
4382 } VkExternalFenceProperties32;
4383 typedef VkExternalFenceProperties32 VkExternalFencePropertiesKHR32;
4384
4385 typedef struct VkPhysicalDeviceExternalSemaphoreInfo32
4386 {
4387     VkStructureType sType;
4388     PTR32 pNext;
4389     VkExternalSemaphoreHandleTypeFlagBits handleType;
4390 } VkPhysicalDeviceExternalSemaphoreInfo32;
4391 typedef VkPhysicalDeviceExternalSemaphoreInfo32 VkPhysicalDeviceExternalSemaphoreInfoKHR32;
4392
4393 typedef struct VkExternalSemaphoreProperties32
4394 {
4395     VkStructureType sType;
4396     PTR32 pNext;
4397     VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
4398     VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
4399     VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
4400 } VkExternalSemaphoreProperties32;
4401 typedef VkExternalSemaphoreProperties32 VkExternalSemaphorePropertiesKHR32;
4402
4403 typedef struct VkSubpassResolvePerformanceQueryEXT32
4404 {
4405     VkStructureType sType;
4406     PTR32 pNext;
4407     VkBool32 optimal;
4408 } VkSubpassResolvePerformanceQueryEXT32;
4409
4410 typedef struct VkFormatProperties332
4411 {
4412     VkStructureType sType;
4413     PTR32 pNext;
4414     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingFeatures;
4415     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingFeatures;
4416     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) bufferFeatures;
4417 } VkFormatProperties332;
4418 typedef VkFormatProperties332 VkFormatProperties3KHR32;
4419
4420 typedef struct VkFormatProperties232
4421 {
4422     VkStructureType sType;
4423     PTR32 pNext;
4424     VkFormatProperties formatProperties;
4425 } VkFormatProperties232;
4426 typedef VkFormatProperties232 VkFormatProperties2KHR32;
4427
4428 typedef struct VkPhysicalDeviceFragmentShadingRateKHR32
4429 {
4430     VkStructureType sType;
4431     PTR32 pNext;
4432     VkSampleCountFlags sampleCounts;
4433     VkExtent2D fragmentSize;
4434 } VkPhysicalDeviceFragmentShadingRateKHR32;
4435
4436 typedef struct VkImageFormatProperties32
4437 {
4438     VkExtent3D maxExtent;
4439     uint32_t maxMipLevels;
4440     uint32_t maxArrayLayers;
4441     VkSampleCountFlags sampleCounts;
4442     VkDeviceSize DECLSPEC_ALIGN(8) maxResourceSize;
4443 } VkImageFormatProperties32;
4444
4445 typedef struct VkPhysicalDeviceExternalImageFormatInfo32
4446 {
4447     VkStructureType sType;
4448     PTR32 pNext;
4449     VkExternalMemoryHandleTypeFlagBits handleType;
4450 } VkPhysicalDeviceExternalImageFormatInfo32;
4451 typedef VkPhysicalDeviceExternalImageFormatInfo32 VkPhysicalDeviceExternalImageFormatInfoKHR32;
4452
4453 typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT32
4454 {
4455     VkStructureType sType;
4456     PTR32 pNext;
4457     VkImageViewType imageViewType;
4458 } VkPhysicalDeviceImageViewImageFormatInfoEXT32;
4459
4460 typedef struct VkPhysicalDeviceImageFormatInfo232
4461 {
4462     VkStructureType sType;
4463     PTR32 pNext;
4464     VkFormat format;
4465     VkImageType type;
4466     VkImageTiling tiling;
4467     VkImageUsageFlags usage;
4468     VkImageCreateFlags flags;
4469 } VkPhysicalDeviceImageFormatInfo232;
4470 typedef VkPhysicalDeviceImageFormatInfo232 VkPhysicalDeviceImageFormatInfo2KHR32;
4471
4472 typedef struct VkExternalImageFormatProperties32
4473 {
4474     VkStructureType sType;
4475     PTR32 pNext;
4476     VkExternalMemoryProperties externalMemoryProperties;
4477 } VkExternalImageFormatProperties32;
4478 typedef VkExternalImageFormatProperties32 VkExternalImageFormatPropertiesKHR32;
4479
4480 typedef struct VkSamplerYcbcrConversionImageFormatProperties32
4481 {
4482     VkStructureType sType;
4483     PTR32 pNext;
4484     uint32_t combinedImageSamplerDescriptorCount;
4485 } VkSamplerYcbcrConversionImageFormatProperties32;
4486 typedef VkSamplerYcbcrConversionImageFormatProperties32 VkSamplerYcbcrConversionImageFormatPropertiesKHR32;
4487
4488 typedef struct VkTextureLODGatherFormatPropertiesAMD32
4489 {
4490     VkStructureType sType;
4491     PTR32 pNext;
4492     VkBool32 supportsTextureGatherLODBiasAMD;
4493 } VkTextureLODGatherFormatPropertiesAMD32;
4494
4495 typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT32
4496 {
4497     VkStructureType sType;
4498     PTR32 pNext;
4499     VkBool32 filterCubic;
4500     VkBool32 filterCubicMinmax;
4501 } VkFilterCubicImageViewImageFormatPropertiesEXT32;
4502
4503 typedef struct VkImageFormatProperties232
4504 {
4505     VkStructureType sType;
4506     PTR32 pNext;
4507     VkImageFormatProperties32 DECLSPEC_ALIGN(8) imageFormatProperties;
4508 } VkImageFormatProperties232;
4509 typedef VkImageFormatProperties232 VkImageFormatProperties2KHR32;
4510
4511 typedef struct VkMemoryHeap32
4512 {
4513     VkDeviceSize DECLSPEC_ALIGN(8) size;
4514     VkMemoryHeapFlags flags;
4515 } VkMemoryHeap32;
4516
4517 typedef struct VkPhysicalDeviceMemoryProperties32
4518 {
4519     uint32_t memoryTypeCount;
4520     VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
4521     uint32_t memoryHeapCount;
4522     VkMemoryHeap32 DECLSPEC_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS];
4523 } VkPhysicalDeviceMemoryProperties32;
4524
4525 typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT32
4526 {
4527     VkStructureType sType;
4528     PTR32 pNext;
4529     VkDeviceSize DECLSPEC_ALIGN(8) heapBudget[VK_MAX_MEMORY_HEAPS];
4530     VkDeviceSize DECLSPEC_ALIGN(8) heapUsage[VK_MAX_MEMORY_HEAPS];
4531 } VkPhysicalDeviceMemoryBudgetPropertiesEXT32;
4532
4533 typedef struct VkPhysicalDeviceMemoryProperties232
4534 {
4535     VkStructureType sType;
4536     PTR32 pNext;
4537     VkPhysicalDeviceMemoryProperties32 DECLSPEC_ALIGN(8) memoryProperties;
4538 } VkPhysicalDeviceMemoryProperties232;
4539 typedef VkPhysicalDeviceMemoryProperties232 VkPhysicalDeviceMemoryProperties2KHR32;
4540
4541 typedef struct VkMultisamplePropertiesEXT32
4542 {
4543     VkStructureType sType;
4544     PTR32 pNext;
4545     VkExtent2D maxSampleLocationGridSize;
4546 } VkMultisamplePropertiesEXT32;
4547
4548 typedef struct VkOpticalFlowImageFormatPropertiesNV32
4549 {
4550     VkStructureType sType;
4551     PTR32 pNext;
4552     VkFormat format;
4553 } VkOpticalFlowImageFormatPropertiesNV32;
4554
4555 typedef struct VkPhysicalDeviceLimits32
4556 {
4557     uint32_t maxImageDimension1D;
4558     uint32_t maxImageDimension2D;
4559     uint32_t maxImageDimension3D;
4560     uint32_t maxImageDimensionCube;
4561     uint32_t maxImageArrayLayers;
4562     uint32_t maxTexelBufferElements;
4563     uint32_t maxUniformBufferRange;
4564     uint32_t maxStorageBufferRange;
4565     uint32_t maxPushConstantsSize;
4566     uint32_t maxMemoryAllocationCount;
4567     uint32_t maxSamplerAllocationCount;
4568     VkDeviceSize DECLSPEC_ALIGN(8) bufferImageGranularity;
4569     VkDeviceSize DECLSPEC_ALIGN(8) sparseAddressSpaceSize;
4570     uint32_t maxBoundDescriptorSets;
4571     uint32_t maxPerStageDescriptorSamplers;
4572     uint32_t maxPerStageDescriptorUniformBuffers;
4573     uint32_t maxPerStageDescriptorStorageBuffers;
4574     uint32_t maxPerStageDescriptorSampledImages;
4575     uint32_t maxPerStageDescriptorStorageImages;
4576     uint32_t maxPerStageDescriptorInputAttachments;
4577     uint32_t maxPerStageResources;
4578     uint32_t maxDescriptorSetSamplers;
4579     uint32_t maxDescriptorSetUniformBuffers;
4580     uint32_t maxDescriptorSetUniformBuffersDynamic;
4581     uint32_t maxDescriptorSetStorageBuffers;
4582     uint32_t maxDescriptorSetStorageBuffersDynamic;
4583     uint32_t maxDescriptorSetSampledImages;
4584     uint32_t maxDescriptorSetStorageImages;
4585     uint32_t maxDescriptorSetInputAttachments;
4586     uint32_t maxVertexInputAttributes;
4587     uint32_t maxVertexInputBindings;
4588     uint32_t maxVertexInputAttributeOffset;
4589     uint32_t maxVertexInputBindingStride;
4590     uint32_t maxVertexOutputComponents;
4591     uint32_t maxTessellationGenerationLevel;
4592     uint32_t maxTessellationPatchSize;
4593     uint32_t maxTessellationControlPerVertexInputComponents;
4594     uint32_t maxTessellationControlPerVertexOutputComponents;
4595     uint32_t maxTessellationControlPerPatchOutputComponents;
4596     uint32_t maxTessellationControlTotalOutputComponents;
4597     uint32_t maxTessellationEvaluationInputComponents;
4598     uint32_t maxTessellationEvaluationOutputComponents;
4599     uint32_t maxGeometryShaderInvocations;
4600     uint32_t maxGeometryInputComponents;
4601     uint32_t maxGeometryOutputComponents;
4602     uint32_t maxGeometryOutputVertices;
4603     uint32_t maxGeometryTotalOutputComponents;
4604     uint32_t maxFragmentInputComponents;
4605     uint32_t maxFragmentOutputAttachments;
4606     uint32_t maxFragmentDualSrcAttachments;
4607     uint32_t maxFragmentCombinedOutputResources;
4608     uint32_t maxComputeSharedMemorySize;
4609     uint32_t maxComputeWorkGroupCount[3];
4610     uint32_t maxComputeWorkGroupInvocations;
4611     uint32_t maxComputeWorkGroupSize[3];
4612     uint32_t subPixelPrecisionBits;
4613     uint32_t subTexelPrecisionBits;
4614     uint32_t mipmapPrecisionBits;
4615     uint32_t maxDrawIndexedIndexValue;
4616     uint32_t maxDrawIndirectCount;
4617     float maxSamplerLodBias;
4618     float maxSamplerAnisotropy;
4619     uint32_t maxViewports;
4620     uint32_t maxViewportDimensions[2];
4621     float viewportBoundsRange[2];
4622     uint32_t viewportSubPixelBits;
4623     PTR32 minMemoryMapAlignment;
4624     VkDeviceSize DECLSPEC_ALIGN(8) minTexelBufferOffsetAlignment;
4625     VkDeviceSize DECLSPEC_ALIGN(8) minUniformBufferOffsetAlignment;
4626     VkDeviceSize DECLSPEC_ALIGN(8) minStorageBufferOffsetAlignment;
4627     int32_t minTexelOffset;
4628     uint32_t maxTexelOffset;
4629     int32_t minTexelGatherOffset;
4630     uint32_t maxTexelGatherOffset;
4631     float minInterpolationOffset;
4632     float maxInterpolationOffset;
4633     uint32_t subPixelInterpolationOffsetBits;
4634     uint32_t maxFramebufferWidth;
4635     uint32_t maxFramebufferHeight;
4636     uint32_t maxFramebufferLayers;
4637     VkSampleCountFlags framebufferColorSampleCounts;
4638     VkSampleCountFlags framebufferDepthSampleCounts;
4639     VkSampleCountFlags framebufferStencilSampleCounts;
4640     VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
4641     uint32_t maxColorAttachments;
4642     VkSampleCountFlags sampledImageColorSampleCounts;
4643     VkSampleCountFlags sampledImageIntegerSampleCounts;
4644     VkSampleCountFlags sampledImageDepthSampleCounts;
4645     VkSampleCountFlags sampledImageStencilSampleCounts;
4646     VkSampleCountFlags storageImageSampleCounts;
4647     uint32_t maxSampleMaskWords;
4648     VkBool32 timestampComputeAndGraphics;
4649     float timestampPeriod;
4650     uint32_t maxClipDistances;
4651     uint32_t maxCullDistances;
4652     uint32_t maxCombinedClipAndCullDistances;
4653     uint32_t discreteQueuePriorities;
4654     float pointSizeRange[2];
4655     float lineWidthRange[2];
4656     float pointSizeGranularity;
4657     float lineWidthGranularity;
4658     VkBool32 strictLines;
4659     VkBool32 standardSampleLocations;
4660     VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyOffsetAlignment;
4661     VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyRowPitchAlignment;
4662     VkDeviceSize DECLSPEC_ALIGN(8) nonCoherentAtomSize;
4663 } VkPhysicalDeviceLimits32;
4664
4665 typedef struct VkPhysicalDeviceProperties32
4666 {
4667     uint32_t apiVersion;
4668     uint32_t driverVersion;
4669     uint32_t vendorID;
4670     uint32_t deviceID;
4671     VkPhysicalDeviceType deviceType;
4672     char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
4673     uint8_t pipelineCacheUUID[VK_UUID_SIZE];
4674     VkPhysicalDeviceLimits32 DECLSPEC_ALIGN(8) limits;
4675     VkPhysicalDeviceSparseProperties sparseProperties;
4676 } VkPhysicalDeviceProperties32;
4677
4678 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32
4679 {
4680     VkStructureType sType;
4681     PTR32 pNext;
4682     uint32_t maxGraphicsShaderGroupCount;
4683     uint32_t maxIndirectSequenceCount;
4684     uint32_t maxIndirectCommandsTokenCount;
4685     uint32_t maxIndirectCommandsStreamCount;
4686     uint32_t maxIndirectCommandsTokenOffset;
4687     uint32_t maxIndirectCommandsStreamStride;
4688     uint32_t minSequencesCountBufferOffsetAlignment;
4689     uint32_t minSequencesIndexBufferOffsetAlignment;
4690     uint32_t minIndirectCommandsBufferOffsetAlignment;
4691 } VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32;
4692
4693 typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT32
4694 {
4695     VkStructureType sType;
4696     PTR32 pNext;
4697     uint32_t maxMultiDrawCount;
4698 } VkPhysicalDeviceMultiDrawPropertiesEXT32;
4699
4700 typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR32
4701 {
4702     VkStructureType sType;
4703     PTR32 pNext;
4704     uint32_t maxPushDescriptors;
4705 } VkPhysicalDevicePushDescriptorPropertiesKHR32;
4706
4707 typedef struct VkPhysicalDeviceDriverProperties32
4708 {
4709     VkStructureType sType;
4710     PTR32 pNext;
4711     VkDriverId driverID;
4712     char driverName[VK_MAX_DRIVER_NAME_SIZE];
4713     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
4714     VkConformanceVersion conformanceVersion;
4715 } VkPhysicalDeviceDriverProperties32;
4716 typedef VkPhysicalDeviceDriverProperties32 VkPhysicalDeviceDriverPropertiesKHR32;
4717
4718 typedef struct VkPhysicalDeviceIDProperties32
4719 {
4720     VkStructureType sType;
4721     PTR32 pNext;
4722     uint8_t deviceUUID[VK_UUID_SIZE];
4723     uint8_t driverUUID[VK_UUID_SIZE];
4724     uint8_t deviceLUID[VK_LUID_SIZE];
4725     uint32_t deviceNodeMask;
4726     VkBool32 deviceLUIDValid;
4727 } VkPhysicalDeviceIDProperties32;
4728 typedef VkPhysicalDeviceIDProperties32 VkPhysicalDeviceIDPropertiesKHR32;
4729
4730 typedef struct VkPhysicalDeviceMultiviewProperties32
4731 {
4732     VkStructureType sType;
4733     PTR32 pNext;
4734     uint32_t maxMultiviewViewCount;
4735     uint32_t maxMultiviewInstanceIndex;
4736 } VkPhysicalDeviceMultiviewProperties32;
4737 typedef VkPhysicalDeviceMultiviewProperties32 VkPhysicalDeviceMultiviewPropertiesKHR32;
4738
4739 typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT32
4740 {
4741     VkStructureType sType;
4742     PTR32 pNext;
4743     uint32_t maxDiscardRectangles;
4744 } VkPhysicalDeviceDiscardRectanglePropertiesEXT32;
4745
4746 typedef struct VkPhysicalDeviceSubgroupProperties32
4747 {
4748     VkStructureType sType;
4749     PTR32 pNext;
4750     uint32_t subgroupSize;
4751     VkShaderStageFlags supportedStages;
4752     VkSubgroupFeatureFlags supportedOperations;
4753     VkBool32 quadOperationsInAllStages;
4754 } VkPhysicalDeviceSubgroupProperties32;
4755
4756 typedef struct VkPhysicalDevicePointClippingProperties32
4757 {
4758     VkStructureType sType;
4759     PTR32 pNext;
4760     VkPointClippingBehavior pointClippingBehavior;
4761 } VkPhysicalDevicePointClippingProperties32;
4762 typedef VkPhysicalDevicePointClippingProperties32 VkPhysicalDevicePointClippingPropertiesKHR32;
4763
4764 typedef struct VkPhysicalDeviceProtectedMemoryProperties32
4765 {
4766     VkStructureType sType;
4767     PTR32 pNext;
4768     VkBool32 protectedNoFault;
4769 } VkPhysicalDeviceProtectedMemoryProperties32;
4770
4771 typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties32
4772 {
4773     VkStructureType sType;
4774     PTR32 pNext;
4775     VkBool32 filterMinmaxSingleComponentFormats;
4776     VkBool32 filterMinmaxImageComponentMapping;
4777 } VkPhysicalDeviceSamplerFilterMinmaxProperties32;
4778 typedef VkPhysicalDeviceSamplerFilterMinmaxProperties32 VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT32;
4779
4780 typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT32
4781 {
4782     VkStructureType sType;
4783     PTR32 pNext;
4784     VkSampleCountFlags sampleLocationSampleCounts;
4785     VkExtent2D maxSampleLocationGridSize;
4786     float sampleLocationCoordinateRange[2];
4787     uint32_t sampleLocationSubPixelBits;
4788     VkBool32 variableSampleLocations;
4789 } VkPhysicalDeviceSampleLocationsPropertiesEXT32;
4790
4791 typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32
4792 {
4793     VkStructureType sType;
4794     PTR32 pNext;
4795     uint32_t advancedBlendMaxColorAttachments;
4796     VkBool32 advancedBlendIndependentBlend;
4797     VkBool32 advancedBlendNonPremultipliedSrcColor;
4798     VkBool32 advancedBlendNonPremultipliedDstColor;
4799     VkBool32 advancedBlendCorrelatedOverlap;
4800     VkBool32 advancedBlendAllOperations;
4801 } VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32;
4802
4803 typedef struct VkPhysicalDeviceInlineUniformBlockProperties32
4804 {
4805     VkStructureType sType;
4806     PTR32 pNext;
4807     uint32_t maxInlineUniformBlockSize;
4808     uint32_t maxPerStageDescriptorInlineUniformBlocks;
4809     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
4810     uint32_t maxDescriptorSetInlineUniformBlocks;
4811     uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
4812 } VkPhysicalDeviceInlineUniformBlockProperties32;
4813 typedef VkPhysicalDeviceInlineUniformBlockProperties32 VkPhysicalDeviceInlineUniformBlockPropertiesEXT32;
4814
4815 typedef struct VkPhysicalDeviceMaintenance3Properties32
4816 {
4817     VkStructureType sType;
4818     PTR32 pNext;
4819     uint32_t maxPerSetDescriptors;
4820     VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
4821 } VkPhysicalDeviceMaintenance3Properties32;
4822 typedef VkPhysicalDeviceMaintenance3Properties32 VkPhysicalDeviceMaintenance3PropertiesKHR32;
4823
4824 typedef struct VkPhysicalDeviceMaintenance4Properties32
4825 {
4826     VkStructureType sType;
4827     PTR32 pNext;
4828     VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
4829 } VkPhysicalDeviceMaintenance4Properties32;
4830 typedef VkPhysicalDeviceMaintenance4Properties32 VkPhysicalDeviceMaintenance4PropertiesKHR32;
4831
4832 typedef struct VkPhysicalDeviceFloatControlsProperties32
4833 {
4834     VkStructureType sType;
4835     PTR32 pNext;
4836     VkShaderFloatControlsIndependence denormBehaviorIndependence;
4837     VkShaderFloatControlsIndependence roundingModeIndependence;
4838     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
4839     VkBool32 shaderSignedZeroInfNanPreserveFloat32;
4840     VkBool32 shaderSignedZeroInfNanPreserveFloat64;
4841     VkBool32 shaderDenormPreserveFloat16;
4842     VkBool32 shaderDenormPreserveFloat32;
4843     VkBool32 shaderDenormPreserveFloat64;
4844     VkBool32 shaderDenormFlushToZeroFloat16;
4845     VkBool32 shaderDenormFlushToZeroFloat32;
4846     VkBool32 shaderDenormFlushToZeroFloat64;
4847     VkBool32 shaderRoundingModeRTEFloat16;
4848     VkBool32 shaderRoundingModeRTEFloat32;
4849     VkBool32 shaderRoundingModeRTEFloat64;
4850     VkBool32 shaderRoundingModeRTZFloat16;
4851     VkBool32 shaderRoundingModeRTZFloat32;
4852     VkBool32 shaderRoundingModeRTZFloat64;
4853 } VkPhysicalDeviceFloatControlsProperties32;
4854 typedef VkPhysicalDeviceFloatControlsProperties32 VkPhysicalDeviceFloatControlsPropertiesKHR32;
4855
4856 typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT32
4857 {
4858     VkStructureType sType;
4859     PTR32 pNext;
4860     VkDeviceSize DECLSPEC_ALIGN(8) minImportedHostPointerAlignment;
4861 } VkPhysicalDeviceExternalMemoryHostPropertiesEXT32;
4862
4863 typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT32
4864 {
4865     VkStructureType sType;
4866     PTR32 pNext;
4867     float primitiveOverestimationSize;
4868     float maxExtraPrimitiveOverestimationSize;
4869     float extraPrimitiveOverestimationSizeGranularity;
4870     VkBool32 primitiveUnderestimation;
4871     VkBool32 conservativePointAndLineRasterization;
4872     VkBool32 degenerateTrianglesRasterized;
4873     VkBool32 degenerateLinesRasterized;
4874     VkBool32 fullyCoveredFragmentShaderInputVariable;
4875     VkBool32 conservativeRasterizationPostDepthCoverage;
4876 } VkPhysicalDeviceConservativeRasterizationPropertiesEXT32;
4877
4878 typedef struct VkPhysicalDeviceShaderCorePropertiesAMD32
4879 {
4880     VkStructureType sType;
4881     PTR32 pNext;
4882     uint32_t shaderEngineCount;
4883     uint32_t shaderArraysPerEngineCount;
4884     uint32_t computeUnitsPerShaderArray;
4885     uint32_t simdPerComputeUnit;
4886     uint32_t wavefrontsPerSimd;
4887     uint32_t wavefrontSize;
4888     uint32_t sgprsPerSimd;
4889     uint32_t minSgprAllocation;
4890     uint32_t maxSgprAllocation;
4891     uint32_t sgprAllocationGranularity;
4892     uint32_t vgprsPerSimd;
4893     uint32_t minVgprAllocation;
4894     uint32_t maxVgprAllocation;
4895     uint32_t vgprAllocationGranularity;
4896 } VkPhysicalDeviceShaderCorePropertiesAMD32;
4897
4898 typedef struct VkPhysicalDeviceShaderCoreProperties2AMD32
4899 {
4900     VkStructureType sType;
4901     PTR32 pNext;
4902     VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;
4903     uint32_t activeComputeUnitCount;
4904 } VkPhysicalDeviceShaderCoreProperties2AMD32;
4905
4906 typedef struct VkPhysicalDeviceDescriptorIndexingProperties32
4907 {
4908     VkStructureType sType;
4909     PTR32 pNext;
4910     uint32_t maxUpdateAfterBindDescriptorsInAllPools;
4911     VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
4912     VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
4913     VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
4914     VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
4915     VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
4916     VkBool32 robustBufferAccessUpdateAfterBind;
4917     VkBool32 quadDivergentImplicitLod;
4918     uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
4919     uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
4920     uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
4921     uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
4922     uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
4923     uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
4924     uint32_t maxPerStageUpdateAfterBindResources;
4925     uint32_t maxDescriptorSetUpdateAfterBindSamplers;
4926     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
4927     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
4928     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
4929     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
4930     uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
4931     uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
4932     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
4933 } VkPhysicalDeviceDescriptorIndexingProperties32;
4934 typedef VkPhysicalDeviceDescriptorIndexingProperties32 VkPhysicalDeviceDescriptorIndexingPropertiesEXT32;
4935
4936 typedef struct VkPhysicalDeviceTimelineSemaphoreProperties32
4937 {
4938     VkStructureType sType;
4939     PTR32 pNext;
4940     uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
4941 } VkPhysicalDeviceTimelineSemaphoreProperties32;
4942 typedef VkPhysicalDeviceTimelineSemaphoreProperties32 VkPhysicalDeviceTimelineSemaphorePropertiesKHR32;
4943
4944 typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32
4945 {
4946     VkStructureType sType;
4947     PTR32 pNext;
4948     uint32_t maxVertexAttribDivisor;
4949 } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32;
4950
4951 typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT32
4952 {
4953     VkStructureType sType;
4954     PTR32 pNext;
4955     uint32_t pciDomain;
4956     uint32_t pciBus;
4957     uint32_t pciDevice;
4958     uint32_t pciFunction;
4959 } VkPhysicalDevicePCIBusInfoPropertiesEXT32;
4960
4961 typedef struct VkPhysicalDeviceDepthStencilResolveProperties32
4962 {
4963     VkStructureType sType;
4964     PTR32 pNext;
4965     VkResolveModeFlags supportedDepthResolveModes;
4966     VkResolveModeFlags supportedStencilResolveModes;
4967     VkBool32 independentResolveNone;
4968     VkBool32 independentResolve;
4969 } VkPhysicalDeviceDepthStencilResolveProperties32;
4970 typedef VkPhysicalDeviceDepthStencilResolveProperties32 VkPhysicalDeviceDepthStencilResolvePropertiesKHR32;
4971
4972 typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT32
4973 {
4974     VkStructureType sType;
4975     PTR32 pNext;
4976     uint32_t maxTransformFeedbackStreams;
4977     uint32_t maxTransformFeedbackBuffers;
4978     VkDeviceSize DECLSPEC_ALIGN(8) maxTransformFeedbackBufferSize;
4979     uint32_t maxTransformFeedbackStreamDataSize;
4980     uint32_t maxTransformFeedbackBufferDataSize;
4981     uint32_t maxTransformFeedbackBufferDataStride;
4982     VkBool32 transformFeedbackQueries;
4983     VkBool32 transformFeedbackStreamsLinesTriangles;
4984     VkBool32 transformFeedbackRasterizationStreamSelect;
4985     VkBool32 transformFeedbackDraw;
4986 } VkPhysicalDeviceTransformFeedbackPropertiesEXT32;
4987
4988 typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32
4989 {
4990     VkStructureType sType;
4991     PTR32 pNext;
4992     VkQueueFlags supportedQueues;
4993 } VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32;
4994
4995 typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV32
4996 {
4997     VkStructureType sType;
4998     PTR32 pNext;
4999     VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethods;
5000     uint64_t DECLSPEC_ALIGN(8) maxDecompressionIndirectCount;
5001 } VkPhysicalDeviceMemoryDecompressionPropertiesNV32;
5002
5003 typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV32
5004 {
5005     VkStructureType sType;
5006     PTR32 pNext;
5007     VkExtent2D shadingRateTexelSize;
5008     uint32_t shadingRatePaletteSize;
5009     uint32_t shadingRateMaxCoarseSamples;
5010 } VkPhysicalDeviceShadingRateImagePropertiesNV32;
5011
5012 typedef struct VkPhysicalDeviceMeshShaderPropertiesNV32
5013 {
5014     VkStructureType sType;
5015     PTR32 pNext;
5016     uint32_t maxDrawMeshTasksCount;
5017     uint32_t maxTaskWorkGroupInvocations;
5018     uint32_t maxTaskWorkGroupSize[3];
5019     uint32_t maxTaskTotalMemorySize;
5020     uint32_t maxTaskOutputCount;
5021     uint32_t maxMeshWorkGroupInvocations;
5022     uint32_t maxMeshWorkGroupSize[3];
5023     uint32_t maxMeshTotalMemorySize;
5024     uint32_t maxMeshOutputVertices;
5025     uint32_t maxMeshOutputPrimitives;
5026     uint32_t maxMeshMultiviewViewCount;
5027     uint32_t meshOutputPerVertexGranularity;
5028     uint32_t meshOutputPerPrimitiveGranularity;
5029 } VkPhysicalDeviceMeshShaderPropertiesNV32;
5030
5031 typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT32
5032 {
5033     VkStructureType sType;
5034     PTR32 pNext;
5035     uint32_t maxTaskWorkGroupTotalCount;
5036     uint32_t maxTaskWorkGroupCount[3];
5037     uint32_t maxTaskWorkGroupInvocations;
5038     uint32_t maxTaskWorkGroupSize[3];
5039     uint32_t maxTaskPayloadSize;
5040     uint32_t maxTaskSharedMemorySize;
5041     uint32_t maxTaskPayloadAndSharedMemorySize;
5042     uint32_t maxMeshWorkGroupTotalCount;
5043     uint32_t maxMeshWorkGroupCount[3];
5044     uint32_t maxMeshWorkGroupInvocations;
5045     uint32_t maxMeshWorkGroupSize[3];
5046     uint32_t maxMeshSharedMemorySize;
5047     uint32_t maxMeshPayloadAndSharedMemorySize;
5048     uint32_t maxMeshOutputMemorySize;
5049     uint32_t maxMeshPayloadAndOutputMemorySize;
5050     uint32_t maxMeshOutputComponents;
5051     uint32_t maxMeshOutputVertices;
5052     uint32_t maxMeshOutputPrimitives;
5053     uint32_t maxMeshOutputLayers;
5054     uint32_t maxMeshMultiviewViewCount;
5055     uint32_t meshOutputPerVertexGranularity;
5056     uint32_t meshOutputPerPrimitiveGranularity;
5057     uint32_t maxPreferredTaskWorkGroupInvocations;
5058     uint32_t maxPreferredMeshWorkGroupInvocations;
5059     VkBool32 prefersLocalInvocationVertexOutput;
5060     VkBool32 prefersLocalInvocationPrimitiveOutput;
5061     VkBool32 prefersCompactVertexOutput;
5062     VkBool32 prefersCompactPrimitiveOutput;
5063 } VkPhysicalDeviceMeshShaderPropertiesEXT32;
5064
5065 typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR32
5066 {
5067     VkStructureType sType;
5068     PTR32 pNext;
5069     uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
5070     uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
5071     uint64_t DECLSPEC_ALIGN(8) maxPrimitiveCount;
5072     uint32_t maxPerStageDescriptorAccelerationStructures;
5073     uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
5074     uint32_t maxDescriptorSetAccelerationStructures;
5075     uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures;
5076     uint32_t minAccelerationStructureScratchOffsetAlignment;
5077 } VkPhysicalDeviceAccelerationStructurePropertiesKHR32;
5078
5079 typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR32
5080 {
5081     VkStructureType sType;
5082     PTR32 pNext;
5083     uint32_t shaderGroupHandleSize;
5084     uint32_t maxRayRecursionDepth;
5085     uint32_t maxShaderGroupStride;
5086     uint32_t shaderGroupBaseAlignment;
5087     uint32_t shaderGroupHandleCaptureReplaySize;
5088     uint32_t maxRayDispatchInvocationCount;
5089     uint32_t shaderGroupHandleAlignment;
5090     uint32_t maxRayHitAttributeSize;
5091 } VkPhysicalDeviceRayTracingPipelinePropertiesKHR32;
5092
5093 typedef struct VkPhysicalDeviceRayTracingPropertiesNV32
5094 {
5095     VkStructureType sType;
5096     PTR32 pNext;
5097     uint32_t shaderGroupHandleSize;
5098     uint32_t maxRecursionDepth;
5099     uint32_t maxShaderGroupStride;
5100     uint32_t shaderGroupBaseAlignment;
5101     uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
5102     uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
5103     uint64_t DECLSPEC_ALIGN(8) maxTriangleCount;
5104     uint32_t maxDescriptorSetAccelerationStructures;
5105 } VkPhysicalDeviceRayTracingPropertiesNV32;
5106
5107 typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT32
5108 {
5109     VkStructureType sType;
5110     PTR32 pNext;
5111     VkExtent2D minFragmentDensityTexelSize;
5112     VkExtent2D maxFragmentDensityTexelSize;
5113     VkBool32 fragmentDensityInvocations;
5114 } VkPhysicalDeviceFragmentDensityMapPropertiesEXT32;
5115
5116 typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32
5117 {
5118     VkStructureType sType;
5119     PTR32 pNext;
5120     VkBool32 subsampledLoads;
5121     VkBool32 subsampledCoarseReconstructionEarlyAccess;
5122     uint32_t maxSubsampledArrayLayers;
5123     uint32_t maxDescriptorSetSubsampledSamplers;
5124 } VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32;
5125
5126 typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32
5127 {
5128     VkStructureType sType;
5129     PTR32 pNext;
5130     VkExtent2D fragmentDensityOffsetGranularity;
5131 } VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32;
5132
5133 typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV32
5134 {
5135     VkStructureType sType;
5136     PTR32 pNext;
5137     VkShaderStageFlags cooperativeMatrixSupportedStages;
5138 } VkPhysicalDeviceCooperativeMatrixPropertiesNV32;
5139
5140 typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR32
5141 {
5142     VkStructureType sType;
5143     PTR32 pNext;
5144     VkBool32 allowCommandBufferQueryCopies;
5145 } VkPhysicalDevicePerformanceQueryPropertiesKHR32;
5146
5147 typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32
5148 {
5149     VkStructureType sType;
5150     PTR32 pNext;
5151     uint32_t shaderSMCount;
5152     uint32_t shaderWarpsPerSM;
5153 } VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32;
5154
5155 typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties32
5156 {
5157     VkStructureType sType;
5158     PTR32 pNext;
5159     VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
5160     VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
5161     VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
5162     VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
5163 } VkPhysicalDeviceTexelBufferAlignmentProperties32;
5164 typedef VkPhysicalDeviceTexelBufferAlignmentProperties32 VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT32;
5165
5166 typedef struct VkPhysicalDeviceSubgroupSizeControlProperties32
5167 {
5168     VkStructureType sType;
5169     PTR32 pNext;
5170     uint32_t minSubgroupSize;
5171     uint32_t maxSubgroupSize;
5172     uint32_t maxComputeWorkgroupSubgroups;
5173     VkShaderStageFlags requiredSubgroupSizeStages;
5174 } VkPhysicalDeviceSubgroupSizeControlProperties32;
5175 typedef VkPhysicalDeviceSubgroupSizeControlProperties32 VkPhysicalDeviceSubgroupSizeControlPropertiesEXT32;
5176
5177 typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32
5178 {
5179     VkStructureType sType;
5180     PTR32 pNext;
5181     uint32_t maxSubpassShadingWorkgroupSizeAspectRatio;
5182 } VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32;
5183
5184 typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT32
5185 {
5186     VkStructureType sType;
5187     PTR32 pNext;
5188     uint32_t lineSubPixelPrecisionBits;
5189 } VkPhysicalDeviceLineRasterizationPropertiesEXT32;
5190
5191 typedef struct VkPhysicalDeviceVulkan11Properties32
5192 {
5193     VkStructureType sType;
5194     PTR32 pNext;
5195     uint8_t deviceUUID[VK_UUID_SIZE];
5196     uint8_t driverUUID[VK_UUID_SIZE];
5197     uint8_t deviceLUID[VK_LUID_SIZE];
5198     uint32_t deviceNodeMask;
5199     VkBool32 deviceLUIDValid;
5200     uint32_t subgroupSize;
5201     VkShaderStageFlags subgroupSupportedStages;
5202     VkSubgroupFeatureFlags subgroupSupportedOperations;
5203     VkBool32 subgroupQuadOperationsInAllStages;
5204     VkPointClippingBehavior pointClippingBehavior;
5205     uint32_t maxMultiviewViewCount;
5206     uint32_t maxMultiviewInstanceIndex;
5207     VkBool32 protectedNoFault;
5208     uint32_t maxPerSetDescriptors;
5209     VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
5210 } VkPhysicalDeviceVulkan11Properties32;
5211
5212 typedef struct VkPhysicalDeviceVulkan12Properties32
5213 {
5214     VkStructureType sType;
5215     PTR32 pNext;
5216     VkDriverId driverID;
5217     char driverName[VK_MAX_DRIVER_NAME_SIZE];
5218     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
5219     VkConformanceVersion conformanceVersion;
5220     VkShaderFloatControlsIndependence denormBehaviorIndependence;
5221     VkShaderFloatControlsIndependence roundingModeIndependence;
5222     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
5223     VkBool32 shaderSignedZeroInfNanPreserveFloat32;
5224     VkBool32 shaderSignedZeroInfNanPreserveFloat64;
5225     VkBool32 shaderDenormPreserveFloat16;
5226     VkBool32 shaderDenormPreserveFloat32;
5227     VkBool32 shaderDenormPreserveFloat64;
5228     VkBool32 shaderDenormFlushToZeroFloat16;
5229     VkBool32 shaderDenormFlushToZeroFloat32;
5230     VkBool32 shaderDenormFlushToZeroFloat64;
5231     VkBool32 shaderRoundingModeRTEFloat16;
5232     VkBool32 shaderRoundingModeRTEFloat32;
5233     VkBool32 shaderRoundingModeRTEFloat64;
5234     VkBool32 shaderRoundingModeRTZFloat16;
5235     VkBool32 shaderRoundingModeRTZFloat32;
5236     VkBool32 shaderRoundingModeRTZFloat64;
5237     uint32_t maxUpdateAfterBindDescriptorsInAllPools;
5238     VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
5239     VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
5240     VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
5241     VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
5242     VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
5243     VkBool32 robustBufferAccessUpdateAfterBind;
5244     VkBool32 quadDivergentImplicitLod;
5245     uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
5246     uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
5247     uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
5248     uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
5249     uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
5250     uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
5251     uint32_t maxPerStageUpdateAfterBindResources;
5252     uint32_t maxDescriptorSetUpdateAfterBindSamplers;
5253     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
5254     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
5255     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
5256     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
5257     uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
5258     uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
5259     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
5260     VkResolveModeFlags supportedDepthResolveModes;
5261     VkResolveModeFlags supportedStencilResolveModes;
5262     VkBool32 independentResolveNone;
5263     VkBool32 independentResolve;
5264     VkBool32 filterMinmaxSingleComponentFormats;
5265     VkBool32 filterMinmaxImageComponentMapping;
5266     uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
5267     VkSampleCountFlags framebufferIntegerColorSampleCounts;
5268 } VkPhysicalDeviceVulkan12Properties32;
5269
5270 typedef struct VkPhysicalDeviceVulkan13Properties32
5271 {
5272     VkStructureType sType;
5273     PTR32 pNext;
5274     uint32_t minSubgroupSize;
5275     uint32_t maxSubgroupSize;
5276     uint32_t maxComputeWorkgroupSubgroups;
5277     VkShaderStageFlags requiredSubgroupSizeStages;
5278     uint32_t maxInlineUniformBlockSize;
5279     uint32_t maxPerStageDescriptorInlineUniformBlocks;
5280     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
5281     uint32_t maxDescriptorSetInlineUniformBlocks;
5282     uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
5283     uint32_t maxInlineUniformTotalSize;
5284     VkBool32 integerDotProduct8BitUnsignedAccelerated;
5285     VkBool32 integerDotProduct8BitSignedAccelerated;
5286     VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
5287     VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
5288     VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
5289     VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
5290     VkBool32 integerDotProduct16BitUnsignedAccelerated;
5291     VkBool32 integerDotProduct16BitSignedAccelerated;
5292     VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
5293     VkBool32 integerDotProduct32BitUnsignedAccelerated;
5294     VkBool32 integerDotProduct32BitSignedAccelerated;
5295     VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
5296     VkBool32 integerDotProduct64BitUnsignedAccelerated;
5297     VkBool32 integerDotProduct64BitSignedAccelerated;
5298     VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
5299     VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
5300     VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
5301     VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
5302     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
5303     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
5304     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
5305     VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
5306     VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
5307     VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
5308     VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
5309     VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
5310     VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
5311     VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
5312     VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
5313     VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
5314     VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
5315     VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
5316     VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
5317     VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
5318     VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
5319 } VkPhysicalDeviceVulkan13Properties32;
5320
5321 typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT32
5322 {
5323     VkStructureType sType;
5324     PTR32 pNext;
5325     uint32_t maxCustomBorderColorSamplers;
5326 } VkPhysicalDeviceCustomBorderColorPropertiesEXT32;
5327
5328 typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32
5329 {
5330     VkStructureType sType;
5331     PTR32 pNext;
5332     VkBool32 dynamicPrimitiveTopologyUnrestricted;
5333 } VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32;
5334
5335 typedef struct VkPhysicalDeviceRobustness2PropertiesEXT32
5336 {
5337     VkStructureType sType;
5338     PTR32 pNext;
5339     VkDeviceSize DECLSPEC_ALIGN(8) robustStorageBufferAccessSizeAlignment;
5340     VkDeviceSize DECLSPEC_ALIGN(8) robustUniformBufferAccessSizeAlignment;
5341 } VkPhysicalDeviceRobustness2PropertiesEXT32;
5342
5343 typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR32
5344 {
5345     VkStructureType sType;
5346     PTR32 pNext;
5347     VkExtent2D minFragmentShadingRateAttachmentTexelSize;
5348     VkExtent2D maxFragmentShadingRateAttachmentTexelSize;
5349     uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
5350     VkBool32 primitiveFragmentShadingRateWithMultipleViewports;
5351     VkBool32 layeredShadingRateAttachments;
5352     VkBool32 fragmentShadingRateNonTrivialCombinerOps;
5353     VkExtent2D maxFragmentSize;
5354     uint32_t maxFragmentSizeAspectRatio;
5355     uint32_t maxFragmentShadingRateCoverageSamples;
5356     VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples;
5357     VkBool32 fragmentShadingRateWithShaderDepthStencilWrites;
5358     VkBool32 fragmentShadingRateWithSampleMask;
5359     VkBool32 fragmentShadingRateWithShaderSampleMask;
5360     VkBool32 fragmentShadingRateWithConservativeRasterization;
5361     VkBool32 fragmentShadingRateWithFragmentShaderInterlock;
5362     VkBool32 fragmentShadingRateWithCustomSampleLocations;
5363     VkBool32 fragmentShadingRateStrictMultiplyCombiner;
5364 } VkPhysicalDeviceFragmentShadingRatePropertiesKHR32;
5365
5366 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32
5367 {
5368     VkStructureType sType;
5369     PTR32 pNext;
5370     VkSampleCountFlagBits maxFragmentShadingRateInvocationCount;
5371 } VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32;
5372
5373 typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT32
5374 {
5375     VkStructureType sType;
5376     PTR32 pNext;
5377     VkBool32 provokingVertexModePerPipeline;
5378     VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex;
5379 } VkPhysicalDeviceProvokingVertexPropertiesEXT32;
5380
5381 typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT32
5382 {
5383     VkStructureType sType;
5384     PTR32 pNext;
5385     VkBool32 combinedImageSamplerDescriptorSingleArray;
5386     VkBool32 bufferlessPushDescriptors;
5387     VkBool32 allowSamplerImageViewPostSubmitCreation;
5388     VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferOffsetAlignment;
5389     uint32_t maxDescriptorBufferBindings;
5390     uint32_t maxResourceDescriptorBufferBindings;
5391     uint32_t maxSamplerDescriptorBufferBindings;
5392     uint32_t maxEmbeddedImmutableSamplerBindings;
5393     uint32_t maxEmbeddedImmutableSamplers;
5394     PTR32 bufferCaptureReplayDescriptorDataSize;
5395     PTR32 imageCaptureReplayDescriptorDataSize;
5396     PTR32 imageViewCaptureReplayDescriptorDataSize;
5397     PTR32 samplerCaptureReplayDescriptorDataSize;
5398     PTR32 accelerationStructureCaptureReplayDescriptorDataSize;
5399     PTR32 samplerDescriptorSize;
5400     PTR32 combinedImageSamplerDescriptorSize;
5401     PTR32 sampledImageDescriptorSize;
5402     PTR32 storageImageDescriptorSize;
5403     PTR32 uniformTexelBufferDescriptorSize;
5404     PTR32 robustUniformTexelBufferDescriptorSize;
5405     PTR32 storageTexelBufferDescriptorSize;
5406     PTR32 robustStorageTexelBufferDescriptorSize;
5407     PTR32 uniformBufferDescriptorSize;
5408     PTR32 robustUniformBufferDescriptorSize;
5409     PTR32 storageBufferDescriptorSize;
5410     PTR32 robustStorageBufferDescriptorSize;
5411     PTR32 inputAttachmentDescriptorSize;
5412     PTR32 accelerationStructureDescriptorSize;
5413     VkDeviceSize DECLSPEC_ALIGN(8) maxSamplerDescriptorBufferRange;
5414     VkDeviceSize DECLSPEC_ALIGN(8) maxResourceDescriptorBufferRange;
5415     VkDeviceSize DECLSPEC_ALIGN(8) samplerDescriptorBufferAddressSpaceSize;
5416     VkDeviceSize DECLSPEC_ALIGN(8) resourceDescriptorBufferAddressSpaceSize;
5417     VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferAddressSpaceSize;
5418 } VkPhysicalDeviceDescriptorBufferPropertiesEXT32;
5419
5420 typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32
5421 {
5422     VkStructureType sType;
5423     PTR32 pNext;
5424     PTR32 combinedImageSamplerDensityMapDescriptorSize;
5425 } VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32;
5426
5427 typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties32
5428 {
5429     VkStructureType sType;
5430     PTR32 pNext;
5431     VkBool32 integerDotProduct8BitUnsignedAccelerated;
5432     VkBool32 integerDotProduct8BitSignedAccelerated;
5433     VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
5434     VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
5435     VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
5436     VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
5437     VkBool32 integerDotProduct16BitUnsignedAccelerated;
5438     VkBool32 integerDotProduct16BitSignedAccelerated;
5439     VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
5440     VkBool32 integerDotProduct32BitUnsignedAccelerated;
5441     VkBool32 integerDotProduct32BitSignedAccelerated;
5442     VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
5443     VkBool32 integerDotProduct64BitUnsignedAccelerated;
5444     VkBool32 integerDotProduct64BitSignedAccelerated;
5445     VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
5446     VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
5447     VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
5448     VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
5449     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
5450     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
5451     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
5452     VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
5453     VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
5454     VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
5455     VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
5456     VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
5457     VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
5458     VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
5459     VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
5460     VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
5461 } VkPhysicalDeviceShaderIntegerDotProductProperties32;
5462 typedef VkPhysicalDeviceShaderIntegerDotProductProperties32 VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR32;
5463
5464 typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32
5465 {
5466     VkStructureType sType;
5467     PTR32 pNext;
5468     VkBool32 triStripVertexOrderIndependentOfProvokingVertex;
5469 } VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32;
5470
5471 typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32
5472 {
5473     VkStructureType sType;
5474     PTR32 pNext;
5475     VkBool32 graphicsPipelineLibraryFastLinking;
5476     VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration;
5477 } VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32;
5478
5479 typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32
5480 {
5481     VkStructureType sType;
5482     PTR32 pNext;
5483     uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE];
5484 } VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32;
5485
5486 typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT32
5487 {
5488     VkStructureType sType;
5489     PTR32 pNext;
5490     uint32_t maxOpacity2StateSubdivisionLevel;
5491     uint32_t maxOpacity4StateSubdivisionLevel;
5492 } VkPhysicalDeviceOpacityMicromapPropertiesEXT32;
5493
5494 typedef struct VkPhysicalDevicePipelineRobustnessPropertiesEXT32
5495 {
5496     VkStructureType sType;
5497     PTR32 pNext;
5498     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers;
5499     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers;
5500     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs;
5501     VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages;
5502 } VkPhysicalDevicePipelineRobustnessPropertiesEXT32;
5503
5504 typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM32
5505 {
5506     VkStructureType sType;
5507     PTR32 pNext;
5508     uint32_t maxWeightFilterPhases;
5509     VkExtent2D maxWeightFilterDimension;
5510     VkExtent2D maxBlockMatchRegion;
5511     VkExtent2D maxBoxFilterBlockSize;
5512 } VkPhysicalDeviceImageProcessingPropertiesQCOM32;
5513
5514 typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV32
5515 {
5516     VkStructureType sType;
5517     PTR32 pNext;
5518     VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes;
5519     VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes;
5520     VkBool32 hintSupported;
5521     VkBool32 costSupported;
5522     VkBool32 bidirectionalFlowSupported;
5523     VkBool32 globalFlowSupported;
5524     uint32_t minWidth;
5525     uint32_t minHeight;
5526     uint32_t maxWidth;
5527     uint32_t maxHeight;
5528     uint32_t maxNumRegionsOfInterest;
5529 } VkPhysicalDeviceOpticalFlowPropertiesNV32;
5530
5531 typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32
5532 {
5533     VkStructureType sType;
5534     PTR32 pNext;
5535     uint64_t DECLSPEC_ALIGN(8) shaderCoreMask;
5536     uint32_t shaderCoreCount;
5537     uint32_t shaderWarpsPerCore;
5538 } VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32;
5539
5540 typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32
5541 {
5542     VkStructureType sType;
5543     PTR32 pNext;
5544     VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint;
5545 } VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32;
5546
5547 typedef struct VkPhysicalDeviceProperties232
5548 {
5549     VkStructureType sType;
5550     PTR32 pNext;
5551     VkPhysicalDeviceProperties32 DECLSPEC_ALIGN(8) properties;
5552 } VkPhysicalDeviceProperties232;
5553 typedef VkPhysicalDeviceProperties232 VkPhysicalDeviceProperties2KHR32;
5554
5555 typedef struct VkQueueFamilyGlobalPriorityPropertiesKHR32
5556 {
5557     VkStructureType sType;
5558     PTR32 pNext;
5559     uint32_t priorityCount;
5560     VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR];
5561 } VkQueueFamilyGlobalPriorityPropertiesKHR32;
5562 typedef VkQueueFamilyGlobalPriorityPropertiesKHR32 VkQueueFamilyGlobalPriorityPropertiesEXT32;
5563
5564 typedef struct VkQueueFamilyCheckpointPropertiesNV32
5565 {
5566     VkStructureType sType;
5567     PTR32 pNext;
5568     VkPipelineStageFlags checkpointExecutionStageMask;
5569 } VkQueueFamilyCheckpointPropertiesNV32;
5570
5571 typedef struct VkQueueFamilyCheckpointProperties2NV32
5572 {
5573     VkStructureType sType;
5574     PTR32 pNext;
5575     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) checkpointExecutionStageMask;
5576 } VkQueueFamilyCheckpointProperties2NV32;
5577
5578 typedef struct VkQueueFamilyProperties232
5579 {
5580     VkStructureType sType;
5581     PTR32 pNext;
5582     VkQueueFamilyProperties queueFamilyProperties;
5583 } VkQueueFamilyProperties232;
5584 typedef VkQueueFamilyProperties232 VkQueueFamilyProperties2KHR32;
5585
5586 typedef struct VkPhysicalDeviceSparseImageFormatInfo232
5587 {
5588     VkStructureType sType;
5589     PTR32 pNext;
5590     VkFormat format;
5591     VkImageType type;
5592     VkSampleCountFlagBits samples;
5593     VkImageUsageFlags usage;
5594     VkImageTiling tiling;
5595 } VkPhysicalDeviceSparseImageFormatInfo232;
5596 typedef VkPhysicalDeviceSparseImageFormatInfo232 VkPhysicalDeviceSparseImageFormatInfo2KHR32;
5597
5598 typedef struct VkSparseImageFormatProperties232
5599 {
5600     VkStructureType sType;
5601     PTR32 pNext;
5602     VkSparseImageFormatProperties properties;
5603 } VkSparseImageFormatProperties232;
5604 typedef VkSparseImageFormatProperties232 VkSparseImageFormatProperties2KHR32;
5605
5606 typedef struct VkFramebufferMixedSamplesCombinationNV32
5607 {
5608     VkStructureType sType;
5609     PTR32 pNext;
5610     VkCoverageReductionModeNV coverageReductionMode;
5611     VkSampleCountFlagBits rasterizationSamples;
5612     VkSampleCountFlags depthStencilSamples;
5613     VkSampleCountFlags colorSamples;
5614 } VkFramebufferMixedSamplesCombinationNV32;
5615
5616 typedef struct VkPhysicalDeviceSurfaceInfo2KHR32
5617 {
5618     VkStructureType sType;
5619     PTR32 pNext;
5620     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
5621 } VkPhysicalDeviceSurfaceInfo2KHR32;
5622
5623 typedef struct VkSurfaceCapabilitiesPresentBarrierNV32
5624 {
5625     VkStructureType sType;
5626     PTR32 pNext;
5627     VkBool32 presentBarrierSupported;
5628 } VkSurfaceCapabilitiesPresentBarrierNV32;
5629
5630 typedef struct VkSurfaceCapabilities2KHR32
5631 {
5632     VkStructureType sType;
5633     PTR32 pNext;
5634     VkSurfaceCapabilitiesKHR surfaceCapabilities;
5635 } VkSurfaceCapabilities2KHR32;
5636
5637 typedef struct VkSurfaceFormat2KHR32
5638 {
5639     VkStructureType sType;
5640     PTR32 pNext;
5641     VkSurfaceFormatKHR surfaceFormat;
5642 } VkSurfaceFormat2KHR32;
5643
5644 typedef struct VkPhysicalDeviceToolProperties32
5645 {
5646     VkStructureType sType;
5647     PTR32 pNext;
5648     char name[VK_MAX_EXTENSION_NAME_SIZE];
5649     char version[VK_MAX_EXTENSION_NAME_SIZE];
5650     VkToolPurposeFlags purposes;
5651     char description[VK_MAX_DESCRIPTION_SIZE];
5652     char layer[VK_MAX_EXTENSION_NAME_SIZE];
5653 } VkPhysicalDeviceToolProperties32;
5654 typedef VkPhysicalDeviceToolProperties32 VkPhysicalDeviceToolPropertiesEXT32;
5655
5656 typedef struct VkPipelineExecutableInfoKHR32
5657 {
5658     VkStructureType sType;
5659     PTR32 pNext;
5660     VkPipeline DECLSPEC_ALIGN(8) pipeline;
5661     uint32_t executableIndex;
5662 } VkPipelineExecutableInfoKHR32;
5663
5664 typedef struct VkPipelineExecutableInternalRepresentationKHR32
5665 {
5666     VkStructureType sType;
5667     PTR32 pNext;
5668     char name[VK_MAX_DESCRIPTION_SIZE];
5669     char description[VK_MAX_DESCRIPTION_SIZE];
5670     VkBool32 isText;
5671     PTR32 dataSize;
5672     PTR32 pData;
5673 } VkPipelineExecutableInternalRepresentationKHR32;
5674
5675 typedef struct VkPipelineInfoKHR32
5676 {
5677     VkStructureType sType;
5678     PTR32 pNext;
5679     VkPipeline DECLSPEC_ALIGN(8) pipeline;
5680 } VkPipelineInfoKHR32;
5681 typedef VkPipelineInfoKHR32 VkPipelineInfoEXT32;
5682
5683 typedef struct VkPipelineExecutablePropertiesKHR32
5684 {
5685     VkStructureType sType;
5686     PTR32 pNext;
5687     VkShaderStageFlags stages;
5688     char name[VK_MAX_DESCRIPTION_SIZE];
5689     char description[VK_MAX_DESCRIPTION_SIZE];
5690     uint32_t subgroupSize;
5691 } VkPipelineExecutablePropertiesKHR32;
5692
5693 typedef union VkPipelineExecutableStatisticValueKHR32
5694 {
5695     VkBool32 b32;
5696     int64_t i64;
5697     uint64_t DECLSPEC_ALIGN(8) u64;
5698     double f64;
5699 } VkPipelineExecutableStatisticValueKHR32;
5700
5701 typedef struct VkPipelineExecutableStatisticKHR32
5702 {
5703     VkStructureType sType;
5704     PTR32 pNext;
5705     char name[VK_MAX_DESCRIPTION_SIZE];
5706     char description[VK_MAX_DESCRIPTION_SIZE];
5707     VkPipelineExecutableStatisticFormatKHR format;
5708     VkPipelineExecutableStatisticValueKHR32 DECLSPEC_ALIGN(8) value;
5709 } VkPipelineExecutableStatisticKHR32;
5710
5711
5712 typedef struct VkCheckpointData2NV32
5713 {
5714     VkStructureType sType;
5715     PTR32 pNext;
5716     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
5717     PTR32 pCheckpointMarker;
5718 } VkCheckpointData2NV32;
5719
5720 typedef struct VkCheckpointDataNV32
5721 {
5722     VkStructureType sType;
5723     PTR32 pNext;
5724     VkPipelineStageFlagBits stage;
5725     PTR32 pCheckpointMarker;
5726 } VkCheckpointDataNV32;
5727
5728 typedef struct VkSamplerCaptureDescriptorDataInfoEXT32
5729 {
5730     VkStructureType sType;
5731     PTR32 pNext;
5732     VkSampler DECLSPEC_ALIGN(8) sampler;
5733 } VkSamplerCaptureDescriptorDataInfoEXT32;
5734
5735 typedef struct VkShaderModuleIdentifierEXT32
5736 {
5737     VkStructureType sType;
5738     PTR32 pNext;
5739     uint32_t identifierSize;
5740     uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT];
5741 } VkShaderModuleIdentifierEXT32;
5742
5743 typedef struct VkInitializePerformanceApiInfoINTEL32
5744 {
5745     VkStructureType sType;
5746     PTR32 pNext;
5747     PTR32 pUserData;
5748 } VkInitializePerformanceApiInfoINTEL32;
5749
5750 typedef struct VkSparseMemoryBind32
5751 {
5752     VkDeviceSize DECLSPEC_ALIGN(8) resourceOffset;
5753     VkDeviceSize DECLSPEC_ALIGN(8) size;
5754     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
5755     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
5756     VkSparseMemoryBindFlags flags;
5757 } VkSparseMemoryBind32;
5758
5759 typedef struct VkSparseBufferMemoryBindInfo32
5760 {
5761     VkBuffer DECLSPEC_ALIGN(8) buffer;
5762     uint32_t bindCount;
5763     PTR32 pBinds;
5764 } VkSparseBufferMemoryBindInfo32;
5765
5766 typedef struct VkSparseImageOpaqueMemoryBindInfo32
5767 {
5768     VkImage DECLSPEC_ALIGN(8) image;
5769     uint32_t bindCount;
5770     PTR32 pBinds;
5771 } VkSparseImageOpaqueMemoryBindInfo32;
5772
5773 typedef struct VkSparseImageMemoryBind32
5774 {
5775     VkImageSubresource subresource;
5776     VkOffset3D offset;
5777     VkExtent3D extent;
5778     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
5779     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
5780     VkSparseMemoryBindFlags flags;
5781 } VkSparseImageMemoryBind32;
5782
5783 typedef struct VkSparseImageMemoryBindInfo32
5784 {
5785     VkImage DECLSPEC_ALIGN(8) image;
5786     uint32_t bindCount;
5787     PTR32 pBinds;
5788 } VkSparseImageMemoryBindInfo32;
5789
5790 typedef struct VkDeviceGroupBindSparseInfo32
5791 {
5792     VkStructureType sType;
5793     PTR32 pNext;
5794     uint32_t resourceDeviceIndex;
5795     uint32_t memoryDeviceIndex;
5796 } VkDeviceGroupBindSparseInfo32;
5797 typedef VkDeviceGroupBindSparseInfo32 VkDeviceGroupBindSparseInfoKHR32;
5798
5799 typedef struct VkTimelineSemaphoreSubmitInfo32
5800 {
5801     VkStructureType sType;
5802     PTR32 pNext;
5803     uint32_t waitSemaphoreValueCount;
5804     PTR32 pWaitSemaphoreValues;
5805     uint32_t signalSemaphoreValueCount;
5806     PTR32 pSignalSemaphoreValues;
5807 } VkTimelineSemaphoreSubmitInfo32;
5808 typedef VkTimelineSemaphoreSubmitInfo32 VkTimelineSemaphoreSubmitInfoKHR32;
5809
5810 typedef struct VkBindSparseInfo32
5811 {
5812     VkStructureType sType;
5813     PTR32 pNext;
5814     uint32_t waitSemaphoreCount;
5815     PTR32 pWaitSemaphores;
5816     uint32_t bufferBindCount;
5817     PTR32 pBufferBinds;
5818     uint32_t imageOpaqueBindCount;
5819     PTR32 pImageOpaqueBinds;
5820     uint32_t imageBindCount;
5821     PTR32 pImageBinds;
5822     uint32_t signalSemaphoreCount;
5823     PTR32 pSignalSemaphores;
5824 } VkBindSparseInfo32;
5825
5826 typedef struct VkPresentRegionKHR32
5827 {
5828     uint32_t rectangleCount;
5829     PTR32 pRectangles;
5830 } VkPresentRegionKHR32;
5831
5832 typedef struct VkPresentRegionsKHR32
5833 {
5834     VkStructureType sType;
5835     PTR32 pNext;
5836     uint32_t swapchainCount;
5837     PTR32 pRegions;
5838 } VkPresentRegionsKHR32;
5839
5840 typedef struct VkDeviceGroupPresentInfoKHR32
5841 {
5842     VkStructureType sType;
5843     PTR32 pNext;
5844     uint32_t swapchainCount;
5845     PTR32 pDeviceMasks;
5846     VkDeviceGroupPresentModeFlagBitsKHR mode;
5847 } VkDeviceGroupPresentInfoKHR32;
5848
5849 typedef struct VkPresentIdKHR32
5850 {
5851     VkStructureType sType;
5852     PTR32 pNext;
5853     uint32_t swapchainCount;
5854     PTR32 pPresentIds;
5855 } VkPresentIdKHR32;
5856
5857 typedef struct VkPresentInfoKHR32
5858 {
5859     VkStructureType sType;
5860     PTR32 pNext;
5861     uint32_t waitSemaphoreCount;
5862     PTR32 pWaitSemaphores;
5863     uint32_t swapchainCount;
5864     PTR32 pSwapchains;
5865     PTR32 pImageIndices;
5866     PTR32 pResults;
5867 } VkPresentInfoKHR32;
5868
5869 typedef struct VkDeviceGroupSubmitInfo32
5870 {
5871     VkStructureType sType;
5872     PTR32 pNext;
5873     uint32_t waitSemaphoreCount;
5874     PTR32 pWaitSemaphoreDeviceIndices;
5875     uint32_t commandBufferCount;
5876     PTR32 pCommandBufferDeviceMasks;
5877     uint32_t signalSemaphoreCount;
5878     PTR32 pSignalSemaphoreDeviceIndices;
5879 } VkDeviceGroupSubmitInfo32;
5880 typedef VkDeviceGroupSubmitInfo32 VkDeviceGroupSubmitInfoKHR32;
5881
5882 typedef struct VkProtectedSubmitInfo32
5883 {
5884     VkStructureType sType;
5885     PTR32 pNext;
5886     VkBool32 protectedSubmit;
5887 } VkProtectedSubmitInfo32;
5888
5889 typedef struct VkPerformanceQuerySubmitInfoKHR32
5890 {
5891     VkStructureType sType;
5892     PTR32 pNext;
5893     uint32_t counterPassIndex;
5894 } VkPerformanceQuerySubmitInfoKHR32;
5895
5896 typedef struct VkSubmitInfo32
5897 {
5898     VkStructureType sType;
5899     PTR32 pNext;
5900     uint32_t waitSemaphoreCount;
5901     PTR32 pWaitSemaphores;
5902     PTR32 pWaitDstStageMask;
5903     uint32_t commandBufferCount;
5904     PTR32 pCommandBuffers;
5905     uint32_t signalSemaphoreCount;
5906     PTR32 pSignalSemaphores;
5907 } VkSubmitInfo32;
5908
5909 typedef struct VkSemaphoreSubmitInfo32
5910 {
5911     VkStructureType sType;
5912     PTR32 pNext;
5913     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
5914     uint64_t DECLSPEC_ALIGN(8) value;
5915     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
5916     uint32_t deviceIndex;
5917 } VkSemaphoreSubmitInfo32;
5918 typedef VkSemaphoreSubmitInfo32 VkSemaphoreSubmitInfoKHR32;
5919
5920 typedef struct VkCommandBufferSubmitInfo32
5921 {
5922     VkStructureType sType;
5923     PTR32 pNext;
5924     PTR32 commandBuffer;
5925     uint32_t deviceMask;
5926 } VkCommandBufferSubmitInfo32;
5927 typedef VkCommandBufferSubmitInfo32 VkCommandBufferSubmitInfoKHR32;
5928
5929 typedef struct VkSubmitInfo232
5930 {
5931     VkStructureType sType;
5932     PTR32 pNext;
5933     VkSubmitFlags flags;
5934     uint32_t waitSemaphoreInfoCount;
5935     PTR32 pWaitSemaphoreInfos;
5936     uint32_t commandBufferInfoCount;
5937     PTR32 pCommandBufferInfos;
5938     uint32_t signalSemaphoreInfoCount;
5939     PTR32 pSignalSemaphoreInfos;
5940 } VkSubmitInfo232;
5941 typedef VkSubmitInfo232 VkSubmitInfo2KHR32;
5942
5943 typedef struct VkDebugUtilsObjectTagInfoEXT32
5944 {
5945     VkStructureType sType;
5946     PTR32 pNext;
5947     VkObjectType objectType;
5948     uint64_t DECLSPEC_ALIGN(8) objectHandle;
5949     uint64_t DECLSPEC_ALIGN(8) tagName;
5950     PTR32 tagSize;
5951     PTR32 pTag;
5952 } VkDebugUtilsObjectTagInfoEXT32;
5953
5954 typedef struct VkSemaphoreSignalInfo32
5955 {
5956     VkStructureType sType;
5957     PTR32 pNext;
5958     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
5959     uint64_t DECLSPEC_ALIGN(8) value;
5960 } VkSemaphoreSignalInfo32;
5961 typedef VkSemaphoreSignalInfo32 VkSemaphoreSignalInfoKHR32;
5962
5963 typedef struct VkDeviceAddressBindingCallbackDataEXT32
5964 {
5965     VkStructureType sType;
5966     PTR32 pNext;
5967     VkDeviceAddressBindingFlagsEXT flags;
5968     VkDeviceAddress DECLSPEC_ALIGN(8) baseAddress;
5969     VkDeviceSize DECLSPEC_ALIGN(8) size;
5970     VkDeviceAddressBindingTypeEXT bindingType;
5971 } VkDeviceAddressBindingCallbackDataEXT32;
5972
5973 typedef struct VkDebugUtilsMessengerCallbackDataEXT32
5974 {
5975     VkStructureType sType;
5976     PTR32 pNext;
5977     VkDebugUtilsMessengerCallbackDataFlagsEXT flags;
5978     PTR32 pMessageIdName;
5979     int32_t messageIdNumber;
5980     PTR32 pMessage;
5981     uint32_t queueLabelCount;
5982     PTR32 pQueueLabels;
5983     uint32_t cmdBufLabelCount;
5984     PTR32 pCmdBufLabels;
5985     uint32_t objectCount;
5986     PTR32 pObjects;
5987 } VkDebugUtilsMessengerCallbackDataEXT32;
5988
5989 typedef struct VkCopyDescriptorSet32
5990 {
5991     VkStructureType sType;
5992     PTR32 pNext;
5993     VkDescriptorSet DECLSPEC_ALIGN(8) srcSet;
5994     uint32_t srcBinding;
5995     uint32_t srcArrayElement;
5996     VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
5997     uint32_t dstBinding;
5998     uint32_t dstArrayElement;
5999     uint32_t descriptorCount;
6000 } VkCopyDescriptorSet32;
6001
6002 typedef struct VkSemaphoreWaitInfo32
6003 {
6004     VkStructureType sType;
6005     PTR32 pNext;
6006     VkSemaphoreWaitFlags flags;
6007     uint32_t semaphoreCount;
6008     PTR32 pSemaphores;
6009     PTR32 pValues;
6010 } VkSemaphoreWaitInfo32;
6011 typedef VkSemaphoreWaitInfo32 VkSemaphoreWaitInfoKHR32;
6012
6013 static uint64_t wine_vk_unwrap_handle(uint32_t type, uint64_t handle)
6014 {
6015     switch(type)
6016     {
6017     case VK_OBJECT_TYPE_COMMAND_BUFFER:
6018         return (uint64_t) (uintptr_t) wine_cmd_buffer_from_handle(((VkCommandBuffer) (uintptr_t) handle))->command_buffer;
6019     case VK_OBJECT_TYPE_COMMAND_POOL:
6020         return (uint64_t) wine_cmd_pool_from_handle(handle)->command_pool;
6021     case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
6022         return (uint64_t) wine_debug_report_callback_from_handle(handle)->debug_callback;
6023     case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
6024         return (uint64_t) wine_debug_utils_messenger_from_handle(handle)->debug_messenger;
6025     case VK_OBJECT_TYPE_DEVICE:
6026         return (uint64_t) (uintptr_t) wine_device_from_handle(((VkDevice) (uintptr_t) handle))->device;
6027     case VK_OBJECT_TYPE_INSTANCE:
6028         return (uint64_t) (uintptr_t) wine_instance_from_handle(((VkInstance) (uintptr_t) handle))->instance;
6029     case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
6030         return (uint64_t) (uintptr_t) wine_phys_dev_from_handle(((VkPhysicalDevice) (uintptr_t) handle))->phys_dev;
6031     case VK_OBJECT_TYPE_QUEUE:
6032         return (uint64_t) (uintptr_t) wine_queue_from_handle(((VkQueue) (uintptr_t) handle))->queue;
6033     case VK_OBJECT_TYPE_SURFACE_KHR:
6034         return (uint64_t) wine_surface_from_handle(handle)->surface;
6035     default:
6036        return handle;
6037     }
6038 }
6039
6040 static inline void convert_VkAcquireNextImageInfoKHR_win32_to_host(const VkAcquireNextImageInfoKHR32 *in, VkAcquireNextImageInfoKHR *out)
6041 {
6042     if (!in) return;
6043
6044     out->sType = in->sType;
6045     out->pNext = NULL;
6046     out->swapchain = in->swapchain;
6047     out->timeout = in->timeout;
6048     out->semaphore = in->semaphore;
6049     out->fence = in->fence;
6050     out->deviceMask = in->deviceMask;
6051     if (in->pNext)
6052         FIXME("Unexpected pNext\n");
6053 }
6054
6055 static inline void convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host(const VkPerformanceConfigurationAcquireInfoINTEL32 *in, VkPerformanceConfigurationAcquireInfoINTEL *out)
6056 {
6057     if (!in) return;
6058
6059     out->sType = in->sType;
6060     out->pNext = NULL;
6061     out->type = in->type;
6062     if (in->pNext)
6063         FIXME("Unexpected pNext\n");
6064 }
6065
6066 static inline void convert_VkAcquireProfilingLockInfoKHR_win32_to_host(const VkAcquireProfilingLockInfoKHR32 *in, VkAcquireProfilingLockInfoKHR *out)
6067 {
6068     if (!in) return;
6069
6070     out->sType = in->sType;
6071     out->pNext = NULL;
6072     out->flags = in->flags;
6073     out->timeout = in->timeout;
6074     if (in->pNext)
6075         FIXME("Unexpected pNext\n");
6076 }
6077
6078 static inline void convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(const VkCommandBufferAllocateInfo32 *in, VkCommandBufferAllocateInfo *out)
6079 {
6080     if (!in) return;
6081
6082     out->sType = in->sType;
6083     out->pNext = NULL;
6084     out->commandPool = in->commandPool;
6085     out->level = in->level;
6086     out->commandBufferCount = in->commandBufferCount;
6087     if (in->pNext)
6088         FIXME("Unexpected pNext\n");
6089 }
6090
6091 static inline VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_unwrapped_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
6092 {
6093     VkCommandBuffer *out;
6094     unsigned int i;
6095
6096     if (!in || !count) return NULL;
6097
6098     out = conversion_context_alloc(ctx, count * sizeof(*out));
6099     for (i = 0; i < count; i++)
6100     {
6101         out[i] = UlongToPtr(in[i]);
6102     }
6103
6104     return out;
6105 }
6106
6107 static inline void convert_VkDescriptorSetAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetAllocateInfo32 *in, VkDescriptorSetAllocateInfo *out)
6108 {
6109     const VkBaseInStructure32 *in_header;
6110     VkBaseOutStructure *out_header = (void *)out;
6111
6112     if (!in) return;
6113
6114     out->sType = in->sType;
6115     out->pNext = NULL;
6116     out->descriptorPool = in->descriptorPool;
6117     out->descriptorSetCount = in->descriptorSetCount;
6118     out->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in->pSetLayouts);
6119
6120     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6121     {
6122         switch (in_header->sType)
6123         {
6124         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
6125         {
6126             VkDescriptorSetVariableDescriptorCountAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6127             const VkDescriptorSetVariableDescriptorCountAllocateInfo32 *in_ext = (const VkDescriptorSetVariableDescriptorCountAllocateInfo32 *)in_header;
6128             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
6129             out_ext->pNext = NULL;
6130             out_ext->descriptorSetCount = in_ext->descriptorSetCount;
6131             out_ext->pDescriptorCounts = (const uint32_t *)UlongToPtr(in_ext->pDescriptorCounts);
6132             out_header->pNext = (void *)out_ext;
6133             out_header = (void *)out_ext;
6134             break;
6135         }
6136         default:
6137             FIXME("Unhandled sType %u.", in_header->sType);
6138             break;
6139         }
6140     }
6141 }
6142
6143 static inline void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryAllocateInfo32 *in, VkMemoryAllocateInfo *out)
6144 {
6145     const VkBaseInStructure32 *in_header;
6146     VkBaseOutStructure *out_header = (void *)out;
6147
6148     if (!in) return;
6149
6150     out->sType = in->sType;
6151     out->pNext = NULL;
6152     out->allocationSize = in->allocationSize;
6153     out->memoryTypeIndex = in->memoryTypeIndex;
6154
6155     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6156     {
6157         switch (in_header->sType)
6158         {
6159         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
6160         {
6161             VkDedicatedAllocationMemoryAllocateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6162             const VkDedicatedAllocationMemoryAllocateInfoNV32 *in_ext = (const VkDedicatedAllocationMemoryAllocateInfoNV32 *)in_header;
6163             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV;
6164             out_ext->pNext = NULL;
6165             out_ext->image = in_ext->image;
6166             out_ext->buffer = in_ext->buffer;
6167             out_header->pNext = (void *)out_ext;
6168             out_header = (void *)out_ext;
6169             break;
6170         }
6171         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
6172         {
6173             VkExportMemoryAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6174             const VkExportMemoryAllocateInfo32 *in_ext = (const VkExportMemoryAllocateInfo32 *)in_header;
6175             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
6176             out_ext->pNext = NULL;
6177             out_ext->handleTypes = in_ext->handleTypes;
6178             out_header->pNext = (void *)out_ext;
6179             out_header = (void *)out_ext;
6180             break;
6181         }
6182         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
6183         {
6184             VkImportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6185             const VkImportMemoryWin32HandleInfoKHR32 *in_ext = (const VkImportMemoryWin32HandleInfoKHR32 *)in_header;
6186             out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
6187             out_ext->pNext = NULL;
6188             out_ext->handleType = in_ext->handleType;
6189             out_ext->handle = in_ext->handle;
6190             out_ext->name = in_ext->name;
6191             out_header->pNext = (void *)out_ext;
6192             out_header = (void *)out_ext;
6193             break;
6194         }
6195         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
6196         {
6197             VkExportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6198             const VkExportMemoryWin32HandleInfoKHR32 *in_ext = (const VkExportMemoryWin32HandleInfoKHR32 *)in_header;
6199             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
6200             out_ext->pNext = NULL;
6201             out_ext->pAttributes = (const SECURITY_ATTRIBUTES *)UlongToPtr(in_ext->pAttributes);
6202             out_ext->dwAccess = in_ext->dwAccess;
6203             out_ext->name = in_ext->name;
6204             out_header->pNext = (void *)out_ext;
6205             out_header = (void *)out_ext;
6206             break;
6207         }
6208         case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
6209         {
6210             VkMemoryAllocateFlagsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6211             const VkMemoryAllocateFlagsInfo32 *in_ext = (const VkMemoryAllocateFlagsInfo32 *)in_header;
6212             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO;
6213             out_ext->pNext = NULL;
6214             out_ext->flags = in_ext->flags;
6215             out_ext->deviceMask = in_ext->deviceMask;
6216             out_header->pNext = (void *)out_ext;
6217             out_header = (void *)out_ext;
6218             break;
6219         }
6220         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
6221         {
6222             VkMemoryDedicatedAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6223             const VkMemoryDedicatedAllocateInfo32 *in_ext = (const VkMemoryDedicatedAllocateInfo32 *)in_header;
6224             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
6225             out_ext->pNext = NULL;
6226             out_ext->image = in_ext->image;
6227             out_ext->buffer = in_ext->buffer;
6228             out_header->pNext = (void *)out_ext;
6229             out_header = (void *)out_ext;
6230             break;
6231         }
6232         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
6233         {
6234             VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6235             const VkImportMemoryHostPointerInfoEXT32 *in_ext = (const VkImportMemoryHostPointerInfoEXT32 *)in_header;
6236             out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT;
6237             out_ext->pNext = NULL;
6238             out_ext->handleType = in_ext->handleType;
6239             out_ext->pHostPointer = (void *)UlongToPtr(in_ext->pHostPointer);
6240             out_header->pNext = (void *)out_ext;
6241             out_header = (void *)out_ext;
6242             break;
6243         }
6244         case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
6245         {
6246             VkMemoryPriorityAllocateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6247             const VkMemoryPriorityAllocateInfoEXT32 *in_ext = (const VkMemoryPriorityAllocateInfoEXT32 *)in_header;
6248             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT;
6249             out_ext->pNext = NULL;
6250             out_ext->priority = in_ext->priority;
6251             out_header->pNext = (void *)out_ext;
6252             out_header = (void *)out_ext;
6253             break;
6254         }
6255         case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
6256         {
6257             VkMemoryOpaqueCaptureAddressAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6258             const VkMemoryOpaqueCaptureAddressAllocateInfo32 *in_ext = (const VkMemoryOpaqueCaptureAddressAllocateInfo32 *)in_header;
6259             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
6260             out_ext->pNext = NULL;
6261             out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress;
6262             out_header->pNext = (void *)out_ext;
6263             out_header = (void *)out_ext;
6264             break;
6265         }
6266         default:
6267             FIXME("Unhandled sType %u.", in_header->sType);
6268             break;
6269         }
6270     }
6271 }
6272
6273 static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, VkCommandBufferInheritanceInfo *out)
6274 {
6275     const VkBaseInStructure32 *in_header;
6276     VkBaseOutStructure *out_header = (void *)out;
6277
6278     if (!in) return;
6279
6280     out->sType = in->sType;
6281     out->pNext = NULL;
6282     out->renderPass = in->renderPass;
6283     out->subpass = in->subpass;
6284     out->framebuffer = in->framebuffer;
6285     out->occlusionQueryEnable = in->occlusionQueryEnable;
6286     out->queryFlags = in->queryFlags;
6287     out->pipelineStatistics = in->pipelineStatistics;
6288
6289     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6290     {
6291         switch (in_header->sType)
6292         {
6293         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
6294         {
6295             VkCommandBufferInheritanceConditionalRenderingInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6296             const VkCommandBufferInheritanceConditionalRenderingInfoEXT32 *in_ext = (const VkCommandBufferInheritanceConditionalRenderingInfoEXT32 *)in_header;
6297             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT;
6298             out_ext->pNext = NULL;
6299             out_ext->conditionalRenderingEnable = in_ext->conditionalRenderingEnable;
6300             out_header->pNext = (void *)out_ext;
6301             out_header = (void *)out_ext;
6302             break;
6303         }
6304         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
6305         {
6306             VkCommandBufferInheritanceRenderPassTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6307             const VkCommandBufferInheritanceRenderPassTransformInfoQCOM32 *in_ext = (const VkCommandBufferInheritanceRenderPassTransformInfoQCOM32 *)in_header;
6308             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM;
6309             out_ext->pNext = NULL;
6310             out_ext->transform = in_ext->transform;
6311             out_ext->renderArea = in_ext->renderArea;
6312             out_header->pNext = (void *)out_ext;
6313             out_header = (void *)out_ext;
6314             break;
6315         }
6316         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
6317         {
6318             VkCommandBufferInheritanceViewportScissorInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6319             const VkCommandBufferInheritanceViewportScissorInfoNV32 *in_ext = (const VkCommandBufferInheritanceViewportScissorInfoNV32 *)in_header;
6320             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV;
6321             out_ext->pNext = NULL;
6322             out_ext->viewportScissor2D = in_ext->viewportScissor2D;
6323             out_ext->viewportDepthCount = in_ext->viewportDepthCount;
6324             out_ext->pViewportDepths = (const VkViewport *)UlongToPtr(in_ext->pViewportDepths);
6325             out_header->pNext = (void *)out_ext;
6326             out_header = (void *)out_ext;
6327             break;
6328         }
6329         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
6330         {
6331             VkCommandBufferInheritanceRenderingInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6332             const VkCommandBufferInheritanceRenderingInfo32 *in_ext = (const VkCommandBufferInheritanceRenderingInfo32 *)in_header;
6333             out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
6334             out_ext->pNext = NULL;
6335             out_ext->flags = in_ext->flags;
6336             out_ext->viewMask = in_ext->viewMask;
6337             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
6338             out_ext->pColorAttachmentFormats = (const VkFormat *)UlongToPtr(in_ext->pColorAttachmentFormats);
6339             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
6340             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
6341             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
6342             out_header->pNext = (void *)out_ext;
6343             out_header = (void *)out_ext;
6344             break;
6345         }
6346         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
6347         {
6348             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6349             const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header;
6350             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
6351             out_ext->pNext = NULL;
6352             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
6353             out_ext->pColorAttachmentSamples = (const VkSampleCountFlagBits *)UlongToPtr(in_ext->pColorAttachmentSamples);
6354             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
6355             out_header->pNext = (void *)out_ext;
6356             out_header = (void *)out_ext;
6357             break;
6358         }
6359         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
6360         {
6361             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6362             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
6363             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
6364             out_ext->pNext = NULL;
6365             out_ext->perViewAttributes = in_ext->perViewAttributes;
6366             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
6367             out_header->pNext = (void *)out_ext;
6368             out_header = (void *)out_ext;
6369             break;
6370         }
6371         default:
6372             FIXME("Unhandled sType %u.", in_header->sType);
6373             break;
6374         }
6375     }
6376 }
6377
6378 static inline const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInheritanceInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, uint32_t count)
6379 {
6380     VkCommandBufferInheritanceInfo *out;
6381     unsigned int i;
6382
6383     if (!in || !count) return NULL;
6384
6385     out = conversion_context_alloc(ctx, count * sizeof(*out));
6386     for (i = 0; i < count; i++)
6387     {
6388         convert_VkCommandBufferInheritanceInfo_win32_to_host(ctx, &in[i], &out[i]);
6389     }
6390
6391     return out;
6392 }
6393
6394 static inline void convert_VkCommandBufferBeginInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferBeginInfo32 *in, VkCommandBufferBeginInfo *out)
6395 {
6396     const VkBaseInStructure32 *in_header;
6397     VkBaseOutStructure *out_header = (void *)out;
6398
6399     if (!in) return;
6400
6401     out->sType = in->sType;
6402     out->pNext = NULL;
6403     out->flags = in->flags;
6404     out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win32_to_host(ctx, (const VkCommandBufferInheritanceInfo32 *)UlongToPtr(in->pInheritanceInfo), 1);
6405
6406     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6407     {
6408         switch (in_header->sType)
6409         {
6410         case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
6411         {
6412             VkDeviceGroupCommandBufferBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6413             const VkDeviceGroupCommandBufferBeginInfo32 *in_ext = (const VkDeviceGroupCommandBufferBeginInfo32 *)in_header;
6414             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
6415             out_ext->pNext = NULL;
6416             out_ext->deviceMask = in_ext->deviceMask;
6417             out_header->pNext = (void *)out_ext;
6418             out_header = (void *)out_ext;
6419             break;
6420         }
6421         default:
6422             FIXME("Unhandled sType %u.", in_header->sType);
6423             break;
6424         }
6425     }
6426 }
6427
6428 static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(const VkBindAccelerationStructureMemoryInfoNV32 *in, VkBindAccelerationStructureMemoryInfoNV *out)
6429 {
6430     if (!in) return;
6431
6432     out->sType = in->sType;
6433     out->pNext = NULL;
6434     out->accelerationStructure = in->accelerationStructure;
6435     out->memory = in->memory;
6436     out->memoryOffset = in->memoryOffset;
6437     out->deviceIndexCount = in->deviceIndexCount;
6438     out->pDeviceIndices = (const uint32_t *)UlongToPtr(in->pDeviceIndices);
6439     if (in->pNext)
6440         FIXME("Unexpected pNext\n");
6441 }
6442
6443 static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV32 *in, uint32_t count)
6444 {
6445     VkBindAccelerationStructureMemoryInfoNV *out;
6446     unsigned int i;
6447
6448     if (!in || !count) return NULL;
6449
6450     out = conversion_context_alloc(ctx, count * sizeof(*out));
6451     for (i = 0; i < count; i++)
6452     {
6453         convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(&in[i], &out[i]);
6454     }
6455
6456     return out;
6457 }
6458
6459 static inline void convert_VkBindBufferMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, VkBindBufferMemoryInfo *out)
6460 {
6461     const VkBaseInStructure32 *in_header;
6462     VkBaseOutStructure *out_header = (void *)out;
6463
6464     if (!in) return;
6465
6466     out->sType = in->sType;
6467     out->pNext = NULL;
6468     out->buffer = in->buffer;
6469     out->memory = in->memory;
6470     out->memoryOffset = in->memoryOffset;
6471
6472     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6473     {
6474         switch (in_header->sType)
6475         {
6476         case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
6477         {
6478             VkBindBufferMemoryDeviceGroupInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6479             const VkBindBufferMemoryDeviceGroupInfo32 *in_ext = (const VkBindBufferMemoryDeviceGroupInfo32 *)in_header;
6480             out_ext->sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
6481             out_ext->pNext = NULL;
6482             out_ext->deviceIndexCount = in_ext->deviceIndexCount;
6483             out_ext->pDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pDeviceIndices);
6484             out_header->pNext = (void *)out_ext;
6485             out_header = (void *)out_ext;
6486             break;
6487         }
6488         default:
6489             FIXME("Unhandled sType %u.", in_header->sType);
6490             break;
6491         }
6492     }
6493 }
6494
6495 static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, uint32_t count)
6496 {
6497     VkBindBufferMemoryInfo *out;
6498     unsigned int i;
6499
6500     if (!in || !count) return NULL;
6501
6502     out = conversion_context_alloc(ctx, count * sizeof(*out));
6503     for (i = 0; i < count; i++)
6504     {
6505         convert_VkBindBufferMemoryInfo_win32_to_host(ctx, &in[i], &out[i]);
6506     }
6507
6508     return out;
6509 }
6510
6511 static inline void convert_VkBindImageMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, VkBindImageMemoryInfo *out)
6512 {
6513     const VkBaseInStructure32 *in_header;
6514     VkBaseOutStructure *out_header = (void *)out;
6515
6516     if (!in) return;
6517
6518     out->sType = in->sType;
6519     out->pNext = NULL;
6520     out->image = in->image;
6521     out->memory = in->memory;
6522     out->memoryOffset = in->memoryOffset;
6523
6524     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6525     {
6526         switch (in_header->sType)
6527         {
6528         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
6529         {
6530             VkBindImageMemoryDeviceGroupInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6531             const VkBindImageMemoryDeviceGroupInfo32 *in_ext = (const VkBindImageMemoryDeviceGroupInfo32 *)in_header;
6532             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
6533             out_ext->pNext = NULL;
6534             out_ext->deviceIndexCount = in_ext->deviceIndexCount;
6535             out_ext->pDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pDeviceIndices);
6536             out_ext->splitInstanceBindRegionCount = in_ext->splitInstanceBindRegionCount;
6537             out_ext->pSplitInstanceBindRegions = (const VkRect2D *)UlongToPtr(in_ext->pSplitInstanceBindRegions);
6538             out_header->pNext = (void *)out_ext;
6539             out_header = (void *)out_ext;
6540             break;
6541         }
6542         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
6543         {
6544             VkBindImageMemorySwapchainInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6545             const VkBindImageMemorySwapchainInfoKHR32 *in_ext = (const VkBindImageMemorySwapchainInfoKHR32 *)in_header;
6546             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR;
6547             out_ext->pNext = NULL;
6548             out_ext->swapchain = in_ext->swapchain;
6549             out_ext->imageIndex = in_ext->imageIndex;
6550             out_header->pNext = (void *)out_ext;
6551             out_header = (void *)out_ext;
6552             break;
6553         }
6554         case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
6555         {
6556             VkBindImagePlaneMemoryInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6557             const VkBindImagePlaneMemoryInfo32 *in_ext = (const VkBindImagePlaneMemoryInfo32 *)in_header;
6558             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO;
6559             out_ext->pNext = NULL;
6560             out_ext->planeAspect = in_ext->planeAspect;
6561             out_header->pNext = (void *)out_ext;
6562             out_header = (void *)out_ext;
6563             break;
6564         }
6565         default:
6566             FIXME("Unhandled sType %u.", in_header->sType);
6567             break;
6568         }
6569     }
6570 }
6571
6572 static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, uint32_t count)
6573 {
6574     VkBindImageMemoryInfo *out;
6575     unsigned int i;
6576
6577     if (!in || !count) return NULL;
6578
6579     out = conversion_context_alloc(ctx, count * sizeof(*out));
6580     for (i = 0; i < count; i++)
6581     {
6582         convert_VkBindImageMemoryInfo_win32_to_host(ctx, &in[i], &out[i]);
6583     }
6584
6585     return out;
6586 }
6587
6588 static inline const VkMicromapUsageEXT * const*convert_VkMicromapUsageEXT_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
6589 {
6590     VkMicromapUsageEXT **out;
6591     unsigned int i;
6592
6593     if (!in || !count) return NULL;
6594
6595     out = conversion_context_alloc(ctx, count * sizeof(*out));
6596     for (i = 0; i < count; i++)
6597     {
6598         out[i] = UlongToPtr(in[i]);
6599     }
6600
6601     return (void *)out;
6602 }
6603
6604 static inline void convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryTrianglesDataKHR32 *in, VkAccelerationStructureGeometryTrianglesDataKHR *out)
6605 {
6606     const VkBaseInStructure32 *in_header;
6607     VkBaseOutStructure *out_header = (void *)out;
6608
6609     if (!in) return;
6610
6611     out->sType = in->sType;
6612     out->pNext = NULL;
6613     out->vertexFormat = in->vertexFormat;
6614     out->vertexData = in->vertexData;
6615     out->vertexStride = in->vertexStride;
6616     out->maxVertex = in->maxVertex;
6617     out->indexType = in->indexType;
6618     out->indexData = in->indexData;
6619     out->transformData = in->transformData;
6620
6621     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6622     {
6623         switch (in_header->sType)
6624         {
6625         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
6626         {
6627             VkAccelerationStructureGeometryMotionTrianglesDataNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6628             const VkAccelerationStructureGeometryMotionTrianglesDataNV32 *in_ext = (const VkAccelerationStructureGeometryMotionTrianglesDataNV32 *)in_header;
6629             out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV;
6630             out_ext->pNext = NULL;
6631             out_ext->vertexData = in_ext->vertexData;
6632             out_header->pNext = (void *)out_ext;
6633             out_header = (void *)out_ext;
6634             break;
6635         }
6636         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
6637         {
6638             VkAccelerationStructureTrianglesOpacityMicromapEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6639             const VkAccelerationStructureTrianglesOpacityMicromapEXT32 *in_ext = (const VkAccelerationStructureTrianglesOpacityMicromapEXT32 *)in_header;
6640             out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT;
6641             out_ext->pNext = NULL;
6642             out_ext->indexType = in_ext->indexType;
6643             out_ext->indexBuffer = in_ext->indexBuffer;
6644             out_ext->indexStride = in_ext->indexStride;
6645             out_ext->baseTriangle = in_ext->baseTriangle;
6646             out_ext->usageCountsCount = in_ext->usageCountsCount;
6647             out_ext->pUsageCounts = (const VkMicromapUsageEXT *)UlongToPtr(in_ext->pUsageCounts);
6648             out_ext->ppUsageCounts = convert_VkMicromapUsageEXT_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->ppUsageCounts), in_ext->usageCountsCount);
6649             out_ext->micromap = in_ext->micromap;
6650             out_header->pNext = (void *)out_ext;
6651             out_header = (void *)out_ext;
6652             break;
6653         }
6654         default:
6655             FIXME("Unhandled sType %u.", in_header->sType);
6656             break;
6657         }
6658     }
6659 }
6660
6661 static inline void convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_host(const VkAccelerationStructureGeometryAabbsDataKHR32 *in, VkAccelerationStructureGeometryAabbsDataKHR *out)
6662 {
6663     if (!in) return;
6664
6665     out->sType = in->sType;
6666     out->pNext = NULL;
6667     out->data = in->data;
6668     out->stride = in->stride;
6669     if (in->pNext)
6670         FIXME("Unexpected pNext\n");
6671 }
6672
6673 static inline void convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(const VkAccelerationStructureGeometryInstancesDataKHR32 *in, VkAccelerationStructureGeometryInstancesDataKHR *out)
6674 {
6675     if (!in) return;
6676
6677     out->sType = in->sType;
6678     out->pNext = NULL;
6679     out->arrayOfPointers = in->arrayOfPointers;
6680     out->data = in->data;
6681     if (in->pNext)
6682         FIXME("Unexpected pNext\n");
6683 }
6684
6685 static inline void convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryDataKHR32 *in, VkAccelerationStructureGeometryDataKHR *out, VkFlags selector)
6686 {
6687     if (!in) return;
6688
6689     if (selector == VK_GEOMETRY_TYPE_TRIANGLES_KHR)
6690         convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_host(ctx, &in->triangles, &out->triangles);
6691     if (selector == VK_GEOMETRY_TYPE_AABBS_KHR)
6692         convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_host(&in->aabbs, &out->aabbs);
6693     if (selector == VK_GEOMETRY_TYPE_INSTANCES_KHR)
6694         convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(&in->instances, &out->instances);
6695 }
6696
6697 static inline void convert_VkAccelerationStructureGeometryKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, VkAccelerationStructureGeometryKHR *out)
6698 {
6699     if (!in) return;
6700
6701     out->sType = in->sType;
6702     out->pNext = NULL;
6703     out->geometryType = in->geometryType;
6704     convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(ctx, &in->geometry, &out->geometry, in->geometryType);
6705     out->flags = in->flags;
6706     if (in->pNext)
6707         FIXME("Unexpected pNext\n");
6708 }
6709
6710 static inline const VkAccelerationStructureGeometryKHR *convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, uint32_t count)
6711 {
6712     VkAccelerationStructureGeometryKHR *out;
6713     unsigned int i;
6714
6715     if (!in || !count) return NULL;
6716
6717     out = conversion_context_alloc(ctx, count * sizeof(*out));
6718     for (i = 0; i < count; i++)
6719     {
6720         convert_VkAccelerationStructureGeometryKHR_win32_to_host(ctx, &in[i], &out[i]);
6721     }
6722
6723     return out;
6724 }
6725
6726 static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
6727 {
6728     VkAccelerationStructureGeometryKHR **out;
6729     unsigned int i;
6730
6731     if (!in || !count) return NULL;
6732
6733     out = conversion_context_alloc(ctx, count * sizeof(*out));
6734     for (i = 0; i < count; i++)
6735     {
6736         if (in[i])
6737         {
6738             out[i] = conversion_context_alloc(ctx, sizeof(*out[i]));
6739             convert_VkAccelerationStructureGeometryKHR_win32_to_host(ctx, (VkAccelerationStructureGeometryKHR32 *)UlongToPtr(in[i]), out[i]);
6740         }
6741         else
6742             out[i] = NULL;
6743     }
6744
6745     return (void *)out;
6746 }
6747
6748 static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, VkAccelerationStructureBuildGeometryInfoKHR *out)
6749 {
6750     if (!in) return;
6751
6752     out->sType = in->sType;
6753     out->pNext = NULL;
6754     out->type = in->type;
6755     out->flags = in->flags;
6756     out->mode = in->mode;
6757     out->srcAccelerationStructure = in->srcAccelerationStructure;
6758     out->dstAccelerationStructure = in->dstAccelerationStructure;
6759     out->geometryCount = in->geometryCount;
6760     out->pGeometries = convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(ctx, (const VkAccelerationStructureGeometryKHR32 *)UlongToPtr(in->pGeometries), in->geometryCount);
6761     out->ppGeometries = convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppGeometries), in->geometryCount);
6762     out->scratchData = in->scratchData;
6763     if (in->pNext)
6764         FIXME("Unexpected pNext\n");
6765 }
6766
6767 static inline const VkAccelerationStructureBuildGeometryInfoKHR *convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, uint32_t count)
6768 {
6769     VkAccelerationStructureBuildGeometryInfoKHR *out;
6770     unsigned int i;
6771
6772     if (!in || !count) return NULL;
6773
6774     out = conversion_context_alloc(ctx, count * sizeof(*out));
6775     for (i = 0; i < count; i++)
6776     {
6777         convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
6778     }
6779
6780     return out;
6781 }
6782
6783 static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, VkMicromapBuildInfoEXT *out)
6784 {
6785     if (!in) return;
6786
6787     out->sType = in->sType;
6788     out->pNext = NULL;
6789     out->type = in->type;
6790     out->flags = in->flags;
6791     out->mode = in->mode;
6792     out->dstMicromap = in->dstMicromap;
6793     out->usageCountsCount = in->usageCountsCount;
6794     out->pUsageCounts = (const VkMicromapUsageEXT *)UlongToPtr(in->pUsageCounts);
6795     out->ppUsageCounts = convert_VkMicromapUsageEXT_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppUsageCounts), in->usageCountsCount);
6796     out->data = in->data;
6797     out->scratchData = in->scratchData;
6798     out->triangleArray = in->triangleArray;
6799     out->triangleArrayStride = in->triangleArrayStride;
6800     if (in->pNext)
6801         FIXME("Unexpected pNext\n");
6802 }
6803
6804 static inline const VkMicromapBuildInfoEXT *convert_VkMicromapBuildInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, uint32_t count)
6805 {
6806     VkMicromapBuildInfoEXT *out;
6807     unsigned int i;
6808
6809     if (!in || !count) return NULL;
6810
6811     out = conversion_context_alloc(ctx, count * sizeof(*out));
6812     for (i = 0; i < count; i++)
6813     {
6814         convert_VkMicromapBuildInfoEXT_win32_to_host(ctx, &in[i], &out[i]);
6815     }
6816
6817     return out;
6818 }
6819
6820 static inline void convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(const VkConditionalRenderingBeginInfoEXT32 *in, VkConditionalRenderingBeginInfoEXT *out)
6821 {
6822     if (!in) return;
6823
6824     out->sType = in->sType;
6825     out->pNext = NULL;
6826     out->buffer = in->buffer;
6827     out->offset = in->offset;
6828     out->flags = in->flags;
6829     if (in->pNext)
6830         FIXME("Unexpected pNext\n");
6831 }
6832
6833 static inline void convert_VkDebugUtilsLabelEXT_win32_to_host(const VkDebugUtilsLabelEXT32 *in, VkDebugUtilsLabelEXT *out)
6834 {
6835     if (!in) return;
6836
6837     out->sType = in->sType;
6838     out->pNext = NULL;
6839     out->pLabelName = (const char *)UlongToPtr(in->pLabelName);
6840     memcpy(out->color, in->color, 4 * sizeof(float));
6841     if (in->pNext)
6842         FIXME("Unexpected pNext\n");
6843 }
6844
6845 static inline void convert_VkSampleLocationsInfoEXT_win32_to_host(const VkSampleLocationsInfoEXT32 *in, VkSampleLocationsInfoEXT *out)
6846 {
6847     if (!in) return;
6848
6849     out->sType = in->sType;
6850     out->pNext = NULL;
6851     out->sampleLocationsPerPixel = in->sampleLocationsPerPixel;
6852     out->sampleLocationGridSize = in->sampleLocationGridSize;
6853     out->sampleLocationsCount = in->sampleLocationsCount;
6854     out->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in->pSampleLocations);
6855     if (in->pNext)
6856         FIXME("Unexpected pNext\n");
6857 }
6858
6859 static inline void convert_VkAttachmentSampleLocationsEXT_win32_to_host(const VkAttachmentSampleLocationsEXT32 *in, VkAttachmentSampleLocationsEXT *out)
6860 {
6861     if (!in) return;
6862
6863     out->attachmentIndex = in->attachmentIndex;
6864     convert_VkSampleLocationsInfoEXT_win32_to_host(&in->sampleLocationsInfo, &out->sampleLocationsInfo);
6865 }
6866
6867 static inline const VkAttachmentSampleLocationsEXT *convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentSampleLocationsEXT32 *in, uint32_t count)
6868 {
6869     VkAttachmentSampleLocationsEXT *out;
6870     unsigned int i;
6871
6872     if (!in || !count) return NULL;
6873
6874     out = conversion_context_alloc(ctx, count * sizeof(*out));
6875     for (i = 0; i < count; i++)
6876     {
6877         convert_VkAttachmentSampleLocationsEXT_win32_to_host(&in[i], &out[i]);
6878     }
6879
6880     return out;
6881 }
6882
6883 static inline void convert_VkSubpassSampleLocationsEXT_win32_to_host(const VkSubpassSampleLocationsEXT32 *in, VkSubpassSampleLocationsEXT *out)
6884 {
6885     if (!in) return;
6886
6887     out->subpassIndex = in->subpassIndex;
6888     convert_VkSampleLocationsInfoEXT_win32_to_host(&in->sampleLocationsInfo, &out->sampleLocationsInfo);
6889 }
6890
6891 static inline const VkSubpassSampleLocationsEXT *convert_VkSubpassSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkSubpassSampleLocationsEXT32 *in, uint32_t count)
6892 {
6893     VkSubpassSampleLocationsEXT *out;
6894     unsigned int i;
6895
6896     if (!in || !count) return NULL;
6897
6898     out = conversion_context_alloc(ctx, count * sizeof(*out));
6899     for (i = 0; i < count; i++)
6900     {
6901         convert_VkSubpassSampleLocationsEXT_win32_to_host(&in[i], &out[i]);
6902     }
6903
6904     return out;
6905 }
6906
6907 static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassBeginInfo32 *in, VkRenderPassBeginInfo *out)
6908 {
6909     const VkBaseInStructure32 *in_header;
6910     VkBaseOutStructure *out_header = (void *)out;
6911
6912     if (!in) return;
6913
6914     out->sType = in->sType;
6915     out->pNext = NULL;
6916     out->renderPass = in->renderPass;
6917     out->framebuffer = in->framebuffer;
6918     out->renderArea = in->renderArea;
6919     out->clearValueCount = in->clearValueCount;
6920     out->pClearValues = (const VkClearValue *)UlongToPtr(in->pClearValues);
6921
6922     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
6923     {
6924         switch (in_header->sType)
6925         {
6926         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
6927         {
6928             VkDeviceGroupRenderPassBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6929             const VkDeviceGroupRenderPassBeginInfo32 *in_ext = (const VkDeviceGroupRenderPassBeginInfo32 *)in_header;
6930             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
6931             out_ext->pNext = NULL;
6932             out_ext->deviceMask = in_ext->deviceMask;
6933             out_ext->deviceRenderAreaCount = in_ext->deviceRenderAreaCount;
6934             out_ext->pDeviceRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pDeviceRenderAreas);
6935             out_header->pNext = (void *)out_ext;
6936             out_header = (void *)out_ext;
6937             break;
6938         }
6939         case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
6940         {
6941             VkRenderPassSampleLocationsBeginInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6942             const VkRenderPassSampleLocationsBeginInfoEXT32 *in_ext = (const VkRenderPassSampleLocationsBeginInfoEXT32 *)in_header;
6943             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT;
6944             out_ext->pNext = NULL;
6945             out_ext->attachmentInitialSampleLocationsCount = in_ext->attachmentInitialSampleLocationsCount;
6946             out_ext->pAttachmentInitialSampleLocations = convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(ctx, (const VkAttachmentSampleLocationsEXT32 *)UlongToPtr(in_ext->pAttachmentInitialSampleLocations), in_ext->attachmentInitialSampleLocationsCount);
6947             out_ext->postSubpassSampleLocationsCount = in_ext->postSubpassSampleLocationsCount;
6948             out_ext->pPostSubpassSampleLocations = convert_VkSubpassSampleLocationsEXT_array_win32_to_host(ctx, (const VkSubpassSampleLocationsEXT32 *)UlongToPtr(in_ext->pPostSubpassSampleLocations), in_ext->postSubpassSampleLocationsCount);
6949             out_header->pNext = (void *)out_ext;
6950             out_header = (void *)out_ext;
6951             break;
6952         }
6953         case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
6954         {
6955             VkRenderPassAttachmentBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6956             const VkRenderPassAttachmentBeginInfo32 *in_ext = (const VkRenderPassAttachmentBeginInfo32 *)in_header;
6957             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO;
6958             out_ext->pNext = NULL;
6959             out_ext->attachmentCount = in_ext->attachmentCount;
6960             out_ext->pAttachments = (const VkImageView *)UlongToPtr(in_ext->pAttachments);
6961             out_header->pNext = (void *)out_ext;
6962             out_header = (void *)out_ext;
6963             break;
6964         }
6965         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
6966         {
6967             VkRenderPassTransformBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6968             const VkRenderPassTransformBeginInfoQCOM32 *in_ext = (const VkRenderPassTransformBeginInfoQCOM32 *)in_header;
6969             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM;
6970             out_ext->pNext = NULL;
6971             out_ext->transform = in_ext->transform;
6972             out_header->pNext = (void *)out_ext;
6973             out_header = (void *)out_ext;
6974             break;
6975         }
6976         default:
6977             FIXME("Unhandled sType %u.", in_header->sType);
6978             break;
6979         }
6980     }
6981 }
6982
6983 static inline void convert_VkSubpassBeginInfo_win32_to_host(const VkSubpassBeginInfo32 *in, VkSubpassBeginInfo *out)
6984 {
6985     if (!in) return;
6986
6987     out->sType = in->sType;
6988     out->pNext = NULL;
6989     out->contents = in->contents;
6990     if (in->pNext)
6991         FIXME("Unexpected pNext\n");
6992 }
6993
6994 static inline void convert_VkRenderingAttachmentInfo_win32_to_host(const VkRenderingAttachmentInfo32 *in, VkRenderingAttachmentInfo *out)
6995 {
6996     if (!in) return;
6997
6998     out->sType = in->sType;
6999     out->pNext = NULL;
7000     out->imageView = in->imageView;
7001     out->imageLayout = in->imageLayout;
7002     out->resolveMode = in->resolveMode;
7003     out->resolveImageView = in->resolveImageView;
7004     out->resolveImageLayout = in->resolveImageLayout;
7005     out->loadOp = in->loadOp;
7006     out->storeOp = in->storeOp;
7007     out->clearValue = in->clearValue;
7008     if (in->pNext)
7009         FIXME("Unexpected pNext\n");
7010 }
7011
7012 static inline const VkRenderingAttachmentInfo *convert_VkRenderingAttachmentInfo_array_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, uint32_t count)
7013 {
7014     VkRenderingAttachmentInfo *out;
7015     unsigned int i;
7016
7017     if (!in || !count) return NULL;
7018
7019     out = conversion_context_alloc(ctx, count * sizeof(*out));
7020     for (i = 0; i < count; i++)
7021     {
7022         convert_VkRenderingAttachmentInfo_win32_to_host(&in[i], &out[i]);
7023     }
7024
7025     return out;
7026 }
7027
7028 static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingInfo32 *in, VkRenderingInfo *out)
7029 {
7030     const VkBaseInStructure32 *in_header;
7031     VkBaseOutStructure *out_header = (void *)out;
7032
7033     if (!in) return;
7034
7035     out->sType = in->sType;
7036     out->pNext = NULL;
7037     out->flags = in->flags;
7038     out->renderArea = in->renderArea;
7039     out->layerCount = in->layerCount;
7040     out->viewMask = in->viewMask;
7041     out->colorAttachmentCount = in->colorAttachmentCount;
7042     out->pColorAttachments = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pColorAttachments), in->colorAttachmentCount);
7043     out->pDepthAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pDepthAttachment), 1);
7044     out->pStencilAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pStencilAttachment), 1);
7045
7046     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7047     {
7048         switch (in_header->sType)
7049         {
7050         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
7051         {
7052             VkDeviceGroupRenderPassBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7053             const VkDeviceGroupRenderPassBeginInfo32 *in_ext = (const VkDeviceGroupRenderPassBeginInfo32 *)in_header;
7054             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
7055             out_ext->pNext = NULL;
7056             out_ext->deviceMask = in_ext->deviceMask;
7057             out_ext->deviceRenderAreaCount = in_ext->deviceRenderAreaCount;
7058             out_ext->pDeviceRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pDeviceRenderAreas);
7059             out_header->pNext = (void *)out_ext;
7060             out_header = (void *)out_ext;
7061             break;
7062         }
7063         case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
7064         {
7065             VkMultisampledRenderToSingleSampledInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7066             const VkMultisampledRenderToSingleSampledInfoEXT32 *in_ext = (const VkMultisampledRenderToSingleSampledInfoEXT32 *)in_header;
7067             out_ext->sType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
7068             out_ext->pNext = NULL;
7069             out_ext->multisampledRenderToSingleSampledEnable = in_ext->multisampledRenderToSingleSampledEnable;
7070             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
7071             out_header->pNext = (void *)out_ext;
7072             out_header = (void *)out_ext;
7073             break;
7074         }
7075         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
7076         {
7077             VkRenderingFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7078             const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *)in_header;
7079             out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
7080             out_ext->pNext = NULL;
7081             out_ext->imageView = in_ext->imageView;
7082             out_ext->imageLayout = in_ext->imageLayout;
7083             out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize;
7084             out_header->pNext = (void *)out_ext;
7085             out_header = (void *)out_ext;
7086             break;
7087         }
7088         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
7089         {
7090             VkRenderingFragmentDensityMapAttachmentInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7091             const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *in_ext = (const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *)in_header;
7092             out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT;
7093             out_ext->pNext = NULL;
7094             out_ext->imageView = in_ext->imageView;
7095             out_ext->imageLayout = in_ext->imageLayout;
7096             out_header->pNext = (void *)out_ext;
7097             out_header = (void *)out_ext;
7098             break;
7099         }
7100         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
7101         {
7102             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7103             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
7104             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
7105             out_ext->pNext = NULL;
7106             out_ext->perViewAttributes = in_ext->perViewAttributes;
7107             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
7108             out_header->pNext = (void *)out_ext;
7109             out_header = (void *)out_ext;
7110             break;
7111         }
7112         default:
7113             FIXME("Unhandled sType %u.", in_header->sType);
7114             break;
7115         }
7116     }
7117 }
7118
7119 static inline void convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, VkDescriptorBufferBindingInfoEXT *out)
7120 {
7121     const VkBaseInStructure32 *in_header;
7122     VkBaseOutStructure *out_header = (void *)out;
7123
7124     if (!in) return;
7125
7126     out->sType = in->sType;
7127     out->pNext = NULL;
7128     out->address = in->address;
7129     out->usage = in->usage;
7130
7131     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7132     {
7133         switch (in_header->sType)
7134         {
7135         case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
7136         {
7137             VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7138             const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32 *in_ext = (const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32 *)in_header;
7139             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT;
7140             out_ext->pNext = NULL;
7141             out_ext->buffer = in_ext->buffer;
7142             out_header->pNext = (void *)out_ext;
7143             out_header = (void *)out_ext;
7144             break;
7145         }
7146         default:
7147             FIXME("Unhandled sType %u.", in_header->sType);
7148             break;
7149         }
7150     }
7151 }
7152
7153 static inline const VkDescriptorBufferBindingInfoEXT *convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, uint32_t count)
7154 {
7155     VkDescriptorBufferBindingInfoEXT *out;
7156     unsigned int i;
7157
7158     if (!in || !count) return NULL;
7159
7160     out = conversion_context_alloc(ctx, count * sizeof(*out));
7161     for (i = 0; i < count; i++)
7162     {
7163         convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(ctx, &in[i], &out[i]);
7164     }
7165
7166     return out;
7167 }
7168
7169 static inline void convert_VkImageBlit2_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, VkImageBlit2 *out)
7170 {
7171     const VkBaseInStructure32 *in_header;
7172     VkBaseOutStructure *out_header = (void *)out;
7173
7174     if (!in) return;
7175
7176     out->sType = in->sType;
7177     out->pNext = NULL;
7178     out->srcSubresource = in->srcSubresource;
7179     memcpy(out->srcOffsets, in->srcOffsets, 2 * sizeof(VkOffset3D));
7180     out->dstSubresource = in->dstSubresource;
7181     memcpy(out->dstOffsets, in->dstOffsets, 2 * sizeof(VkOffset3D));
7182
7183     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7184     {
7185         switch (in_header->sType)
7186         {
7187         case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
7188         {
7189             VkCopyCommandTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7190             const VkCopyCommandTransformInfoQCOM32 *in_ext = (const VkCopyCommandTransformInfoQCOM32 *)in_header;
7191             out_ext->sType = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM;
7192             out_ext->pNext = NULL;
7193             out_ext->transform = in_ext->transform;
7194             out_header->pNext = (void *)out_ext;
7195             out_header = (void *)out_ext;
7196             break;
7197         }
7198         default:
7199             FIXME("Unhandled sType %u.", in_header->sType);
7200             break;
7201         }
7202     }
7203 }
7204
7205 static inline const VkImageBlit2 *convert_VkImageBlit2_array_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, uint32_t count)
7206 {
7207     VkImageBlit2 *out;
7208     unsigned int i;
7209
7210     if (!in || !count) return NULL;
7211
7212     out = conversion_context_alloc(ctx, count * sizeof(*out));
7213     for (i = 0; i < count; i++)
7214     {
7215         convert_VkImageBlit2_win32_to_host(ctx, &in[i], &out[i]);
7216     }
7217
7218     return out;
7219 }
7220
7221 static inline void convert_VkBlitImageInfo2_win32_to_host(struct conversion_context *ctx, const VkBlitImageInfo232 *in, VkBlitImageInfo2 *out)
7222 {
7223     if (!in) return;
7224
7225     out->sType = in->sType;
7226     out->pNext = NULL;
7227     out->srcImage = in->srcImage;
7228     out->srcImageLayout = in->srcImageLayout;
7229     out->dstImage = in->dstImage;
7230     out->dstImageLayout = in->dstImageLayout;
7231     out->regionCount = in->regionCount;
7232     out->pRegions = convert_VkImageBlit2_array_win32_to_host(ctx, (const VkImageBlit232 *)UlongToPtr(in->pRegions), in->regionCount);
7233     out->filter = in->filter;
7234     if (in->pNext)
7235         FIXME("Unexpected pNext\n");
7236 }
7237
7238 static inline void convert_VkGeometryTrianglesNV_win32_to_host(const VkGeometryTrianglesNV32 *in, VkGeometryTrianglesNV *out)
7239 {
7240     if (!in) return;
7241
7242     out->sType = in->sType;
7243     out->pNext = NULL;
7244     out->vertexData = in->vertexData;
7245     out->vertexOffset = in->vertexOffset;
7246     out->vertexCount = in->vertexCount;
7247     out->vertexStride = in->vertexStride;
7248     out->vertexFormat = in->vertexFormat;
7249     out->indexData = in->indexData;
7250     out->indexOffset = in->indexOffset;
7251     out->indexCount = in->indexCount;
7252     out->indexType = in->indexType;
7253     out->transformData = in->transformData;
7254     out->transformOffset = in->transformOffset;
7255     if (in->pNext)
7256         FIXME("Unexpected pNext\n");
7257 }
7258
7259 static inline void convert_VkGeometryAABBNV_win32_to_host(const VkGeometryAABBNV32 *in, VkGeometryAABBNV *out)
7260 {
7261     if (!in) return;
7262
7263     out->sType = in->sType;
7264     out->pNext = NULL;
7265     out->aabbData = in->aabbData;
7266     out->numAABBs = in->numAABBs;
7267     out->stride = in->stride;
7268     out->offset = in->offset;
7269     if (in->pNext)
7270         FIXME("Unexpected pNext\n");
7271 }
7272
7273 static inline void convert_VkGeometryDataNV_win32_to_host(const VkGeometryDataNV32 *in, VkGeometryDataNV *out)
7274 {
7275     if (!in) return;
7276
7277     convert_VkGeometryTrianglesNV_win32_to_host(&in->triangles, &out->triangles);
7278     convert_VkGeometryAABBNV_win32_to_host(&in->aabbs, &out->aabbs);
7279 }
7280
7281 static inline void convert_VkGeometryNV_win32_to_host(const VkGeometryNV32 *in, VkGeometryNV *out)
7282 {
7283     if (!in) return;
7284
7285     out->sType = in->sType;
7286     out->pNext = NULL;
7287     out->geometryType = in->geometryType;
7288     convert_VkGeometryDataNV_win32_to_host(&in->geometry, &out->geometry);
7289     out->flags = in->flags;
7290     if (in->pNext)
7291         FIXME("Unexpected pNext\n");
7292 }
7293
7294 static inline const VkGeometryNV *convert_VkGeometryNV_array_win32_to_host(struct conversion_context *ctx, const VkGeometryNV32 *in, uint32_t count)
7295 {
7296     VkGeometryNV *out;
7297     unsigned int i;
7298
7299     if (!in || !count) return NULL;
7300
7301     out = conversion_context_alloc(ctx, count * sizeof(*out));
7302     for (i = 0; i < count; i++)
7303     {
7304         convert_VkGeometryNV_win32_to_host(&in[i], &out[i]);
7305     }
7306
7307     return out;
7308 }
7309
7310 static inline void convert_VkAccelerationStructureInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureInfoNV32 *in, VkAccelerationStructureInfoNV *out)
7311 {
7312     if (!in) return;
7313
7314     out->sType = in->sType;
7315     out->pNext = NULL;
7316     out->type = in->type;
7317     out->flags = in->flags;
7318     out->instanceCount = in->instanceCount;
7319     out->geometryCount = in->geometryCount;
7320     out->pGeometries = convert_VkGeometryNV_array_win32_to_host(ctx, (const VkGeometryNV32 *)UlongToPtr(in->pGeometries), in->geometryCount);
7321     if (in->pNext)
7322         FIXME("Unexpected pNext\n");
7323 }
7324
7325 static inline void convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(const VkCopyAccelerationStructureInfoKHR32 *in, VkCopyAccelerationStructureInfoKHR *out)
7326 {
7327     if (!in) return;
7328
7329     out->sType = in->sType;
7330     out->pNext = NULL;
7331     out->src = in->src;
7332     out->dst = in->dst;
7333     out->mode = in->mode;
7334     if (in->pNext)
7335         FIXME("Unexpected pNext\n");
7336 }
7337
7338 static inline void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(const VkCopyAccelerationStructureToMemoryInfoKHR32 *in, VkCopyAccelerationStructureToMemoryInfoKHR *out)
7339 {
7340     if (!in) return;
7341
7342     out->sType = in->sType;
7343     out->pNext = NULL;
7344     out->src = in->src;
7345     out->dst = in->dst;
7346     out->mode = in->mode;
7347     if (in->pNext)
7348         FIXME("Unexpected pNext\n");
7349 }
7350
7351 static inline void convert_VkBufferCopy_win32_to_host(const VkBufferCopy32 *in, VkBufferCopy *out)
7352 {
7353     if (!in) return;
7354
7355     out->srcOffset = in->srcOffset;
7356     out->dstOffset = in->dstOffset;
7357     out->size = in->size;
7358 }
7359
7360 static inline const VkBufferCopy *convert_VkBufferCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy32 *in, uint32_t count)
7361 {
7362     VkBufferCopy *out;
7363     unsigned int i;
7364
7365     if (!in || !count) return NULL;
7366
7367     out = conversion_context_alloc(ctx, count * sizeof(*out));
7368     for (i = 0; i < count; i++)
7369     {
7370         convert_VkBufferCopy_win32_to_host(&in[i], &out[i]);
7371     }
7372
7373     return out;
7374 }
7375
7376 static inline void convert_VkBufferCopy2_win32_to_host(const VkBufferCopy232 *in, VkBufferCopy2 *out)
7377 {
7378     if (!in) return;
7379
7380     out->sType = in->sType;
7381     out->pNext = NULL;
7382     out->srcOffset = in->srcOffset;
7383     out->dstOffset = in->dstOffset;
7384     out->size = in->size;
7385     if (in->pNext)
7386         FIXME("Unexpected pNext\n");
7387 }
7388
7389 static inline const VkBufferCopy2 *convert_VkBufferCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy232 *in, uint32_t count)
7390 {
7391     VkBufferCopy2 *out;
7392     unsigned int i;
7393
7394     if (!in || !count) return NULL;
7395
7396     out = conversion_context_alloc(ctx, count * sizeof(*out));
7397     for (i = 0; i < count; i++)
7398     {
7399         convert_VkBufferCopy2_win32_to_host(&in[i], &out[i]);
7400     }
7401
7402     return out;
7403 }
7404
7405 static inline void convert_VkCopyBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferInfo232 *in, VkCopyBufferInfo2 *out)
7406 {
7407     if (!in) return;
7408
7409     out->sType = in->sType;
7410     out->pNext = NULL;
7411     out->srcBuffer = in->srcBuffer;
7412     out->dstBuffer = in->dstBuffer;
7413     out->regionCount = in->regionCount;
7414     out->pRegions = convert_VkBufferCopy2_array_win32_to_host(ctx, (const VkBufferCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
7415     if (in->pNext)
7416         FIXME("Unexpected pNext\n");
7417 }
7418
7419 static inline void convert_VkBufferImageCopy_win32_to_host(const VkBufferImageCopy32 *in, VkBufferImageCopy *out)
7420 {
7421     if (!in) return;
7422
7423     out->bufferOffset = in->bufferOffset;
7424     out->bufferRowLength = in->bufferRowLength;
7425     out->bufferImageHeight = in->bufferImageHeight;
7426     out->imageSubresource = in->imageSubresource;
7427     out->imageOffset = in->imageOffset;
7428     out->imageExtent = in->imageExtent;
7429 }
7430
7431 static inline const VkBufferImageCopy *convert_VkBufferImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy32 *in, uint32_t count)
7432 {
7433     VkBufferImageCopy *out;
7434     unsigned int i;
7435
7436     if (!in || !count) return NULL;
7437
7438     out = conversion_context_alloc(ctx, count * sizeof(*out));
7439     for (i = 0; i < count; i++)
7440     {
7441         convert_VkBufferImageCopy_win32_to_host(&in[i], &out[i]);
7442     }
7443
7444     return out;
7445 }
7446
7447 static inline void convert_VkBufferImageCopy2_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, VkBufferImageCopy2 *out)
7448 {
7449     const VkBaseInStructure32 *in_header;
7450     VkBaseOutStructure *out_header = (void *)out;
7451
7452     if (!in) return;
7453
7454     out->sType = in->sType;
7455     out->pNext = NULL;
7456     out->bufferOffset = in->bufferOffset;
7457     out->bufferRowLength = in->bufferRowLength;
7458     out->bufferImageHeight = in->bufferImageHeight;
7459     out->imageSubresource = in->imageSubresource;
7460     out->imageOffset = in->imageOffset;
7461     out->imageExtent = in->imageExtent;
7462
7463     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7464     {
7465         switch (in_header->sType)
7466         {
7467         case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
7468         {
7469             VkCopyCommandTransformInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7470             const VkCopyCommandTransformInfoQCOM32 *in_ext = (const VkCopyCommandTransformInfoQCOM32 *)in_header;
7471             out_ext->sType = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM;
7472             out_ext->pNext = NULL;
7473             out_ext->transform = in_ext->transform;
7474             out_header->pNext = (void *)out_ext;
7475             out_header = (void *)out_ext;
7476             break;
7477         }
7478         default:
7479             FIXME("Unhandled sType %u.", in_header->sType);
7480             break;
7481         }
7482     }
7483 }
7484
7485 static inline const VkBufferImageCopy2 *convert_VkBufferImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, uint32_t count)
7486 {
7487     VkBufferImageCopy2 *out;
7488     unsigned int i;
7489
7490     if (!in || !count) return NULL;
7491
7492     out = conversion_context_alloc(ctx, count * sizeof(*out));
7493     for (i = 0; i < count; i++)
7494     {
7495         convert_VkBufferImageCopy2_win32_to_host(ctx, &in[i], &out[i]);
7496     }
7497
7498     return out;
7499 }
7500
7501 static inline void convert_VkCopyBufferToImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferToImageInfo232 *in, VkCopyBufferToImageInfo2 *out)
7502 {
7503     if (!in) return;
7504
7505     out->sType = in->sType;
7506     out->pNext = NULL;
7507     out->srcBuffer = in->srcBuffer;
7508     out->dstImage = in->dstImage;
7509     out->dstImageLayout = in->dstImageLayout;
7510     out->regionCount = in->regionCount;
7511     out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, (const VkBufferImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
7512     if (in->pNext)
7513         FIXME("Unexpected pNext\n");
7514 }
7515
7516 static inline void convert_VkImageCopy2_win32_to_host(const VkImageCopy232 *in, VkImageCopy2 *out)
7517 {
7518     if (!in) return;
7519
7520     out->sType = in->sType;
7521     out->pNext = NULL;
7522     out->srcSubresource = in->srcSubresource;
7523     out->srcOffset = in->srcOffset;
7524     out->dstSubresource = in->dstSubresource;
7525     out->dstOffset = in->dstOffset;
7526     out->extent = in->extent;
7527     if (in->pNext)
7528         FIXME("Unexpected pNext\n");
7529 }
7530
7531 static inline const VkImageCopy2 *convert_VkImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkImageCopy232 *in, uint32_t count)
7532 {
7533     VkImageCopy2 *out;
7534     unsigned int i;
7535
7536     if (!in || !count) return NULL;
7537
7538     out = conversion_context_alloc(ctx, count * sizeof(*out));
7539     for (i = 0; i < count; i++)
7540     {
7541         convert_VkImageCopy2_win32_to_host(&in[i], &out[i]);
7542     }
7543
7544     return out;
7545 }
7546
7547 static inline void convert_VkCopyImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageInfo232 *in, VkCopyImageInfo2 *out)
7548 {
7549     if (!in) return;
7550
7551     out->sType = in->sType;
7552     out->pNext = NULL;
7553     out->srcImage = in->srcImage;
7554     out->srcImageLayout = in->srcImageLayout;
7555     out->dstImage = in->dstImage;
7556     out->dstImageLayout = in->dstImageLayout;
7557     out->regionCount = in->regionCount;
7558     out->pRegions = convert_VkImageCopy2_array_win32_to_host(ctx, (const VkImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
7559     if (in->pNext)
7560         FIXME("Unexpected pNext\n");
7561 }
7562
7563 static inline void convert_VkCopyImageToBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageToBufferInfo232 *in, VkCopyImageToBufferInfo2 *out)
7564 {
7565     if (!in) return;
7566
7567     out->sType = in->sType;
7568     out->pNext = NULL;
7569     out->srcImage = in->srcImage;
7570     out->srcImageLayout = in->srcImageLayout;
7571     out->dstBuffer = in->dstBuffer;
7572     out->regionCount = in->regionCount;
7573     out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, (const VkBufferImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
7574     if (in->pNext)
7575         FIXME("Unexpected pNext\n");
7576 }
7577
7578 static inline void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(const VkCopyMemoryToAccelerationStructureInfoKHR32 *in, VkCopyMemoryToAccelerationStructureInfoKHR *out)
7579 {
7580     if (!in) return;
7581
7582     out->sType = in->sType;
7583     out->pNext = NULL;
7584     out->src = in->src;
7585     out->dst = in->dst;
7586     out->mode = in->mode;
7587     if (in->pNext)
7588         FIXME("Unexpected pNext\n");
7589 }
7590
7591 static inline void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkCopyMemoryToMicromapInfoEXT32 *in, VkCopyMemoryToMicromapInfoEXT *out)
7592 {
7593     if (!in) return;
7594
7595     out->sType = in->sType;
7596     out->pNext = NULL;
7597     out->src = in->src;
7598     out->dst = in->dst;
7599     out->mode = in->mode;
7600     if (in->pNext)
7601         FIXME("Unexpected pNext\n");
7602 }
7603
7604 static inline void convert_VkCopyMicromapInfoEXT_win32_to_host(const VkCopyMicromapInfoEXT32 *in, VkCopyMicromapInfoEXT *out)
7605 {
7606     if (!in) return;
7607
7608     out->sType = in->sType;
7609     out->pNext = NULL;
7610     out->src = in->src;
7611     out->dst = in->dst;
7612     out->mode = in->mode;
7613     if (in->pNext)
7614         FIXME("Unexpected pNext\n");
7615 }
7616
7617 static inline void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkCopyMicromapToMemoryInfoEXT32 *in, VkCopyMicromapToMemoryInfoEXT *out)
7618 {
7619     if (!in) return;
7620
7621     out->sType = in->sType;
7622     out->pNext = NULL;
7623     out->src = in->src;
7624     out->dst = in->dst;
7625     out->mode = in->mode;
7626     if (in->pNext)
7627         FIXME("Unexpected pNext\n");
7628 }
7629
7630 static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoNVX32 *in, VkCuLaunchInfoNVX *out)
7631 {
7632     if (!in) return;
7633
7634     out->sType = in->sType;
7635     out->pNext = NULL;
7636     out->function = in->function;
7637     out->gridDimX = in->gridDimX;
7638     out->gridDimY = in->gridDimY;
7639     out->gridDimZ = in->gridDimZ;
7640     out->blockDimX = in->blockDimX;
7641     out->blockDimY = in->blockDimY;
7642     out->blockDimZ = in->blockDimZ;
7643     out->sharedMemBytes = in->sharedMemBytes;
7644     out->paramCount = in->paramCount;
7645     out->pParams = (const void * const *)UlongToPtr(in->pParams);
7646     out->extraCount = in->extraCount;
7647     out->pExtras = (const void * const *)UlongToPtr(in->pExtras);
7648     if (in->pNext)
7649         FIXME("Unexpected pNext\n");
7650 }
7651
7652 static inline void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebugMarkerMarkerInfoEXT32 *in, VkDebugMarkerMarkerInfoEXT *out)
7653 {
7654     if (!in) return;
7655
7656     out->sType = in->sType;
7657     out->pNext = NULL;
7658     out->pMarkerName = (const char *)UlongToPtr(in->pMarkerName);
7659     memcpy(out->color, in->color, 4 * sizeof(float));
7660     if (in->pNext)
7661         FIXME("Unexpected pNext\n");
7662 }
7663
7664 static inline void convert_VkDecompressMemoryRegionNV_win32_to_host(const VkDecompressMemoryRegionNV32 *in, VkDecompressMemoryRegionNV *out)
7665 {
7666     if (!in) return;
7667
7668     out->srcAddress = in->srcAddress;
7669     out->dstAddress = in->dstAddress;
7670     out->compressedSize = in->compressedSize;
7671     out->decompressedSize = in->decompressedSize;
7672     out->decompressionMethod = in->decompressionMethod;
7673 }
7674
7675 static inline const VkDecompressMemoryRegionNV *convert_VkDecompressMemoryRegionNV_array_win32_to_host(struct conversion_context *ctx, const VkDecompressMemoryRegionNV32 *in, uint32_t count)
7676 {
7677     VkDecompressMemoryRegionNV *out;
7678     unsigned int i;
7679
7680     if (!in || !count) return NULL;
7681
7682     out = conversion_context_alloc(ctx, count * sizeof(*out));
7683     for (i = 0; i < count; i++)
7684     {
7685         convert_VkDecompressMemoryRegionNV_win32_to_host(&in[i], &out[i]);
7686     }
7687
7688     return out;
7689 }
7690
7691 static inline void convert_VkSubpassEndInfo_win32_to_host(struct conversion_context *ctx, const VkSubpassEndInfo32 *in, VkSubpassEndInfo *out)
7692 {
7693     const VkBaseInStructure32 *in_header;
7694     VkBaseOutStructure *out_header = (void *)out;
7695
7696     if (!in) return;
7697
7698     out->sType = in->sType;
7699     out->pNext = NULL;
7700
7701     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7702     {
7703         switch (in_header->sType)
7704         {
7705         case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
7706         {
7707             VkSubpassFragmentDensityMapOffsetEndInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7708             const VkSubpassFragmentDensityMapOffsetEndInfoQCOM32 *in_ext = (const VkSubpassFragmentDensityMapOffsetEndInfoQCOM32 *)in_header;
7709             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM;
7710             out_ext->pNext = NULL;
7711             out_ext->fragmentDensityOffsetCount = in_ext->fragmentDensityOffsetCount;
7712             out_ext->pFragmentDensityOffsets = (const VkOffset2D *)UlongToPtr(in_ext->pFragmentDensityOffsets);
7713             out_header->pNext = (void *)out_ext;
7714             out_header = (void *)out_ext;
7715             break;
7716         }
7717         default:
7718             FIXME("Unhandled sType %u.", in_header->sType);
7719             break;
7720         }
7721     }
7722 }
7723
7724 #ifdef _WIN64
7725 static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win64_to_host(struct conversion_context *ctx, const VkCommandBuffer *in, uint32_t count)
7726 {
7727     VkCommandBuffer *out;
7728     unsigned int i;
7729
7730     if (!in || !count) return NULL;
7731
7732     out = conversion_context_alloc(ctx, count * sizeof(*out));
7733     for (i = 0; i < count; i++)
7734     {
7735         out[i] = wine_cmd_buffer_from_handle(in[i])->command_buffer;
7736     }
7737
7738     return out;
7739 }
7740 #endif /* _WIN64 */
7741
7742 static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
7743 {
7744     VkCommandBuffer *out;
7745     unsigned int i;
7746
7747     if (!in || !count) return NULL;
7748
7749     out = conversion_context_alloc(ctx, count * sizeof(*out));
7750     for (i = 0; i < count; i++)
7751     {
7752         out[i] = wine_cmd_buffer_from_handle(UlongToPtr(in[i]))->command_buffer;
7753     }
7754
7755     return out;
7756 }
7757
7758 static inline void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndirectCommandsStreamNV32 *in, VkIndirectCommandsStreamNV *out)
7759 {
7760     if (!in) return;
7761
7762     out->buffer = in->buffer;
7763     out->offset = in->offset;
7764 }
7765
7766 static inline const VkIndirectCommandsStreamNV *convert_VkIndirectCommandsStreamNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsStreamNV32 *in, uint32_t count)
7767 {
7768     VkIndirectCommandsStreamNV *out;
7769     unsigned int i;
7770
7771     if (!in || !count) return NULL;
7772
7773     out = conversion_context_alloc(ctx, count * sizeof(*out));
7774     for (i = 0; i < count; i++)
7775     {
7776         convert_VkIndirectCommandsStreamNV_win32_to_host(&in[i], &out[i]);
7777     }
7778
7779     return out;
7780 }
7781
7782 static inline void convert_VkGeneratedCommandsInfoNV_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoNV32 *in, VkGeneratedCommandsInfoNV *out)
7783 {
7784     if (!in) return;
7785
7786     out->sType = in->sType;
7787     out->pNext = NULL;
7788     out->pipelineBindPoint = in->pipelineBindPoint;
7789     out->pipeline = in->pipeline;
7790     out->indirectCommandsLayout = in->indirectCommandsLayout;
7791     out->streamCount = in->streamCount;
7792     out->pStreams = convert_VkIndirectCommandsStreamNV_array_win32_to_host(ctx, (const VkIndirectCommandsStreamNV32 *)UlongToPtr(in->pStreams), in->streamCount);
7793     out->sequencesCount = in->sequencesCount;
7794     out->preprocessBuffer = in->preprocessBuffer;
7795     out->preprocessOffset = in->preprocessOffset;
7796     out->preprocessSize = in->preprocessSize;
7797     out->sequencesCountBuffer = in->sequencesCountBuffer;
7798     out->sequencesCountOffset = in->sequencesCountOffset;
7799     out->sequencesIndexBuffer = in->sequencesIndexBuffer;
7800     out->sequencesIndexOffset = in->sequencesIndexOffset;
7801     if (in->pNext)
7802         FIXME("Unexpected pNext\n");
7803 }
7804
7805 static inline void convert_VkOpticalFlowExecuteInfoNV_win32_to_host(const VkOpticalFlowExecuteInfoNV32 *in, VkOpticalFlowExecuteInfoNV *out)
7806 {
7807     if (!in) return;
7808
7809     out->sType = in->sType;
7810     out->pNext = NULL;
7811     out->flags = in->flags;
7812     out->regionCount = in->regionCount;
7813     out->pRegions = (const VkRect2D *)UlongToPtr(in->pRegions);
7814     if (in->pNext)
7815         FIXME("Unexpected pNext\n");
7816 }
7817
7818 static inline void convert_VkMemoryBarrier_win32_to_host(const VkMemoryBarrier32 *in, VkMemoryBarrier *out)
7819 {
7820     if (!in) return;
7821
7822     out->sType = in->sType;
7823     out->pNext = NULL;
7824     out->srcAccessMask = in->srcAccessMask;
7825     out->dstAccessMask = in->dstAccessMask;
7826     if (in->pNext)
7827         FIXME("Unexpected pNext\n");
7828 }
7829
7830 static inline const VkMemoryBarrier *convert_VkMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier32 *in, uint32_t count)
7831 {
7832     VkMemoryBarrier *out;
7833     unsigned int i;
7834
7835     if (!in || !count) return NULL;
7836
7837     out = conversion_context_alloc(ctx, count * sizeof(*out));
7838     for (i = 0; i < count; i++)
7839     {
7840         convert_VkMemoryBarrier_win32_to_host(&in[i], &out[i]);
7841     }
7842
7843     return out;
7844 }
7845
7846 static inline void convert_VkBufferMemoryBarrier_win32_to_host(const VkBufferMemoryBarrier32 *in, VkBufferMemoryBarrier *out)
7847 {
7848     if (!in) return;
7849
7850     out->sType = in->sType;
7851     out->pNext = NULL;
7852     out->srcAccessMask = in->srcAccessMask;
7853     out->dstAccessMask = in->dstAccessMask;
7854     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
7855     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
7856     out->buffer = in->buffer;
7857     out->offset = in->offset;
7858     out->size = in->size;
7859     if (in->pNext)
7860         FIXME("Unexpected pNext\n");
7861 }
7862
7863 static inline const VkBufferMemoryBarrier *convert_VkBufferMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, uint32_t count)
7864 {
7865     VkBufferMemoryBarrier *out;
7866     unsigned int i;
7867
7868     if (!in || !count) return NULL;
7869
7870     out = conversion_context_alloc(ctx, count * sizeof(*out));
7871     for (i = 0; i < count; i++)
7872     {
7873         convert_VkBufferMemoryBarrier_win32_to_host(&in[i], &out[i]);
7874     }
7875
7876     return out;
7877 }
7878
7879 static inline void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, VkImageMemoryBarrier *out)
7880 {
7881     const VkBaseInStructure32 *in_header;
7882     VkBaseOutStructure *out_header = (void *)out;
7883
7884     if (!in) return;
7885
7886     out->sType = in->sType;
7887     out->pNext = NULL;
7888     out->srcAccessMask = in->srcAccessMask;
7889     out->dstAccessMask = in->dstAccessMask;
7890     out->oldLayout = in->oldLayout;
7891     out->newLayout = in->newLayout;
7892     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
7893     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
7894     out->image = in->image;
7895     out->subresourceRange = in->subresourceRange;
7896
7897     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
7898     {
7899         switch (in_header->sType)
7900         {
7901         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
7902         {
7903             VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7904             const VkSampleLocationsInfoEXT32 *in_ext = (const VkSampleLocationsInfoEXT32 *)in_header;
7905             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT;
7906             out_ext->pNext = NULL;
7907             out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel;
7908             out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize;
7909             out_ext->sampleLocationsCount = in_ext->sampleLocationsCount;
7910             out_ext->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in_ext->pSampleLocations);
7911             out_header->pNext = (void *)out_ext;
7912             out_header = (void *)out_ext;
7913             break;
7914         }
7915         default:
7916             FIXME("Unhandled sType %u.", in_header->sType);
7917             break;
7918         }
7919     }
7920 }
7921
7922 static inline const VkImageMemoryBarrier *convert_VkImageMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, uint32_t count)
7923 {
7924     VkImageMemoryBarrier *out;
7925     unsigned int i;
7926
7927     if (!in || !count) return NULL;
7928
7929     out = conversion_context_alloc(ctx, count * sizeof(*out));
7930     for (i = 0; i < count; i++)
7931     {
7932         convert_VkImageMemoryBarrier_win32_to_host(ctx, &in[i], &out[i]);
7933     }
7934
7935     return out;
7936 }
7937
7938 static inline void convert_VkMemoryBarrier2_win32_to_host(const VkMemoryBarrier232 *in, VkMemoryBarrier2 *out)
7939 {
7940     if (!in) return;
7941
7942     out->sType = in->sType;
7943     out->pNext = NULL;
7944     out->srcStageMask = in->srcStageMask;
7945     out->srcAccessMask = in->srcAccessMask;
7946     out->dstStageMask = in->dstStageMask;
7947     out->dstAccessMask = in->dstAccessMask;
7948     if (in->pNext)
7949         FIXME("Unexpected pNext\n");
7950 }
7951
7952 static inline const VkMemoryBarrier2 *convert_VkMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier232 *in, uint32_t count)
7953 {
7954     VkMemoryBarrier2 *out;
7955     unsigned int i;
7956
7957     if (!in || !count) return NULL;
7958
7959     out = conversion_context_alloc(ctx, count * sizeof(*out));
7960     for (i = 0; i < count; i++)
7961     {
7962         convert_VkMemoryBarrier2_win32_to_host(&in[i], &out[i]);
7963     }
7964
7965     return out;
7966 }
7967
7968 static inline void convert_VkBufferMemoryBarrier2_win32_to_host(const VkBufferMemoryBarrier232 *in, VkBufferMemoryBarrier2 *out)
7969 {
7970     if (!in) return;
7971
7972     out->sType = in->sType;
7973     out->pNext = NULL;
7974     out->srcStageMask = in->srcStageMask;
7975     out->srcAccessMask = in->srcAccessMask;
7976     out->dstStageMask = in->dstStageMask;
7977     out->dstAccessMask = in->dstAccessMask;
7978     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
7979     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
7980     out->buffer = in->buffer;
7981     out->offset = in->offset;
7982     out->size = in->size;
7983     if (in->pNext)
7984         FIXME("Unexpected pNext\n");
7985 }
7986
7987 static inline const VkBufferMemoryBarrier2 *convert_VkBufferMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, uint32_t count)
7988 {
7989     VkBufferMemoryBarrier2 *out;
7990     unsigned int i;
7991
7992     if (!in || !count) return NULL;
7993
7994     out = conversion_context_alloc(ctx, count * sizeof(*out));
7995     for (i = 0; i < count; i++)
7996     {
7997         convert_VkBufferMemoryBarrier2_win32_to_host(&in[i], &out[i]);
7998     }
7999
8000     return out;
8001 }
8002
8003 static inline void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, VkImageMemoryBarrier2 *out)
8004 {
8005     const VkBaseInStructure32 *in_header;
8006     VkBaseOutStructure *out_header = (void *)out;
8007
8008     if (!in) return;
8009
8010     out->sType = in->sType;
8011     out->pNext = NULL;
8012     out->srcStageMask = in->srcStageMask;
8013     out->srcAccessMask = in->srcAccessMask;
8014     out->dstStageMask = in->dstStageMask;
8015     out->dstAccessMask = in->dstAccessMask;
8016     out->oldLayout = in->oldLayout;
8017     out->newLayout = in->newLayout;
8018     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
8019     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
8020     out->image = in->image;
8021     out->subresourceRange = in->subresourceRange;
8022
8023     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8024     {
8025         switch (in_header->sType)
8026         {
8027         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
8028         {
8029             VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8030             const VkSampleLocationsInfoEXT32 *in_ext = (const VkSampleLocationsInfoEXT32 *)in_header;
8031             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT;
8032             out_ext->pNext = NULL;
8033             out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel;
8034             out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize;
8035             out_ext->sampleLocationsCount = in_ext->sampleLocationsCount;
8036             out_ext->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in_ext->pSampleLocations);
8037             out_header->pNext = (void *)out_ext;
8038             out_header = (void *)out_ext;
8039             break;
8040         }
8041         default:
8042             FIXME("Unhandled sType %u.", in_header->sType);
8043             break;
8044         }
8045     }
8046 }
8047
8048 static inline const VkImageMemoryBarrier2 *convert_VkImageMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, uint32_t count)
8049 {
8050     VkImageMemoryBarrier2 *out;
8051     unsigned int i;
8052
8053     if (!in || !count) return NULL;
8054
8055     out = conversion_context_alloc(ctx, count * sizeof(*out));
8056     for (i = 0; i < count; i++)
8057     {
8058         convert_VkImageMemoryBarrier2_win32_to_host(ctx, &in[i], &out[i]);
8059     }
8060
8061     return out;
8062 }
8063
8064 static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, VkDependencyInfo *out)
8065 {
8066     if (!in) return;
8067
8068     out->sType = in->sType;
8069     out->pNext = NULL;
8070     out->dependencyFlags = in->dependencyFlags;
8071     out->memoryBarrierCount = in->memoryBarrierCount;
8072     out->pMemoryBarriers = convert_VkMemoryBarrier2_array_win32_to_host(ctx, (const VkMemoryBarrier232 *)UlongToPtr(in->pMemoryBarriers), in->memoryBarrierCount);
8073     out->bufferMemoryBarrierCount = in->bufferMemoryBarrierCount;
8074     out->pBufferMemoryBarriers = convert_VkBufferMemoryBarrier2_array_win32_to_host(ctx, (const VkBufferMemoryBarrier232 *)UlongToPtr(in->pBufferMemoryBarriers), in->bufferMemoryBarrierCount);
8075     out->imageMemoryBarrierCount = in->imageMemoryBarrierCount;
8076     out->pImageMemoryBarriers = convert_VkImageMemoryBarrier2_array_win32_to_host(ctx, (const VkImageMemoryBarrier232 *)UlongToPtr(in->pImageMemoryBarriers), in->imageMemoryBarrierCount);
8077     if (in->pNext)
8078         FIXME("Unexpected pNext\n");
8079 }
8080
8081 static inline void convert_VkDescriptorImageInfo_win32_to_host(const VkDescriptorImageInfo32 *in, VkDescriptorImageInfo *out)
8082 {
8083     if (!in) return;
8084
8085     out->sampler = in->sampler;
8086     out->imageView = in->imageView;
8087     out->imageLayout = in->imageLayout;
8088 }
8089
8090 static inline const VkDescriptorImageInfo *convert_VkDescriptorImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorImageInfo32 *in, uint32_t count)
8091 {
8092     VkDescriptorImageInfo *out;
8093     unsigned int i;
8094
8095     if (!in || !count) return NULL;
8096
8097     out = conversion_context_alloc(ctx, count * sizeof(*out));
8098     for (i = 0; i < count; i++)
8099     {
8100         convert_VkDescriptorImageInfo_win32_to_host(&in[i], &out[i]);
8101     }
8102
8103     return out;
8104 }
8105
8106 static inline void convert_VkDescriptorBufferInfo_win32_to_host(const VkDescriptorBufferInfo32 *in, VkDescriptorBufferInfo *out)
8107 {
8108     if (!in) return;
8109
8110     out->buffer = in->buffer;
8111     out->offset = in->offset;
8112     out->range = in->range;
8113 }
8114
8115 static inline const VkDescriptorBufferInfo *convert_VkDescriptorBufferInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferInfo32 *in, uint32_t count)
8116 {
8117     VkDescriptorBufferInfo *out;
8118     unsigned int i;
8119
8120     if (!in || !count) return NULL;
8121
8122     out = conversion_context_alloc(ctx, count * sizeof(*out));
8123     for (i = 0; i < count; i++)
8124     {
8125         convert_VkDescriptorBufferInfo_win32_to_host(&in[i], &out[i]);
8126     }
8127
8128     return out;
8129 }
8130
8131 static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, VkWriteDescriptorSet *out)
8132 {
8133     const VkBaseInStructure32 *in_header;
8134     VkBaseOutStructure *out_header = (void *)out;
8135
8136     if (!in) return;
8137
8138     out->sType = in->sType;
8139     out->pNext = NULL;
8140     out->dstSet = in->dstSet;
8141     out->dstBinding = in->dstBinding;
8142     out->dstArrayElement = in->dstArrayElement;
8143     out->descriptorCount = in->descriptorCount;
8144     out->descriptorType = in->descriptorType;
8145     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);
8146     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);
8147     out->pTexelBufferView = (const VkBufferView *)UlongToPtr(in->pTexelBufferView);
8148
8149     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8150     {
8151         switch (in_header->sType)
8152         {
8153         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
8154         {
8155             VkWriteDescriptorSetInlineUniformBlock *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8156             const VkWriteDescriptorSetInlineUniformBlock32 *in_ext = (const VkWriteDescriptorSetInlineUniformBlock32 *)in_header;
8157             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
8158             out_ext->pNext = NULL;
8159             out_ext->dataSize = in_ext->dataSize;
8160             out_ext->pData = (const void *)UlongToPtr(in_ext->pData);
8161             out_header->pNext = (void *)out_ext;
8162             out_header = (void *)out_ext;
8163             break;
8164         }
8165         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
8166         {
8167             VkWriteDescriptorSetAccelerationStructureKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8168             const VkWriteDescriptorSetAccelerationStructureKHR32 *in_ext = (const VkWriteDescriptorSetAccelerationStructureKHR32 *)in_header;
8169             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR;
8170             out_ext->pNext = NULL;
8171             out_ext->accelerationStructureCount = in_ext->accelerationStructureCount;
8172             out_ext->pAccelerationStructures = (const VkAccelerationStructureKHR *)UlongToPtr(in_ext->pAccelerationStructures);
8173             out_header->pNext = (void *)out_ext;
8174             out_header = (void *)out_ext;
8175             break;
8176         }
8177         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
8178         {
8179             VkWriteDescriptorSetAccelerationStructureNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8180             const VkWriteDescriptorSetAccelerationStructureNV32 *in_ext = (const VkWriteDescriptorSetAccelerationStructureNV32 *)in_header;
8181             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV;
8182             out_ext->pNext = NULL;
8183             out_ext->accelerationStructureCount = in_ext->accelerationStructureCount;
8184             out_ext->pAccelerationStructures = (const VkAccelerationStructureNV *)UlongToPtr(in_ext->pAccelerationStructures);
8185             out_header->pNext = (void *)out_ext;
8186             out_header = (void *)out_ext;
8187             break;
8188         }
8189         default:
8190             FIXME("Unhandled sType %u.", in_header->sType);
8191             break;
8192         }
8193     }
8194 }
8195
8196 static inline const VkWriteDescriptorSet *convert_VkWriteDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, uint32_t count)
8197 {
8198     VkWriteDescriptorSet *out;
8199     unsigned int i;
8200
8201     if (!in || !count) return NULL;
8202
8203     out = conversion_context_alloc(ctx, count * sizeof(*out));
8204     for (i = 0; i < count; i++)
8205     {
8206         convert_VkWriteDescriptorSet_win32_to_host(ctx, &in[i], &out[i]);
8207     }
8208
8209     return out;
8210 }
8211
8212 static inline void convert_VkImageResolve2_win32_to_host(const VkImageResolve232 *in, VkImageResolve2 *out)
8213 {
8214     if (!in) return;
8215
8216     out->sType = in->sType;
8217     out->pNext = NULL;
8218     out->srcSubresource = in->srcSubresource;
8219     out->srcOffset = in->srcOffset;
8220     out->dstSubresource = in->dstSubresource;
8221     out->dstOffset = in->dstOffset;
8222     out->extent = in->extent;
8223     if (in->pNext)
8224         FIXME("Unexpected pNext\n");
8225 }
8226
8227 static inline const VkImageResolve2 *convert_VkImageResolve2_array_win32_to_host(struct conversion_context *ctx, const VkImageResolve232 *in, uint32_t count)
8228 {
8229     VkImageResolve2 *out;
8230     unsigned int i;
8231
8232     if (!in || !count) return NULL;
8233
8234     out = conversion_context_alloc(ctx, count * sizeof(*out));
8235     for (i = 0; i < count; i++)
8236     {
8237         convert_VkImageResolve2_win32_to_host(&in[i], &out[i]);
8238     }
8239
8240     return out;
8241 }
8242
8243 static inline void convert_VkResolveImageInfo2_win32_to_host(struct conversion_context *ctx, const VkResolveImageInfo232 *in, VkResolveImageInfo2 *out)
8244 {
8245     if (!in) return;
8246
8247     out->sType = in->sType;
8248     out->pNext = NULL;
8249     out->srcImage = in->srcImage;
8250     out->srcImageLayout = in->srcImageLayout;
8251     out->dstImage = in->dstImage;
8252     out->dstImageLayout = in->dstImageLayout;
8253     out->regionCount = in->regionCount;
8254     out->pRegions = convert_VkImageResolve2_array_win32_to_host(ctx, (const VkImageResolve232 *)UlongToPtr(in->pRegions), in->regionCount);
8255     if (in->pNext)
8256         FIXME("Unexpected pNext\n");
8257 }
8258
8259 static inline void convert_VkCoarseSampleOrderCustomNV_win32_to_host(const VkCoarseSampleOrderCustomNV32 *in, VkCoarseSampleOrderCustomNV *out)
8260 {
8261     if (!in) return;
8262
8263     out->shadingRate = in->shadingRate;
8264     out->sampleCount = in->sampleCount;
8265     out->sampleLocationCount = in->sampleLocationCount;
8266     out->pSampleLocations = (const VkCoarseSampleLocationNV *)UlongToPtr(in->pSampleLocations);
8267 }
8268
8269 static inline const VkCoarseSampleOrderCustomNV *convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(struct conversion_context *ctx, const VkCoarseSampleOrderCustomNV32 *in, uint32_t count)
8270 {
8271     VkCoarseSampleOrderCustomNV *out;
8272     unsigned int i;
8273
8274     if (!in || !count) return NULL;
8275
8276     out = conversion_context_alloc(ctx, count * sizeof(*out));
8277     for (i = 0; i < count; i++)
8278     {
8279         convert_VkCoarseSampleOrderCustomNV_win32_to_host(&in[i], &out[i]);
8280     }
8281
8282     return out;
8283 }
8284
8285 static inline void convert_VkPerformanceMarkerInfoINTEL_win32_to_host(const VkPerformanceMarkerInfoINTEL32 *in, VkPerformanceMarkerInfoINTEL *out)
8286 {
8287     if (!in) return;
8288
8289     out->sType = in->sType;
8290     out->pNext = NULL;
8291     out->marker = in->marker;
8292     if (in->pNext)
8293         FIXME("Unexpected pNext\n");
8294 }
8295
8296 static inline void convert_VkPerformanceOverrideInfoINTEL_win32_to_host(const VkPerformanceOverrideInfoINTEL32 *in, VkPerformanceOverrideInfoINTEL *out)
8297 {
8298     if (!in) return;
8299
8300     out->sType = in->sType;
8301     out->pNext = NULL;
8302     out->type = in->type;
8303     out->enable = in->enable;
8304     out->parameter = in->parameter;
8305     if (in->pNext)
8306         FIXME("Unexpected pNext\n");
8307 }
8308
8309 static inline void convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(const VkPerformanceStreamMarkerInfoINTEL32 *in, VkPerformanceStreamMarkerInfoINTEL *out)
8310 {
8311     if (!in) return;
8312
8313     out->sType = in->sType;
8314     out->pNext = NULL;
8315     out->marker = in->marker;
8316     if (in->pNext)
8317         FIXME("Unexpected pNext\n");
8318 }
8319
8320 static inline void convert_VkVertexInputBindingDescription2EXT_win32_to_host(const VkVertexInputBindingDescription2EXT32 *in, VkVertexInputBindingDescription2EXT *out)
8321 {
8322     if (!in) return;
8323
8324     out->sType = in->sType;
8325     out->pNext = NULL;
8326     out->binding = in->binding;
8327     out->stride = in->stride;
8328     out->inputRate = in->inputRate;
8329     out->divisor = in->divisor;
8330     if (in->pNext)
8331         FIXME("Unexpected pNext\n");
8332 }
8333
8334 static inline const VkVertexInputBindingDescription2EXT *convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputBindingDescription2EXT32 *in, uint32_t count)
8335 {
8336     VkVertexInputBindingDescription2EXT *out;
8337     unsigned int i;
8338
8339     if (!in || !count) return NULL;
8340
8341     out = conversion_context_alloc(ctx, count * sizeof(*out));
8342     for (i = 0; i < count; i++)
8343     {
8344         convert_VkVertexInputBindingDescription2EXT_win32_to_host(&in[i], &out[i]);
8345     }
8346
8347     return out;
8348 }
8349
8350 static inline void convert_VkVertexInputAttributeDescription2EXT_win32_to_host(const VkVertexInputAttributeDescription2EXT32 *in, VkVertexInputAttributeDescription2EXT *out)
8351 {
8352     if (!in) return;
8353
8354     out->sType = in->sType;
8355     out->pNext = NULL;
8356     out->location = in->location;
8357     out->binding = in->binding;
8358     out->format = in->format;
8359     out->offset = in->offset;
8360     if (in->pNext)
8361         FIXME("Unexpected pNext\n");
8362 }
8363
8364 static inline const VkVertexInputAttributeDescription2EXT *convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputAttributeDescription2EXT32 *in, uint32_t count)
8365 {
8366     VkVertexInputAttributeDescription2EXT *out;
8367     unsigned int i;
8368
8369     if (!in || !count) return NULL;
8370
8371     out = conversion_context_alloc(ctx, count * sizeof(*out));
8372     for (i = 0; i < count; i++)
8373     {
8374         convert_VkVertexInputAttributeDescription2EXT_win32_to_host(&in[i], &out[i]);
8375     }
8376
8377     return out;
8378 }
8379
8380 static inline void convert_VkShadingRatePaletteNV_win32_to_host(const VkShadingRatePaletteNV32 *in, VkShadingRatePaletteNV *out)
8381 {
8382     if (!in) return;
8383
8384     out->shadingRatePaletteEntryCount = in->shadingRatePaletteEntryCount;
8385     out->pShadingRatePaletteEntries = (const VkShadingRatePaletteEntryNV *)UlongToPtr(in->pShadingRatePaletteEntries);
8386 }
8387
8388 static inline const VkShadingRatePaletteNV *convert_VkShadingRatePaletteNV_array_win32_to_host(struct conversion_context *ctx, const VkShadingRatePaletteNV32 *in, uint32_t count)
8389 {
8390     VkShadingRatePaletteNV *out;
8391     unsigned int i;
8392
8393     if (!in || !count) return NULL;
8394
8395     out = conversion_context_alloc(ctx, count * sizeof(*out));
8396     for (i = 0; i < count; i++)
8397     {
8398         convert_VkShadingRatePaletteNV_win32_to_host(&in[i], &out[i]);
8399     }
8400
8401     return out;
8402 }
8403
8404 static inline void convert_VkStridedDeviceAddressRegionKHR_win32_to_host(const VkStridedDeviceAddressRegionKHR32 *in, VkStridedDeviceAddressRegionKHR *out)
8405 {
8406     if (!in) return;
8407
8408     out->deviceAddress = in->deviceAddress;
8409     out->stride = in->stride;
8410     out->size = in->size;
8411 }
8412
8413 static inline const VkDependencyInfo *convert_VkDependencyInfo_array_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, uint32_t count)
8414 {
8415     VkDependencyInfo *out;
8416     unsigned int i;
8417
8418     if (!in || !count) return NULL;
8419
8420     out = conversion_context_alloc(ctx, count * sizeof(*out));
8421     for (i = 0; i < count; i++)
8422     {
8423         convert_VkDependencyInfo_win32_to_host(ctx, &in[i], &out[i]);
8424     }
8425
8426     return out;
8427 }
8428
8429 static inline void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoKHR32 *in, VkAccelerationStructureCreateInfoKHR *out)
8430 {
8431     const VkBaseInStructure32 *in_header;
8432     VkBaseOutStructure *out_header = (void *)out;
8433
8434     if (!in) return;
8435
8436     out->sType = in->sType;
8437     out->pNext = NULL;
8438     out->createFlags = in->createFlags;
8439     out->buffer = in->buffer;
8440     out->offset = in->offset;
8441     out->size = in->size;
8442     out->type = in->type;
8443     out->deviceAddress = in->deviceAddress;
8444
8445     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8446     {
8447         switch (in_header->sType)
8448         {
8449         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
8450         {
8451             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8452             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
8453             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
8454             out_ext->pNext = NULL;
8455             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
8456             out_header->pNext = (void *)out_ext;
8457             out_header = (void *)out_ext;
8458             break;
8459         }
8460         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
8461         {
8462             VkAccelerationStructureMotionInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8463             const VkAccelerationStructureMotionInfoNV32 *in_ext = (const VkAccelerationStructureMotionInfoNV32 *)in_header;
8464             out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV;
8465             out_ext->pNext = NULL;
8466             out_ext->maxInstances = in_ext->maxInstances;
8467             out_ext->flags = in_ext->flags;
8468             out_header->pNext = (void *)out_ext;
8469             out_header = (void *)out_ext;
8470             break;
8471         }
8472         default:
8473             FIXME("Unhandled sType %u.", in_header->sType);
8474             break;
8475         }
8476     }
8477 }
8478
8479 static inline void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoNV32 *in, VkAccelerationStructureCreateInfoNV *out)
8480 {
8481     const VkBaseInStructure32 *in_header;
8482     VkBaseOutStructure *out_header = (void *)out;
8483
8484     if (!in) return;
8485
8486     out->sType = in->sType;
8487     out->pNext = NULL;
8488     out->compactedSize = in->compactedSize;
8489     convert_VkAccelerationStructureInfoNV_win32_to_host(ctx, &in->info, &out->info);
8490
8491     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8492     {
8493         switch (in_header->sType)
8494         {
8495         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
8496         {
8497             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8498             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
8499             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
8500             out_ext->pNext = NULL;
8501             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
8502             out_header->pNext = (void *)out_ext;
8503             out_header = (void *)out_ext;
8504             break;
8505         }
8506         default:
8507             FIXME("Unhandled sType %u.", in_header->sType);
8508             break;
8509         }
8510     }
8511 }
8512
8513 static inline void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, VkBufferCreateInfo *out)
8514 {
8515     const VkBaseInStructure32 *in_header;
8516     VkBaseOutStructure *out_header = (void *)out;
8517
8518     if (!in) return;
8519
8520     out->sType = in->sType;
8521     out->pNext = NULL;
8522     out->flags = in->flags;
8523     out->size = in->size;
8524     out->usage = in->usage;
8525     out->sharingMode = in->sharingMode;
8526     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
8527     out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);
8528
8529     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8530     {
8531         switch (in_header->sType)
8532         {
8533         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
8534         {
8535             VkDedicatedAllocationBufferCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8536             const VkDedicatedAllocationBufferCreateInfoNV32 *in_ext = (const VkDedicatedAllocationBufferCreateInfoNV32 *)in_header;
8537             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV;
8538             out_ext->pNext = NULL;
8539             out_ext->dedicatedAllocation = in_ext->dedicatedAllocation;
8540             out_header->pNext = (void *)out_ext;
8541             out_header = (void *)out_ext;
8542             break;
8543         }
8544         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
8545         {
8546             VkExternalMemoryBufferCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8547             const VkExternalMemoryBufferCreateInfo32 *in_ext = (const VkExternalMemoryBufferCreateInfo32 *)in_header;
8548             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
8549             out_ext->pNext = NULL;
8550             out_ext->handleTypes = in_ext->handleTypes;
8551             out_header->pNext = (void *)out_ext;
8552             out_header = (void *)out_ext;
8553             break;
8554         }
8555         case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
8556         {
8557             VkBufferOpaqueCaptureAddressCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8558             const VkBufferOpaqueCaptureAddressCreateInfo32 *in_ext = (const VkBufferOpaqueCaptureAddressCreateInfo32 *)in_header;
8559             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
8560             out_ext->pNext = NULL;
8561             out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress;
8562             out_header->pNext = (void *)out_ext;
8563             out_header = (void *)out_ext;
8564             break;
8565         }
8566         case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
8567         {
8568             VkBufferDeviceAddressCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8569             const VkBufferDeviceAddressCreateInfoEXT32 *in_ext = (const VkBufferDeviceAddressCreateInfoEXT32 *)in_header;
8570             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT;
8571             out_ext->pNext = NULL;
8572             out_ext->deviceAddress = in_ext->deviceAddress;
8573             out_header->pNext = (void *)out_ext;
8574             out_header = (void *)out_ext;
8575             break;
8576         }
8577         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
8578         {
8579             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8580             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
8581             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
8582             out_ext->pNext = NULL;
8583             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
8584             out_header->pNext = (void *)out_ext;
8585             out_header = (void *)out_ext;
8586             break;
8587         }
8588         default:
8589             FIXME("Unhandled sType %u.", in_header->sType);
8590             break;
8591         }
8592     }
8593 }
8594
8595 static inline void convert_VkBufferViewCreateInfo_win32_to_host(const VkBufferViewCreateInfo32 *in, VkBufferViewCreateInfo *out)
8596 {
8597     if (!in) return;
8598
8599     out->sType = in->sType;
8600     out->pNext = NULL;
8601     out->flags = in->flags;
8602     out->buffer = in->buffer;
8603     out->format = in->format;
8604     out->offset = in->offset;
8605     out->range = in->range;
8606     if (in->pNext)
8607         FIXME("Unexpected pNext\n");
8608 }
8609
8610 static inline void convert_VkCommandPoolCreateInfo_win32_to_host(const VkCommandPoolCreateInfo32 *in, VkCommandPoolCreateInfo *out)
8611 {
8612     if (!in) return;
8613
8614     out->sType = in->sType;
8615     out->pNext = NULL;
8616     out->flags = in->flags;
8617     out->queueFamilyIndex = in->queueFamilyIndex;
8618     if (in->pNext)
8619         FIXME("Unexpected pNext\n");
8620 }
8621
8622 static inline void convert_VkPipelineCreationFeedback_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out)
8623 {
8624     if (!in) return;
8625
8626     out->flags = in->flags;
8627     out->duration = in->duration;
8628 }
8629
8630 static inline VkPipelineCreationFeedback *convert_VkPipelineCreationFeedback_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreationFeedback32 *in, uint32_t count)
8631 {
8632     VkPipelineCreationFeedback *out;
8633     if (!in || !count) return NULL;
8634
8635     out = conversion_context_alloc(ctx, count * sizeof(*out));
8636
8637     return out;
8638 }
8639
8640 static inline void convert_VkPipelineCreationFeedback_array_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out, uint32_t count)
8641 {
8642     unsigned int i;
8643
8644     if (!in) return;
8645
8646     for (i = 0; i < count; i++)
8647     {
8648         convert_VkPipelineCreationFeedback_host_to_win32(&in[i], &out[i]);
8649     }
8650 }
8651
8652 static inline void convert_VkSpecializationMapEntry_win32_to_host(const VkSpecializationMapEntry32 *in, VkSpecializationMapEntry *out)
8653 {
8654     if (!in) return;
8655
8656     out->constantID = in->constantID;
8657     out->offset = in->offset;
8658     out->size = in->size;
8659 }
8660
8661 static inline const VkSpecializationMapEntry *convert_VkSpecializationMapEntry_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationMapEntry32 *in, uint32_t count)
8662 {
8663     VkSpecializationMapEntry *out;
8664     unsigned int i;
8665
8666     if (!in || !count) return NULL;
8667
8668     out = conversion_context_alloc(ctx, count * sizeof(*out));
8669     for (i = 0; i < count; i++)
8670     {
8671         convert_VkSpecializationMapEntry_win32_to_host(&in[i], &out[i]);
8672     }
8673
8674     return out;
8675 }
8676
8677 static inline void convert_VkSpecializationInfo_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, VkSpecializationInfo *out)
8678 {
8679     if (!in) return;
8680
8681     out->mapEntryCount = in->mapEntryCount;
8682     out->pMapEntries = convert_VkSpecializationMapEntry_array_win32_to_host(ctx, (const VkSpecializationMapEntry32 *)UlongToPtr(in->pMapEntries), in->mapEntryCount);
8683     out->dataSize = in->dataSize;
8684     out->pData = (const void *)UlongToPtr(in->pData);
8685 }
8686
8687 static inline const VkSpecializationInfo *convert_VkSpecializationInfo_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, uint32_t count)
8688 {
8689     VkSpecializationInfo *out;
8690     unsigned int i;
8691
8692     if (!in || !count) return NULL;
8693
8694     out = conversion_context_alloc(ctx, count * sizeof(*out));
8695     for (i = 0; i < count; i++)
8696     {
8697         convert_VkSpecializationInfo_win32_to_host(ctx, &in[i], &out[i]);
8698     }
8699
8700     return out;
8701 }
8702
8703 #ifdef _WIN64
8704 static inline void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo *out)
8705 {
8706     const VkBaseInStructure *in_header;
8707     VkBaseOutStructure *out_header = (void *)out;
8708
8709     if (!in) return;
8710
8711     out->sType = in->sType;
8712     out->pNext = NULL;
8713     out->flags = in->flags;
8714     out->stage = in->stage;
8715     out->module = in->module;
8716     out->pName = in->pName;
8717     out->pSpecializationInfo = in->pSpecializationInfo;
8718
8719     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
8720     {
8721         switch (in_header->sType)
8722         {
8723         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
8724         {
8725             VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8726             const VkShaderModuleCreateInfo *in_ext = (const VkShaderModuleCreateInfo *)in_header;
8727             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
8728             out_ext->pNext = NULL;
8729             out_ext->flags = in_ext->flags;
8730             out_ext->codeSize = in_ext->codeSize;
8731             out_ext->pCode = in_ext->pCode;
8732             out_header->pNext = (void *)out_ext;
8733             out_header = (void *)out_ext;
8734             break;
8735         }
8736         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
8737         {
8738             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8739             const VkShaderModuleValidationCacheCreateInfoEXT *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT *)in_header;
8740             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
8741             out_ext->pNext = NULL;
8742             out_ext->validationCache = in_ext->validationCache;
8743             out_header->pNext = (void *)out_ext;
8744             out_header = (void *)out_ext;
8745             break;
8746         }
8747         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
8748         {
8749             VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8750             const VkDebugUtilsObjectNameInfoEXT *in_ext = (const VkDebugUtilsObjectNameInfoEXT *)in_header;
8751             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
8752             out_ext->pNext = NULL;
8753             out_ext->objectType = in_ext->objectType;
8754             out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
8755             out_ext->pObjectName = in_ext->pObjectName;
8756             out_header->pNext = (void *)out_ext;
8757             out_header = (void *)out_ext;
8758             break;
8759         }
8760         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
8761         {
8762             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8763             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)in_header;
8764             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
8765             out_ext->pNext = NULL;
8766             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
8767             out_header->pNext = (void *)out_ext;
8768             out_header = (void *)out_ext;
8769             break;
8770         }
8771         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
8772         {
8773             VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8774             const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *)in_header;
8775             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
8776             out_ext->pNext = NULL;
8777             out_ext->identifierSize = in_ext->identifierSize;
8778             out_ext->pIdentifier = in_ext->pIdentifier;
8779             out_header->pNext = (void *)out_ext;
8780             out_header = (void *)out_ext;
8781             break;
8782         }
8783         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
8784         {
8785             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8786             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
8787             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
8788             out_ext->pNext = NULL;
8789             out_ext->storageBuffers = in_ext->storageBuffers;
8790             out_ext->uniformBuffers = in_ext->uniformBuffers;
8791             out_ext->vertexInputs = in_ext->vertexInputs;
8792             out_ext->images = in_ext->images;
8793             out_header->pNext = (void *)out_ext;
8794             out_header = (void *)out_ext;
8795             break;
8796         }
8797         default:
8798             FIXME("Unhandled sType %u.", in_header->sType);
8799             break;
8800         }
8801     }
8802 }
8803 #endif /* _WIN64 */
8804
8805 static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, VkPipelineShaderStageCreateInfo *out)
8806 {
8807     const VkBaseInStructure32 *in_header;
8808     VkBaseOutStructure *out_header = (void *)out;
8809
8810     if (!in) return;
8811
8812     out->sType = in->sType;
8813     out->pNext = NULL;
8814     out->flags = in->flags;
8815     out->stage = in->stage;
8816     out->module = in->module;
8817     out->pName = (const char *)UlongToPtr(in->pName);
8818     out->pSpecializationInfo = convert_VkSpecializationInfo_array_win32_to_host(ctx, (const VkSpecializationInfo32 *)UlongToPtr(in->pSpecializationInfo), 1);
8819
8820     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8821     {
8822         switch (in_header->sType)
8823         {
8824         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
8825         {
8826             VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8827             const VkShaderModuleCreateInfo32 *in_ext = (const VkShaderModuleCreateInfo32 *)in_header;
8828             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
8829             out_ext->pNext = NULL;
8830             out_ext->flags = in_ext->flags;
8831             out_ext->codeSize = in_ext->codeSize;
8832             out_ext->pCode = (const uint32_t *)UlongToPtr(in_ext->pCode);
8833             out_header->pNext = (void *)out_ext;
8834             out_header = (void *)out_ext;
8835             break;
8836         }
8837         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
8838         {
8839             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8840             const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
8841             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
8842             out_ext->pNext = NULL;
8843             out_ext->validationCache = in_ext->validationCache;
8844             out_header->pNext = (void *)out_ext;
8845             out_header = (void *)out_ext;
8846             break;
8847         }
8848         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
8849         {
8850             VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8851             const VkDebugUtilsObjectNameInfoEXT32 *in_ext = (const VkDebugUtilsObjectNameInfoEXT32 *)in_header;
8852             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
8853             out_ext->pNext = NULL;
8854             out_ext->objectType = in_ext->objectType;
8855             out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
8856             out_ext->pObjectName = (const char *)UlongToPtr(in_ext->pObjectName);
8857             out_header->pNext = (void *)out_ext;
8858             out_header = (void *)out_ext;
8859             break;
8860         }
8861         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
8862         {
8863             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8864             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *)in_header;
8865             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
8866             out_ext->pNext = NULL;
8867             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
8868             out_header->pNext = (void *)out_ext;
8869             out_header = (void *)out_ext;
8870             break;
8871         }
8872         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
8873         {
8874             VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8875             const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *)in_header;
8876             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
8877             out_ext->pNext = NULL;
8878             out_ext->identifierSize = in_ext->identifierSize;
8879             out_ext->pIdentifier = (const uint8_t *)UlongToPtr(in_ext->pIdentifier);
8880             out_header->pNext = (void *)out_ext;
8881             out_header = (void *)out_ext;
8882             break;
8883         }
8884         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
8885         {
8886             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8887             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
8888             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
8889             out_ext->pNext = NULL;
8890             out_ext->storageBuffers = in_ext->storageBuffers;
8891             out_ext->uniformBuffers = in_ext->uniformBuffers;
8892             out_ext->vertexInputs = in_ext->vertexInputs;
8893             out_ext->images = in_ext->images;
8894             out_header->pNext = (void *)out_ext;
8895             out_header = (void *)out_ext;
8896             break;
8897         }
8898         default:
8899             FIXME("Unhandled sType %u.", in_header->sType);
8900             break;
8901         }
8902     }
8903 }
8904
8905 #ifdef _WIN64
8906 static inline void convert_VkComputePipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, VkComputePipelineCreateInfo *out)
8907 {
8908     if (!in) return;
8909
8910     out->sType = in->sType;
8911     out->pNext = in->pNext;
8912     out->flags = in->flags;
8913     convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in->stage, &out->stage);
8914     out->layout = in->layout;
8915     out->basePipelineHandle = in->basePipelineHandle;
8916     out->basePipelineIndex = in->basePipelineIndex;
8917 }
8918 #endif /* _WIN64 */
8919
8920 static inline void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, VkComputePipelineCreateInfo *out)
8921 {
8922     const VkBaseInStructure32 *in_header;
8923     VkBaseOutStructure *out_header = (void *)out;
8924
8925     if (!in) return;
8926
8927     out->sType = in->sType;
8928     out->pNext = NULL;
8929     out->flags = in->flags;
8930     convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in->stage, &out->stage);
8931     out->layout = in->layout;
8932     out->basePipelineHandle = in->basePipelineHandle;
8933     out->basePipelineIndex = in->basePipelineIndex;
8934
8935     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
8936     {
8937         switch (in_header->sType)
8938         {
8939         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
8940         {
8941             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8942             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
8943             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
8944             out_ext->pNext = NULL;
8945             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
8946             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
8947             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
8948             out_header->pNext = (void *)out_ext;
8949             out_header = (void *)out_ext;
8950             break;
8951         }
8952         case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
8953         {
8954             VkSubpassShadingPipelineCreateInfoHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8955             const VkSubpassShadingPipelineCreateInfoHUAWEI32 *in_ext = (const VkSubpassShadingPipelineCreateInfoHUAWEI32 *)in_header;
8956             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI;
8957             out_ext->pNext = NULL;
8958             out_ext->renderPass = in_ext->renderPass;
8959             out_ext->subpass = in_ext->subpass;
8960             out_header->pNext = (void *)out_ext;
8961             out_header = (void *)out_ext;
8962             break;
8963         }
8964         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
8965         {
8966             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8967             const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header;
8968             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
8969             out_ext->pNext = NULL;
8970             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
8971             out_header->pNext = (void *)out_ext;
8972             out_header = (void *)out_ext;
8973             break;
8974         }
8975         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
8976         {
8977             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8978             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
8979             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
8980             out_ext->pNext = NULL;
8981             out_ext->storageBuffers = in_ext->storageBuffers;
8982             out_ext->uniformBuffers = in_ext->uniformBuffers;
8983             out_ext->vertexInputs = in_ext->vertexInputs;
8984             out_ext->images = in_ext->images;
8985             out_header->pNext = (void *)out_ext;
8986             out_header = (void *)out_ext;
8987             break;
8988         }
8989         default:
8990             FIXME("Unhandled sType %u.", in_header->sType);
8991             break;
8992         }
8993     }
8994 }
8995
8996 static inline void convert_VkComputePipelineCreateInfo_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out)
8997 {
8998     const VkBaseInStructure *in_header;
8999     VkBaseOutStructure32 *out_header = (void *)out;
9000
9001     if (!in) return;
9002
9003
9004     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
9005     {
9006         switch (in_header->sType)
9007         {
9008         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
9009         {
9010             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
9011             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
9012             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
9013             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
9014             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
9015             out_header = (void *)out_ext;
9016             break;
9017         }
9018         default:
9019             break;
9020         }
9021     }
9022 }
9023
9024 #ifdef _WIN64
9025 static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, uint32_t count)
9026 {
9027     VkComputePipelineCreateInfo *out;
9028     unsigned int i;
9029
9030     if (!in || !count) return NULL;
9031
9032     out = conversion_context_alloc(ctx, count * sizeof(*out));
9033     for (i = 0; i < count; i++)
9034     {
9035         convert_VkComputePipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
9036     }
9037
9038     return out;
9039 }
9040 #endif /* _WIN64 */
9041
9042 static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, uint32_t count)
9043 {
9044     VkComputePipelineCreateInfo *out;
9045     unsigned int i;
9046
9047     if (!in || !count) return NULL;
9048
9049     out = conversion_context_alloc(ctx, count * sizeof(*out));
9050     for (i = 0; i < count; i++)
9051     {
9052         convert_VkComputePipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
9053     }
9054
9055     return out;
9056 }
9057
9058 static inline void convert_VkComputePipelineCreateInfo_array_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out, uint32_t count)
9059 {
9060     unsigned int i;
9061
9062     if (!in) return;
9063
9064     for (i = 0; i < count; i++)
9065     {
9066         convert_VkComputePipelineCreateInfo_host_to_win32(&in[i], &out[i]);
9067     }
9068 }
9069
9070 static inline void convert_VkCuFunctionCreateInfoNVX_win32_to_host(const VkCuFunctionCreateInfoNVX32 *in, VkCuFunctionCreateInfoNVX *out)
9071 {
9072     if (!in) return;
9073
9074     out->sType = in->sType;
9075     out->pNext = NULL;
9076     out->module = in->module;
9077     out->pName = (const char *)UlongToPtr(in->pName);
9078     if (in->pNext)
9079         FIXME("Unexpected pNext\n");
9080 }
9081
9082 static inline void convert_VkCuModuleCreateInfoNVX_win32_to_host(const VkCuModuleCreateInfoNVX32 *in, VkCuModuleCreateInfoNVX *out)
9083 {
9084     if (!in) return;
9085
9086     out->sType = in->sType;
9087     out->pNext = NULL;
9088     out->dataSize = in->dataSize;
9089     out->pData = (const void *)UlongToPtr(in->pData);
9090     if (in->pNext)
9091         FIXME("Unexpected pNext\n");
9092 }
9093
9094 static inline void convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(const VkDebugReportCallbackCreateInfoEXT32 *in, VkDebugReportCallbackCreateInfoEXT *out)
9095 {
9096     if (!in) return;
9097
9098     out->sType = in->sType;
9099     out->pNext = NULL;
9100     out->flags = in->flags;
9101     out->pfnCallback = in->pfnCallback;
9102     out->pUserData = (void *)UlongToPtr(in->pUserData);
9103     if (in->pNext)
9104         FIXME("Unexpected pNext\n");
9105 }
9106
9107 static inline void convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host(const VkDebugUtilsMessengerCreateInfoEXT32 *in, VkDebugUtilsMessengerCreateInfoEXT *out)
9108 {
9109     if (!in) return;
9110
9111     out->sType = in->sType;
9112     out->pNext = NULL;
9113     out->flags = in->flags;
9114     out->messageSeverity = in->messageSeverity;
9115     out->messageType = in->messageType;
9116     out->pfnUserCallback = in->pfnUserCallback;
9117     out->pUserData = (void *)UlongToPtr(in->pUserData);
9118     if (in->pNext)
9119         FIXME("Unexpected pNext\n");
9120 }
9121
9122 static inline void convert_VkMutableDescriptorTypeListEXT_win32_to_host(const VkMutableDescriptorTypeListEXT32 *in, VkMutableDescriptorTypeListEXT *out)
9123 {
9124     if (!in) return;
9125
9126     out->descriptorTypeCount = in->descriptorTypeCount;
9127     out->pDescriptorTypes = (const VkDescriptorType *)UlongToPtr(in->pDescriptorTypes);
9128 }
9129
9130 static inline const VkMutableDescriptorTypeListEXT *convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(struct conversion_context *ctx, const VkMutableDescriptorTypeListEXT32 *in, uint32_t count)
9131 {
9132     VkMutableDescriptorTypeListEXT *out;
9133     unsigned int i;
9134
9135     if (!in || !count) return NULL;
9136
9137     out = conversion_context_alloc(ctx, count * sizeof(*out));
9138     for (i = 0; i < count; i++)
9139     {
9140         convert_VkMutableDescriptorTypeListEXT_win32_to_host(&in[i], &out[i]);
9141     }
9142
9143     return out;
9144 }
9145
9146 static inline void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorPoolCreateInfo32 *in, VkDescriptorPoolCreateInfo *out)
9147 {
9148     const VkBaseInStructure32 *in_header;
9149     VkBaseOutStructure *out_header = (void *)out;
9150
9151     if (!in) return;
9152
9153     out->sType = in->sType;
9154     out->pNext = NULL;
9155     out->flags = in->flags;
9156     out->maxSets = in->maxSets;
9157     out->poolSizeCount = in->poolSizeCount;
9158     out->pPoolSizes = (const VkDescriptorPoolSize *)UlongToPtr(in->pPoolSizes);
9159
9160     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9161     {
9162         switch (in_header->sType)
9163         {
9164         case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
9165         {
9166             VkDescriptorPoolInlineUniformBlockCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9167             const VkDescriptorPoolInlineUniformBlockCreateInfo32 *in_ext = (const VkDescriptorPoolInlineUniformBlockCreateInfo32 *)in_header;
9168             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
9169             out_ext->pNext = NULL;
9170             out_ext->maxInlineUniformBlockBindings = in_ext->maxInlineUniformBlockBindings;
9171             out_header->pNext = (void *)out_ext;
9172             out_header = (void *)out_ext;
9173             break;
9174         }
9175         case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
9176         {
9177             VkMutableDescriptorTypeCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9178             const VkMutableDescriptorTypeCreateInfoEXT32 *in_ext = (const VkMutableDescriptorTypeCreateInfoEXT32 *)in_header;
9179             out_ext->sType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
9180             out_ext->pNext = NULL;
9181             out_ext->mutableDescriptorTypeListCount = in_ext->mutableDescriptorTypeListCount;
9182             out_ext->pMutableDescriptorTypeLists = convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(ctx, (const VkMutableDescriptorTypeListEXT32 *)UlongToPtr(in_ext->pMutableDescriptorTypeLists), in_ext->mutableDescriptorTypeListCount);
9183             out_header->pNext = (void *)out_ext;
9184             out_header = (void *)out_ext;
9185             break;
9186         }
9187         default:
9188             FIXME("Unhandled sType %u.", in_header->sType);
9189             break;
9190         }
9191     }
9192 }
9193
9194 static inline void convert_VkDescriptorSetLayoutBinding_win32_to_host(const VkDescriptorSetLayoutBinding32 *in, VkDescriptorSetLayoutBinding *out)
9195 {
9196     if (!in) return;
9197
9198     out->binding = in->binding;
9199     out->descriptorType = in->descriptorType;
9200     out->descriptorCount = in->descriptorCount;
9201     out->stageFlags = in->stageFlags;
9202     out->pImmutableSamplers = (const VkSampler *)UlongToPtr(in->pImmutableSamplers);
9203 }
9204
9205 static inline const VkDescriptorSetLayoutBinding *convert_VkDescriptorSetLayoutBinding_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutBinding32 *in, uint32_t count)
9206 {
9207     VkDescriptorSetLayoutBinding *out;
9208     unsigned int i;
9209
9210     if (!in || !count) return NULL;
9211
9212     out = conversion_context_alloc(ctx, count * sizeof(*out));
9213     for (i = 0; i < count; i++)
9214     {
9215         convert_VkDescriptorSetLayoutBinding_win32_to_host(&in[i], &out[i]);
9216     }
9217
9218     return out;
9219 }
9220
9221 static inline void convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutCreateInfo32 *in, VkDescriptorSetLayoutCreateInfo *out)
9222 {
9223     const VkBaseInStructure32 *in_header;
9224     VkBaseOutStructure *out_header = (void *)out;
9225
9226     if (!in) return;
9227
9228     out->sType = in->sType;
9229     out->pNext = NULL;
9230     out->flags = in->flags;
9231     out->bindingCount = in->bindingCount;
9232     out->pBindings = convert_VkDescriptorSetLayoutBinding_array_win32_to_host(ctx, (const VkDescriptorSetLayoutBinding32 *)UlongToPtr(in->pBindings), in->bindingCount);
9233
9234     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9235     {
9236         switch (in_header->sType)
9237         {
9238         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
9239         {
9240             VkDescriptorSetLayoutBindingFlagsCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9241             const VkDescriptorSetLayoutBindingFlagsCreateInfo32 *in_ext = (const VkDescriptorSetLayoutBindingFlagsCreateInfo32 *)in_header;
9242             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
9243             out_ext->pNext = NULL;
9244             out_ext->bindingCount = in_ext->bindingCount;
9245             out_ext->pBindingFlags = (const VkDescriptorBindingFlags *)UlongToPtr(in_ext->pBindingFlags);
9246             out_header->pNext = (void *)out_ext;
9247             out_header = (void *)out_ext;
9248             break;
9249         }
9250         case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
9251         {
9252             VkMutableDescriptorTypeCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9253             const VkMutableDescriptorTypeCreateInfoEXT32 *in_ext = (const VkMutableDescriptorTypeCreateInfoEXT32 *)in_header;
9254             out_ext->sType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
9255             out_ext->pNext = NULL;
9256             out_ext->mutableDescriptorTypeListCount = in_ext->mutableDescriptorTypeListCount;
9257             out_ext->pMutableDescriptorTypeLists = convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(ctx, (const VkMutableDescriptorTypeListEXT32 *)UlongToPtr(in_ext->pMutableDescriptorTypeLists), in_ext->mutableDescriptorTypeListCount);
9258             out_header->pNext = (void *)out_ext;
9259             out_header = (void *)out_ext;
9260             break;
9261         }
9262         default:
9263             FIXME("Unhandled sType %u.", in_header->sType);
9264             break;
9265         }
9266     }
9267 }
9268
9269 static inline void convert_VkDescriptorUpdateTemplateEntry_win32_to_host(const VkDescriptorUpdateTemplateEntry32 *in, VkDescriptorUpdateTemplateEntry *out)
9270 {
9271     if (!in) return;
9272
9273     out->dstBinding = in->dstBinding;
9274     out->dstArrayElement = in->dstArrayElement;
9275     out->descriptorCount = in->descriptorCount;
9276     out->descriptorType = in->descriptorType;
9277     out->offset = in->offset;
9278     out->stride = in->stride;
9279 }
9280
9281 static inline const VkDescriptorUpdateTemplateEntry *convert_VkDescriptorUpdateTemplateEntry_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateEntry32 *in, uint32_t count)
9282 {
9283     VkDescriptorUpdateTemplateEntry *out;
9284     unsigned int i;
9285
9286     if (!in || !count) return NULL;
9287
9288     out = conversion_context_alloc(ctx, count * sizeof(*out));
9289     for (i = 0; i < count; i++)
9290     {
9291         convert_VkDescriptorUpdateTemplateEntry_win32_to_host(&in[i], &out[i]);
9292     }
9293
9294     return out;
9295 }
9296
9297 static inline void convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateCreateInfo32 *in, VkDescriptorUpdateTemplateCreateInfo *out)
9298 {
9299     if (!in) return;
9300
9301     out->sType = in->sType;
9302     out->pNext = NULL;
9303     out->flags = in->flags;
9304     out->descriptorUpdateEntryCount = in->descriptorUpdateEntryCount;
9305     out->pDescriptorUpdateEntries = convert_VkDescriptorUpdateTemplateEntry_array_win32_to_host(ctx, (const VkDescriptorUpdateTemplateEntry32 *)UlongToPtr(in->pDescriptorUpdateEntries), in->descriptorUpdateEntryCount);
9306     out->templateType = in->templateType;
9307     out->descriptorSetLayout = in->descriptorSetLayout;
9308     out->pipelineBindPoint = in->pipelineBindPoint;
9309     out->pipelineLayout = in->pipelineLayout;
9310     out->set = in->set;
9311     if (in->pNext)
9312         FIXME("Unexpected pNext\n");
9313 }
9314
9315 #ifdef _WIN64
9316 static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win64_to_host(struct conversion_context *ctx, const VkPhysicalDevice *in, uint32_t count)
9317 {
9318     VkPhysicalDevice *out;
9319     unsigned int i;
9320
9321     if (!in || !count) return NULL;
9322
9323     out = conversion_context_alloc(ctx, count * sizeof(*out));
9324     for (i = 0; i < count; i++)
9325     {
9326         out[i] = wine_phys_dev_from_handle(in[i])->phys_dev;
9327     }
9328
9329     return out;
9330 }
9331 #endif /* _WIN64 */
9332
9333 static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
9334 {
9335     VkPhysicalDevice *out;
9336     unsigned int i;
9337
9338     if (!in || !count) return NULL;
9339
9340     out = conversion_context_alloc(ctx, count * sizeof(*out));
9341     for (i = 0; i < count; i++)
9342     {
9343         out[i] = wine_phys_dev_from_handle(UlongToPtr(in[i]))->phys_dev;
9344     }
9345
9346     return out;
9347 }
9348
9349 static inline void convert_VkDeviceQueueCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, VkDeviceQueueCreateInfo *out)
9350 {
9351     const VkBaseInStructure32 *in_header;
9352     VkBaseOutStructure *out_header = (void *)out;
9353
9354     if (!in) return;
9355
9356     out->sType = in->sType;
9357     out->pNext = NULL;
9358     out->flags = in->flags;
9359     out->queueFamilyIndex = in->queueFamilyIndex;
9360     out->queueCount = in->queueCount;
9361     out->pQueuePriorities = (const float *)UlongToPtr(in->pQueuePriorities);
9362
9363     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
9364     {
9365         switch (in_header->sType)
9366         {
9367         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
9368         {
9369             VkDeviceQueueGlobalPriorityCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9370             const VkDeviceQueueGlobalPriorityCreateInfoKHR32 *in_ext = (const VkDeviceQueueGlobalPriorityCreateInfoKHR32 *)in_header;
9371             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR;
9372             out_ext->pNext = NULL;
9373             out_ext->globalPriority = in_ext->globalPriority;
9374             out_header->pNext = (void *)out_ext;
9375             out_header = (void *)out_ext;
9376             break;
9377         }
9378         default:
9379             FIXME("Unhandled sType %u.", in_header->sType);
9380             break;
9381         }
9382     }
9383 }
9384
9385 static inline const VkDeviceQueueCreateInfo *convert_VkDeviceQueueCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, uint32_t count)
9386 {
9387     VkDeviceQueueCreateInfo *out;
9388     unsigned int i;
9389
9390     if (!in || !count) return NULL;
9391
9392     out = conversion_context_alloc(ctx, count * sizeof(*out));
9393     for (i = 0; i < count; i++)
9394     {
9395         convert_VkDeviceQueueCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
9396     }
9397
9398     return out;
9399 }
9400
9401 static inline const char * const*convert_char_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
9402 {
9403     char **out;
9404     unsigned int i;
9405
9406     if (!in || !count) return NULL;
9407
9408     out = conversion_context_alloc(ctx, count * sizeof(*out));
9409     for (i = 0; i < count; i++)
9410     {
9411         out[i] = UlongToPtr(in[i]);
9412     }
9413
9414     return (void *)out;
9415 }
9416
9417 #ifdef _WIN64
9418 static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo *in, VkDeviceCreateInfo *out)
9419 {
9420     const VkBaseInStructure *in_header;
9421     VkBaseOutStructure *out_header = (void *)out;
9422
9423     if (!in) return;
9424
9425     out->sType = in->sType;
9426     out->pNext = NULL;
9427     out->flags = in->flags;
9428     out->queueCreateInfoCount = in->queueCreateInfoCount;
9429     out->pQueueCreateInfos = in->pQueueCreateInfos;
9430     out->enabledLayerCount = in->enabledLayerCount;
9431     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
9432     out->enabledExtensionCount = in->enabledExtensionCount;
9433     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
9434     out->pEnabledFeatures = in->pEnabledFeatures;
9435
9436     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
9437     {
9438         switch (in_header->sType)
9439         {
9440         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
9441             break;
9442         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
9443         {
9444             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9445             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
9446             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
9447             out_ext->pNext = NULL;
9448             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
9449             out_header->pNext = (void *)out_ext;
9450             out_header = (void *)out_ext;
9451             break;
9452         }
9453         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
9454         {
9455             VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9456             const VkDevicePrivateDataCreateInfo *in_ext = (const VkDevicePrivateDataCreateInfo *)in_header;
9457             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
9458             out_ext->pNext = NULL;
9459             out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
9460             out_header->pNext = (void *)out_ext;
9461             out_header = (void *)out_ext;
9462             break;
9463         }
9464         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
9465         {
9466             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9467             const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
9468             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
9469             out_ext->pNext = NULL;
9470             out_ext->privateData = in_ext->privateData;
9471             out_header->pNext = (void *)out_ext;
9472             out_header = (void *)out_ext;
9473             break;
9474         }
9475         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
9476         {
9477             VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9478             const VkPhysicalDeviceFeatures2 *in_ext = (const VkPhysicalDeviceFeatures2 *)in_header;
9479             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
9480             out_ext->pNext = NULL;
9481             out_ext->features = in_ext->features;
9482             out_header->pNext = (void *)out_ext;
9483             out_header = (void *)out_ext;
9484             break;
9485         }
9486         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
9487         {
9488             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9489             const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
9490             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
9491             out_ext->pNext = NULL;
9492             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
9493             out_ext->variablePointers = in_ext->variablePointers;
9494             out_header->pNext = (void *)out_ext;
9495             out_header = (void *)out_ext;
9496             break;
9497         }
9498         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
9499         {
9500             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9501             const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
9502             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
9503             out_ext->pNext = NULL;
9504             out_ext->multiview = in_ext->multiview;
9505             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
9506             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
9507             out_header->pNext = (void *)out_ext;
9508             out_header = (void *)out_ext;
9509             break;
9510         }
9511         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
9512         {
9513             VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9514             const VkDeviceGroupDeviceCreateInfo *in_ext = (const VkDeviceGroupDeviceCreateInfo *)in_header;
9515             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
9516             out_ext->pNext = NULL;
9517             out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
9518             out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win64_to_host(ctx, in_ext->pPhysicalDevices, in_ext->physicalDeviceCount);
9519             out_header->pNext = (void *)out_ext;
9520             out_header = (void *)out_ext;
9521             break;
9522         }
9523         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
9524         {
9525             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9526             const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
9527             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
9528             out_ext->pNext = NULL;
9529             out_ext->presentId = in_ext->presentId;
9530             out_header->pNext = (void *)out_ext;
9531             out_header = (void *)out_ext;
9532             break;
9533         }
9534         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
9535         {
9536             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9537             const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
9538             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
9539             out_ext->pNext = NULL;
9540             out_ext->presentWait = in_ext->presentWait;
9541             out_header->pNext = (void *)out_ext;
9542             out_header = (void *)out_ext;
9543             break;
9544         }
9545         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
9546         {
9547             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9548             const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
9549             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
9550             out_ext->pNext = NULL;
9551             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
9552             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
9553             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
9554             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
9555             out_header->pNext = (void *)out_ext;
9556             out_header = (void *)out_ext;
9557             break;
9558         }
9559         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
9560         {
9561             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9562             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
9563             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
9564             out_ext->pNext = NULL;
9565             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
9566             out_header->pNext = (void *)out_ext;
9567             out_header = (void *)out_ext;
9568             break;
9569         }
9570         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
9571         {
9572             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9573             const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
9574             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
9575             out_ext->pNext = NULL;
9576             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
9577             out_header->pNext = (void *)out_ext;
9578             out_header = (void *)out_ext;
9579             break;
9580         }
9581         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
9582         {
9583             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9584             const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
9585             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
9586             out_ext->pNext = NULL;
9587             out_ext->protectedMemory = in_ext->protectedMemory;
9588             out_header->pNext = (void *)out_ext;
9589             out_header = (void *)out_ext;
9590             break;
9591         }
9592         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
9593         {
9594             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9595             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
9596             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
9597             out_ext->pNext = NULL;
9598             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
9599             out_header->pNext = (void *)out_ext;
9600             out_header = (void *)out_ext;
9601             break;
9602         }
9603         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
9604         {
9605             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9606             const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
9607             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
9608             out_ext->pNext = NULL;
9609             out_ext->multiDraw = in_ext->multiDraw;
9610             out_header->pNext = (void *)out_ext;
9611             out_header = (void *)out_ext;
9612             break;
9613         }
9614         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
9615         {
9616             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9617             const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
9618             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
9619             out_ext->pNext = NULL;
9620             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
9621             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
9622             out_header->pNext = (void *)out_ext;
9623             out_header = (void *)out_ext;
9624             break;
9625         }
9626         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
9627         {
9628             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9629             const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
9630             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
9631             out_ext->pNext = NULL;
9632             out_ext->maintenance4 = in_ext->maintenance4;
9633             out_header->pNext = (void *)out_ext;
9634             out_header = (void *)out_ext;
9635             break;
9636         }
9637         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
9638         {
9639             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9640             const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
9641             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
9642             out_ext->pNext = NULL;
9643             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
9644             out_header->pNext = (void *)out_ext;
9645             out_header = (void *)out_ext;
9646             break;
9647         }
9648         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
9649         {
9650             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9651             const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
9652             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
9653             out_ext->pNext = NULL;
9654             out_ext->shaderFloat16 = in_ext->shaderFloat16;
9655             out_ext->shaderInt8 = in_ext->shaderInt8;
9656             out_header->pNext = (void *)out_ext;
9657             out_header = (void *)out_ext;
9658             break;
9659         }
9660         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
9661         {
9662             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9663             const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
9664             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
9665             out_ext->pNext = NULL;
9666             out_ext->hostQueryReset = in_ext->hostQueryReset;
9667             out_header->pNext = (void *)out_ext;
9668             out_header = (void *)out_ext;
9669             break;
9670         }
9671         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
9672         {
9673             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9674             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *)in_header;
9675             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
9676             out_ext->pNext = NULL;
9677             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
9678             out_header->pNext = (void *)out_ext;
9679             out_header = (void *)out_ext;
9680             break;
9681         }
9682         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
9683         {
9684             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9685             const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
9686             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
9687             out_ext->pNext = NULL;
9688             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
9689             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
9690             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
9691             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
9692             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
9693             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
9694             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
9695             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
9696             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
9697             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
9698             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
9699             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
9700             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
9701             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
9702             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
9703             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
9704             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
9705             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
9706             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
9707             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
9708             out_header->pNext = (void *)out_ext;
9709             out_header = (void *)out_ext;
9710             break;
9711         }
9712         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
9713         {
9714             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9715             const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
9716             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
9717             out_ext->pNext = NULL;
9718             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
9719             out_header->pNext = (void *)out_ext;
9720             out_header = (void *)out_ext;
9721             break;
9722         }
9723         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
9724         {
9725             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9726             const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
9727             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
9728             out_ext->pNext = NULL;
9729             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
9730             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
9731             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
9732             out_header->pNext = (void *)out_ext;
9733             out_header = (void *)out_ext;
9734             break;
9735         }
9736         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
9737         {
9738             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9739             const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
9740             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
9741             out_ext->pNext = NULL;
9742             out_ext->conditionalRendering = in_ext->conditionalRendering;
9743             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
9744             out_header->pNext = (void *)out_ext;
9745             out_header = (void *)out_ext;
9746             break;
9747         }
9748         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
9749         {
9750             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9751             const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
9752             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
9753             out_ext->pNext = NULL;
9754             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
9755             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
9756             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
9757             out_header->pNext = (void *)out_ext;
9758             out_header = (void *)out_ext;
9759             break;
9760         }
9761         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
9762         {
9763             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9764             const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
9765             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
9766             out_ext->pNext = NULL;
9767             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
9768             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
9769             out_header->pNext = (void *)out_ext;
9770             out_header = (void *)out_ext;
9771             break;
9772         }
9773         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
9774         {
9775             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9776             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
9777             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
9778             out_ext->pNext = NULL;
9779             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
9780             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
9781             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
9782             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
9783             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
9784             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
9785             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
9786             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
9787             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
9788             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
9789             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
9790             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
9791             out_header->pNext = (void *)out_ext;
9792             out_header = (void *)out_ext;
9793             break;
9794         }
9795         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
9796         {
9797             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9798             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
9799             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
9800             out_ext->pNext = NULL;
9801             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
9802             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
9803             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
9804             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
9805             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
9806             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
9807             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
9808             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
9809             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
9810             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
9811             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
9812             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
9813             out_header->pNext = (void *)out_ext;
9814             out_header = (void *)out_ext;
9815             break;
9816         }
9817         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
9818         {
9819             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9820             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header;
9821             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
9822             out_ext->pNext = NULL;
9823             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
9824             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
9825             out_header->pNext = (void *)out_ext;
9826             out_header = (void *)out_ext;
9827             break;
9828         }
9829         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
9830         {
9831             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9832             const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
9833             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
9834             out_ext->pNext = NULL;
9835             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
9836             out_header->pNext = (void *)out_ext;
9837             out_header = (void *)out_ext;
9838             break;
9839         }
9840         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
9841         {
9842             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9843             const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
9844             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
9845             out_ext->pNext = NULL;
9846             out_ext->transformFeedback = in_ext->transformFeedback;
9847             out_ext->geometryStreams = in_ext->geometryStreams;
9848             out_header->pNext = (void *)out_ext;
9849             out_header = (void *)out_ext;
9850             break;
9851         }
9852         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
9853         {
9854             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9855             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
9856             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
9857             out_ext->pNext = NULL;
9858             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
9859             out_header->pNext = (void *)out_ext;
9860             out_header = (void *)out_ext;
9861             break;
9862         }
9863         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
9864         {
9865             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9866             const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
9867             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
9868             out_ext->pNext = NULL;
9869             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
9870             out_header->pNext = (void *)out_ext;
9871             out_header = (void *)out_ext;
9872             break;
9873         }
9874         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
9875         {
9876             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9877             const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
9878             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
9879             out_ext->pNext = NULL;
9880             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
9881             out_header->pNext = (void *)out_ext;
9882             out_header = (void *)out_ext;
9883             break;
9884         }
9885         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
9886         {
9887             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9888             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header;
9889             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
9890             out_ext->pNext = NULL;
9891             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
9892             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
9893             out_header->pNext = (void *)out_ext;
9894             out_header = (void *)out_ext;
9895             break;
9896         }
9897         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
9898         {
9899             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9900             const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
9901             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
9902             out_ext->pNext = NULL;
9903             out_ext->imageFootprint = in_ext->imageFootprint;
9904             out_header->pNext = (void *)out_ext;
9905             out_header = (void *)out_ext;
9906             break;
9907         }
9908         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
9909         {
9910             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9911             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
9912             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
9913             out_ext->pNext = NULL;
9914             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
9915             out_header->pNext = (void *)out_ext;
9916             out_header = (void *)out_ext;
9917             break;
9918         }
9919         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
9920         {
9921             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9922             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
9923             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
9924             out_ext->pNext = NULL;
9925             out_ext->indirectCopy = in_ext->indirectCopy;
9926             out_header->pNext = (void *)out_ext;
9927             out_header = (void *)out_ext;
9928             break;
9929         }
9930         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
9931         {
9932             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9933             const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
9934             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
9935             out_ext->pNext = NULL;
9936             out_ext->memoryDecompression = in_ext->memoryDecompression;
9937             out_header->pNext = (void *)out_ext;
9938             out_header = (void *)out_ext;
9939             break;
9940         }
9941         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
9942         {
9943             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9944             const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
9945             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
9946             out_ext->pNext = NULL;
9947             out_ext->shadingRateImage = in_ext->shadingRateImage;
9948             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
9949             out_header->pNext = (void *)out_ext;
9950             out_header = (void *)out_ext;
9951             break;
9952         }
9953         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
9954         {
9955             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9956             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
9957             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
9958             out_ext->pNext = NULL;
9959             out_ext->invocationMask = in_ext->invocationMask;
9960             out_header->pNext = (void *)out_ext;
9961             out_header = (void *)out_ext;
9962             break;
9963         }
9964         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
9965         {
9966             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9967             const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
9968             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
9969             out_ext->pNext = NULL;
9970             out_ext->taskShader = in_ext->taskShader;
9971             out_ext->meshShader = in_ext->meshShader;
9972             out_header->pNext = (void *)out_ext;
9973             out_header = (void *)out_ext;
9974             break;
9975         }
9976         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
9977         {
9978             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9979             const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
9980             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
9981             out_ext->pNext = NULL;
9982             out_ext->taskShader = in_ext->taskShader;
9983             out_ext->meshShader = in_ext->meshShader;
9984             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
9985             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
9986             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
9987             out_header->pNext = (void *)out_ext;
9988             out_header = (void *)out_ext;
9989             break;
9990         }
9991         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
9992         {
9993             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9994             const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
9995             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
9996             out_ext->pNext = NULL;
9997             out_ext->accelerationStructure = in_ext->accelerationStructure;
9998             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
9999             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
10000             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
10001             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
10002             out_header->pNext = (void *)out_ext;
10003             out_header = (void *)out_ext;
10004             break;
10005         }
10006         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
10007         {
10008             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10009             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
10010             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
10011             out_ext->pNext = NULL;
10012             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
10013             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
10014             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
10015             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
10016             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
10017             out_header->pNext = (void *)out_ext;
10018             out_header = (void *)out_ext;
10019             break;
10020         }
10021         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
10022         {
10023             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10024             const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
10025             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
10026             out_ext->pNext = NULL;
10027             out_ext->rayQuery = in_ext->rayQuery;
10028             out_header->pNext = (void *)out_ext;
10029             out_header = (void *)out_ext;
10030             break;
10031         }
10032         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
10033         {
10034             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10035             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
10036             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
10037             out_ext->pNext = NULL;
10038             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
10039             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
10040             out_header->pNext = (void *)out_ext;
10041             out_header = (void *)out_ext;
10042             break;
10043         }
10044         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
10045         {
10046             VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10047             const VkDeviceMemoryOverallocationCreateInfoAMD *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD *)in_header;
10048             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
10049             out_ext->pNext = NULL;
10050             out_ext->overallocationBehavior = in_ext->overallocationBehavior;
10051             out_header->pNext = (void *)out_ext;
10052             out_header = (void *)out_ext;
10053             break;
10054         }
10055         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
10056         {
10057             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10058             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
10059             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
10060             out_ext->pNext = NULL;
10061             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
10062             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
10063             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
10064             out_header->pNext = (void *)out_ext;
10065             out_header = (void *)out_ext;
10066             break;
10067         }
10068         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
10069         {
10070             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10071             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
10072             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
10073             out_ext->pNext = NULL;
10074             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
10075             out_header->pNext = (void *)out_ext;
10076             out_header = (void *)out_ext;
10077             break;
10078         }
10079         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
10080         {
10081             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10082             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *)in_header;
10083             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
10084             out_ext->pNext = NULL;
10085             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
10086             out_header->pNext = (void *)out_ext;
10087             out_header = (void *)out_ext;
10088             break;
10089         }
10090         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
10091         {
10092             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10093             const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
10094             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
10095             out_ext->pNext = NULL;
10096             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
10097             out_header->pNext = (void *)out_ext;
10098             out_header = (void *)out_ext;
10099             break;
10100         }
10101         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
10102         {
10103             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10104             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
10105             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
10106             out_ext->pNext = NULL;
10107             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
10108             out_header->pNext = (void *)out_ext;
10109             out_header = (void *)out_ext;
10110             break;
10111         }
10112         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
10113         {
10114             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10115             const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
10116             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
10117             out_ext->pNext = NULL;
10118             out_ext->depthClipEnable = in_ext->depthClipEnable;
10119             out_header->pNext = (void *)out_ext;
10120             out_header = (void *)out_ext;
10121             break;
10122         }
10123         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
10124         {
10125             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10126             const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
10127             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
10128             out_ext->pNext = NULL;
10129             out_ext->memoryPriority = in_ext->memoryPriority;
10130             out_header->pNext = (void *)out_ext;
10131             out_header = (void *)out_ext;
10132             break;
10133         }
10134         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
10135         {
10136             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10137             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
10138             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
10139             out_ext->pNext = NULL;
10140             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
10141             out_header->pNext = (void *)out_ext;
10142             out_header = (void *)out_ext;
10143             break;
10144         }
10145         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
10146         {
10147             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10148             const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
10149             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
10150             out_ext->pNext = NULL;
10151             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
10152             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
10153             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
10154             out_header->pNext = (void *)out_ext;
10155             out_header = (void *)out_ext;
10156             break;
10157         }
10158         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
10159         {
10160             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10161             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
10162             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
10163             out_ext->pNext = NULL;
10164             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
10165             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
10166             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
10167             out_header->pNext = (void *)out_ext;
10168             out_header = (void *)out_ext;
10169             break;
10170         }
10171         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
10172         {
10173             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10174             const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
10175             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
10176             out_ext->pNext = NULL;
10177             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
10178             out_header->pNext = (void *)out_ext;
10179             out_header = (void *)out_ext;
10180             break;
10181         }
10182         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
10183         {
10184             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10185             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
10186             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
10187             out_ext->pNext = NULL;
10188             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
10189             out_header->pNext = (void *)out_ext;
10190             out_header = (void *)out_ext;
10191             break;
10192         }
10193         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
10194         {
10195             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10196             const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
10197             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
10198             out_ext->pNext = NULL;
10199             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
10200             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
10201             out_header->pNext = (void *)out_ext;
10202             out_header = (void *)out_ext;
10203             break;
10204         }
10205         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
10206         {
10207             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10208             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
10209             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
10210             out_ext->pNext = NULL;
10211             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
10212             out_header->pNext = (void *)out_ext;
10213             out_header = (void *)out_ext;
10214             break;
10215         }
10216         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
10217         {
10218             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10219             const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
10220             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
10221             out_ext->pNext = NULL;
10222             out_ext->presentBarrier = in_ext->presentBarrier;
10223             out_header->pNext = (void *)out_ext;
10224             out_header = (void *)out_ext;
10225             break;
10226         }
10227         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
10228         {
10229             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10230             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
10231             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
10232             out_ext->pNext = NULL;
10233             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
10234             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
10235             out_header->pNext = (void *)out_ext;
10236             out_header = (void *)out_ext;
10237             break;
10238         }
10239         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
10240         {
10241             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10242             const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
10243             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
10244             out_ext->pNext = NULL;
10245             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
10246             out_header->pNext = (void *)out_ext;
10247             out_header = (void *)out_ext;
10248             break;
10249         }
10250         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
10251         {
10252             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10253             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
10254             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
10255             out_ext->pNext = NULL;
10256             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
10257             out_header->pNext = (void *)out_ext;
10258             out_header = (void *)out_ext;
10259             break;
10260         }
10261         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
10262         {
10263             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10264             const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
10265             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
10266             out_ext->pNext = NULL;
10267             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
10268             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
10269             out_header->pNext = (void *)out_ext;
10270             out_header = (void *)out_ext;
10271             break;
10272         }
10273         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
10274         {
10275             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10276             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header;
10277             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
10278             out_ext->pNext = NULL;
10279             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
10280             out_header->pNext = (void *)out_ext;
10281             out_header = (void *)out_ext;
10282             break;
10283         }
10284         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
10285         {
10286             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10287             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
10288             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
10289             out_ext->pNext = NULL;
10290             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
10291             out_header->pNext = (void *)out_ext;
10292             out_header = (void *)out_ext;
10293             break;
10294         }
10295         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
10296         {
10297             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10298             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
10299             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
10300             out_ext->pNext = NULL;
10301             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
10302             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
10303             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
10304             out_header->pNext = (void *)out_ext;
10305             out_header = (void *)out_ext;
10306             break;
10307         }
10308         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
10309         {
10310             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10311             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
10312             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
10313             out_ext->pNext = NULL;
10314             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
10315             out_header->pNext = (void *)out_ext;
10316             out_header = (void *)out_ext;
10317             break;
10318         }
10319         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
10320         {
10321             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10322             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
10323             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
10324             out_ext->pNext = NULL;
10325             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
10326             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
10327             out_header->pNext = (void *)out_ext;
10328             out_header = (void *)out_ext;
10329             break;
10330         }
10331         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
10332         {
10333             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10334             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
10335             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
10336             out_ext->pNext = NULL;
10337             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
10338             out_header->pNext = (void *)out_ext;
10339             out_header = (void *)out_ext;
10340             break;
10341         }
10342         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
10343         {
10344             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10345             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
10346             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
10347             out_ext->pNext = NULL;
10348             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
10349             out_header->pNext = (void *)out_ext;
10350             out_header = (void *)out_ext;
10351             break;
10352         }
10353         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
10354         {
10355             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10356             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
10357             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
10358             out_ext->pNext = NULL;
10359             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
10360             out_header->pNext = (void *)out_ext;
10361             out_header = (void *)out_ext;
10362             break;
10363         }
10364         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
10365         {
10366             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10367             const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
10368             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
10369             out_ext->pNext = NULL;
10370             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
10371             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
10372             out_header->pNext = (void *)out_ext;
10373             out_header = (void *)out_ext;
10374             break;
10375         }
10376         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
10377         {
10378             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10379             const VkPhysicalDeviceLineRasterizationFeaturesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header;
10380             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
10381             out_ext->pNext = NULL;
10382             out_ext->rectangularLines = in_ext->rectangularLines;
10383             out_ext->bresenhamLines = in_ext->bresenhamLines;
10384             out_ext->smoothLines = in_ext->smoothLines;
10385             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
10386             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
10387             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
10388             out_header->pNext = (void *)out_ext;
10389             out_header = (void *)out_ext;
10390             break;
10391         }
10392         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
10393         {
10394             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10395             const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
10396             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
10397             out_ext->pNext = NULL;
10398             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
10399             out_header->pNext = (void *)out_ext;
10400             out_header = (void *)out_ext;
10401             break;
10402         }
10403         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
10404         {
10405             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10406             const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
10407             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
10408             out_ext->pNext = NULL;
10409             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
10410             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
10411             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
10412             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
10413             out_ext->multiview = in_ext->multiview;
10414             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
10415             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
10416             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
10417             out_ext->variablePointers = in_ext->variablePointers;
10418             out_ext->protectedMemory = in_ext->protectedMemory;
10419             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
10420             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
10421             out_header->pNext = (void *)out_ext;
10422             out_header = (void *)out_ext;
10423             break;
10424         }
10425         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
10426         {
10427             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10428             const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
10429             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
10430             out_ext->pNext = NULL;
10431             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
10432             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
10433             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
10434             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
10435             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
10436             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
10437             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
10438             out_ext->shaderFloat16 = in_ext->shaderFloat16;
10439             out_ext->shaderInt8 = in_ext->shaderInt8;
10440             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
10441             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
10442             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
10443             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
10444             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
10445             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
10446             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
10447             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
10448             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
10449             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
10450             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
10451             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
10452             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
10453             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
10454             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
10455             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
10456             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
10457             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
10458             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
10459             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
10460             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
10461             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
10462             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
10463             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
10464             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
10465             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
10466             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
10467             out_ext->hostQueryReset = in_ext->hostQueryReset;
10468             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
10469             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
10470             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
10471             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
10472             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
10473             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
10474             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
10475             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
10476             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
10477             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
10478             out_header->pNext = (void *)out_ext;
10479             out_header = (void *)out_ext;
10480             break;
10481         }
10482         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
10483         {
10484             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10485             const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
10486             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
10487             out_ext->pNext = NULL;
10488             out_ext->robustImageAccess = in_ext->robustImageAccess;
10489             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
10490             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
10491             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
10492             out_ext->privateData = in_ext->privateData;
10493             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
10494             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
10495             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
10496             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
10497             out_ext->synchronization2 = in_ext->synchronization2;
10498             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
10499             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
10500             out_ext->dynamicRendering = in_ext->dynamicRendering;
10501             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
10502             out_ext->maintenance4 = in_ext->maintenance4;
10503             out_header->pNext = (void *)out_ext;
10504             out_header = (void *)out_ext;
10505             break;
10506         }
10507         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
10508         {
10509             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10510             const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
10511             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
10512             out_ext->pNext = NULL;
10513             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
10514             out_header->pNext = (void *)out_ext;
10515             out_header = (void *)out_ext;
10516             break;
10517         }
10518         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
10519         {
10520             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10521             const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
10522             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
10523             out_ext->pNext = NULL;
10524             out_ext->customBorderColors = in_ext->customBorderColors;
10525             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
10526             out_header->pNext = (void *)out_ext;
10527             out_header = (void *)out_ext;
10528             break;
10529         }
10530         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
10531         {
10532             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10533             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
10534             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
10535             out_ext->pNext = NULL;
10536             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
10537             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
10538             out_header->pNext = (void *)out_ext;
10539             out_header = (void *)out_ext;
10540             break;
10541         }
10542         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
10543         {
10544             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10545             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
10546             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
10547             out_ext->pNext = NULL;
10548             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
10549             out_header->pNext = (void *)out_ext;
10550             out_header = (void *)out_ext;
10551             break;
10552         }
10553         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
10554         {
10555             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10556             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
10557             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
10558             out_ext->pNext = NULL;
10559             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
10560             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
10561             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
10562             out_header->pNext = (void *)out_ext;
10563             out_header = (void *)out_ext;
10564             break;
10565         }
10566         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
10567         {
10568             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10569             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
10570             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
10571             out_ext->pNext = NULL;
10572             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
10573             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
10574             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
10575             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
10576             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
10577             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
10578             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
10579             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
10580             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
10581             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
10582             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
10583             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
10584             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
10585             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
10586             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
10587             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
10588             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
10589             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
10590             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
10591             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
10592             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
10593             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
10594             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
10595             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
10596             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
10597             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
10598             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
10599             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
10600             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
10601             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
10602             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
10603             out_header->pNext = (void *)out_ext;
10604             out_header = (void *)out_ext;
10605             break;
10606         }
10607         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
10608         {
10609             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10610             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
10611             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
10612             out_ext->pNext = NULL;
10613             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
10614             out_header->pNext = (void *)out_ext;
10615             out_header = (void *)out_ext;
10616             break;
10617         }
10618         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
10619         {
10620             VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10621             const VkDeviceDiagnosticsConfigCreateInfoNV *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV *)in_header;
10622             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
10623             out_ext->pNext = NULL;
10624             out_ext->flags = in_ext->flags;
10625             out_header->pNext = (void *)out_ext;
10626             out_header = (void *)out_ext;
10627             break;
10628         }
10629         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
10630         {
10631             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10632             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
10633             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
10634             out_ext->pNext = NULL;
10635             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
10636             out_header->pNext = (void *)out_ext;
10637             out_header = (void *)out_ext;
10638             break;
10639         }
10640         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
10641         {
10642             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10643             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
10644             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
10645             out_ext->pNext = NULL;
10646             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
10647             out_header->pNext = (void *)out_ext;
10648             out_header = (void *)out_ext;
10649             break;
10650         }
10651         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
10652         {
10653             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10654             const VkPhysicalDeviceRobustness2FeaturesEXT *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT *)in_header;
10655             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
10656             out_ext->pNext = NULL;
10657             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
10658             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
10659             out_ext->nullDescriptor = in_ext->nullDescriptor;
10660             out_header->pNext = (void *)out_ext;
10661             out_header = (void *)out_ext;
10662             break;
10663         }
10664         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
10665         {
10666             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10667             const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
10668             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
10669             out_ext->pNext = NULL;
10670             out_ext->robustImageAccess = in_ext->robustImageAccess;
10671             out_header->pNext = (void *)out_ext;
10672             out_header = (void *)out_ext;
10673             break;
10674         }
10675         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
10676         {
10677             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10678             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
10679             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
10680             out_ext->pNext = NULL;
10681             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
10682             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
10683             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
10684             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
10685             out_header->pNext = (void *)out_ext;
10686             out_header = (void *)out_ext;
10687             break;
10688         }
10689         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
10690         {
10691             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10692             const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
10693             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
10694             out_ext->pNext = NULL;
10695             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
10696             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
10697             out_header->pNext = (void *)out_ext;
10698             out_header = (void *)out_ext;
10699             break;
10700         }
10701         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
10702         {
10703             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10704             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
10705             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
10706             out_ext->pNext = NULL;
10707             out_ext->subpassShading = in_ext->subpassShading;
10708             out_header->pNext = (void *)out_ext;
10709             out_header = (void *)out_ext;
10710             break;
10711         }
10712         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
10713         {
10714             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10715             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
10716             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
10717             out_ext->pNext = NULL;
10718             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
10719             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
10720             out_header->pNext = (void *)out_ext;
10721             out_header = (void *)out_ext;
10722             break;
10723         }
10724         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
10725         {
10726             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10727             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
10728             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
10729             out_ext->pNext = NULL;
10730             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
10731             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
10732             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
10733             out_header->pNext = (void *)out_ext;
10734             out_header = (void *)out_ext;
10735             break;
10736         }
10737         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
10738         {
10739             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10740             const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
10741             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
10742             out_ext->pNext = NULL;
10743             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
10744             out_header->pNext = (void *)out_ext;
10745             out_header = (void *)out_ext;
10746             break;
10747         }
10748         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
10749         {
10750             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10751             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
10752             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
10753             out_ext->pNext = NULL;
10754             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
10755             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
10756             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
10757             out_header->pNext = (void *)out_ext;
10758             out_header = (void *)out_ext;
10759             break;
10760         }
10761         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
10762         {
10763             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10764             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
10765             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
10766             out_ext->pNext = NULL;
10767             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
10768             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
10769             out_header->pNext = (void *)out_ext;
10770             out_header = (void *)out_ext;
10771             break;
10772         }
10773         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
10774         {
10775             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10776             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
10777             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
10778             out_ext->pNext = NULL;
10779             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
10780             out_header->pNext = (void *)out_ext;
10781             out_header = (void *)out_ext;
10782             break;
10783         }
10784         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
10785         {
10786             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10787             const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
10788             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
10789             out_ext->pNext = NULL;
10790             out_ext->depthClipControl = in_ext->depthClipControl;
10791             out_header->pNext = (void *)out_ext;
10792             out_header = (void *)out_ext;
10793             break;
10794         }
10795         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
10796         {
10797             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10798             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
10799             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
10800             out_ext->pNext = NULL;
10801             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
10802             out_header->pNext = (void *)out_ext;
10803             out_header = (void *)out_ext;
10804             break;
10805         }
10806         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
10807         {
10808             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10809             const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
10810             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
10811             out_ext->pNext = NULL;
10812             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
10813             out_header->pNext = (void *)out_ext;
10814             out_header = (void *)out_ext;
10815             break;
10816         }
10817         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
10818         {
10819             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10820             const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
10821             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
10822             out_ext->pNext = NULL;
10823             out_ext->synchronization2 = in_ext->synchronization2;
10824             out_header->pNext = (void *)out_ext;
10825             out_header = (void *)out_ext;
10826             break;
10827         }
10828         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
10829         {
10830             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10831             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
10832             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
10833             out_ext->pNext = NULL;
10834             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
10835             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
10836             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
10837             out_header->pNext = (void *)out_ext;
10838             out_header = (void *)out_ext;
10839             break;
10840         }
10841         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
10842         {
10843             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10844             const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
10845             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
10846             out_ext->pNext = NULL;
10847             out_ext->legacyDithering = in_ext->legacyDithering;
10848             out_header->pNext = (void *)out_ext;
10849             out_header = (void *)out_ext;
10850             break;
10851         }
10852         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
10853         {
10854             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10855             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
10856             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
10857             out_ext->pNext = NULL;
10858             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
10859             out_header->pNext = (void *)out_ext;
10860             out_header = (void *)out_ext;
10861             break;
10862         }
10863         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
10864         {
10865             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10866             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)in_header;
10867             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
10868             out_ext->pNext = NULL;
10869             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
10870             out_header->pNext = (void *)out_ext;
10871             out_header = (void *)out_ext;
10872             break;
10873         }
10874         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
10875         {
10876             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10877             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
10878             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
10879             out_ext->pNext = NULL;
10880             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
10881             out_header->pNext = (void *)out_ext;
10882             out_header = (void *)out_ext;
10883             break;
10884         }
10885         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
10886         {
10887             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10888             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
10889             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
10890             out_ext->pNext = NULL;
10891             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
10892             out_header->pNext = (void *)out_ext;
10893             out_header = (void *)out_ext;
10894             break;
10895         }
10896         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
10897         {
10898             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10899             const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
10900             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
10901             out_ext->pNext = NULL;
10902             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
10903             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
10904             out_header->pNext = (void *)out_ext;
10905             out_header = (void *)out_ext;
10906             break;
10907         }
10908         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
10909         {
10910             VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10911             const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header;
10912             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
10913             out_ext->pNext = NULL;
10914             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
10915             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
10916             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
10917             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
10918             out_header->pNext = (void *)out_ext;
10919             out_header = (void *)out_ext;
10920             break;
10921         }
10922         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
10923         {
10924             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10925             const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
10926             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
10927             out_ext->pNext = NULL;
10928             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
10929             out_header->pNext = (void *)out_ext;
10930             out_header = (void *)out_ext;
10931             break;
10932         }
10933         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
10934         {
10935             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10936             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
10937             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
10938             out_ext->pNext = NULL;
10939             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
10940             out_header->pNext = (void *)out_ext;
10941             out_header = (void *)out_ext;
10942             break;
10943         }
10944         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
10945         {
10946             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10947             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
10948             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
10949             out_ext->pNext = NULL;
10950             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
10951             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
10952             out_header->pNext = (void *)out_ext;
10953             out_header = (void *)out_ext;
10954             break;
10955         }
10956         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
10957         {
10958             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10959             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
10960             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
10961             out_ext->pNext = NULL;
10962             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
10963             out_header->pNext = (void *)out_ext;
10964             out_header = (void *)out_ext;
10965             break;
10966         }
10967         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
10968         {
10969             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10970             const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
10971             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
10972             out_ext->pNext = NULL;
10973             out_ext->dynamicRendering = in_ext->dynamicRendering;
10974             out_header->pNext = (void *)out_ext;
10975             out_header = (void *)out_ext;
10976             break;
10977         }
10978         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
10979         {
10980             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10981             const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
10982             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
10983             out_ext->pNext = NULL;
10984             out_ext->minLod = in_ext->minLod;
10985             out_header->pNext = (void *)out_ext;
10986             out_header = (void *)out_ext;
10987             break;
10988         }
10989         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
10990         {
10991             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10992             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
10993             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
10994             out_ext->pNext = NULL;
10995             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
10996             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
10997             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
10998             out_header->pNext = (void *)out_ext;
10999             out_header = (void *)out_ext;
11000             break;
11001         }
11002         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
11003         {
11004             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11005             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
11006             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
11007             out_ext->pNext = NULL;
11008             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
11009             out_header->pNext = (void *)out_ext;
11010             out_header = (void *)out_ext;
11011             break;
11012         }
11013         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
11014         {
11015             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11016             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
11017             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
11018             out_ext->pNext = NULL;
11019             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
11020             out_header->pNext = (void *)out_ext;
11021             out_header = (void *)out_ext;
11022             break;
11023         }
11024         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
11025         {
11026             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11027             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
11028             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
11029             out_ext->pNext = NULL;
11030             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
11031             out_header->pNext = (void *)out_ext;
11032             out_header = (void *)out_ext;
11033             break;
11034         }
11035         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
11036         {
11037             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11038             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
11039             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
11040             out_ext->pNext = NULL;
11041             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
11042             out_header->pNext = (void *)out_ext;
11043             out_header = (void *)out_ext;
11044             break;
11045         }
11046         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
11047         {
11048             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11049             const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
11050             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
11051             out_ext->pNext = NULL;
11052             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
11053             out_header->pNext = (void *)out_ext;
11054             out_header = (void *)out_ext;
11055             break;
11056         }
11057         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
11058         {
11059             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11060             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
11061             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
11062             out_ext->pNext = NULL;
11063             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
11064             out_header->pNext = (void *)out_ext;
11065             out_header = (void *)out_ext;
11066             break;
11067         }
11068         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
11069         {
11070             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11071             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
11072             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
11073             out_ext->pNext = NULL;
11074             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
11075             out_header->pNext = (void *)out_ext;
11076             out_header = (void *)out_ext;
11077             break;
11078         }
11079         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
11080         {
11081             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11082             const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
11083             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
11084             out_ext->pNext = NULL;
11085             out_ext->micromap = in_ext->micromap;
11086             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
11087             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
11088             out_header->pNext = (void *)out_ext;
11089             out_header = (void *)out_ext;
11090             break;
11091         }
11092         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
11093         {
11094             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11095             const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
11096             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
11097             out_ext->pNext = NULL;
11098             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
11099             out_header->pNext = (void *)out_ext;
11100             out_header = (void *)out_ext;
11101             break;
11102         }
11103         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
11104         {
11105             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11106             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header;
11107             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
11108             out_ext->pNext = NULL;
11109             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
11110             out_header->pNext = (void *)out_ext;
11111             out_header = (void *)out_ext;
11112             break;
11113         }
11114         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
11115         {
11116             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11117             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
11118             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
11119             out_ext->pNext = NULL;
11120             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
11121             out_header->pNext = (void *)out_ext;
11122             out_header = (void *)out_ext;
11123             break;
11124         }
11125         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
11126         {
11127             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11128             const VkPhysicalDevicePipelineRobustnessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT *)in_header;
11129             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
11130             out_ext->pNext = NULL;
11131             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
11132             out_header->pNext = (void *)out_ext;
11133             out_header = (void *)out_ext;
11134             break;
11135         }
11136         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
11137         {
11138             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11139             const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
11140             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
11141             out_ext->pNext = NULL;
11142             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
11143             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
11144             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
11145             out_header->pNext = (void *)out_ext;
11146             out_header = (void *)out_ext;
11147             break;
11148         }
11149         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
11150         {
11151             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11152             const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
11153             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
11154             out_ext->pNext = NULL;
11155             out_ext->tileProperties = in_ext->tileProperties;
11156             out_header->pNext = (void *)out_ext;
11157             out_header = (void *)out_ext;
11158             break;
11159         }
11160         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
11161         {
11162             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11163             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
11164             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
11165             out_ext->pNext = NULL;
11166             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
11167             out_header->pNext = (void *)out_ext;
11168             out_header = (void *)out_ext;
11169             break;
11170         }
11171         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
11172         {
11173             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11174             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *)in_header;
11175             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
11176             out_ext->pNext = NULL;
11177             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
11178             out_header->pNext = (void *)out_ext;
11179             out_header = (void *)out_ext;
11180             break;
11181         }
11182         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
11183         {
11184             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11185             const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
11186             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
11187             out_ext->pNext = NULL;
11188             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
11189             out_header->pNext = (void *)out_ext;
11190             out_header = (void *)out_ext;
11191             break;
11192         }
11193         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
11194         {
11195             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11196             const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
11197             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
11198             out_ext->pNext = NULL;
11199             out_ext->opticalFlow = in_ext->opticalFlow;
11200             out_header->pNext = (void *)out_ext;
11201             out_header = (void *)out_ext;
11202             break;
11203         }
11204         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
11205         {
11206             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11207             const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
11208             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
11209             out_ext->pNext = NULL;
11210             out_ext->deviceFault = in_ext->deviceFault;
11211             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
11212             out_header->pNext = (void *)out_ext;
11213             out_header = (void *)out_ext;
11214             break;
11215         }
11216         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
11217         {
11218             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11219             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
11220             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
11221             out_ext->pNext = NULL;
11222             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
11223             out_header->pNext = (void *)out_ext;
11224             out_header = (void *)out_ext;
11225             break;
11226         }
11227         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
11228         {
11229             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11230             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
11231             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
11232             out_ext->pNext = NULL;
11233             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
11234             out_header->pNext = (void *)out_ext;
11235             out_header = (void *)out_ext;
11236             break;
11237         }
11238         default:
11239             FIXME("Unhandled sType %u.", in_header->sType);
11240             break;
11241         }
11242     }
11243 }
11244 #endif /* _WIN64 */
11245
11246 static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo32 *in, VkDeviceCreateInfo *out)
11247 {
11248     const VkBaseInStructure32 *in_header;
11249     VkBaseOutStructure *out_header = (void *)out;
11250
11251     if (!in) return;
11252
11253     out->sType = in->sType;
11254     out->pNext = NULL;
11255     out->flags = in->flags;
11256     out->queueCreateInfoCount = in->queueCreateInfoCount;
11257     out->pQueueCreateInfos = convert_VkDeviceQueueCreateInfo_array_win32_to_host(ctx, (const VkDeviceQueueCreateInfo32 *)UlongToPtr(in->pQueueCreateInfos), in->queueCreateInfoCount);
11258     out->enabledLayerCount = in->enabledLayerCount;
11259     out->ppEnabledLayerNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledLayerNames), in->enabledLayerCount);
11260     out->enabledExtensionCount = in->enabledExtensionCount;
11261     out->ppEnabledExtensionNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledExtensionNames), in->enabledExtensionCount);
11262     out->pEnabledFeatures = (const VkPhysicalDeviceFeatures *)UlongToPtr(in->pEnabledFeatures);
11263
11264     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
11265     {
11266         switch (in_header->sType)
11267         {
11268         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
11269             break;
11270         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
11271         {
11272             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11273             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header;
11274             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
11275             out_ext->pNext = NULL;
11276             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
11277             out_header->pNext = (void *)out_ext;
11278             out_header = (void *)out_ext;
11279             break;
11280         }
11281         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
11282         {
11283             VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11284             const VkDevicePrivateDataCreateInfo32 *in_ext = (const VkDevicePrivateDataCreateInfo32 *)in_header;
11285             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
11286             out_ext->pNext = NULL;
11287             out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
11288             out_header->pNext = (void *)out_ext;
11289             out_header = (void *)out_ext;
11290             break;
11291         }
11292         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
11293         {
11294             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11295             const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header;
11296             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
11297             out_ext->pNext = NULL;
11298             out_ext->privateData = in_ext->privateData;
11299             out_header->pNext = (void *)out_ext;
11300             out_header = (void *)out_ext;
11301             break;
11302         }
11303         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
11304         {
11305             VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11306             const VkPhysicalDeviceFeatures232 *in_ext = (const VkPhysicalDeviceFeatures232 *)in_header;
11307             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
11308             out_ext->pNext = NULL;
11309             out_ext->features = in_ext->features;
11310             out_header->pNext = (void *)out_ext;
11311             out_header = (void *)out_ext;
11312             break;
11313         }
11314         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
11315         {
11316             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11317             const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header;
11318             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
11319             out_ext->pNext = NULL;
11320             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
11321             out_ext->variablePointers = in_ext->variablePointers;
11322             out_header->pNext = (void *)out_ext;
11323             out_header = (void *)out_ext;
11324             break;
11325         }
11326         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
11327         {
11328             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11329             const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header;
11330             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
11331             out_ext->pNext = NULL;
11332             out_ext->multiview = in_ext->multiview;
11333             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
11334             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
11335             out_header->pNext = (void *)out_ext;
11336             out_header = (void *)out_ext;
11337             break;
11338         }
11339         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
11340         {
11341             VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11342             const VkDeviceGroupDeviceCreateInfo32 *in_ext = (const VkDeviceGroupDeviceCreateInfo32 *)in_header;
11343             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
11344             out_ext->pNext = NULL;
11345             out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
11346             out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->pPhysicalDevices), in_ext->physicalDeviceCount);
11347             out_header->pNext = (void *)out_ext;
11348             out_header = (void *)out_ext;
11349             break;
11350         }
11351         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
11352         {
11353             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11354             const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header;
11355             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
11356             out_ext->pNext = NULL;
11357             out_ext->presentId = in_ext->presentId;
11358             out_header->pNext = (void *)out_ext;
11359             out_header = (void *)out_ext;
11360             break;
11361         }
11362         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
11363         {
11364             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11365             const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header;
11366             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
11367             out_ext->pNext = NULL;
11368             out_ext->presentWait = in_ext->presentWait;
11369             out_header->pNext = (void *)out_ext;
11370             out_header = (void *)out_ext;
11371             break;
11372         }
11373         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
11374         {
11375             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11376             const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header;
11377             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
11378             out_ext->pNext = NULL;
11379             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
11380             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
11381             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
11382             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
11383             out_header->pNext = (void *)out_ext;
11384             out_header = (void *)out_ext;
11385             break;
11386         }
11387         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
11388         {
11389             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11390             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header;
11391             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
11392             out_ext->pNext = NULL;
11393             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
11394             out_header->pNext = (void *)out_ext;
11395             out_header = (void *)out_ext;
11396             break;
11397         }
11398         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
11399         {
11400             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11401             const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header;
11402             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
11403             out_ext->pNext = NULL;
11404             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
11405             out_header->pNext = (void *)out_ext;
11406             out_header = (void *)out_ext;
11407             break;
11408         }
11409         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
11410         {
11411             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11412             const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header;
11413             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
11414             out_ext->pNext = NULL;
11415             out_ext->protectedMemory = in_ext->protectedMemory;
11416             out_header->pNext = (void *)out_ext;
11417             out_header = (void *)out_ext;
11418             break;
11419         }
11420         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
11421         {
11422             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11423             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *)in_header;
11424             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
11425             out_ext->pNext = NULL;
11426             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
11427             out_header->pNext = (void *)out_ext;
11428             out_header = (void *)out_ext;
11429             break;
11430         }
11431         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
11432         {
11433             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11434             const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header;
11435             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
11436             out_ext->pNext = NULL;
11437             out_ext->multiDraw = in_ext->multiDraw;
11438             out_header->pNext = (void *)out_ext;
11439             out_header = (void *)out_ext;
11440             break;
11441         }
11442         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
11443         {
11444             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11445             const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header;
11446             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
11447             out_ext->pNext = NULL;
11448             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
11449             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
11450             out_header->pNext = (void *)out_ext;
11451             out_header = (void *)out_ext;
11452             break;
11453         }
11454         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
11455         {
11456             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11457             const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header;
11458             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
11459             out_ext->pNext = NULL;
11460             out_ext->maintenance4 = in_ext->maintenance4;
11461             out_header->pNext = (void *)out_ext;
11462             out_header = (void *)out_ext;
11463             break;
11464         }
11465         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
11466         {
11467             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11468             const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header;
11469             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
11470             out_ext->pNext = NULL;
11471             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
11472             out_header->pNext = (void *)out_ext;
11473             out_header = (void *)out_ext;
11474             break;
11475         }
11476         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
11477         {
11478             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11479             const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header;
11480             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
11481             out_ext->pNext = NULL;
11482             out_ext->shaderFloat16 = in_ext->shaderFloat16;
11483             out_ext->shaderInt8 = in_ext->shaderInt8;
11484             out_header->pNext = (void *)out_ext;
11485             out_header = (void *)out_ext;
11486             break;
11487         }
11488         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
11489         {
11490             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11491             const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header;
11492             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
11493             out_ext->pNext = NULL;
11494             out_ext->hostQueryReset = in_ext->hostQueryReset;
11495             out_header->pNext = (void *)out_ext;
11496             out_header = (void *)out_ext;
11497             break;
11498         }
11499         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
11500         {
11501             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11502             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *)in_header;
11503             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
11504             out_ext->pNext = NULL;
11505             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
11506             out_header->pNext = (void *)out_ext;
11507             out_header = (void *)out_ext;
11508             break;
11509         }
11510         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
11511         {
11512             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11513             const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header;
11514             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
11515             out_ext->pNext = NULL;
11516             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
11517             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
11518             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
11519             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
11520             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
11521             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
11522             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
11523             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
11524             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
11525             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
11526             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
11527             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
11528             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
11529             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
11530             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
11531             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
11532             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
11533             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
11534             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
11535             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
11536             out_header->pNext = (void *)out_ext;
11537             out_header = (void *)out_ext;
11538             break;
11539         }
11540         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
11541         {
11542             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11543             const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header;
11544             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
11545             out_ext->pNext = NULL;
11546             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
11547             out_header->pNext = (void *)out_ext;
11548             out_header = (void *)out_ext;
11549             break;
11550         }
11551         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
11552         {
11553             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11554             const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header;
11555             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
11556             out_ext->pNext = NULL;
11557             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
11558             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
11559             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
11560             out_header->pNext = (void *)out_ext;
11561             out_header = (void *)out_ext;
11562             break;
11563         }
11564         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
11565         {
11566             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11567             const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header;
11568             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
11569             out_ext->pNext = NULL;
11570             out_ext->conditionalRendering = in_ext->conditionalRendering;
11571             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
11572             out_header->pNext = (void *)out_ext;
11573             out_header = (void *)out_ext;
11574             break;
11575         }
11576         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
11577         {
11578             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11579             const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header;
11580             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
11581             out_ext->pNext = NULL;
11582             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
11583             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
11584             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
11585             out_header->pNext = (void *)out_ext;
11586             out_header = (void *)out_ext;
11587             break;
11588         }
11589         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
11590         {
11591             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11592             const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header;
11593             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
11594             out_ext->pNext = NULL;
11595             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
11596             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
11597             out_header->pNext = (void *)out_ext;
11598             out_header = (void *)out_ext;
11599             break;
11600         }
11601         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
11602         {
11603             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11604             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header;
11605             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
11606             out_ext->pNext = NULL;
11607             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
11608             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
11609             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
11610             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
11611             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
11612             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
11613             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
11614             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
11615             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
11616             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
11617             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
11618             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
11619             out_header->pNext = (void *)out_ext;
11620             out_header = (void *)out_ext;
11621             break;
11622         }
11623         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
11624         {
11625             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11626             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header;
11627             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
11628             out_ext->pNext = NULL;
11629             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
11630             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
11631             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
11632             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
11633             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
11634             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
11635             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
11636             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
11637             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
11638             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
11639             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
11640             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
11641             out_header->pNext = (void *)out_ext;
11642             out_header = (void *)out_ext;
11643             break;
11644         }
11645         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
11646         {
11647             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11648             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *)in_header;
11649             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
11650             out_ext->pNext = NULL;
11651             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
11652             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
11653             out_header->pNext = (void *)out_ext;
11654             out_header = (void *)out_ext;
11655             break;
11656         }
11657         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
11658         {
11659             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11660             const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header;
11661             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
11662             out_ext->pNext = NULL;
11663             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
11664             out_header->pNext = (void *)out_ext;
11665             out_header = (void *)out_ext;
11666             break;
11667         }
11668         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
11669         {
11670             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11671             const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header;
11672             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
11673             out_ext->pNext = NULL;
11674             out_ext->transformFeedback = in_ext->transformFeedback;
11675             out_ext->geometryStreams = in_ext->geometryStreams;
11676             out_header->pNext = (void *)out_ext;
11677             out_header = (void *)out_ext;
11678             break;
11679         }
11680         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
11681         {
11682             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11683             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header;
11684             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
11685             out_ext->pNext = NULL;
11686             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
11687             out_header->pNext = (void *)out_ext;
11688             out_header = (void *)out_ext;
11689             break;
11690         }
11691         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
11692         {
11693             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11694             const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header;
11695             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
11696             out_ext->pNext = NULL;
11697             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
11698             out_header->pNext = (void *)out_ext;
11699             out_header = (void *)out_ext;
11700             break;
11701         }
11702         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
11703         {
11704             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11705             const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header;
11706             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
11707             out_ext->pNext = NULL;
11708             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
11709             out_header->pNext = (void *)out_ext;
11710             out_header = (void *)out_ext;
11711             break;
11712         }
11713         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
11714         {
11715             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11716             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *)in_header;
11717             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
11718             out_ext->pNext = NULL;
11719             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
11720             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
11721             out_header->pNext = (void *)out_ext;
11722             out_header = (void *)out_ext;
11723             break;
11724         }
11725         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
11726         {
11727             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11728             const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header;
11729             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
11730             out_ext->pNext = NULL;
11731             out_ext->imageFootprint = in_ext->imageFootprint;
11732             out_header->pNext = (void *)out_ext;
11733             out_header = (void *)out_ext;
11734             break;
11735         }
11736         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
11737         {
11738             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11739             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header;
11740             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
11741             out_ext->pNext = NULL;
11742             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
11743             out_header->pNext = (void *)out_ext;
11744             out_header = (void *)out_ext;
11745             break;
11746         }
11747         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
11748         {
11749             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11750             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header;
11751             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
11752             out_ext->pNext = NULL;
11753             out_ext->indirectCopy = in_ext->indirectCopy;
11754             out_header->pNext = (void *)out_ext;
11755             out_header = (void *)out_ext;
11756             break;
11757         }
11758         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
11759         {
11760             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11761             const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header;
11762             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
11763             out_ext->pNext = NULL;
11764             out_ext->memoryDecompression = in_ext->memoryDecompression;
11765             out_header->pNext = (void *)out_ext;
11766             out_header = (void *)out_ext;
11767             break;
11768         }
11769         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
11770         {
11771             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11772             const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header;
11773             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
11774             out_ext->pNext = NULL;
11775             out_ext->shadingRateImage = in_ext->shadingRateImage;
11776             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
11777             out_header->pNext = (void *)out_ext;
11778             out_header = (void *)out_ext;
11779             break;
11780         }
11781         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
11782         {
11783             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11784             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header;
11785             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
11786             out_ext->pNext = NULL;
11787             out_ext->invocationMask = in_ext->invocationMask;
11788             out_header->pNext = (void *)out_ext;
11789             out_header = (void *)out_ext;
11790             break;
11791         }
11792         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
11793         {
11794             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11795             const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header;
11796             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
11797             out_ext->pNext = NULL;
11798             out_ext->taskShader = in_ext->taskShader;
11799             out_ext->meshShader = in_ext->meshShader;
11800             out_header->pNext = (void *)out_ext;
11801             out_header = (void *)out_ext;
11802             break;
11803         }
11804         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
11805         {
11806             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11807             const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header;
11808             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
11809             out_ext->pNext = NULL;
11810             out_ext->taskShader = in_ext->taskShader;
11811             out_ext->meshShader = in_ext->meshShader;
11812             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
11813             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
11814             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
11815             out_header->pNext = (void *)out_ext;
11816             out_header = (void *)out_ext;
11817             break;
11818         }
11819         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
11820         {
11821             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11822             const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header;
11823             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
11824             out_ext->pNext = NULL;
11825             out_ext->accelerationStructure = in_ext->accelerationStructure;
11826             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
11827             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
11828             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
11829             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
11830             out_header->pNext = (void *)out_ext;
11831             out_header = (void *)out_ext;
11832             break;
11833         }
11834         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
11835         {
11836             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11837             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header;
11838             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
11839             out_ext->pNext = NULL;
11840             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
11841             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
11842             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
11843             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
11844             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
11845             out_header->pNext = (void *)out_ext;
11846             out_header = (void *)out_ext;
11847             break;
11848         }
11849         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
11850         {
11851             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11852             const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header;
11853             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
11854             out_ext->pNext = NULL;
11855             out_ext->rayQuery = in_ext->rayQuery;
11856             out_header->pNext = (void *)out_ext;
11857             out_header = (void *)out_ext;
11858             break;
11859         }
11860         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
11861         {
11862             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11863             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header;
11864             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
11865             out_ext->pNext = NULL;
11866             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
11867             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
11868             out_header->pNext = (void *)out_ext;
11869             out_header = (void *)out_ext;
11870             break;
11871         }
11872         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
11873         {
11874             VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11875             const VkDeviceMemoryOverallocationCreateInfoAMD32 *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD32 *)in_header;
11876             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
11877             out_ext->pNext = NULL;
11878             out_ext->overallocationBehavior = in_ext->overallocationBehavior;
11879             out_header->pNext = (void *)out_ext;
11880             out_header = (void *)out_ext;
11881             break;
11882         }
11883         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
11884         {
11885             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11886             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header;
11887             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
11888             out_ext->pNext = NULL;
11889             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
11890             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
11891             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
11892             out_header->pNext = (void *)out_ext;
11893             out_header = (void *)out_ext;
11894             break;
11895         }
11896         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
11897         {
11898             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11899             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header;
11900             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
11901             out_ext->pNext = NULL;
11902             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
11903             out_header->pNext = (void *)out_ext;
11904             out_header = (void *)out_ext;
11905             break;
11906         }
11907         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
11908         {
11909             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11910             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *)in_header;
11911             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
11912             out_ext->pNext = NULL;
11913             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
11914             out_header->pNext = (void *)out_ext;
11915             out_header = (void *)out_ext;
11916             break;
11917         }
11918         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
11919         {
11920             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11921             const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header;
11922             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
11923             out_ext->pNext = NULL;
11924             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
11925             out_header->pNext = (void *)out_ext;
11926             out_header = (void *)out_ext;
11927             break;
11928         }
11929         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
11930         {
11931             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11932             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header;
11933             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
11934             out_ext->pNext = NULL;
11935             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
11936             out_header->pNext = (void *)out_ext;
11937             out_header = (void *)out_ext;
11938             break;
11939         }
11940         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
11941         {
11942             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11943             const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header;
11944             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
11945             out_ext->pNext = NULL;
11946             out_ext->depthClipEnable = in_ext->depthClipEnable;
11947             out_header->pNext = (void *)out_ext;
11948             out_header = (void *)out_ext;
11949             break;
11950         }
11951         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
11952         {
11953             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11954             const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header;
11955             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
11956             out_ext->pNext = NULL;
11957             out_ext->memoryPriority = in_ext->memoryPriority;
11958             out_header->pNext = (void *)out_ext;
11959             out_header = (void *)out_ext;
11960             break;
11961         }
11962         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
11963         {
11964             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11965             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header;
11966             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
11967             out_ext->pNext = NULL;
11968             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
11969             out_header->pNext = (void *)out_ext;
11970             out_header = (void *)out_ext;
11971             break;
11972         }
11973         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
11974         {
11975             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11976             const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header;
11977             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
11978             out_ext->pNext = NULL;
11979             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
11980             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
11981             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
11982             out_header->pNext = (void *)out_ext;
11983             out_header = (void *)out_ext;
11984             break;
11985         }
11986         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
11987         {
11988             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
11989             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header;
11990             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
11991             out_ext->pNext = NULL;
11992             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
11993             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
11994             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
11995             out_header->pNext = (void *)out_ext;
11996             out_header = (void *)out_ext;
11997             break;
11998         }
11999         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
12000         {
12001             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12002             const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header;
12003             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
12004             out_ext->pNext = NULL;
12005             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
12006             out_header->pNext = (void *)out_ext;
12007             out_header = (void *)out_ext;
12008             break;
12009         }
12010         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
12011         {
12012             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12013             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header;
12014             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
12015             out_ext->pNext = NULL;
12016             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
12017             out_header->pNext = (void *)out_ext;
12018             out_header = (void *)out_ext;
12019             break;
12020         }
12021         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
12022         {
12023             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12024             const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header;
12025             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
12026             out_ext->pNext = NULL;
12027             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
12028             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
12029             out_header->pNext = (void *)out_ext;
12030             out_header = (void *)out_ext;
12031             break;
12032         }
12033         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
12034         {
12035             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12036             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header;
12037             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
12038             out_ext->pNext = NULL;
12039             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
12040             out_header->pNext = (void *)out_ext;
12041             out_header = (void *)out_ext;
12042             break;
12043         }
12044         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
12045         {
12046             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12047             const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header;
12048             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
12049             out_ext->pNext = NULL;
12050             out_ext->presentBarrier = in_ext->presentBarrier;
12051             out_header->pNext = (void *)out_ext;
12052             out_header = (void *)out_ext;
12053             break;
12054         }
12055         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
12056         {
12057             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12058             const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header;
12059             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
12060             out_ext->pNext = NULL;
12061             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
12062             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
12063             out_header->pNext = (void *)out_ext;
12064             out_header = (void *)out_ext;
12065             break;
12066         }
12067         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
12068         {
12069             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12070             const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header;
12071             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
12072             out_ext->pNext = NULL;
12073             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
12074             out_header->pNext = (void *)out_ext;
12075             out_header = (void *)out_ext;
12076             break;
12077         }
12078         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
12079         {
12080             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12081             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header;
12082             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
12083             out_ext->pNext = NULL;
12084             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
12085             out_header->pNext = (void *)out_ext;
12086             out_header = (void *)out_ext;
12087             break;
12088         }
12089         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
12090         {
12091             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12092             const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header;
12093             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
12094             out_ext->pNext = NULL;
12095             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
12096             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
12097             out_header->pNext = (void *)out_ext;
12098             out_header = (void *)out_ext;
12099             break;
12100         }
12101         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
12102         {
12103             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12104             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *)in_header;
12105             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
12106             out_ext->pNext = NULL;
12107             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
12108             out_header->pNext = (void *)out_ext;
12109             out_header = (void *)out_ext;
12110             break;
12111         }
12112         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
12113         {
12114             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12115             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header;
12116             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
12117             out_ext->pNext = NULL;
12118             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
12119             out_header->pNext = (void *)out_ext;
12120             out_header = (void *)out_ext;
12121             break;
12122         }
12123         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
12124         {
12125             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12126             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header;
12127             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
12128             out_ext->pNext = NULL;
12129             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
12130             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
12131             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
12132             out_header->pNext = (void *)out_ext;
12133             out_header = (void *)out_ext;
12134             break;
12135         }
12136         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
12137         {
12138             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12139             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header;
12140             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
12141             out_ext->pNext = NULL;
12142             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
12143             out_header->pNext = (void *)out_ext;
12144             out_header = (void *)out_ext;
12145             break;
12146         }
12147         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
12148         {
12149             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12150             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header;
12151             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
12152             out_ext->pNext = NULL;
12153             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
12154             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
12155             out_header->pNext = (void *)out_ext;
12156             out_header = (void *)out_ext;
12157             break;
12158         }
12159         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
12160         {
12161             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12162             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header;
12163             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
12164             out_ext->pNext = NULL;
12165             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
12166             out_header->pNext = (void *)out_ext;
12167             out_header = (void *)out_ext;
12168             break;
12169         }
12170         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
12171         {
12172             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12173             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header;
12174             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
12175             out_ext->pNext = NULL;
12176             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
12177             out_header->pNext = (void *)out_ext;
12178             out_header = (void *)out_ext;
12179             break;
12180         }
12181         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
12182         {
12183             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12184             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header;
12185             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
12186             out_ext->pNext = NULL;
12187             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
12188             out_header->pNext = (void *)out_ext;
12189             out_header = (void *)out_ext;
12190             break;
12191         }
12192         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
12193         {
12194             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12195             const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header;
12196             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
12197             out_ext->pNext = NULL;
12198             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
12199             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
12200             out_header->pNext = (void *)out_ext;
12201             out_header = (void *)out_ext;
12202             break;
12203         }
12204         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
12205         {
12206             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12207             const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *)in_header;
12208             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
12209             out_ext->pNext = NULL;
12210             out_ext->rectangularLines = in_ext->rectangularLines;
12211             out_ext->bresenhamLines = in_ext->bresenhamLines;
12212             out_ext->smoothLines = in_ext->smoothLines;
12213             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
12214             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
12215             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
12216             out_header->pNext = (void *)out_ext;
12217             out_header = (void *)out_ext;
12218             break;
12219         }
12220         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
12221         {
12222             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12223             const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header;
12224             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
12225             out_ext->pNext = NULL;
12226             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
12227             out_header->pNext = (void *)out_ext;
12228             out_header = (void *)out_ext;
12229             break;
12230         }
12231         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
12232         {
12233             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12234             const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header;
12235             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
12236             out_ext->pNext = NULL;
12237             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
12238             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
12239             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
12240             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
12241             out_ext->multiview = in_ext->multiview;
12242             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
12243             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
12244             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
12245             out_ext->variablePointers = in_ext->variablePointers;
12246             out_ext->protectedMemory = in_ext->protectedMemory;
12247             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
12248             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
12249             out_header->pNext = (void *)out_ext;
12250             out_header = (void *)out_ext;
12251             break;
12252         }
12253         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
12254         {
12255             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12256             const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header;
12257             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
12258             out_ext->pNext = NULL;
12259             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
12260             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
12261             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
12262             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
12263             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
12264             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
12265             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
12266             out_ext->shaderFloat16 = in_ext->shaderFloat16;
12267             out_ext->shaderInt8 = in_ext->shaderInt8;
12268             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
12269             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
12270             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
12271             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
12272             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
12273             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
12274             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
12275             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
12276             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
12277             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
12278             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
12279             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
12280             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
12281             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
12282             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
12283             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
12284             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
12285             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
12286             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
12287             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
12288             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
12289             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
12290             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
12291             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
12292             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
12293             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
12294             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
12295             out_ext->hostQueryReset = in_ext->hostQueryReset;
12296             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
12297             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
12298             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
12299             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
12300             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
12301             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
12302             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
12303             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
12304             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
12305             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
12306             out_header->pNext = (void *)out_ext;
12307             out_header = (void *)out_ext;
12308             break;
12309         }
12310         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
12311         {
12312             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12313             const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header;
12314             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
12315             out_ext->pNext = NULL;
12316             out_ext->robustImageAccess = in_ext->robustImageAccess;
12317             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
12318             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
12319             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
12320             out_ext->privateData = in_ext->privateData;
12321             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
12322             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
12323             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
12324             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
12325             out_ext->synchronization2 = in_ext->synchronization2;
12326             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
12327             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
12328             out_ext->dynamicRendering = in_ext->dynamicRendering;
12329             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
12330             out_ext->maintenance4 = in_ext->maintenance4;
12331             out_header->pNext = (void *)out_ext;
12332             out_header = (void *)out_ext;
12333             break;
12334         }
12335         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
12336         {
12337             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12338             const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header;
12339             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
12340             out_ext->pNext = NULL;
12341             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
12342             out_header->pNext = (void *)out_ext;
12343             out_header = (void *)out_ext;
12344             break;
12345         }
12346         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
12347         {
12348             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12349             const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header;
12350             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
12351             out_ext->pNext = NULL;
12352             out_ext->customBorderColors = in_ext->customBorderColors;
12353             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
12354             out_header->pNext = (void *)out_ext;
12355             out_header = (void *)out_ext;
12356             break;
12357         }
12358         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
12359         {
12360             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12361             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header;
12362             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
12363             out_ext->pNext = NULL;
12364             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
12365             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
12366             out_header->pNext = (void *)out_ext;
12367             out_header = (void *)out_ext;
12368             break;
12369         }
12370         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
12371         {
12372             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12373             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header;
12374             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
12375             out_ext->pNext = NULL;
12376             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
12377             out_header->pNext = (void *)out_ext;
12378             out_header = (void *)out_ext;
12379             break;
12380         }
12381         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
12382         {
12383             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12384             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header;
12385             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
12386             out_ext->pNext = NULL;
12387             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
12388             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
12389             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
12390             out_header->pNext = (void *)out_ext;
12391             out_header = (void *)out_ext;
12392             break;
12393         }
12394         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
12395         {
12396             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12397             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header;
12398             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
12399             out_ext->pNext = NULL;
12400             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
12401             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
12402             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
12403             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
12404             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
12405             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
12406             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
12407             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
12408             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
12409             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
12410             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
12411             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
12412             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
12413             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
12414             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
12415             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
12416             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
12417             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
12418             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
12419             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
12420             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
12421             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
12422             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
12423             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
12424             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
12425             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
12426             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
12427             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
12428             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
12429             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
12430             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
12431             out_header->pNext = (void *)out_ext;
12432             out_header = (void *)out_ext;
12433             break;
12434         }
12435         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
12436         {
12437             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12438             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header;
12439             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
12440             out_ext->pNext = NULL;
12441             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
12442             out_header->pNext = (void *)out_ext;
12443             out_header = (void *)out_ext;
12444             break;
12445         }
12446         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
12447         {
12448             VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12449             const VkDeviceDiagnosticsConfigCreateInfoNV32 *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV32 *)in_header;
12450             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
12451             out_ext->pNext = NULL;
12452             out_ext->flags = in_ext->flags;
12453             out_header->pNext = (void *)out_ext;
12454             out_header = (void *)out_ext;
12455             break;
12456         }
12457         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
12458         {
12459             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12460             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header;
12461             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
12462             out_ext->pNext = NULL;
12463             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
12464             out_header->pNext = (void *)out_ext;
12465             out_header = (void *)out_ext;
12466             break;
12467         }
12468         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
12469         {
12470             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12471             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header;
12472             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
12473             out_ext->pNext = NULL;
12474             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
12475             out_header->pNext = (void *)out_ext;
12476             out_header = (void *)out_ext;
12477             break;
12478         }
12479         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
12480         {
12481             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12482             const VkPhysicalDeviceRobustness2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT32 *)in_header;
12483             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
12484             out_ext->pNext = NULL;
12485             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
12486             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
12487             out_ext->nullDescriptor = in_ext->nullDescriptor;
12488             out_header->pNext = (void *)out_ext;
12489             out_header = (void *)out_ext;
12490             break;
12491         }
12492         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
12493         {
12494             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12495             const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header;
12496             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
12497             out_ext->pNext = NULL;
12498             out_ext->robustImageAccess = in_ext->robustImageAccess;
12499             out_header->pNext = (void *)out_ext;
12500             out_header = (void *)out_ext;
12501             break;
12502         }
12503         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
12504         {
12505             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12506             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header;
12507             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
12508             out_ext->pNext = NULL;
12509             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
12510             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
12511             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
12512             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
12513             out_header->pNext = (void *)out_ext;
12514             out_header = (void *)out_ext;
12515             break;
12516         }
12517         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
12518         {
12519             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12520             const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header;
12521             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
12522             out_ext->pNext = NULL;
12523             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
12524             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
12525             out_header->pNext = (void *)out_ext;
12526             out_header = (void *)out_ext;
12527             break;
12528         }
12529         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
12530         {
12531             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12532             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header;
12533             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
12534             out_ext->pNext = NULL;
12535             out_ext->subpassShading = in_ext->subpassShading;
12536             out_header->pNext = (void *)out_ext;
12537             out_header = (void *)out_ext;
12538             break;
12539         }
12540         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
12541         {
12542             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12543             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header;
12544             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
12545             out_ext->pNext = NULL;
12546             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
12547             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
12548             out_header->pNext = (void *)out_ext;
12549             out_header = (void *)out_ext;
12550             break;
12551         }
12552         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
12553         {
12554             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12555             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header;
12556             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
12557             out_ext->pNext = NULL;
12558             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
12559             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
12560             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
12561             out_header->pNext = (void *)out_ext;
12562             out_header = (void *)out_ext;
12563             break;
12564         }
12565         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
12566         {
12567             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12568             const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header;
12569             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
12570             out_ext->pNext = NULL;
12571             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
12572             out_header->pNext = (void *)out_ext;
12573             out_header = (void *)out_ext;
12574             break;
12575         }
12576         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
12577         {
12578             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12579             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header;
12580             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
12581             out_ext->pNext = NULL;
12582             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
12583             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
12584             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
12585             out_header->pNext = (void *)out_ext;
12586             out_header = (void *)out_ext;
12587             break;
12588         }
12589         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
12590         {
12591             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12592             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header;
12593             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
12594             out_ext->pNext = NULL;
12595             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
12596             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
12597             out_header->pNext = (void *)out_ext;
12598             out_header = (void *)out_ext;
12599             break;
12600         }
12601         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
12602         {
12603             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12604             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header;
12605             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
12606             out_ext->pNext = NULL;
12607             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
12608             out_header->pNext = (void *)out_ext;
12609             out_header = (void *)out_ext;
12610             break;
12611         }
12612         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
12613         {
12614             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12615             const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header;
12616             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
12617             out_ext->pNext = NULL;
12618             out_ext->depthClipControl = in_ext->depthClipControl;
12619             out_header->pNext = (void *)out_ext;
12620             out_header = (void *)out_ext;
12621             break;
12622         }
12623         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
12624         {
12625             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12626             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header;
12627             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
12628             out_ext->pNext = NULL;
12629             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
12630             out_header->pNext = (void *)out_ext;
12631             out_header = (void *)out_ext;
12632             break;
12633         }
12634         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
12635         {
12636             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12637             const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header;
12638             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
12639             out_ext->pNext = NULL;
12640             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
12641             out_header->pNext = (void *)out_ext;
12642             out_header = (void *)out_ext;
12643             break;
12644         }
12645         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
12646         {
12647             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12648             const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header;
12649             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
12650             out_ext->pNext = NULL;
12651             out_ext->synchronization2 = in_ext->synchronization2;
12652             out_header->pNext = (void *)out_ext;
12653             out_header = (void *)out_ext;
12654             break;
12655         }
12656         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
12657         {
12658             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12659             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header;
12660             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
12661             out_ext->pNext = NULL;
12662             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
12663             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
12664             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
12665             out_header->pNext = (void *)out_ext;
12666             out_header = (void *)out_ext;
12667             break;
12668         }
12669         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
12670         {
12671             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12672             const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header;
12673             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
12674             out_ext->pNext = NULL;
12675             out_ext->legacyDithering = in_ext->legacyDithering;
12676             out_header->pNext = (void *)out_ext;
12677             out_header = (void *)out_ext;
12678             break;
12679         }
12680         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
12681         {
12682             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12683             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header;
12684             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
12685             out_ext->pNext = NULL;
12686             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
12687             out_header->pNext = (void *)out_ext;
12688             out_header = (void *)out_ext;
12689             break;
12690         }
12691         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
12692         {
12693             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12694             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *)in_header;
12695             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
12696             out_ext->pNext = NULL;
12697             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
12698             out_header->pNext = (void *)out_ext;
12699             out_header = (void *)out_ext;
12700             break;
12701         }
12702         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
12703         {
12704             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12705             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header;
12706             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
12707             out_ext->pNext = NULL;
12708             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
12709             out_header->pNext = (void *)out_ext;
12710             out_header = (void *)out_ext;
12711             break;
12712         }
12713         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
12714         {
12715             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12716             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header;
12717             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
12718             out_ext->pNext = NULL;
12719             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
12720             out_header->pNext = (void *)out_ext;
12721             out_header = (void *)out_ext;
12722             break;
12723         }
12724         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
12725         {
12726             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12727             const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *)in_header;
12728             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
12729             out_ext->pNext = NULL;
12730             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
12731             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
12732             out_header->pNext = (void *)out_ext;
12733             out_header = (void *)out_ext;
12734             break;
12735         }
12736         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
12737         {
12738             VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12739             const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header;
12740             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
12741             out_ext->pNext = NULL;
12742             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
12743             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
12744             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
12745             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
12746             out_header->pNext = (void *)out_ext;
12747             out_header = (void *)out_ext;
12748             break;
12749         }
12750         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
12751         {
12752             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12753             const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header;
12754             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
12755             out_ext->pNext = NULL;
12756             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
12757             out_header->pNext = (void *)out_ext;
12758             out_header = (void *)out_ext;
12759             break;
12760         }
12761         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
12762         {
12763             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12764             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header;
12765             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
12766             out_ext->pNext = NULL;
12767             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
12768             out_header->pNext = (void *)out_ext;
12769             out_header = (void *)out_ext;
12770             break;
12771         }
12772         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
12773         {
12774             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12775             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header;
12776             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
12777             out_ext->pNext = NULL;
12778             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
12779             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
12780             out_header->pNext = (void *)out_ext;
12781             out_header = (void *)out_ext;
12782             break;
12783         }
12784         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
12785         {
12786             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12787             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header;
12788             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
12789             out_ext->pNext = NULL;
12790             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
12791             out_header->pNext = (void *)out_ext;
12792             out_header = (void *)out_ext;
12793             break;
12794         }
12795         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
12796         {
12797             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12798             const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header;
12799             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
12800             out_ext->pNext = NULL;
12801             out_ext->dynamicRendering = in_ext->dynamicRendering;
12802             out_header->pNext = (void *)out_ext;
12803             out_header = (void *)out_ext;
12804             break;
12805         }
12806         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
12807         {
12808             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12809             const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header;
12810             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
12811             out_ext->pNext = NULL;
12812             out_ext->minLod = in_ext->minLod;
12813             out_header->pNext = (void *)out_ext;
12814             out_header = (void *)out_ext;
12815             break;
12816         }
12817         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
12818         {
12819             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12820             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header;
12821             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
12822             out_ext->pNext = NULL;
12823             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
12824             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
12825             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
12826             out_header->pNext = (void *)out_ext;
12827             out_header = (void *)out_ext;
12828             break;
12829         }
12830         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
12831         {
12832             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12833             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header;
12834             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
12835             out_ext->pNext = NULL;
12836             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
12837             out_header->pNext = (void *)out_ext;
12838             out_header = (void *)out_ext;
12839             break;
12840         }
12841         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
12842         {
12843             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12844             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header;
12845             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
12846             out_ext->pNext = NULL;
12847             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
12848             out_header->pNext = (void *)out_ext;
12849             out_header = (void *)out_ext;
12850             break;
12851         }
12852         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
12853         {
12854             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12855             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header;
12856             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
12857             out_ext->pNext = NULL;
12858             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
12859             out_header->pNext = (void *)out_ext;
12860             out_header = (void *)out_ext;
12861             break;
12862         }
12863         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
12864         {
12865             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12866             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header;
12867             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
12868             out_ext->pNext = NULL;
12869             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
12870             out_header->pNext = (void *)out_ext;
12871             out_header = (void *)out_ext;
12872             break;
12873         }
12874         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
12875         {
12876             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12877             const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header;
12878             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
12879             out_ext->pNext = NULL;
12880             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
12881             out_header->pNext = (void *)out_ext;
12882             out_header = (void *)out_ext;
12883             break;
12884         }
12885         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
12886         {
12887             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12888             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header;
12889             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
12890             out_ext->pNext = NULL;
12891             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
12892             out_header->pNext = (void *)out_ext;
12893             out_header = (void *)out_ext;
12894             break;
12895         }
12896         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
12897         {
12898             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12899             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header;
12900             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
12901             out_ext->pNext = NULL;
12902             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
12903             out_header->pNext = (void *)out_ext;
12904             out_header = (void *)out_ext;
12905             break;
12906         }
12907         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
12908         {
12909             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12910             const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header;
12911             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
12912             out_ext->pNext = NULL;
12913             out_ext->micromap = in_ext->micromap;
12914             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
12915             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
12916             out_header->pNext = (void *)out_ext;
12917             out_header = (void *)out_ext;
12918             break;
12919         }
12920         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
12921         {
12922             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12923             const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header;
12924             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
12925             out_ext->pNext = NULL;
12926             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
12927             out_header->pNext = (void *)out_ext;
12928             out_header = (void *)out_ext;
12929             break;
12930         }
12931         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
12932         {
12933             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12934             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header;
12935             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
12936             out_ext->pNext = NULL;
12937             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
12938             out_header->pNext = (void *)out_ext;
12939             out_header = (void *)out_ext;
12940             break;
12941         }
12942         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
12943         {
12944             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12945             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header;
12946             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
12947             out_ext->pNext = NULL;
12948             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
12949             out_header->pNext = (void *)out_ext;
12950             out_header = (void *)out_ext;
12951             break;
12952         }
12953         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
12954         {
12955             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12956             const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *)in_header;
12957             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
12958             out_ext->pNext = NULL;
12959             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
12960             out_header->pNext = (void *)out_ext;
12961             out_header = (void *)out_ext;
12962             break;
12963         }
12964         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
12965         {
12966             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12967             const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header;
12968             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
12969             out_ext->pNext = NULL;
12970             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
12971             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
12972             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
12973             out_header->pNext = (void *)out_ext;
12974             out_header = (void *)out_ext;
12975             break;
12976         }
12977         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
12978         {
12979             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12980             const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header;
12981             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
12982             out_ext->pNext = NULL;
12983             out_ext->tileProperties = in_ext->tileProperties;
12984             out_header->pNext = (void *)out_ext;
12985             out_header = (void *)out_ext;
12986             break;
12987         }
12988         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
12989         {
12990             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12991             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header;
12992             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
12993             out_ext->pNext = NULL;
12994             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
12995             out_header->pNext = (void *)out_ext;
12996             out_header = (void *)out_ext;
12997             break;
12998         }
12999         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
13000         {
13001             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13002             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *)in_header;
13003             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
13004             out_ext->pNext = NULL;
13005             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
13006             out_header->pNext = (void *)out_ext;
13007             out_header = (void *)out_ext;
13008             break;
13009         }
13010         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
13011         {
13012             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13013             const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header;
13014             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
13015             out_ext->pNext = NULL;
13016             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
13017             out_header->pNext = (void *)out_ext;
13018             out_header = (void *)out_ext;
13019             break;
13020         }
13021         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
13022         {
13023             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13024             const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header;
13025             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
13026             out_ext->pNext = NULL;
13027             out_ext->opticalFlow = in_ext->opticalFlow;
13028             out_header->pNext = (void *)out_ext;
13029             out_header = (void *)out_ext;
13030             break;
13031         }
13032         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
13033         {
13034             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13035             const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header;
13036             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
13037             out_ext->pNext = NULL;
13038             out_ext->deviceFault = in_ext->deviceFault;
13039             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
13040             out_header->pNext = (void *)out_ext;
13041             out_header = (void *)out_ext;
13042             break;
13043         }
13044         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
13045         {
13046             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13047             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header;
13048             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
13049             out_ext->pNext = NULL;
13050             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
13051             out_header->pNext = (void *)out_ext;
13052             out_header = (void *)out_ext;
13053             break;
13054         }
13055         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
13056         {
13057             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13058             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header;
13059             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
13060             out_ext->pNext = NULL;
13061             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
13062             out_header->pNext = (void *)out_ext;
13063             out_header = (void *)out_ext;
13064             break;
13065         }
13066         default:
13067             FIXME("Unhandled sType %u.", in_header->sType);
13068             break;
13069         }
13070     }
13071 }
13072
13073 static inline void convert_VkEventCreateInfo_win32_to_host(const VkEventCreateInfo32 *in, VkEventCreateInfo *out)
13074 {
13075     if (!in) return;
13076
13077     out->sType = in->sType;
13078     out->pNext = NULL;
13079     out->flags = in->flags;
13080     if (in->pNext)
13081         FIXME("Unexpected pNext\n");
13082 }
13083
13084 static inline void convert_VkFenceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFenceCreateInfo32 *in, VkFenceCreateInfo *out)
13085 {
13086     const VkBaseInStructure32 *in_header;
13087     VkBaseOutStructure *out_header = (void *)out;
13088
13089     if (!in) return;
13090
13091     out->sType = in->sType;
13092     out->pNext = NULL;
13093     out->flags = in->flags;
13094
13095     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
13096     {
13097         switch (in_header->sType)
13098         {
13099         case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
13100         {
13101             VkExportFenceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13102             const VkExportFenceCreateInfo32 *in_ext = (const VkExportFenceCreateInfo32 *)in_header;
13103             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO;
13104             out_ext->pNext = NULL;
13105             out_ext->handleTypes = in_ext->handleTypes;
13106             out_header->pNext = (void *)out_ext;
13107             out_header = (void *)out_ext;
13108             break;
13109         }
13110         default:
13111             FIXME("Unhandled sType %u.", in_header->sType);
13112             break;
13113         }
13114     }
13115 }
13116
13117 static inline void convert_VkFramebufferAttachmentImageInfo_win32_to_host(const VkFramebufferAttachmentImageInfo32 *in, VkFramebufferAttachmentImageInfo *out)
13118 {
13119     if (!in) return;
13120
13121     out->sType = in->sType;
13122     out->pNext = NULL;
13123     out->flags = in->flags;
13124     out->usage = in->usage;
13125     out->width = in->width;
13126     out->height = in->height;
13127     out->layerCount = in->layerCount;
13128     out->viewFormatCount = in->viewFormatCount;
13129     out->pViewFormats = (const VkFormat *)UlongToPtr(in->pViewFormats);
13130     if (in->pNext)
13131         FIXME("Unexpected pNext\n");
13132 }
13133
13134 static inline const VkFramebufferAttachmentImageInfo *convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferAttachmentImageInfo32 *in, uint32_t count)
13135 {
13136     VkFramebufferAttachmentImageInfo *out;
13137     unsigned int i;
13138
13139     if (!in || !count) return NULL;
13140
13141     out = conversion_context_alloc(ctx, count * sizeof(*out));
13142     for (i = 0; i < count; i++)
13143     {
13144         convert_VkFramebufferAttachmentImageInfo_win32_to_host(&in[i], &out[i]);
13145     }
13146
13147     return out;
13148 }
13149
13150 static inline void convert_VkFramebufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFramebufferCreateInfo32 *in, VkFramebufferCreateInfo *out)
13151 {
13152     const VkBaseInStructure32 *in_header;
13153     VkBaseOutStructure *out_header = (void *)out;
13154
13155     if (!in) return;
13156
13157     out->sType = in->sType;
13158     out->pNext = NULL;
13159     out->flags = in->flags;
13160     out->renderPass = in->renderPass;
13161     out->attachmentCount = in->attachmentCount;
13162     out->pAttachments = (const VkImageView *)UlongToPtr(in->pAttachments);
13163     out->width = in->width;
13164     out->height = in->height;
13165     out->layers = in->layers;
13166
13167     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
13168     {
13169         switch (in_header->sType)
13170         {
13171         case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
13172         {
13173             VkFramebufferAttachmentsCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13174             const VkFramebufferAttachmentsCreateInfo32 *in_ext = (const VkFramebufferAttachmentsCreateInfo32 *)in_header;
13175             out_ext->sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
13176             out_ext->pNext = NULL;
13177             out_ext->attachmentImageInfoCount = in_ext->attachmentImageInfoCount;
13178             out_ext->pAttachmentImageInfos = convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(ctx, (const VkFramebufferAttachmentImageInfo32 *)UlongToPtr(in_ext->pAttachmentImageInfos), in_ext->attachmentImageInfoCount);
13179             out_header->pNext = (void *)out_ext;
13180             out_header = (void *)out_ext;
13181             break;
13182         }
13183         default:
13184             FIXME("Unhandled sType %u.", in_header->sType);
13185             break;
13186         }
13187     }
13188 }
13189
13190 #ifdef _WIN64
13191 static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, uint32_t count)
13192 {
13193     VkPipelineShaderStageCreateInfo *out;
13194     unsigned int i;
13195
13196     if (!in || !count) return NULL;
13197
13198     out = conversion_context_alloc(ctx, count * sizeof(*out));
13199     for (i = 0; i < count; i++)
13200     {
13201         convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
13202     }
13203
13204     return out;
13205 }
13206 #endif /* _WIN64 */
13207
13208 static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, uint32_t count)
13209 {
13210     VkPipelineShaderStageCreateInfo *out;
13211     unsigned int i;
13212
13213     if (!in || !count) return NULL;
13214
13215     out = conversion_context_alloc(ctx, count * sizeof(*out));
13216     for (i = 0; i < count; i++)
13217     {
13218         convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
13219     }
13220
13221     return out;
13222 }
13223
13224 static inline void convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, VkPipelineVertexInputStateCreateInfo *out)
13225 {
13226     const VkBaseInStructure32 *in_header;
13227     VkBaseOutStructure *out_header = (void *)out;
13228
13229     if (!in) return;
13230
13231     out->sType = in->sType;
13232     out->pNext = NULL;
13233     out->flags = in->flags;
13234     out->vertexBindingDescriptionCount = in->vertexBindingDescriptionCount;
13235     out->pVertexBindingDescriptions = (const VkVertexInputBindingDescription *)UlongToPtr(in->pVertexBindingDescriptions);
13236     out->vertexAttributeDescriptionCount = in->vertexAttributeDescriptionCount;
13237     out->pVertexAttributeDescriptions = (const VkVertexInputAttributeDescription *)UlongToPtr(in->pVertexAttributeDescriptions);
13238
13239     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
13240     {
13241         switch (in_header->sType)
13242         {
13243         case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
13244         {
13245             VkPipelineVertexInputDivisorStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13246             const VkPipelineVertexInputDivisorStateCreateInfoEXT32 *in_ext = (const VkPipelineVertexInputDivisorStateCreateInfoEXT32 *)in_header;
13247             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT;
13248             out_ext->pNext = NULL;
13249             out_ext->vertexBindingDivisorCount = in_ext->vertexBindingDivisorCount;
13250             out_ext->pVertexBindingDivisors = (const VkVertexInputBindingDivisorDescriptionEXT *)UlongToPtr(in_ext->pVertexBindingDivisors);
13251             out_header->pNext = (void *)out_ext;
13252             out_header = (void *)out_ext;
13253             break;
13254         }
13255         default:
13256             FIXME("Unhandled sType %u.", in_header->sType);
13257             break;
13258         }
13259     }
13260 }
13261
13262 static inline const VkPipelineVertexInputStateCreateInfo *convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, uint32_t count)
13263 {
13264     VkPipelineVertexInputStateCreateInfo *out;
13265     unsigned int i;
13266
13267     if (!in || !count) return NULL;
13268
13269     out = conversion_context_alloc(ctx, count * sizeof(*out));
13270     for (i = 0; i < count; i++)
13271     {
13272         convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
13273     }
13274
13275     return out;
13276 }
13277
13278 static inline void convert_VkPipelineTessellationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, VkPipelineTessellationStateCreateInfo *out)
13279 {
13280     const VkBaseInStructure32 *in_header;
13281     VkBaseOutStructure *out_header = (void *)out;
13282
13283     if (!in) return;
13284
13285     out->sType = in->sType;
13286     out->pNext = NULL;
13287     out->flags = in->flags;
13288     out->patchControlPoints = in->patchControlPoints;
13289
13290     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
13291     {
13292         switch (in_header->sType)
13293         {
13294         case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
13295         {
13296             VkPipelineTessellationDomainOriginStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13297             const VkPipelineTessellationDomainOriginStateCreateInfo32 *in_ext = (const VkPipelineTessellationDomainOriginStateCreateInfo32 *)in_header;
13298             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
13299             out_ext->pNext = NULL;
13300             out_ext->domainOrigin = in_ext->domainOrigin;
13301             out_header->pNext = (void *)out_ext;
13302             out_header = (void *)out_ext;
13303             break;
13304         }
13305         default:
13306             FIXME("Unhandled sType %u.", in_header->sType);
13307             break;
13308         }
13309     }
13310 }
13311
13312 static inline const VkPipelineTessellationStateCreateInfo *convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, uint32_t count)
13313 {
13314     VkPipelineTessellationStateCreateInfo *out;
13315     unsigned int i;
13316
13317     if (!in || !count) return NULL;
13318
13319     out = conversion_context_alloc(ctx, count * sizeof(*out));
13320     for (i = 0; i < count; i++)
13321     {
13322         convert_VkPipelineTessellationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
13323     }
13324
13325     return out;
13326 }
13327
13328 #ifdef _WIN64
13329 static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, VkGraphicsShaderGroupCreateInfoNV *out)
13330 {
13331     if (!in) return;
13332
13333     out->sType = in->sType;
13334     out->pNext = in->pNext;
13335     out->stageCount = in->stageCount;
13336     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
13337     out->pVertexInputState = in->pVertexInputState;
13338     out->pTessellationState = in->pTessellationState;
13339 }
13340 #endif /* _WIN64 */
13341
13342 static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, VkGraphicsShaderGroupCreateInfoNV *out)
13343 {
13344     if (!in) return;
13345
13346     out->sType = in->sType;
13347     out->pNext = NULL;
13348     out->stageCount = in->stageCount;
13349     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
13350     out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineVertexInputStateCreateInfo32 *)UlongToPtr(in->pVertexInputState), 1);
13351     out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineTessellationStateCreateInfo32 *)UlongToPtr(in->pTessellationState), 1);
13352     if (in->pNext)
13353         FIXME("Unexpected pNext\n");
13354 }
13355
13356 #ifdef _WIN64
13357 static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, uint32_t count)
13358 {
13359     VkGraphicsShaderGroupCreateInfoNV *out;
13360     unsigned int i;
13361
13362     if (!in || !count) return NULL;
13363
13364     out = conversion_context_alloc(ctx, count * sizeof(*out));
13365     for (i = 0; i < count; i++)
13366     {
13367         convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
13368     }
13369
13370     return out;
13371 }
13372 #endif /* _WIN64 */
13373
13374 static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, uint32_t count)
13375 {
13376     VkGraphicsShaderGroupCreateInfoNV *out;
13377     unsigned int i;
13378
13379     if (!in || !count) return NULL;
13380
13381     out = conversion_context_alloc(ctx, count * sizeof(*out));
13382     for (i = 0; i < count; i++)
13383     {
13384         convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
13385     }
13386
13387     return out;
13388 }
13389
13390 static inline void convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(const VkPipelineInputAssemblyStateCreateInfo32 *in, VkPipelineInputAssemblyStateCreateInfo *out)
13391 {
13392     if (!in) return;
13393
13394     out->sType = in->sType;
13395     out->pNext = NULL;
13396     out->flags = in->flags;
13397     out->topology = in->topology;
13398     out->primitiveRestartEnable = in->primitiveRestartEnable;
13399     if (in->pNext)
13400         FIXME("Unexpected pNext\n");
13401 }
13402
13403 static inline const VkPipelineInputAssemblyStateCreateInfo *convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineInputAssemblyStateCreateInfo32 *in, uint32_t count)
13404 {
13405     VkPipelineInputAssemblyStateCreateInfo *out;
13406     unsigned int i;
13407
13408     if (!in || !count) return NULL;
13409
13410     out = conversion_context_alloc(ctx, count * sizeof(*out));
13411     for (i = 0; i < count; i++)
13412     {
13413         convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(&in[i], &out[i]);
13414     }
13415
13416     return out;
13417 }
13418
13419 static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, VkPipelineViewportStateCreateInfo *out)
13420 {
13421     const VkBaseInStructure32 *in_header;
13422     VkBaseOutStructure *out_header = (void *)out;
13423
13424     if (!in) return;
13425
13426     out->sType = in->sType;
13427     out->pNext = NULL;
13428     out->flags = in->flags;
13429     out->viewportCount = in->viewportCount;
13430     out->pViewports = (const VkViewport *)UlongToPtr(in->pViewports);
13431     out->scissorCount = in->scissorCount;
13432     out->pScissors = (const VkRect2D *)UlongToPtr(in->pScissors);
13433
13434     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
13435     {
13436         switch (in_header->sType)
13437         {
13438         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
13439         {
13440             VkPipelineViewportWScalingStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13441             const VkPipelineViewportWScalingStateCreateInfoNV32 *in_ext = (const VkPipelineViewportWScalingStateCreateInfoNV32 *)in_header;
13442             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV;
13443             out_ext->pNext = NULL;
13444             out_ext->viewportWScalingEnable = in_ext->viewportWScalingEnable;
13445             out_ext->viewportCount = in_ext->viewportCount;
13446             out_ext->pViewportWScalings = (const VkViewportWScalingNV *)UlongToPtr(in_ext->pViewportWScalings);
13447             out_header->pNext = (void *)out_ext;
13448             out_header = (void *)out_ext;
13449             break;
13450         }
13451         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
13452         {
13453             VkPipelineViewportSwizzleStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13454             const VkPipelineViewportSwizzleStateCreateInfoNV32 *in_ext = (const VkPipelineViewportSwizzleStateCreateInfoNV32 *)in_header;
13455             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV;
13456             out_ext->pNext = NULL;
13457             out_ext->flags = in_ext->flags;
13458             out_ext->viewportCount = in_ext->viewportCount;
13459             out_ext->pViewportSwizzles = (const VkViewportSwizzleNV *)UlongToPtr(in_ext->pViewportSwizzles);
13460             out_header->pNext = (void *)out_ext;
13461             out_header = (void *)out_ext;
13462             break;
13463         }
13464         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
13465         {
13466             VkPipelineViewportExclusiveScissorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13467             const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *in_ext = (const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *)in_header;
13468             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV;
13469             out_ext->pNext = NULL;
13470             out_ext->exclusiveScissorCount = in_ext->exclusiveScissorCount;
13471             out_ext->pExclusiveScissors = (const VkRect2D *)UlongToPtr(in_ext->pExclusiveScissors);
13472             out_header->pNext = (void *)out_ext;
13473             out_header = (void *)out_ext;
13474             break;
13475         }
13476         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
13477         {
13478             VkPipelineViewportShadingRateImageStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13479             const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *in_ext = (const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *)in_header;
13480             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV;
13481             out_ext->pNext = NULL;
13482             out_ext->shadingRateImageEnable = in_ext->shadingRateImageEnable;
13483             out_ext->viewportCount = in_ext->viewportCount;
13484             out_ext->pShadingRatePalettes = convert_VkShadingRatePaletteNV_array_win32_to_host(ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(in_ext->pShadingRatePalettes), in_ext->viewportCount);
13485             out_header->pNext = (void *)out_ext;
13486             out_header = (void *)out_ext;
13487             break;
13488         }
13489         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
13490         {
13491             VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13492             const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *in_ext = (const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *)in_header;
13493             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV;
13494             out_ext->pNext = NULL;
13495             out_ext->sampleOrderType = in_ext->sampleOrderType;
13496             out_ext->customSampleOrderCount = in_ext->customSampleOrderCount;
13497             out_ext->pCustomSampleOrders = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(in_ext->pCustomSampleOrders), in_ext->customSampleOrderCount);
13498             out_header->pNext = (void *)out_ext;
13499             out_header = (void *)out_ext;
13500             break;
13501         }
13502         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
13503         {
13504             VkPipelineViewportDepthClipControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13505             const VkPipelineViewportDepthClipControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClipControlCreateInfoEXT32 *)in_header;
13506             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT;
13507             out_ext->pNext = NULL;
13508             out_ext->negativeOneToOne = in_ext->negativeOneToOne;
13509             out_header->pNext = (void *)out_ext;
13510             out_header = (void *)out_ext;
13511             break;
13512         }
13513         default:
13514             FIXME("Unhandled sType %u.", in_header->sType);
13515             break;
13516         }
13517     }
13518 }
13519
13520 static inline const VkPipelineViewportStateCreateInfo *convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, uint32_t count)
13521 {
13522     VkPipelineViewportStateCreateInfo *out;
13523     unsigned int i;
13524
13525     if (!in || !count) return NULL;
13526
13527     out = conversion_context_alloc(ctx, count * sizeof(*out));
13528     for (i = 0; i < count; i++)
13529     {
13530         convert_VkPipelineViewportStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
13531     }
13532
13533     return out;
13534 }
13535
13536 static inline void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, VkPipelineRasterizationStateCreateInfo *out)
13537 {
13538     const VkBaseInStructure32 *in_header;
13539     VkBaseOutStructure *out_header = (void *)out;
13540
13541     if (!in) return;
13542
13543     out->sType = in->sType;
13544     out->pNext = NULL;
13545     out->flags = in->flags;
13546     out->depthClampEnable = in->depthClampEnable;
13547     out->rasterizerDiscardEnable = in->rasterizerDiscardEnable;
13548     out->polygonMode = in->polygonMode;
13549     out->cullMode = in->cullMode;
13550     out->frontFace = in->frontFace;
13551     out->depthBiasEnable = in->depthBiasEnable;
13552     out->depthBiasConstantFactor = in->depthBiasConstantFactor;
13553     out->depthBiasClamp = in->depthBiasClamp;
13554     out->depthBiasSlopeFactor = in->depthBiasSlopeFactor;
13555     out->lineWidth = in->lineWidth;
13556
13557     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
13558     {
13559         switch (in_header->sType)
13560         {
13561         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
13562         {
13563             VkPipelineRasterizationStateRasterizationOrderAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13564             const VkPipelineRasterizationStateRasterizationOrderAMD32 *in_ext = (const VkPipelineRasterizationStateRasterizationOrderAMD32 *)in_header;
13565             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD;
13566             out_ext->pNext = NULL;
13567             out_ext->rasterizationOrder = in_ext->rasterizationOrder;
13568             out_header->pNext = (void *)out_ext;
13569             out_header = (void *)out_ext;
13570             break;
13571         }
13572         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
13573         {
13574             VkPipelineRasterizationConservativeStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13575             const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *)in_header;
13576             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT;
13577             out_ext->pNext = NULL;
13578             out_ext->flags = in_ext->flags;
13579             out_ext->conservativeRasterizationMode = in_ext->conservativeRasterizationMode;
13580             out_ext->extraPrimitiveOverestimationSize = in_ext->extraPrimitiveOverestimationSize;
13581             out_header->pNext = (void *)out_ext;
13582             out_header = (void *)out_ext;
13583             break;
13584         }
13585         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
13586         {
13587             VkPipelineRasterizationStateStreamCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13588             const VkPipelineRasterizationStateStreamCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationStateStreamCreateInfoEXT32 *)in_header;
13589             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT;
13590             out_ext->pNext = NULL;
13591             out_ext->flags = in_ext->flags;
13592             out_ext->rasterizationStream = in_ext->rasterizationStream;
13593             out_header->pNext = (void *)out_ext;
13594             out_header = (void *)out_ext;
13595             break;
13596         }
13597         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
13598         {
13599             VkPipelineRasterizationDepthClipStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13600             const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *)in_header;
13601             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT;
13602             out_ext->pNext = NULL;
13603             out_ext->flags = in_ext->flags;
13604             out_ext->depthClipEnable = in_ext->depthClipEnable;
13605             out_header->pNext = (void *)out_ext;
13606             out_header = (void *)out_ext;
13607             break;
13608         }
13609         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
13610         {
13611             VkPipelineRasterizationLineStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13612             const VkPipelineRasterizationLineStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationLineStateCreateInfoEXT32 *)in_header;
13613             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT;
13614             out_ext->pNext = NULL;
13615             out_ext->lineRasterizationMode = in_ext->lineRasterizationMode;
13616             out_ext->stippledLineEnable = in_ext->stippledLineEnable;
13617             out_ext->lineStippleFactor = in_ext->lineStippleFactor;
13618             out_ext->lineStipplePattern = in_ext->lineStipplePattern;
13619             out_header->pNext = (void *)out_ext;
13620             out_header = (void *)out_ext;
13621             break;
13622         }
13623         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
13624         {
13625             VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13626             const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *)in_header;
13627             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT;
13628             out_ext->pNext = NULL;
13629             out_ext->provokingVertexMode = in_ext->provokingVertexMode;
13630             out_header->pNext = (void *)out_ext;
13631             out_header = (void *)out_ext;
13632             break;
13633         }
13634         default:
13635             FIXME("Unhandled sType %u.", in_header->sType);
13636             break;
13637         }
13638     }
13639 }
13640
13641 static inline const VkPipelineRasterizationStateCreateInfo *convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, uint32_t count)
13642 {
13643     VkPipelineRasterizationStateCreateInfo *out;
13644     unsigned int i;
13645
13646     if (!in || !count) return NULL;
13647
13648     out = conversion_context_alloc(ctx, count * sizeof(*out));
13649     for (i = 0; i < count; i++)
13650     {
13651         convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
13652     }
13653
13654     return out;
13655 }
13656
13657 static inline void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, VkPipelineMultisampleStateCreateInfo *out)
13658 {
13659     const VkBaseInStructure32 *in_header;
13660     VkBaseOutStructure *out_header = (void *)out;
13661
13662     if (!in) return;
13663
13664     out->sType = in->sType;
13665     out->pNext = NULL;
13666     out->flags = in->flags;
13667     out->rasterizationSamples = in->rasterizationSamples;
13668     out->sampleShadingEnable = in->sampleShadingEnable;
13669     out->minSampleShading = in->minSampleShading;
13670     out->pSampleMask = (const VkSampleMask *)UlongToPtr(in->pSampleMask);
13671     out->alphaToCoverageEnable = in->alphaToCoverageEnable;
13672     out->alphaToOneEnable = in->alphaToOneEnable;
13673
13674     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
13675     {
13676         switch (in_header->sType)
13677         {
13678         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
13679         {
13680             VkPipelineCoverageToColorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13681             const VkPipelineCoverageToColorStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageToColorStateCreateInfoNV32 *)in_header;
13682             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV;
13683             out_ext->pNext = NULL;
13684             out_ext->flags = in_ext->flags;
13685             out_ext->coverageToColorEnable = in_ext->coverageToColorEnable;
13686             out_ext->coverageToColorLocation = in_ext->coverageToColorLocation;
13687             out_header->pNext = (void *)out_ext;
13688             out_header = (void *)out_ext;
13689             break;
13690         }
13691         case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
13692         {
13693             VkPipelineSampleLocationsStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13694             const VkPipelineSampleLocationsStateCreateInfoEXT32 *in_ext = (const VkPipelineSampleLocationsStateCreateInfoEXT32 *)in_header;
13695             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT;
13696             out_ext->pNext = NULL;
13697             out_ext->sampleLocationsEnable = in_ext->sampleLocationsEnable;
13698             convert_VkSampleLocationsInfoEXT_win32_to_host(&in_ext->sampleLocationsInfo, &out_ext->sampleLocationsInfo);
13699             out_header->pNext = (void *)out_ext;
13700             out_header = (void *)out_ext;
13701             break;
13702         }
13703         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
13704         {
13705             VkPipelineCoverageModulationStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13706             const VkPipelineCoverageModulationStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageModulationStateCreateInfoNV32 *)in_header;
13707             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV;
13708             out_ext->pNext = NULL;
13709             out_ext->flags = in_ext->flags;
13710             out_ext->coverageModulationMode = in_ext->coverageModulationMode;
13711             out_ext->coverageModulationTableEnable = in_ext->coverageModulationTableEnable;
13712             out_ext->coverageModulationTableCount = in_ext->coverageModulationTableCount;
13713             out_ext->pCoverageModulationTable = (const float *)UlongToPtr(in_ext->pCoverageModulationTable);
13714             out_header->pNext = (void *)out_ext;
13715             out_header = (void *)out_ext;
13716             break;
13717         }
13718         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
13719         {
13720             VkPipelineCoverageReductionStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13721             const VkPipelineCoverageReductionStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageReductionStateCreateInfoNV32 *)in_header;
13722             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV;
13723             out_ext->pNext = NULL;
13724             out_ext->flags = in_ext->flags;
13725             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
13726             out_header->pNext = (void *)out_ext;
13727             out_header = (void *)out_ext;
13728             break;
13729         }
13730         default:
13731             FIXME("Unhandled sType %u.", in_header->sType);
13732             break;
13733         }
13734     }
13735 }
13736
13737 static inline const VkPipelineMultisampleStateCreateInfo *convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, uint32_t count)
13738 {
13739     VkPipelineMultisampleStateCreateInfo *out;
13740     unsigned int i;
13741
13742     if (!in || !count) return NULL;
13743
13744     out = conversion_context_alloc(ctx, count * sizeof(*out));
13745     for (i = 0; i < count; i++)
13746     {
13747         convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
13748     }
13749
13750     return out;
13751 }
13752
13753 static inline void convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(const VkPipelineDepthStencilStateCreateInfo32 *in, VkPipelineDepthStencilStateCreateInfo *out)
13754 {
13755     if (!in) return;
13756
13757     out->sType = in->sType;
13758     out->pNext = NULL;
13759     out->flags = in->flags;
13760     out->depthTestEnable = in->depthTestEnable;
13761     out->depthWriteEnable = in->depthWriteEnable;
13762     out->depthCompareOp = in->depthCompareOp;
13763     out->depthBoundsTestEnable = in->depthBoundsTestEnable;
13764     out->stencilTestEnable = in->stencilTestEnable;
13765     out->front = in->front;
13766     out->back = in->back;
13767     out->minDepthBounds = in->minDepthBounds;
13768     out->maxDepthBounds = in->maxDepthBounds;
13769     if (in->pNext)
13770         FIXME("Unexpected pNext\n");
13771 }
13772
13773 static inline const VkPipelineDepthStencilStateCreateInfo *convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDepthStencilStateCreateInfo32 *in, uint32_t count)
13774 {
13775     VkPipelineDepthStencilStateCreateInfo *out;
13776     unsigned int i;
13777
13778     if (!in || !count) return NULL;
13779
13780     out = conversion_context_alloc(ctx, count * sizeof(*out));
13781     for (i = 0; i < count; i++)
13782     {
13783         convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(&in[i], &out[i]);
13784     }
13785
13786     return out;
13787 }
13788
13789 static inline void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, VkPipelineColorBlendStateCreateInfo *out)
13790 {
13791     const VkBaseInStructure32 *in_header;
13792     VkBaseOutStructure *out_header = (void *)out;
13793
13794     if (!in) return;
13795
13796     out->sType = in->sType;
13797     out->pNext = NULL;
13798     out->flags = in->flags;
13799     out->logicOpEnable = in->logicOpEnable;
13800     out->logicOp = in->logicOp;
13801     out->attachmentCount = in->attachmentCount;
13802     out->pAttachments = (const VkPipelineColorBlendAttachmentState *)UlongToPtr(in->pAttachments);
13803     memcpy(out->blendConstants, in->blendConstants, 4 * sizeof(float));
13804
13805     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
13806     {
13807         switch (in_header->sType)
13808         {
13809         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
13810         {
13811             VkPipelineColorBlendAdvancedStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13812             const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *in_ext = (const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *)in_header;
13813             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT;
13814             out_ext->pNext = NULL;
13815             out_ext->srcPremultiplied = in_ext->srcPremultiplied;
13816             out_ext->dstPremultiplied = in_ext->dstPremultiplied;
13817             out_ext->blendOverlap = in_ext->blendOverlap;
13818             out_header->pNext = (void *)out_ext;
13819             out_header = (void *)out_ext;
13820             break;
13821         }
13822         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
13823         {
13824             VkPipelineColorWriteCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13825             const VkPipelineColorWriteCreateInfoEXT32 *in_ext = (const VkPipelineColorWriteCreateInfoEXT32 *)in_header;
13826             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT;
13827             out_ext->pNext = NULL;
13828             out_ext->attachmentCount = in_ext->attachmentCount;
13829             out_ext->pColorWriteEnables = (const VkBool32 *)UlongToPtr(in_ext->pColorWriteEnables);
13830             out_header->pNext = (void *)out_ext;
13831             out_header = (void *)out_ext;
13832             break;
13833         }
13834         default:
13835             FIXME("Unhandled sType %u.", in_header->sType);
13836             break;
13837         }
13838     }
13839 }
13840
13841 static inline const VkPipelineColorBlendStateCreateInfo *convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, uint32_t count)
13842 {
13843     VkPipelineColorBlendStateCreateInfo *out;
13844     unsigned int i;
13845
13846     if (!in || !count) return NULL;
13847
13848     out = conversion_context_alloc(ctx, count * sizeof(*out));
13849     for (i = 0; i < count; i++)
13850     {
13851         convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
13852     }
13853
13854     return out;
13855 }
13856
13857 static inline void convert_VkPipelineDynamicStateCreateInfo_win32_to_host(const VkPipelineDynamicStateCreateInfo32 *in, VkPipelineDynamicStateCreateInfo *out)
13858 {
13859     if (!in) return;
13860
13861     out->sType = in->sType;
13862     out->pNext = NULL;
13863     out->flags = in->flags;
13864     out->dynamicStateCount = in->dynamicStateCount;
13865     out->pDynamicStates = (const VkDynamicState *)UlongToPtr(in->pDynamicStates);
13866     if (in->pNext)
13867         FIXME("Unexpected pNext\n");
13868 }
13869
13870 static inline const VkPipelineDynamicStateCreateInfo *convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDynamicStateCreateInfo32 *in, uint32_t count)
13871 {
13872     VkPipelineDynamicStateCreateInfo *out;
13873     unsigned int i;
13874
13875     if (!in || !count) return NULL;
13876
13877     out = conversion_context_alloc(ctx, count * sizeof(*out));
13878     for (i = 0; i < count; i++)
13879     {
13880         convert_VkPipelineDynamicStateCreateInfo_win32_to_host(&in[i], &out[i]);
13881     }
13882
13883     return out;
13884 }
13885
13886 #ifdef _WIN64
13887 static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, VkGraphicsPipelineCreateInfo *out)
13888 {
13889     const VkBaseInStructure *in_header;
13890     VkBaseOutStructure *out_header = (void *)out;
13891
13892     if (!in) return;
13893
13894     out->sType = in->sType;
13895     out->pNext = NULL;
13896     out->flags = in->flags;
13897     out->stageCount = in->stageCount;
13898     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
13899     out->pVertexInputState = in->pVertexInputState;
13900     out->pInputAssemblyState = in->pInputAssemblyState;
13901     out->pTessellationState = in->pTessellationState;
13902     out->pViewportState = in->pViewportState;
13903     out->pRasterizationState = in->pRasterizationState;
13904     out->pMultisampleState = in->pMultisampleState;
13905     out->pDepthStencilState = in->pDepthStencilState;
13906     out->pColorBlendState = in->pColorBlendState;
13907     out->pDynamicState = in->pDynamicState;
13908     out->layout = in->layout;
13909     out->renderPass = in->renderPass;
13910     out->subpass = in->subpass;
13911     out->basePipelineHandle = in->basePipelineHandle;
13912     out->basePipelineIndex = in->basePipelineIndex;
13913
13914     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
13915     {
13916         switch (in_header->sType)
13917         {
13918         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
13919         {
13920             VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13921             const VkGraphicsPipelineShaderGroupsCreateInfoNV *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV *)in_header;
13922             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
13923             out_ext->pNext = NULL;
13924             out_ext->groupCount = in_ext->groupCount;
13925             out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(ctx, in_ext->pGroups, in_ext->groupCount);
13926             out_ext->pipelineCount = in_ext->pipelineCount;
13927             out_ext->pPipelines = in_ext->pPipelines;
13928             out_header->pNext = (void *)out_ext;
13929             out_header = (void *)out_ext;
13930             break;
13931         }
13932         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
13933         {
13934             VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13935             const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header;
13936             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
13937             out_ext->pNext = NULL;
13938             out_ext->flags = in_ext->flags;
13939             out_ext->discardRectangleMode = in_ext->discardRectangleMode;
13940             out_ext->discardRectangleCount = in_ext->discardRectangleCount;
13941             out_ext->pDiscardRectangles = in_ext->pDiscardRectangles;
13942             out_header->pNext = (void *)out_ext;
13943             out_header = (void *)out_ext;
13944             break;
13945         }
13946         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
13947         {
13948             VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13949             const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header;
13950             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
13951             out_ext->pNext = NULL;
13952             out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
13953             out_header->pNext = (void *)out_ext;
13954             out_header = (void *)out_ext;
13955             break;
13956         }
13957         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
13958         {
13959             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13960             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
13961             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
13962             out_ext->pNext = NULL;
13963             out_ext->pPipelineCreationFeedback = in_ext->pPipelineCreationFeedback;
13964             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
13965             out_ext->pPipelineStageCreationFeedbacks = in_ext->pPipelineStageCreationFeedbacks;
13966             out_header->pNext = (void *)out_ext;
13967             out_header = (void *)out_ext;
13968             break;
13969         }
13970         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
13971         {
13972             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13973             const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header;
13974             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
13975             out_ext->pNext = NULL;
13976             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
13977             out_header->pNext = (void *)out_ext;
13978             out_header = (void *)out_ext;
13979             break;
13980         }
13981         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
13982         {
13983             VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13984             const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header;
13985             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
13986             out_ext->pNext = NULL;
13987             out_ext->libraryCount = in_ext->libraryCount;
13988             out_ext->pLibraries = in_ext->pLibraries;
13989             out_header->pNext = (void *)out_ext;
13990             out_header = (void *)out_ext;
13991             break;
13992         }
13993         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
13994         {
13995             VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
13996             const VkPipelineFragmentShadingRateStateCreateInfoKHR *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR *)in_header;
13997             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
13998             out_ext->pNext = NULL;
13999             out_ext->fragmentSize = in_ext->fragmentSize;
14000             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
14001             out_header->pNext = (void *)out_ext;
14002             out_header = (void *)out_ext;
14003             break;
14004         }
14005         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
14006         {
14007             VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14008             const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header;
14009             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
14010             out_ext->pNext = NULL;
14011             out_ext->shadingRateType = in_ext->shadingRateType;
14012             out_ext->shadingRate = in_ext->shadingRate;
14013             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
14014             out_header->pNext = (void *)out_ext;
14015             out_header = (void *)out_ext;
14016             break;
14017         }
14018         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
14019         {
14020             VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14021             const VkPipelineRenderingCreateInfo *in_ext = (const VkPipelineRenderingCreateInfo *)in_header;
14022             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
14023             out_ext->pNext = NULL;
14024             out_ext->viewMask = in_ext->viewMask;
14025             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
14026             out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats;
14027             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
14028             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
14029             out_header->pNext = (void *)out_ext;
14030             out_header = (void *)out_ext;
14031             break;
14032         }
14033         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
14034         {
14035             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14036             const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header;
14037             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
14038             out_ext->pNext = NULL;
14039             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
14040             out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
14041             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
14042             out_header->pNext = (void *)out_ext;
14043             out_header = (void *)out_ext;
14044             break;
14045         }
14046         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
14047         {
14048             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14049             const VkMultiviewPerViewAttributesInfoNVX *in_ext = (const VkMultiviewPerViewAttributesInfoNVX *)in_header;
14050             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
14051             out_ext->pNext = NULL;
14052             out_ext->perViewAttributes = in_ext->perViewAttributes;
14053             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
14054             out_header->pNext = (void *)out_ext;
14055             out_header = (void *)out_ext;
14056             break;
14057         }
14058         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
14059         {
14060             VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14061             const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header;
14062             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
14063             out_ext->pNext = NULL;
14064             out_ext->flags = in_ext->flags;
14065             out_header->pNext = (void *)out_ext;
14066             out_header = (void *)out_ext;
14067             break;
14068         }
14069         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
14070         {
14071             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14072             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
14073             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
14074             out_ext->pNext = NULL;
14075             out_ext->storageBuffers = in_ext->storageBuffers;
14076             out_ext->uniformBuffers = in_ext->uniformBuffers;
14077             out_ext->vertexInputs = in_ext->vertexInputs;
14078             out_ext->images = in_ext->images;
14079             out_header->pNext = (void *)out_ext;
14080             out_header = (void *)out_ext;
14081             break;
14082         }
14083         default:
14084             FIXME("Unhandled sType %u.", in_header->sType);
14085             break;
14086         }
14087     }
14088 }
14089 #endif /* _WIN64 */
14090
14091 static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, VkGraphicsPipelineCreateInfo *out)
14092 {
14093     const VkBaseInStructure32 *in_header;
14094     VkBaseOutStructure *out_header = (void *)out;
14095
14096     if (!in) return;
14097
14098     out->sType = in->sType;
14099     out->pNext = NULL;
14100     out->flags = in->flags;
14101     out->stageCount = in->stageCount;
14102     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
14103     out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineVertexInputStateCreateInfo32 *)UlongToPtr(in->pVertexInputState), 1);
14104     out->pInputAssemblyState = convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineInputAssemblyStateCreateInfo32 *)UlongToPtr(in->pInputAssemblyState), 1);
14105     out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineTessellationStateCreateInfo32 *)UlongToPtr(in->pTessellationState), 1);
14106     out->pViewportState = convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineViewportStateCreateInfo32 *)UlongToPtr(in->pViewportState), 1);
14107     out->pRasterizationState = convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineRasterizationStateCreateInfo32 *)UlongToPtr(in->pRasterizationState), 1);
14108     out->pMultisampleState = convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineMultisampleStateCreateInfo32 *)UlongToPtr(in->pMultisampleState), 1);
14109     out->pDepthStencilState = convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDepthStencilStateCreateInfo32 *)UlongToPtr(in->pDepthStencilState), 1);
14110     out->pColorBlendState = convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineColorBlendStateCreateInfo32 *)UlongToPtr(in->pColorBlendState), 1);
14111     out->pDynamicState = convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDynamicStateCreateInfo32 *)UlongToPtr(in->pDynamicState), 1);
14112     out->layout = in->layout;
14113     out->renderPass = in->renderPass;
14114     out->subpass = in->subpass;
14115     out->basePipelineHandle = in->basePipelineHandle;
14116     out->basePipelineIndex = in->basePipelineIndex;
14117
14118     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14119     {
14120         switch (in_header->sType)
14121         {
14122         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
14123         {
14124             VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14125             const VkGraphicsPipelineShaderGroupsCreateInfoNV32 *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV32 *)in_header;
14126             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
14127             out_ext->pNext = NULL;
14128             out_ext->groupCount = in_ext->groupCount;
14129             out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(ctx, (const VkGraphicsShaderGroupCreateInfoNV32 *)UlongToPtr(in_ext->pGroups), in_ext->groupCount);
14130             out_ext->pipelineCount = in_ext->pipelineCount;
14131             out_ext->pPipelines = (const VkPipeline *)UlongToPtr(in_ext->pPipelines);
14132             out_header->pNext = (void *)out_ext;
14133             out_header = (void *)out_ext;
14134             break;
14135         }
14136         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
14137         {
14138             VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14139             const VkPipelineDiscardRectangleStateCreateInfoEXT32 *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT32 *)in_header;
14140             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
14141             out_ext->pNext = NULL;
14142             out_ext->flags = in_ext->flags;
14143             out_ext->discardRectangleMode = in_ext->discardRectangleMode;
14144             out_ext->discardRectangleCount = in_ext->discardRectangleCount;
14145             out_ext->pDiscardRectangles = (const VkRect2D *)UlongToPtr(in_ext->pDiscardRectangles);
14146             out_header->pNext = (void *)out_ext;
14147             out_header = (void *)out_ext;
14148             break;
14149         }
14150         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
14151         {
14152             VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14153             const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *)in_header;
14154             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
14155             out_ext->pNext = NULL;
14156             out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
14157             out_header->pNext = (void *)out_ext;
14158             out_header = (void *)out_ext;
14159             break;
14160         }
14161         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
14162         {
14163             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14164             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
14165             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
14166             out_ext->pNext = NULL;
14167             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
14168             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
14169             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
14170             out_header->pNext = (void *)out_ext;
14171             out_header = (void *)out_ext;
14172             break;
14173         }
14174         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
14175         {
14176             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14177             const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header;
14178             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
14179             out_ext->pNext = NULL;
14180             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
14181             out_header->pNext = (void *)out_ext;
14182             out_header = (void *)out_ext;
14183             break;
14184         }
14185         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
14186         {
14187             VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14188             const VkPipelineLibraryCreateInfoKHR32 *in_ext = (const VkPipelineLibraryCreateInfoKHR32 *)in_header;
14189             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
14190             out_ext->pNext = NULL;
14191             out_ext->libraryCount = in_ext->libraryCount;
14192             out_ext->pLibraries = (const VkPipeline *)UlongToPtr(in_ext->pLibraries);
14193             out_header->pNext = (void *)out_ext;
14194             out_header = (void *)out_ext;
14195             break;
14196         }
14197         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
14198         {
14199             VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14200             const VkPipelineFragmentShadingRateStateCreateInfoKHR32 *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR32 *)in_header;
14201             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
14202             out_ext->pNext = NULL;
14203             out_ext->fragmentSize = in_ext->fragmentSize;
14204             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
14205             out_header->pNext = (void *)out_ext;
14206             out_header = (void *)out_ext;
14207             break;
14208         }
14209         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
14210         {
14211             VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14212             const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *)in_header;
14213             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
14214             out_ext->pNext = NULL;
14215             out_ext->shadingRateType = in_ext->shadingRateType;
14216             out_ext->shadingRate = in_ext->shadingRate;
14217             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
14218             out_header->pNext = (void *)out_ext;
14219             out_header = (void *)out_ext;
14220             break;
14221         }
14222         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
14223         {
14224             VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14225             const VkPipelineRenderingCreateInfo32 *in_ext = (const VkPipelineRenderingCreateInfo32 *)in_header;
14226             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
14227             out_ext->pNext = NULL;
14228             out_ext->viewMask = in_ext->viewMask;
14229             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
14230             out_ext->pColorAttachmentFormats = (const VkFormat *)UlongToPtr(in_ext->pColorAttachmentFormats);
14231             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
14232             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
14233             out_header->pNext = (void *)out_ext;
14234             out_header = (void *)out_ext;
14235             break;
14236         }
14237         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
14238         {
14239             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14240             const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header;
14241             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
14242             out_ext->pNext = NULL;
14243             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
14244             out_ext->pColorAttachmentSamples = (const VkSampleCountFlagBits *)UlongToPtr(in_ext->pColorAttachmentSamples);
14245             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
14246             out_header->pNext = (void *)out_ext;
14247             out_header = (void *)out_ext;
14248             break;
14249         }
14250         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
14251         {
14252             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14253             const VkMultiviewPerViewAttributesInfoNVX32 *in_ext = (const VkMultiviewPerViewAttributesInfoNVX32 *)in_header;
14254             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
14255             out_ext->pNext = NULL;
14256             out_ext->perViewAttributes = in_ext->perViewAttributes;
14257             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
14258             out_header->pNext = (void *)out_ext;
14259             out_header = (void *)out_ext;
14260             break;
14261         }
14262         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
14263         {
14264             VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14265             const VkGraphicsPipelineLibraryCreateInfoEXT32 *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT32 *)in_header;
14266             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
14267             out_ext->pNext = NULL;
14268             out_ext->flags = in_ext->flags;
14269             out_header->pNext = (void *)out_ext;
14270             out_header = (void *)out_ext;
14271             break;
14272         }
14273         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
14274         {
14275             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14276             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
14277             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
14278             out_ext->pNext = NULL;
14279             out_ext->storageBuffers = in_ext->storageBuffers;
14280             out_ext->uniformBuffers = in_ext->uniformBuffers;
14281             out_ext->vertexInputs = in_ext->vertexInputs;
14282             out_ext->images = in_ext->images;
14283             out_header->pNext = (void *)out_ext;
14284             out_header = (void *)out_ext;
14285             break;
14286         }
14287         default:
14288             FIXME("Unhandled sType %u.", in_header->sType);
14289             break;
14290         }
14291     }
14292 }
14293
14294 static inline void convert_VkGraphicsPipelineCreateInfo_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out)
14295 {
14296     const VkBaseInStructure *in_header;
14297     VkBaseOutStructure32 *out_header = (void *)out;
14298
14299     if (!in) return;
14300
14301
14302     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
14303     {
14304         switch (in_header->sType)
14305         {
14306         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
14307         {
14308             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
14309             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
14310             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
14311             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
14312             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
14313             out_header = (void *)out_ext;
14314             break;
14315         }
14316         default:
14317             break;
14318         }
14319     }
14320 }
14321
14322 #ifdef _WIN64
14323 static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, uint32_t count)
14324 {
14325     VkGraphicsPipelineCreateInfo *out;
14326     unsigned int i;
14327
14328     if (!in || !count) return NULL;
14329
14330     out = conversion_context_alloc(ctx, count * sizeof(*out));
14331     for (i = 0; i < count; i++)
14332     {
14333         convert_VkGraphicsPipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
14334     }
14335
14336     return out;
14337 }
14338 #endif /* _WIN64 */
14339
14340 static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, uint32_t count)
14341 {
14342     VkGraphicsPipelineCreateInfo *out;
14343     unsigned int i;
14344
14345     if (!in || !count) return NULL;
14346
14347     out = conversion_context_alloc(ctx, count * sizeof(*out));
14348     for (i = 0; i < count; i++)
14349     {
14350         convert_VkGraphicsPipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
14351     }
14352
14353     return out;
14354 }
14355
14356 static inline void convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out, uint32_t count)
14357 {
14358     unsigned int i;
14359
14360     if (!in) return;
14361
14362     for (i = 0; i < count; i++)
14363     {
14364         convert_VkGraphicsPipelineCreateInfo_host_to_win32(&in[i], &out[i]);
14365     }
14366 }
14367
14368 static inline void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, VkImageCreateInfo *out)
14369 {
14370     const VkBaseInStructure32 *in_header;
14371     VkBaseOutStructure *out_header = (void *)out;
14372
14373     if (!in) return;
14374
14375     out->sType = in->sType;
14376     out->pNext = NULL;
14377     out->flags = in->flags;
14378     out->imageType = in->imageType;
14379     out->format = in->format;
14380     out->extent = in->extent;
14381     out->mipLevels = in->mipLevels;
14382     out->arrayLayers = in->arrayLayers;
14383     out->samples = in->samples;
14384     out->tiling = in->tiling;
14385     out->usage = in->usage;
14386     out->sharingMode = in->sharingMode;
14387     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
14388     out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);
14389     out->initialLayout = in->initialLayout;
14390
14391     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14392     {
14393         switch (in_header->sType)
14394         {
14395         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
14396         {
14397             VkDedicatedAllocationImageCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14398             const VkDedicatedAllocationImageCreateInfoNV32 *in_ext = (const VkDedicatedAllocationImageCreateInfoNV32 *)in_header;
14399             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV;
14400             out_ext->pNext = NULL;
14401             out_ext->dedicatedAllocation = in_ext->dedicatedAllocation;
14402             out_header->pNext = (void *)out_ext;
14403             out_header = (void *)out_ext;
14404             break;
14405         }
14406         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
14407         {
14408             VkExternalMemoryImageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14409             const VkExternalMemoryImageCreateInfo32 *in_ext = (const VkExternalMemoryImageCreateInfo32 *)in_header;
14410             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
14411             out_ext->pNext = NULL;
14412             out_ext->handleTypes = in_ext->handleTypes;
14413             out_header->pNext = (void *)out_ext;
14414             out_header = (void *)out_ext;
14415             break;
14416         }
14417         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
14418         {
14419             VkImageSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14420             const VkImageSwapchainCreateInfoKHR32 *in_ext = (const VkImageSwapchainCreateInfoKHR32 *)in_header;
14421             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR;
14422             out_ext->pNext = NULL;
14423             out_ext->swapchain = in_ext->swapchain;
14424             out_header->pNext = (void *)out_ext;
14425             out_header = (void *)out_ext;
14426             break;
14427         }
14428         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
14429         {
14430             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14431             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
14432             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
14433             out_ext->pNext = NULL;
14434             out_ext->viewFormatCount = in_ext->viewFormatCount;
14435             out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
14436             out_header->pNext = (void *)out_ext;
14437             out_header = (void *)out_ext;
14438             break;
14439         }
14440         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
14441         {
14442             VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14443             const VkImageStencilUsageCreateInfo32 *in_ext = (const VkImageStencilUsageCreateInfo32 *)in_header;
14444             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
14445             out_ext->pNext = NULL;
14446             out_ext->stencilUsage = in_ext->stencilUsage;
14447             out_header->pNext = (void *)out_ext;
14448             out_header = (void *)out_ext;
14449             break;
14450         }
14451         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
14452         {
14453             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14454             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
14455             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
14456             out_ext->pNext = NULL;
14457             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
14458             out_header->pNext = (void *)out_ext;
14459             out_header = (void *)out_ext;
14460             break;
14461         }
14462         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
14463         {
14464             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14465             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
14466             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
14467             out_ext->pNext = NULL;
14468             out_ext->flags = in_ext->flags;
14469             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
14470             out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
14471             out_header->pNext = (void *)out_ext;
14472             out_header = (void *)out_ext;
14473             break;
14474         }
14475         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
14476         {
14477             VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14478             const VkOpticalFlowImageFormatInfoNV32 *in_ext = (const VkOpticalFlowImageFormatInfoNV32 *)in_header;
14479             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
14480             out_ext->pNext = NULL;
14481             out_ext->usage = in_ext->usage;
14482             out_header->pNext = (void *)out_ext;
14483             out_header = (void *)out_ext;
14484             break;
14485         }
14486         default:
14487             FIXME("Unhandled sType %u.", in_header->sType);
14488             break;
14489         }
14490     }
14491 }
14492
14493 static inline void convert_VkImageViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageViewCreateInfo32 *in, VkImageViewCreateInfo *out)
14494 {
14495     const VkBaseInStructure32 *in_header;
14496     VkBaseOutStructure *out_header = (void *)out;
14497
14498     if (!in) return;
14499
14500     out->sType = in->sType;
14501     out->pNext = NULL;
14502     out->flags = in->flags;
14503     out->image = in->image;
14504     out->viewType = in->viewType;
14505     out->format = in->format;
14506     out->components = in->components;
14507     out->subresourceRange = in->subresourceRange;
14508
14509     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14510     {
14511         switch (in_header->sType)
14512         {
14513         case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
14514         {
14515             VkImageViewUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14516             const VkImageViewUsageCreateInfo32 *in_ext = (const VkImageViewUsageCreateInfo32 *)in_header;
14517             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
14518             out_ext->pNext = NULL;
14519             out_ext->usage = in_ext->usage;
14520             out_header->pNext = (void *)out_ext;
14521             out_header = (void *)out_ext;
14522             break;
14523         }
14524         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
14525         {
14526             VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14527             const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
14528             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
14529             out_ext->pNext = NULL;
14530             out_ext->conversion = in_ext->conversion;
14531             out_header->pNext = (void *)out_ext;
14532             out_header = (void *)out_ext;
14533             break;
14534         }
14535         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
14536         {
14537             VkImageViewASTCDecodeModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14538             const VkImageViewASTCDecodeModeEXT32 *in_ext = (const VkImageViewASTCDecodeModeEXT32 *)in_header;
14539             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT;
14540             out_ext->pNext = NULL;
14541             out_ext->decodeMode = in_ext->decodeMode;
14542             out_header->pNext = (void *)out_ext;
14543             out_header = (void *)out_ext;
14544             break;
14545         }
14546         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
14547         {
14548             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14549             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
14550             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
14551             out_ext->pNext = NULL;
14552             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
14553             out_header->pNext = (void *)out_ext;
14554             out_header = (void *)out_ext;
14555             break;
14556         }
14557         case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
14558         {
14559             VkImageViewMinLodCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14560             const VkImageViewMinLodCreateInfoEXT32 *in_ext = (const VkImageViewMinLodCreateInfoEXT32 *)in_header;
14561             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT;
14562             out_ext->pNext = NULL;
14563             out_ext->minLod = in_ext->minLod;
14564             out_header->pNext = (void *)out_ext;
14565             out_header = (void *)out_ext;
14566             break;
14567         }
14568         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
14569         {
14570             VkImageViewSampleWeightCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14571             const VkImageViewSampleWeightCreateInfoQCOM32 *in_ext = (const VkImageViewSampleWeightCreateInfoQCOM32 *)in_header;
14572             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM;
14573             out_ext->pNext = NULL;
14574             out_ext->filterCenter = in_ext->filterCenter;
14575             out_ext->filterSize = in_ext->filterSize;
14576             out_ext->numPhases = in_ext->numPhases;
14577             out_header->pNext = (void *)out_ext;
14578             out_header = (void *)out_ext;
14579             break;
14580         }
14581         default:
14582             FIXME("Unhandled sType %u.", in_header->sType);
14583             break;
14584         }
14585     }
14586 }
14587
14588 static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const VkIndirectCommandsLayoutTokenNV32 *in, VkIndirectCommandsLayoutTokenNV *out)
14589 {
14590     if (!in) return;
14591
14592     out->sType = in->sType;
14593     out->pNext = NULL;
14594     out->tokenType = in->tokenType;
14595     out->stream = in->stream;
14596     out->offset = in->offset;
14597     out->vertexBindingUnit = in->vertexBindingUnit;
14598     out->vertexDynamicStride = in->vertexDynamicStride;
14599     out->pushconstantPipelineLayout = in->pushconstantPipelineLayout;
14600     out->pushconstantShaderStageFlags = in->pushconstantShaderStageFlags;
14601     out->pushconstantOffset = in->pushconstantOffset;
14602     out->pushconstantSize = in->pushconstantSize;
14603     out->indirectStateFlags = in->indirectStateFlags;
14604     out->indexTypeCount = in->indexTypeCount;
14605     out->pIndexTypes = (const VkIndexType *)UlongToPtr(in->pIndexTypes);
14606     out->pIndexTypeValues = (const uint32_t *)UlongToPtr(in->pIndexTypeValues);
14607     if (in->pNext)
14608         FIXME("Unexpected pNext\n");
14609 }
14610
14611 static inline const VkIndirectCommandsLayoutTokenNV *convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenNV32 *in, uint32_t count)
14612 {
14613     VkIndirectCommandsLayoutTokenNV *out;
14614     unsigned int i;
14615
14616     if (!in || !count) return NULL;
14617
14618     out = conversion_context_alloc(ctx, count * sizeof(*out));
14619     for (i = 0; i < count; i++)
14620     {
14621         convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(&in[i], &out[i]);
14622     }
14623
14624     return out;
14625 }
14626
14627 static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoNV32 *in, VkIndirectCommandsLayoutCreateInfoNV *out)
14628 {
14629     if (!in) return;
14630
14631     out->sType = in->sType;
14632     out->pNext = NULL;
14633     out->flags = in->flags;
14634     out->pipelineBindPoint = in->pipelineBindPoint;
14635     out->tokenCount = in->tokenCount;
14636     out->pTokens = convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(ctx, (const VkIndirectCommandsLayoutTokenNV32 *)UlongToPtr(in->pTokens), in->tokenCount);
14637     out->streamCount = in->streamCount;
14638     out->pStreamStrides = (const uint32_t *)UlongToPtr(in->pStreamStrides);
14639     if (in->pNext)
14640         FIXME("Unexpected pNext\n");
14641 }
14642
14643 static inline void convert_VkApplicationInfo_win32_to_host(const VkApplicationInfo32 *in, VkApplicationInfo *out)
14644 {
14645     if (!in) return;
14646
14647     out->sType = in->sType;
14648     out->pNext = NULL;
14649     out->pApplicationName = (const char *)UlongToPtr(in->pApplicationName);
14650     out->applicationVersion = in->applicationVersion;
14651     out->pEngineName = (const char *)UlongToPtr(in->pEngineName);
14652     out->engineVersion = in->engineVersion;
14653     out->apiVersion = in->apiVersion;
14654     if (in->pNext)
14655         FIXME("Unexpected pNext\n");
14656 }
14657
14658 static inline const VkApplicationInfo *convert_VkApplicationInfo_array_win32_to_host(struct conversion_context *ctx, const VkApplicationInfo32 *in, uint32_t count)
14659 {
14660     VkApplicationInfo *out;
14661     unsigned int i;
14662
14663     if (!in || !count) return NULL;
14664
14665     out = conversion_context_alloc(ctx, count * sizeof(*out));
14666     for (i = 0; i < count; i++)
14667     {
14668         convert_VkApplicationInfo_win32_to_host(&in[i], &out[i]);
14669     }
14670
14671     return out;
14672 }
14673
14674 #ifdef _WIN64
14675 static inline void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo *in, VkInstanceCreateInfo *out)
14676 {
14677     const VkBaseInStructure *in_header;
14678     VkBaseOutStructure *out_header = (void *)out;
14679
14680     if (!in) return;
14681
14682     out->sType = in->sType;
14683     out->pNext = NULL;
14684     out->flags = in->flags;
14685     out->pApplicationInfo = in->pApplicationInfo;
14686     out->enabledLayerCount = in->enabledLayerCount;
14687     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
14688     out->enabledExtensionCount = in->enabledExtensionCount;
14689     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
14690
14691     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
14692     {
14693         switch (in_header->sType)
14694         {
14695         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
14696             break;
14697         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
14698         {
14699             VkDebugReportCallbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14700             const VkDebugReportCallbackCreateInfoEXT *in_ext = (const VkDebugReportCallbackCreateInfoEXT *)in_header;
14701             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
14702             out_ext->pNext = NULL;
14703             out_ext->flags = in_ext->flags;
14704             out_ext->pfnCallback = in_ext->pfnCallback;
14705             out_ext->pUserData = in_ext->pUserData;
14706             out_header->pNext = (void *)out_ext;
14707             out_header = (void *)out_ext;
14708             break;
14709         }
14710         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
14711         {
14712             VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14713             const VkValidationFlagsEXT *in_ext = (const VkValidationFlagsEXT *)in_header;
14714             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
14715             out_ext->pNext = NULL;
14716             out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
14717             out_ext->pDisabledValidationChecks = in_ext->pDisabledValidationChecks;
14718             out_header->pNext = (void *)out_ext;
14719             out_header = (void *)out_ext;
14720             break;
14721         }
14722         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
14723         {
14724             VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14725             const VkValidationFeaturesEXT *in_ext = (const VkValidationFeaturesEXT *)in_header;
14726             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
14727             out_ext->pNext = NULL;
14728             out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount;
14729             out_ext->pEnabledValidationFeatures = in_ext->pEnabledValidationFeatures;
14730             out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount;
14731             out_ext->pDisabledValidationFeatures = in_ext->pDisabledValidationFeatures;
14732             out_header->pNext = (void *)out_ext;
14733             out_header = (void *)out_ext;
14734             break;
14735         }
14736         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
14737         {
14738             VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14739             const VkDebugUtilsMessengerCreateInfoEXT *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT *)in_header;
14740             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
14741             out_ext->pNext = NULL;
14742             out_ext->flags = in_ext->flags;
14743             out_ext->messageSeverity = in_ext->messageSeverity;
14744             out_ext->messageType = in_ext->messageType;
14745             out_ext->pfnUserCallback = in_ext->pfnUserCallback;
14746             out_ext->pUserData = in_ext->pUserData;
14747             out_header->pNext = (void *)out_ext;
14748             out_header = (void *)out_ext;
14749             break;
14750         }
14751         default:
14752             FIXME("Unhandled sType %u.", in_header->sType);
14753             break;
14754         }
14755     }
14756 }
14757 #endif /* _WIN64 */
14758
14759 static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo32 *in, VkInstanceCreateInfo *out)
14760 {
14761     const VkBaseInStructure32 *in_header;
14762     VkBaseOutStructure *out_header = (void *)out;
14763
14764     if (!in) return;
14765
14766     out->sType = in->sType;
14767     out->pNext = NULL;
14768     out->flags = in->flags;
14769     out->pApplicationInfo = convert_VkApplicationInfo_array_win32_to_host(ctx, (const VkApplicationInfo32 *)UlongToPtr(in->pApplicationInfo), 1);
14770     out->enabledLayerCount = in->enabledLayerCount;
14771     out->ppEnabledLayerNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledLayerNames), in->enabledLayerCount);
14772     out->enabledExtensionCount = in->enabledExtensionCount;
14773     out->ppEnabledExtensionNames = convert_char_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppEnabledExtensionNames), in->enabledExtensionCount);
14774
14775     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14776     {
14777         switch (in_header->sType)
14778         {
14779         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
14780             break;
14781         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
14782         {
14783             VkDebugReportCallbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14784             const VkDebugReportCallbackCreateInfoEXT32 *in_ext = (const VkDebugReportCallbackCreateInfoEXT32 *)in_header;
14785             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
14786             out_ext->pNext = NULL;
14787             out_ext->flags = in_ext->flags;
14788             out_ext->pfnCallback = in_ext->pfnCallback;
14789             out_ext->pUserData = (void *)UlongToPtr(in_ext->pUserData);
14790             out_header->pNext = (void *)out_ext;
14791             out_header = (void *)out_ext;
14792             break;
14793         }
14794         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
14795         {
14796             VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14797             const VkValidationFlagsEXT32 *in_ext = (const VkValidationFlagsEXT32 *)in_header;
14798             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
14799             out_ext->pNext = NULL;
14800             out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
14801             out_ext->pDisabledValidationChecks = (const VkValidationCheckEXT *)UlongToPtr(in_ext->pDisabledValidationChecks);
14802             out_header->pNext = (void *)out_ext;
14803             out_header = (void *)out_ext;
14804             break;
14805         }
14806         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
14807         {
14808             VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14809             const VkValidationFeaturesEXT32 *in_ext = (const VkValidationFeaturesEXT32 *)in_header;
14810             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
14811             out_ext->pNext = NULL;
14812             out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount;
14813             out_ext->pEnabledValidationFeatures = (const VkValidationFeatureEnableEXT *)UlongToPtr(in_ext->pEnabledValidationFeatures);
14814             out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount;
14815             out_ext->pDisabledValidationFeatures = (const VkValidationFeatureDisableEXT *)UlongToPtr(in_ext->pDisabledValidationFeatures);
14816             out_header->pNext = (void *)out_ext;
14817             out_header = (void *)out_ext;
14818             break;
14819         }
14820         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
14821         {
14822             VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14823             const VkDebugUtilsMessengerCreateInfoEXT32 *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT32 *)in_header;
14824             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
14825             out_ext->pNext = NULL;
14826             out_ext->flags = in_ext->flags;
14827             out_ext->messageSeverity = in_ext->messageSeverity;
14828             out_ext->messageType = in_ext->messageType;
14829             out_ext->pfnUserCallback = in_ext->pfnUserCallback;
14830             out_ext->pUserData = (void *)UlongToPtr(in_ext->pUserData);
14831             out_header->pNext = (void *)out_ext;
14832             out_header = (void *)out_ext;
14833             break;
14834         }
14835         default:
14836             FIXME("Unhandled sType %u.", in_header->sType);
14837             break;
14838         }
14839     }
14840 }
14841
14842 static inline void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicromapCreateInfoEXT32 *in, VkMicromapCreateInfoEXT *out)
14843 {
14844     if (!in) return;
14845
14846     out->sType = in->sType;
14847     out->pNext = NULL;
14848     out->createFlags = in->createFlags;
14849     out->buffer = in->buffer;
14850     out->offset = in->offset;
14851     out->size = in->size;
14852     out->type = in->type;
14853     out->deviceAddress = in->deviceAddress;
14854     if (in->pNext)
14855         FIXME("Unexpected pNext\n");
14856 }
14857
14858 static inline void convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowSessionCreateInfoNV32 *in, VkOpticalFlowSessionCreateInfoNV *out)
14859 {
14860     const VkBaseInStructure32 *in_header;
14861     VkBaseOutStructure *out_header = (void *)out;
14862
14863     if (!in) return;
14864
14865     out->sType = in->sType;
14866     out->pNext = NULL;
14867     out->width = in->width;
14868     out->height = in->height;
14869     out->imageFormat = in->imageFormat;
14870     out->flowVectorFormat = in->flowVectorFormat;
14871     out->costFormat = in->costFormat;
14872     out->outputGridSize = in->outputGridSize;
14873     out->hintGridSize = in->hintGridSize;
14874     out->performanceLevel = in->performanceLevel;
14875     out->flags = in->flags;
14876
14877     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14878     {
14879         switch (in_header->sType)
14880         {
14881         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
14882         {
14883             VkOpticalFlowSessionCreatePrivateDataInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14884             const VkOpticalFlowSessionCreatePrivateDataInfoNV32 *in_ext = (const VkOpticalFlowSessionCreatePrivateDataInfoNV32 *)in_header;
14885             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV;
14886             out_ext->pNext = NULL;
14887             out_ext->id = in_ext->id;
14888             out_ext->size = in_ext->size;
14889             out_ext->pPrivateData = (const void *)UlongToPtr(in_ext->pPrivateData);
14890             out_header->pNext = (void *)out_ext;
14891             out_header = (void *)out_ext;
14892             break;
14893         }
14894         default:
14895             FIXME("Unhandled sType %u.", in_header->sType);
14896             break;
14897         }
14898     }
14899 }
14900
14901 static inline void convert_VkPipelineCacheCreateInfo_win32_to_host(const VkPipelineCacheCreateInfo32 *in, VkPipelineCacheCreateInfo *out)
14902 {
14903     if (!in) return;
14904
14905     out->sType = in->sType;
14906     out->pNext = NULL;
14907     out->flags = in->flags;
14908     out->initialDataSize = in->initialDataSize;
14909     out->pInitialData = (const void *)UlongToPtr(in->pInitialData);
14910     if (in->pNext)
14911         FIXME("Unexpected pNext\n");
14912 }
14913
14914 static inline void convert_VkPipelineLayoutCreateInfo_win32_to_host(const VkPipelineLayoutCreateInfo32 *in, VkPipelineLayoutCreateInfo *out)
14915 {
14916     if (!in) return;
14917
14918     out->sType = in->sType;
14919     out->pNext = NULL;
14920     out->flags = in->flags;
14921     out->setLayoutCount = in->setLayoutCount;
14922     out->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in->pSetLayouts);
14923     out->pushConstantRangeCount = in->pushConstantRangeCount;
14924     out->pPushConstantRanges = (const VkPushConstantRange *)UlongToPtr(in->pPushConstantRanges);
14925     if (in->pNext)
14926         FIXME("Unexpected pNext\n");
14927 }
14928
14929 static inline void convert_VkPrivateDataSlotCreateInfo_win32_to_host(const VkPrivateDataSlotCreateInfo32 *in, VkPrivateDataSlotCreateInfo *out)
14930 {
14931     if (!in) return;
14932
14933     out->sType = in->sType;
14934     out->pNext = NULL;
14935     out->flags = in->flags;
14936     if (in->pNext)
14937         FIXME("Unexpected pNext\n");
14938 }
14939
14940 static inline void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkQueryPoolCreateInfo32 *in, VkQueryPoolCreateInfo *out)
14941 {
14942     const VkBaseInStructure32 *in_header;
14943     VkBaseOutStructure *out_header = (void *)out;
14944
14945     if (!in) return;
14946
14947     out->sType = in->sType;
14948     out->pNext = NULL;
14949     out->flags = in->flags;
14950     out->queryType = in->queryType;
14951     out->queryCount = in->queryCount;
14952     out->pipelineStatistics = in->pipelineStatistics;
14953
14954     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
14955     {
14956         switch (in_header->sType)
14957         {
14958         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
14959         {
14960             VkQueryPoolPerformanceCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14961             const VkQueryPoolPerformanceCreateInfoKHR32 *in_ext = (const VkQueryPoolPerformanceCreateInfoKHR32 *)in_header;
14962             out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR;
14963             out_ext->pNext = NULL;
14964             out_ext->queueFamilyIndex = in_ext->queueFamilyIndex;
14965             out_ext->counterIndexCount = in_ext->counterIndexCount;
14966             out_ext->pCounterIndices = (const uint32_t *)UlongToPtr(in_ext->pCounterIndices);
14967             out_header->pNext = (void *)out_ext;
14968             out_header = (void *)out_ext;
14969             break;
14970         }
14971         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
14972         {
14973             VkQueryPoolPerformanceQueryCreateInfoINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
14974             const VkQueryPoolPerformanceQueryCreateInfoINTEL32 *in_ext = (const VkQueryPoolPerformanceQueryCreateInfoINTEL32 *)in_header;
14975             out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL;
14976             out_ext->pNext = NULL;
14977             out_ext->performanceCountersSampling = in_ext->performanceCountersSampling;
14978             out_header->pNext = (void *)out_ext;
14979             out_header = (void *)out_ext;
14980             break;
14981         }
14982         default:
14983             FIXME("Unhandled sType %u.", in_header->sType);
14984             break;
14985         }
14986     }
14987 }
14988
14989 static inline void convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(const VkRayTracingShaderGroupCreateInfoKHR32 *in, VkRayTracingShaderGroupCreateInfoKHR *out)
14990 {
14991     if (!in) return;
14992
14993     out->sType = in->sType;
14994     out->pNext = NULL;
14995     out->type = in->type;
14996     out->generalShader = in->generalShader;
14997     out->closestHitShader = in->closestHitShader;
14998     out->anyHitShader = in->anyHitShader;
14999     out->intersectionShader = in->intersectionShader;
15000     out->pShaderGroupCaptureReplayHandle = (const void *)UlongToPtr(in->pShaderGroupCaptureReplayHandle);
15001     if (in->pNext)
15002         FIXME("Unexpected pNext\n");
15003 }
15004
15005 static inline const VkRayTracingShaderGroupCreateInfoKHR *convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoKHR32 *in, uint32_t count)
15006 {
15007     VkRayTracingShaderGroupCreateInfoKHR *out;
15008     unsigned int i;
15009
15010     if (!in || !count) return NULL;
15011
15012     out = conversion_context_alloc(ctx, count * sizeof(*out));
15013     for (i = 0; i < count; i++)
15014     {
15015         convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(&in[i], &out[i]);
15016     }
15017
15018     return out;
15019 }
15020
15021 static inline void convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(const VkPipelineLibraryCreateInfoKHR32 *in, VkPipelineLibraryCreateInfoKHR *out)
15022 {
15023     if (!in) return;
15024
15025     out->sType = in->sType;
15026     out->pNext = NULL;
15027     out->libraryCount = in->libraryCount;
15028     out->pLibraries = (const VkPipeline *)UlongToPtr(in->pLibraries);
15029     if (in->pNext)
15030         FIXME("Unexpected pNext\n");
15031 }
15032
15033 static inline const VkPipelineLibraryCreateInfoKHR *convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineLibraryCreateInfoKHR32 *in, uint32_t count)
15034 {
15035     VkPipelineLibraryCreateInfoKHR *out;
15036     unsigned int i;
15037
15038     if (!in || !count) return NULL;
15039
15040     out = conversion_context_alloc(ctx, count * sizeof(*out));
15041     for (i = 0; i < count; i++)
15042     {
15043         convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(&in[i], &out[i]);
15044     }
15045
15046     return out;
15047 }
15048
15049 static inline void convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_host(const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, VkRayTracingPipelineInterfaceCreateInfoKHR *out)
15050 {
15051     if (!in) return;
15052
15053     out->sType = in->sType;
15054     out->pNext = NULL;
15055     out->maxPipelineRayPayloadSize = in->maxPipelineRayPayloadSize;
15056     out->maxPipelineRayHitAttributeSize = in->maxPipelineRayHitAttributeSize;
15057     if (in->pNext)
15058         FIXME("Unexpected pNext\n");
15059 }
15060
15061 static inline const VkRayTracingPipelineInterfaceCreateInfoKHR *convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, uint32_t count)
15062 {
15063     VkRayTracingPipelineInterfaceCreateInfoKHR *out;
15064     unsigned int i;
15065
15066     if (!in || !count) return NULL;
15067
15068     out = conversion_context_alloc(ctx, count * sizeof(*out));
15069     for (i = 0; i < count; i++)
15070     {
15071         convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_host(&in[i], &out[i]);
15072     }
15073
15074     return out;
15075 }
15076
15077 #ifdef _WIN64
15078 static inline void convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, VkRayTracingPipelineCreateInfoKHR *out)
15079 {
15080     if (!in) return;
15081
15082     out->sType = in->sType;
15083     out->pNext = in->pNext;
15084     out->flags = in->flags;
15085     out->stageCount = in->stageCount;
15086     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
15087     out->groupCount = in->groupCount;
15088     out->pGroups = in->pGroups;
15089     out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
15090     out->pLibraryInfo = in->pLibraryInfo;
15091     out->pLibraryInterface = in->pLibraryInterface;
15092     out->pDynamicState = in->pDynamicState;
15093     out->layout = in->layout;
15094     out->basePipelineHandle = in->basePipelineHandle;
15095     out->basePipelineIndex = in->basePipelineIndex;
15096 }
15097 #endif /* _WIN64 */
15098
15099 static inline void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, VkRayTracingPipelineCreateInfoKHR *out)
15100 {
15101     const VkBaseInStructure32 *in_header;
15102     VkBaseOutStructure *out_header = (void *)out;
15103
15104     if (!in) return;
15105
15106     out->sType = in->sType;
15107     out->pNext = NULL;
15108     out->flags = in->flags;
15109     out->stageCount = in->stageCount;
15110     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
15111     out->groupCount = in->groupCount;
15112     out->pGroups = convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(ctx, (const VkRayTracingShaderGroupCreateInfoKHR32 *)UlongToPtr(in->pGroups), in->groupCount);
15113     out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
15114     out->pLibraryInfo = convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(ctx, (const VkPipelineLibraryCreateInfoKHR32 *)UlongToPtr(in->pLibraryInfo), 1);
15115     out->pLibraryInterface = convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(ctx, (const VkRayTracingPipelineInterfaceCreateInfoKHR32 *)UlongToPtr(in->pLibraryInterface), 1);
15116     out->pDynamicState = convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDynamicStateCreateInfo32 *)UlongToPtr(in->pDynamicState), 1);
15117     out->layout = in->layout;
15118     out->basePipelineHandle = in->basePipelineHandle;
15119     out->basePipelineIndex = in->basePipelineIndex;
15120
15121     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15122     {
15123         switch (in_header->sType)
15124         {
15125         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
15126         {
15127             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15128             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
15129             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
15130             out_ext->pNext = NULL;
15131             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
15132             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
15133             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
15134             out_header->pNext = (void *)out_ext;
15135             out_header = (void *)out_ext;
15136             break;
15137         }
15138         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
15139         {
15140             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15141             const VkPipelineRobustnessCreateInfoEXT32 *in_ext = (const VkPipelineRobustnessCreateInfoEXT32 *)in_header;
15142             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
15143             out_ext->pNext = NULL;
15144             out_ext->storageBuffers = in_ext->storageBuffers;
15145             out_ext->uniformBuffers = in_ext->uniformBuffers;
15146             out_ext->vertexInputs = in_ext->vertexInputs;
15147             out_ext->images = in_ext->images;
15148             out_header->pNext = (void *)out_ext;
15149             out_header = (void *)out_ext;
15150             break;
15151         }
15152         default:
15153             FIXME("Unhandled sType %u.", in_header->sType);
15154             break;
15155         }
15156     }
15157 }
15158
15159 static inline void convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out)
15160 {
15161     const VkBaseInStructure *in_header;
15162     VkBaseOutStructure32 *out_header = (void *)out;
15163
15164     if (!in) return;
15165
15166
15167     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
15168     {
15169         switch (in_header->sType)
15170         {
15171         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
15172         {
15173             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
15174             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
15175             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
15176             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
15177             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
15178             out_header = (void *)out_ext;
15179             break;
15180         }
15181         default:
15182             break;
15183         }
15184     }
15185 }
15186
15187 #ifdef _WIN64
15188 static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, uint32_t count)
15189 {
15190     VkRayTracingPipelineCreateInfoKHR *out;
15191     unsigned int i;
15192
15193     if (!in || !count) return NULL;
15194
15195     out = conversion_context_alloc(ctx, count * sizeof(*out));
15196     for (i = 0; i < count; i++)
15197     {
15198         convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(ctx, &in[i], &out[i]);
15199     }
15200
15201     return out;
15202 }
15203 #endif /* _WIN64 */
15204
15205 static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, uint32_t count)
15206 {
15207     VkRayTracingPipelineCreateInfoKHR *out;
15208     unsigned int i;
15209
15210     if (!in || !count) return NULL;
15211
15212     out = conversion_context_alloc(ctx, count * sizeof(*out));
15213     for (i = 0; i < count; i++)
15214     {
15215         convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
15216     }
15217
15218     return out;
15219 }
15220
15221 static inline void convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out, uint32_t count)
15222 {
15223     unsigned int i;
15224
15225     if (!in) return;
15226
15227     for (i = 0; i < count; i++)
15228     {
15229         convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(&in[i], &out[i]);
15230     }
15231 }
15232
15233 static inline void convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(const VkRayTracingShaderGroupCreateInfoNV32 *in, VkRayTracingShaderGroupCreateInfoNV *out)
15234 {
15235     if (!in) return;
15236
15237     out->sType = in->sType;
15238     out->pNext = NULL;
15239     out->type = in->type;
15240     out->generalShader = in->generalShader;
15241     out->closestHitShader = in->closestHitShader;
15242     out->anyHitShader = in->anyHitShader;
15243     out->intersectionShader = in->intersectionShader;
15244     if (in->pNext)
15245         FIXME("Unexpected pNext\n");
15246 }
15247
15248 static inline const VkRayTracingShaderGroupCreateInfoNV *convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoNV32 *in, uint32_t count)
15249 {
15250     VkRayTracingShaderGroupCreateInfoNV *out;
15251     unsigned int i;
15252
15253     if (!in || !count) return NULL;
15254
15255     out = conversion_context_alloc(ctx, count * sizeof(*out));
15256     for (i = 0; i < count; i++)
15257     {
15258         convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(&in[i], &out[i]);
15259     }
15260
15261     return out;
15262 }
15263
15264 #ifdef _WIN64
15265 static inline void convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, VkRayTracingPipelineCreateInfoNV *out)
15266 {
15267     if (!in) return;
15268
15269     out->sType = in->sType;
15270     out->pNext = in->pNext;
15271     out->flags = in->flags;
15272     out->stageCount = in->stageCount;
15273     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
15274     out->groupCount = in->groupCount;
15275     out->pGroups = in->pGroups;
15276     out->maxRecursionDepth = in->maxRecursionDepth;
15277     out->layout = in->layout;
15278     out->basePipelineHandle = in->basePipelineHandle;
15279     out->basePipelineIndex = in->basePipelineIndex;
15280 }
15281 #endif /* _WIN64 */
15282
15283 static inline void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, VkRayTracingPipelineCreateInfoNV *out)
15284 {
15285     const VkBaseInStructure32 *in_header;
15286     VkBaseOutStructure *out_header = (void *)out;
15287
15288     if (!in) return;
15289
15290     out->sType = in->sType;
15291     out->pNext = NULL;
15292     out->flags = in->flags;
15293     out->stageCount = in->stageCount;
15294     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
15295     out->groupCount = in->groupCount;
15296     out->pGroups = convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(ctx, (const VkRayTracingShaderGroupCreateInfoNV32 *)UlongToPtr(in->pGroups), in->groupCount);
15297     out->maxRecursionDepth = in->maxRecursionDepth;
15298     out->layout = in->layout;
15299     out->basePipelineHandle = in->basePipelineHandle;
15300     out->basePipelineIndex = in->basePipelineIndex;
15301
15302     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15303     {
15304         switch (in_header->sType)
15305         {
15306         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
15307         {
15308             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15309             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
15310             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
15311             out_ext->pNext = NULL;
15312             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
15313             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
15314             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
15315             out_header->pNext = (void *)out_ext;
15316             out_header = (void *)out_ext;
15317             break;
15318         }
15319         default:
15320             FIXME("Unhandled sType %u.", in_header->sType);
15321             break;
15322         }
15323     }
15324 }
15325
15326 static inline void convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out)
15327 {
15328     const VkBaseInStructure *in_header;
15329     VkBaseOutStructure32 *out_header = (void *)out;
15330
15331     if (!in) return;
15332
15333
15334     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
15335     {
15336         switch (in_header->sType)
15337         {
15338         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
15339         {
15340             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
15341             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
15342             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
15343             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
15344             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
15345             out_header = (void *)out_ext;
15346             break;
15347         }
15348         default:
15349             break;
15350         }
15351     }
15352 }
15353
15354 #ifdef _WIN64
15355 static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, uint32_t count)
15356 {
15357     VkRayTracingPipelineCreateInfoNV *out;
15358     unsigned int i;
15359
15360     if (!in || !count) return NULL;
15361
15362     out = conversion_context_alloc(ctx, count * sizeof(*out));
15363     for (i = 0; i < count; i++)
15364     {
15365         convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
15366     }
15367
15368     return out;
15369 }
15370 #endif /* _WIN64 */
15371
15372 static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, uint32_t count)
15373 {
15374     VkRayTracingPipelineCreateInfoNV *out;
15375     unsigned int i;
15376
15377     if (!in || !count) return NULL;
15378
15379     out = conversion_context_alloc(ctx, count * sizeof(*out));
15380     for (i = 0; i < count; i++)
15381     {
15382         convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
15383     }
15384
15385     return out;
15386 }
15387
15388 static inline void convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out, uint32_t count)
15389 {
15390     unsigned int i;
15391
15392     if (!in) return;
15393
15394     for (i = 0; i < count; i++)
15395     {
15396         convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(&in[i], &out[i]);
15397     }
15398 }
15399
15400 static inline void convert_VkSubpassDescription_win32_to_host(const VkSubpassDescription32 *in, VkSubpassDescription *out)
15401 {
15402     if (!in) return;
15403
15404     out->flags = in->flags;
15405     out->pipelineBindPoint = in->pipelineBindPoint;
15406     out->inputAttachmentCount = in->inputAttachmentCount;
15407     out->pInputAttachments = (const VkAttachmentReference *)UlongToPtr(in->pInputAttachments);
15408     out->colorAttachmentCount = in->colorAttachmentCount;
15409     out->pColorAttachments = (const VkAttachmentReference *)UlongToPtr(in->pColorAttachments);
15410     out->pResolveAttachments = (const VkAttachmentReference *)UlongToPtr(in->pResolveAttachments);
15411     out->pDepthStencilAttachment = (const VkAttachmentReference *)UlongToPtr(in->pDepthStencilAttachment);
15412     out->preserveAttachmentCount = in->preserveAttachmentCount;
15413     out->pPreserveAttachments = (const uint32_t *)UlongToPtr(in->pPreserveAttachments);
15414 }
15415
15416 static inline const VkSubpassDescription *convert_VkSubpassDescription_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription32 *in, uint32_t count)
15417 {
15418     VkSubpassDescription *out;
15419     unsigned int i;
15420
15421     if (!in || !count) return NULL;
15422
15423     out = conversion_context_alloc(ctx, count * sizeof(*out));
15424     for (i = 0; i < count; i++)
15425     {
15426         convert_VkSubpassDescription_win32_to_host(&in[i], &out[i]);
15427     }
15428
15429     return out;
15430 }
15431
15432 static inline void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo32 *in, VkRenderPassCreateInfo *out)
15433 {
15434     const VkBaseInStructure32 *in_header;
15435     VkBaseOutStructure *out_header = (void *)out;
15436
15437     if (!in) return;
15438
15439     out->sType = in->sType;
15440     out->pNext = NULL;
15441     out->flags = in->flags;
15442     out->attachmentCount = in->attachmentCount;
15443     out->pAttachments = (const VkAttachmentDescription *)UlongToPtr(in->pAttachments);
15444     out->subpassCount = in->subpassCount;
15445     out->pSubpasses = convert_VkSubpassDescription_array_win32_to_host(ctx, (const VkSubpassDescription32 *)UlongToPtr(in->pSubpasses), in->subpassCount);
15446     out->dependencyCount = in->dependencyCount;
15447     out->pDependencies = (const VkSubpassDependency *)UlongToPtr(in->pDependencies);
15448
15449     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15450     {
15451         switch (in_header->sType)
15452         {
15453         case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
15454         {
15455             VkRenderPassMultiviewCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15456             const VkRenderPassMultiviewCreateInfo32 *in_ext = (const VkRenderPassMultiviewCreateInfo32 *)in_header;
15457             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
15458             out_ext->pNext = NULL;
15459             out_ext->subpassCount = in_ext->subpassCount;
15460             out_ext->pViewMasks = (const uint32_t *)UlongToPtr(in_ext->pViewMasks);
15461             out_ext->dependencyCount = in_ext->dependencyCount;
15462             out_ext->pViewOffsets = (const int32_t *)UlongToPtr(in_ext->pViewOffsets);
15463             out_ext->correlationMaskCount = in_ext->correlationMaskCount;
15464             out_ext->pCorrelationMasks = (const uint32_t *)UlongToPtr(in_ext->pCorrelationMasks);
15465             out_header->pNext = (void *)out_ext;
15466             out_header = (void *)out_ext;
15467             break;
15468         }
15469         case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
15470         {
15471             VkRenderPassInputAttachmentAspectCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15472             const VkRenderPassInputAttachmentAspectCreateInfo32 *in_ext = (const VkRenderPassInputAttachmentAspectCreateInfo32 *)in_header;
15473             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
15474             out_ext->pNext = NULL;
15475             out_ext->aspectReferenceCount = in_ext->aspectReferenceCount;
15476             out_ext->pAspectReferences = (const VkInputAttachmentAspectReference *)UlongToPtr(in_ext->pAspectReferences);
15477             out_header->pNext = (void *)out_ext;
15478             out_header = (void *)out_ext;
15479             break;
15480         }
15481         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
15482         {
15483             VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15484             const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header;
15485             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
15486             out_ext->pNext = NULL;
15487             out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment;
15488             out_header->pNext = (void *)out_ext;
15489             out_header = (void *)out_ext;
15490             break;
15491         }
15492         default:
15493             FIXME("Unhandled sType %u.", in_header->sType);
15494             break;
15495         }
15496     }
15497 }
15498
15499 static inline void convert_VkAttachmentDescription2_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, VkAttachmentDescription2 *out)
15500 {
15501     const VkBaseInStructure32 *in_header;
15502     VkBaseOutStructure *out_header = (void *)out;
15503
15504     if (!in) return;
15505
15506     out->sType = in->sType;
15507     out->pNext = NULL;
15508     out->flags = in->flags;
15509     out->format = in->format;
15510     out->samples = in->samples;
15511     out->loadOp = in->loadOp;
15512     out->storeOp = in->storeOp;
15513     out->stencilLoadOp = in->stencilLoadOp;
15514     out->stencilStoreOp = in->stencilStoreOp;
15515     out->initialLayout = in->initialLayout;
15516     out->finalLayout = in->finalLayout;
15517
15518     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15519     {
15520         switch (in_header->sType)
15521         {
15522         case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
15523         {
15524             VkAttachmentDescriptionStencilLayout *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15525             const VkAttachmentDescriptionStencilLayout32 *in_ext = (const VkAttachmentDescriptionStencilLayout32 *)in_header;
15526             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
15527             out_ext->pNext = NULL;
15528             out_ext->stencilInitialLayout = in_ext->stencilInitialLayout;
15529             out_ext->stencilFinalLayout = in_ext->stencilFinalLayout;
15530             out_header->pNext = (void *)out_ext;
15531             out_header = (void *)out_ext;
15532             break;
15533         }
15534         default:
15535             FIXME("Unhandled sType %u.", in_header->sType);
15536             break;
15537         }
15538     }
15539 }
15540
15541 static inline const VkAttachmentDescription2 *convert_VkAttachmentDescription2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, uint32_t count)
15542 {
15543     VkAttachmentDescription2 *out;
15544     unsigned int i;
15545
15546     if (!in || !count) return NULL;
15547
15548     out = conversion_context_alloc(ctx, count * sizeof(*out));
15549     for (i = 0; i < count; i++)
15550     {
15551         convert_VkAttachmentDescription2_win32_to_host(ctx, &in[i], &out[i]);
15552     }
15553
15554     return out;
15555 }
15556
15557 static inline void convert_VkAttachmentReference2_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, VkAttachmentReference2 *out)
15558 {
15559     const VkBaseInStructure32 *in_header;
15560     VkBaseOutStructure *out_header = (void *)out;
15561
15562     if (!in) return;
15563
15564     out->sType = in->sType;
15565     out->pNext = NULL;
15566     out->attachment = in->attachment;
15567     out->layout = in->layout;
15568     out->aspectMask = in->aspectMask;
15569
15570     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15571     {
15572         switch (in_header->sType)
15573         {
15574         case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
15575         {
15576             VkAttachmentReferenceStencilLayout *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15577             const VkAttachmentReferenceStencilLayout32 *in_ext = (const VkAttachmentReferenceStencilLayout32 *)in_header;
15578             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
15579             out_ext->pNext = NULL;
15580             out_ext->stencilLayout = in_ext->stencilLayout;
15581             out_header->pNext = (void *)out_ext;
15582             out_header = (void *)out_ext;
15583             break;
15584         }
15585         default:
15586             FIXME("Unhandled sType %u.", in_header->sType);
15587             break;
15588         }
15589     }
15590 }
15591
15592 static inline const VkAttachmentReference2 *convert_VkAttachmentReference2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, uint32_t count)
15593 {
15594     VkAttachmentReference2 *out;
15595     unsigned int i;
15596
15597     if (!in || !count) return NULL;
15598
15599     out = conversion_context_alloc(ctx, count * sizeof(*out));
15600     for (i = 0; i < count; i++)
15601     {
15602         convert_VkAttachmentReference2_win32_to_host(ctx, &in[i], &out[i]);
15603     }
15604
15605     return out;
15606 }
15607
15608 static inline void convert_VkSubpassDescription2_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, VkSubpassDescription2 *out)
15609 {
15610     const VkBaseInStructure32 *in_header;
15611     VkBaseOutStructure *out_header = (void *)out;
15612
15613     if (!in) return;
15614
15615     out->sType = in->sType;
15616     out->pNext = NULL;
15617     out->flags = in->flags;
15618     out->pipelineBindPoint = in->pipelineBindPoint;
15619     out->viewMask = in->viewMask;
15620     out->inputAttachmentCount = in->inputAttachmentCount;
15621     out->pInputAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pInputAttachments), in->inputAttachmentCount);
15622     out->colorAttachmentCount = in->colorAttachmentCount;
15623     out->pColorAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pColorAttachments), in->colorAttachmentCount);
15624     out->pResolveAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pResolveAttachments), in->colorAttachmentCount);
15625     out->pDepthStencilAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pDepthStencilAttachment), 1);
15626     out->preserveAttachmentCount = in->preserveAttachmentCount;
15627     out->pPreserveAttachments = (const uint32_t *)UlongToPtr(in->pPreserveAttachments);
15628
15629     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15630     {
15631         switch (in_header->sType)
15632         {
15633         case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
15634         {
15635             VkSubpassDescriptionDepthStencilResolve *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15636             const VkSubpassDescriptionDepthStencilResolve32 *in_ext = (const VkSubpassDescriptionDepthStencilResolve32 *)in_header;
15637             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
15638             out_ext->pNext = NULL;
15639             out_ext->depthResolveMode = in_ext->depthResolveMode;
15640             out_ext->stencilResolveMode = in_ext->stencilResolveMode;
15641             out_ext->pDepthStencilResolveAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in_ext->pDepthStencilResolveAttachment), 1);
15642             out_header->pNext = (void *)out_ext;
15643             out_header = (void *)out_ext;
15644             break;
15645         }
15646         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
15647         {
15648             VkFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15649             const VkFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkFragmentShadingRateAttachmentInfoKHR32 *)in_header;
15650             out_ext->sType = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
15651             out_ext->pNext = NULL;
15652             out_ext->pFragmentShadingRateAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in_ext->pFragmentShadingRateAttachment), 1);
15653             out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize;
15654             out_header->pNext = (void *)out_ext;
15655             out_header = (void *)out_ext;
15656             break;
15657         }
15658         case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
15659         {
15660             VkMultisampledRenderToSingleSampledInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15661             const VkMultisampledRenderToSingleSampledInfoEXT32 *in_ext = (const VkMultisampledRenderToSingleSampledInfoEXT32 *)in_header;
15662             out_ext->sType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
15663             out_ext->pNext = NULL;
15664             out_ext->multisampledRenderToSingleSampledEnable = in_ext->multisampledRenderToSingleSampledEnable;
15665             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
15666             out_header->pNext = (void *)out_ext;
15667             out_header = (void *)out_ext;
15668             break;
15669         }
15670         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
15671         {
15672             VkRenderPassCreationControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15673             const VkRenderPassCreationControlEXT32 *in_ext = (const VkRenderPassCreationControlEXT32 *)in_header;
15674             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT;
15675             out_ext->pNext = NULL;
15676             out_ext->disallowMerging = in_ext->disallowMerging;
15677             out_header->pNext = (void *)out_ext;
15678             out_header = (void *)out_ext;
15679             break;
15680         }
15681         case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
15682         {
15683             VkRenderPassSubpassFeedbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15684             const VkRenderPassSubpassFeedbackCreateInfoEXT32 *in_ext = (const VkRenderPassSubpassFeedbackCreateInfoEXT32 *)in_header;
15685             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT;
15686             out_ext->pNext = NULL;
15687             out_ext->pSubpassFeedback = (VkRenderPassSubpassFeedbackInfoEXT *)UlongToPtr(in_ext->pSubpassFeedback);
15688             out_header->pNext = (void *)out_ext;
15689             out_header = (void *)out_ext;
15690             break;
15691         }
15692         default:
15693             FIXME("Unhandled sType %u.", in_header->sType);
15694             break;
15695         }
15696     }
15697 }
15698
15699 static inline const VkSubpassDescription2 *convert_VkSubpassDescription2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, uint32_t count)
15700 {
15701     VkSubpassDescription2 *out;
15702     unsigned int i;
15703
15704     if (!in || !count) return NULL;
15705
15706     out = conversion_context_alloc(ctx, count * sizeof(*out));
15707     for (i = 0; i < count; i++)
15708     {
15709         convert_VkSubpassDescription2_win32_to_host(ctx, &in[i], &out[i]);
15710     }
15711
15712     return out;
15713 }
15714
15715 static inline void convert_VkSubpassDependency2_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, VkSubpassDependency2 *out)
15716 {
15717     const VkBaseInStructure32 *in_header;
15718     VkBaseOutStructure *out_header = (void *)out;
15719
15720     if (!in) return;
15721
15722     out->sType = in->sType;
15723     out->pNext = NULL;
15724     out->srcSubpass = in->srcSubpass;
15725     out->dstSubpass = in->dstSubpass;
15726     out->srcStageMask = in->srcStageMask;
15727     out->dstStageMask = in->dstStageMask;
15728     out->srcAccessMask = in->srcAccessMask;
15729     out->dstAccessMask = in->dstAccessMask;
15730     out->dependencyFlags = in->dependencyFlags;
15731     out->viewOffset = in->viewOffset;
15732
15733     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15734     {
15735         switch (in_header->sType)
15736         {
15737         case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
15738         {
15739             VkMemoryBarrier2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15740             const VkMemoryBarrier232 *in_ext = (const VkMemoryBarrier232 *)in_header;
15741             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2;
15742             out_ext->pNext = NULL;
15743             out_ext->srcStageMask = in_ext->srcStageMask;
15744             out_ext->srcAccessMask = in_ext->srcAccessMask;
15745             out_ext->dstStageMask = in_ext->dstStageMask;
15746             out_ext->dstAccessMask = in_ext->dstAccessMask;
15747             out_header->pNext = (void *)out_ext;
15748             out_header = (void *)out_ext;
15749             break;
15750         }
15751         default:
15752             FIXME("Unhandled sType %u.", in_header->sType);
15753             break;
15754         }
15755     }
15756 }
15757
15758 static inline const VkSubpassDependency2 *convert_VkSubpassDependency2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, uint32_t count)
15759 {
15760     VkSubpassDependency2 *out;
15761     unsigned int i;
15762
15763     if (!in || !count) return NULL;
15764
15765     out = conversion_context_alloc(ctx, count * sizeof(*out));
15766     for (i = 0; i < count; i++)
15767     {
15768         convert_VkSubpassDependency2_win32_to_host(ctx, &in[i], &out[i]);
15769     }
15770
15771     return out;
15772 }
15773
15774 static inline void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo232 *in, VkRenderPassCreateInfo2 *out)
15775 {
15776     const VkBaseInStructure32 *in_header;
15777     VkBaseOutStructure *out_header = (void *)out;
15778
15779     if (!in) return;
15780
15781     out->sType = in->sType;
15782     out->pNext = NULL;
15783     out->flags = in->flags;
15784     out->attachmentCount = in->attachmentCount;
15785     out->pAttachments = convert_VkAttachmentDescription2_array_win32_to_host(ctx, (const VkAttachmentDescription232 *)UlongToPtr(in->pAttachments), in->attachmentCount);
15786     out->subpassCount = in->subpassCount;
15787     out->pSubpasses = convert_VkSubpassDescription2_array_win32_to_host(ctx, (const VkSubpassDescription232 *)UlongToPtr(in->pSubpasses), in->subpassCount);
15788     out->dependencyCount = in->dependencyCount;
15789     out->pDependencies = convert_VkSubpassDependency2_array_win32_to_host(ctx, (const VkSubpassDependency232 *)UlongToPtr(in->pDependencies), in->dependencyCount);
15790     out->correlatedViewMaskCount = in->correlatedViewMaskCount;
15791     out->pCorrelatedViewMasks = (const uint32_t *)UlongToPtr(in->pCorrelatedViewMasks);
15792
15793     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15794     {
15795         switch (in_header->sType)
15796         {
15797         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
15798         {
15799             VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15800             const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header;
15801             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
15802             out_ext->pNext = NULL;
15803             out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment;
15804             out_header->pNext = (void *)out_ext;
15805             out_header = (void *)out_ext;
15806             break;
15807         }
15808         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
15809         {
15810             VkRenderPassCreationControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15811             const VkRenderPassCreationControlEXT32 *in_ext = (const VkRenderPassCreationControlEXT32 *)in_header;
15812             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT;
15813             out_ext->pNext = NULL;
15814             out_ext->disallowMerging = in_ext->disallowMerging;
15815             out_header->pNext = (void *)out_ext;
15816             out_header = (void *)out_ext;
15817             break;
15818         }
15819         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
15820         {
15821             VkRenderPassCreationFeedbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15822             const VkRenderPassCreationFeedbackCreateInfoEXT32 *in_ext = (const VkRenderPassCreationFeedbackCreateInfoEXT32 *)in_header;
15823             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT;
15824             out_ext->pNext = NULL;
15825             out_ext->pRenderPassFeedback = (VkRenderPassCreationFeedbackInfoEXT *)UlongToPtr(in_ext->pRenderPassFeedback);
15826             out_header->pNext = (void *)out_ext;
15827             out_header = (void *)out_ext;
15828             break;
15829         }
15830         default:
15831             FIXME("Unhandled sType %u.", in_header->sType);
15832             break;
15833         }
15834     }
15835 }
15836
15837 static inline void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSamplerCreateInfo32 *in, VkSamplerCreateInfo *out)
15838 {
15839     const VkBaseInStructure32 *in_header;
15840     VkBaseOutStructure *out_header = (void *)out;
15841
15842     if (!in) return;
15843
15844     out->sType = in->sType;
15845     out->pNext = NULL;
15846     out->flags = in->flags;
15847     out->magFilter = in->magFilter;
15848     out->minFilter = in->minFilter;
15849     out->mipmapMode = in->mipmapMode;
15850     out->addressModeU = in->addressModeU;
15851     out->addressModeV = in->addressModeV;
15852     out->addressModeW = in->addressModeW;
15853     out->mipLodBias = in->mipLodBias;
15854     out->anisotropyEnable = in->anisotropyEnable;
15855     out->maxAnisotropy = in->maxAnisotropy;
15856     out->compareEnable = in->compareEnable;
15857     out->compareOp = in->compareOp;
15858     out->minLod = in->minLod;
15859     out->maxLod = in->maxLod;
15860     out->borderColor = in->borderColor;
15861     out->unnormalizedCoordinates = in->unnormalizedCoordinates;
15862
15863     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15864     {
15865         switch (in_header->sType)
15866         {
15867         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
15868         {
15869             VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15870             const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
15871             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
15872             out_ext->pNext = NULL;
15873             out_ext->conversion = in_ext->conversion;
15874             out_header->pNext = (void *)out_ext;
15875             out_header = (void *)out_ext;
15876             break;
15877         }
15878         case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
15879         {
15880             VkSamplerReductionModeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15881             const VkSamplerReductionModeCreateInfo32 *in_ext = (const VkSamplerReductionModeCreateInfo32 *)in_header;
15882             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO;
15883             out_ext->pNext = NULL;
15884             out_ext->reductionMode = in_ext->reductionMode;
15885             out_header->pNext = (void *)out_ext;
15886             out_header = (void *)out_ext;
15887             break;
15888         }
15889         case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
15890         {
15891             VkSamplerCustomBorderColorCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15892             const VkSamplerCustomBorderColorCreateInfoEXT32 *in_ext = (const VkSamplerCustomBorderColorCreateInfoEXT32 *)in_header;
15893             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT;
15894             out_ext->pNext = NULL;
15895             out_ext->customBorderColor = in_ext->customBorderColor;
15896             out_ext->format = in_ext->format;
15897             out_header->pNext = (void *)out_ext;
15898             out_header = (void *)out_ext;
15899             break;
15900         }
15901         case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
15902         {
15903             VkSamplerBorderColorComponentMappingCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15904             const VkSamplerBorderColorComponentMappingCreateInfoEXT32 *in_ext = (const VkSamplerBorderColorComponentMappingCreateInfoEXT32 *)in_header;
15905             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT;
15906             out_ext->pNext = NULL;
15907             out_ext->components = in_ext->components;
15908             out_ext->srgb = in_ext->srgb;
15909             out_header->pNext = (void *)out_ext;
15910             out_header = (void *)out_ext;
15911             break;
15912         }
15913         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
15914         {
15915             VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15916             const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header;
15917             out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
15918             out_ext->pNext = NULL;
15919             out_ext->opaqueCaptureDescriptorData = (const void *)UlongToPtr(in_ext->opaqueCaptureDescriptorData);
15920             out_header->pNext = (void *)out_ext;
15921             out_header = (void *)out_ext;
15922             break;
15923         }
15924         default:
15925             FIXME("Unhandled sType %u.", in_header->sType);
15926             break;
15927         }
15928     }
15929 }
15930
15931 static inline void convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(const VkSamplerYcbcrConversionCreateInfo32 *in, VkSamplerYcbcrConversionCreateInfo *out)
15932 {
15933     if (!in) return;
15934
15935     out->sType = in->sType;
15936     out->pNext = NULL;
15937     out->format = in->format;
15938     out->ycbcrModel = in->ycbcrModel;
15939     out->ycbcrRange = in->ycbcrRange;
15940     out->components = in->components;
15941     out->xChromaOffset = in->xChromaOffset;
15942     out->yChromaOffset = in->yChromaOffset;
15943     out->chromaFilter = in->chromaFilter;
15944     out->forceExplicitReconstruction = in->forceExplicitReconstruction;
15945     if (in->pNext)
15946         FIXME("Unexpected pNext\n");
15947 }
15948
15949 static inline void convert_VkSemaphoreCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSemaphoreCreateInfo32 *in, VkSemaphoreCreateInfo *out)
15950 {
15951     const VkBaseInStructure32 *in_header;
15952     VkBaseOutStructure *out_header = (void *)out;
15953
15954     if (!in) return;
15955
15956     out->sType = in->sType;
15957     out->pNext = NULL;
15958     out->flags = in->flags;
15959
15960     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
15961     {
15962         switch (in_header->sType)
15963         {
15964         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
15965         {
15966             VkExportSemaphoreCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15967             const VkExportSemaphoreCreateInfo32 *in_ext = (const VkExportSemaphoreCreateInfo32 *)in_header;
15968             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO;
15969             out_ext->pNext = NULL;
15970             out_ext->handleTypes = in_ext->handleTypes;
15971             out_header->pNext = (void *)out_ext;
15972             out_header = (void *)out_ext;
15973             break;
15974         }
15975         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
15976         {
15977             VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
15978             const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header;
15979             out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
15980             out_ext->pNext = NULL;
15981             out_ext->semaphoreType = in_ext->semaphoreType;
15982             out_ext->initialValue = in_ext->initialValue;
15983             out_header->pNext = (void *)out_ext;
15984             out_header = (void *)out_ext;
15985             break;
15986         }
15987         default:
15988             FIXME("Unhandled sType %u.", in_header->sType);
15989             break;
15990         }
15991     }
15992 }
15993
15994 static inline void convert_VkShaderModuleCreateInfo_win32_to_host(struct conversion_context *ctx, const VkShaderModuleCreateInfo32 *in, VkShaderModuleCreateInfo *out)
15995 {
15996     const VkBaseInStructure32 *in_header;
15997     VkBaseOutStructure *out_header = (void *)out;
15998
15999     if (!in) return;
16000
16001     out->sType = in->sType;
16002     out->pNext = NULL;
16003     out->flags = in->flags;
16004     out->codeSize = in->codeSize;
16005     out->pCode = (const uint32_t *)UlongToPtr(in->pCode);
16006
16007     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16008     {
16009         switch (in_header->sType)
16010         {
16011         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
16012         {
16013             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16014             const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
16015             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
16016             out_ext->pNext = NULL;
16017             out_ext->validationCache = in_ext->validationCache;
16018             out_header->pNext = (void *)out_ext;
16019             out_header = (void *)out_ext;
16020             break;
16021         }
16022         default:
16023             FIXME("Unhandled sType %u.", in_header->sType);
16024             break;
16025         }
16026     }
16027 }
16028
16029 #ifdef _WIN64
16030 static inline void convert_VkSwapchainCreateInfoKHR_win64_to_host(const VkSwapchainCreateInfoKHR *in, VkSwapchainCreateInfoKHR *out)
16031 {
16032     if (!in) return;
16033
16034     out->sType = in->sType;
16035     out->pNext = in->pNext;
16036     out->flags = in->flags;
16037     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
16038     out->minImageCount = in->minImageCount;
16039     out->imageFormat = in->imageFormat;
16040     out->imageColorSpace = in->imageColorSpace;
16041     out->imageExtent = in->imageExtent;
16042     out->imageArrayLayers = in->imageArrayLayers;
16043     out->imageUsage = in->imageUsage;
16044     out->imageSharingMode = in->imageSharingMode;
16045     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
16046     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
16047     out->preTransform = in->preTransform;
16048     out->compositeAlpha = in->compositeAlpha;
16049     out->presentMode = in->presentMode;
16050     out->clipped = in->clipped;
16051     out->oldSwapchain = in->oldSwapchain;
16052 }
16053 #endif /* _WIN64 */
16054
16055 static inline void convert_VkSwapchainCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkSwapchainCreateInfoKHR32 *in, VkSwapchainCreateInfoKHR *out)
16056 {
16057     const VkBaseInStructure32 *in_header;
16058     VkBaseOutStructure *out_header = (void *)out;
16059
16060     if (!in) return;
16061
16062     out->sType = in->sType;
16063     out->pNext = NULL;
16064     out->flags = in->flags;
16065     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
16066     out->minImageCount = in->minImageCount;
16067     out->imageFormat = in->imageFormat;
16068     out->imageColorSpace = in->imageColorSpace;
16069     out->imageExtent = in->imageExtent;
16070     out->imageArrayLayers = in->imageArrayLayers;
16071     out->imageUsage = in->imageUsage;
16072     out->imageSharingMode = in->imageSharingMode;
16073     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
16074     out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);
16075     out->preTransform = in->preTransform;
16076     out->compositeAlpha = in->compositeAlpha;
16077     out->presentMode = in->presentMode;
16078     out->clipped = in->clipped;
16079     out->oldSwapchain = in->oldSwapchain;
16080
16081     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16082     {
16083         switch (in_header->sType)
16084         {
16085         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
16086         {
16087             VkDeviceGroupSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16088             const VkDeviceGroupSwapchainCreateInfoKHR32 *in_ext = (const VkDeviceGroupSwapchainCreateInfoKHR32 *)in_header;
16089             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR;
16090             out_ext->pNext = NULL;
16091             out_ext->modes = in_ext->modes;
16092             out_header->pNext = (void *)out_ext;
16093             out_header = (void *)out_ext;
16094             break;
16095         }
16096         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
16097         {
16098             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16099             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
16100             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
16101             out_ext->pNext = NULL;
16102             out_ext->viewFormatCount = in_ext->viewFormatCount;
16103             out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
16104             out_header->pNext = (void *)out_ext;
16105             out_header = (void *)out_ext;
16106             break;
16107         }
16108         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
16109         {
16110             VkSwapchainPresentBarrierCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16111             const VkSwapchainPresentBarrierCreateInfoNV32 *in_ext = (const VkSwapchainPresentBarrierCreateInfoNV32 *)in_header;
16112             out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV;
16113             out_ext->pNext = NULL;
16114             out_ext->presentBarrierEnable = in_ext->presentBarrierEnable;
16115             out_header->pNext = (void *)out_ext;
16116             out_header = (void *)out_ext;
16117             break;
16118         }
16119         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
16120         {
16121             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16122             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
16123             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
16124             out_ext->pNext = NULL;
16125             out_ext->flags = in_ext->flags;
16126             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
16127             out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
16128             out_header->pNext = (void *)out_ext;
16129             out_header = (void *)out_ext;
16130             break;
16131         }
16132         default:
16133             FIXME("Unhandled sType %u.", in_header->sType);
16134             break;
16135         }
16136     }
16137 }
16138
16139 static inline void convert_VkValidationCacheCreateInfoEXT_win32_to_host(const VkValidationCacheCreateInfoEXT32 *in, VkValidationCacheCreateInfoEXT *out)
16140 {
16141     if (!in) return;
16142
16143     out->sType = in->sType;
16144     out->pNext = NULL;
16145     out->flags = in->flags;
16146     out->initialDataSize = in->initialDataSize;
16147     out->pInitialData = (const void *)UlongToPtr(in->pInitialData);
16148     if (in->pNext)
16149         FIXME("Unexpected pNext\n");
16150 }
16151
16152 static inline void convert_VkWin32SurfaceCreateInfoKHR_win32_to_host(const VkWin32SurfaceCreateInfoKHR32 *in, VkWin32SurfaceCreateInfoKHR *out)
16153 {
16154     if (!in) return;
16155
16156     out->sType = in->sType;
16157     out->pNext = NULL;
16158     out->flags = in->flags;
16159     out->hinstance = (HINSTANCE)UlongToPtr(in->hinstance);
16160     out->hwnd = (HWND)UlongToPtr(in->hwnd);
16161     if (in->pNext)
16162         FIXME("Unexpected pNext\n");
16163 }
16164
16165 #ifdef _WIN64
16166 static inline void convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(const VkDebugMarkerObjectNameInfoEXT *in, VkDebugMarkerObjectNameInfoEXT *out)
16167 {
16168     if (!in) return;
16169
16170     out->sType = in->sType;
16171     out->pNext = in->pNext;
16172     out->objectType = in->objectType;
16173     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
16174     out->pObjectName = in->pObjectName;
16175 }
16176 #endif /* _WIN64 */
16177
16178 static inline void convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(const VkDebugMarkerObjectNameInfoEXT32 *in, VkDebugMarkerObjectNameInfoEXT *out)
16179 {
16180     if (!in) return;
16181
16182     out->sType = in->sType;
16183     out->pNext = NULL;
16184     out->objectType = in->objectType;
16185     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
16186     out->pObjectName = (const char *)UlongToPtr(in->pObjectName);
16187     if (in->pNext)
16188         FIXME("Unexpected pNext\n");
16189 }
16190
16191 #ifdef _WIN64
16192 static inline void convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(const VkDebugMarkerObjectTagInfoEXT *in, VkDebugMarkerObjectTagInfoEXT *out)
16193 {
16194     if (!in) return;
16195
16196     out->sType = in->sType;
16197     out->pNext = in->pNext;
16198     out->objectType = in->objectType;
16199     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
16200     out->tagName = in->tagName;
16201     out->tagSize = in->tagSize;
16202     out->pTag = in->pTag;
16203 }
16204 #endif /* _WIN64 */
16205
16206 static inline void convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(const VkDebugMarkerObjectTagInfoEXT32 *in, VkDebugMarkerObjectTagInfoEXT *out)
16207 {
16208     if (!in) return;
16209
16210     out->sType = in->sType;
16211     out->pNext = NULL;
16212     out->objectType = in->objectType;
16213     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
16214     out->tagName = in->tagName;
16215     out->tagSize = in->tagSize;
16216     out->pTag = (const void *)UlongToPtr(in->pTag);
16217     if (in->pNext)
16218         FIXME("Unexpected pNext\n");
16219 }
16220
16221 static inline void convert_VkPhysicalDevice_array_unwrapped_host_to_win32(const VkPhysicalDevice *in, PTR32 *out, uint32_t count)
16222 {
16223     unsigned int i;
16224
16225     if (!in) return;
16226
16227     for (i = 0; i < count; i++)
16228     {
16229         out[i] = PtrToUlong(in[i]);
16230     }
16231 }
16232
16233 static inline void convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_host(const VkPhysicalDeviceGroupProperties32 *in, VkPhysicalDeviceGroupProperties *out)
16234 {
16235     if (!in) return;
16236
16237     out->sType = in->sType;
16238     out->pNext = NULL;
16239     if (in->pNext)
16240         FIXME("Unexpected pNext\n");
16241 }
16242
16243 static inline void convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out)
16244 {
16245     if (!in) return;
16246
16247     out->physicalDeviceCount = in->physicalDeviceCount;
16248     convert_VkPhysicalDevice_array_unwrapped_host_to_win32(in->physicalDevices, out->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE);
16249     out->subsetAllocation = in->subsetAllocation;
16250 }
16251
16252 static inline VkPhysicalDeviceGroupProperties *convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceGroupProperties32 *in, uint32_t count)
16253 {
16254     VkPhysicalDeviceGroupProperties *out;
16255     unsigned int i;
16256
16257     if (!in || !count) return NULL;
16258
16259     out = conversion_context_alloc(ctx, count * sizeof(*out));
16260     for (i = 0; i < count; i++)
16261     {
16262         convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_host(&in[i], &out[i]);
16263     }
16264
16265     return out;
16266 }
16267
16268 static inline void convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out, uint32_t count)
16269 {
16270     unsigned int i;
16271
16272     if (!in) return;
16273
16274     for (i = 0; i < count; i++)
16275     {
16276         convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(&in[i], &out[i]);
16277     }
16278 }
16279
16280 static inline void convert_VkPerformanceCounterKHR_win32_to_host(const VkPerformanceCounterKHR32 *in, VkPerformanceCounterKHR *out)
16281 {
16282     if (!in) return;
16283
16284     out->sType = in->sType;
16285     out->pNext = NULL;
16286     if (in->pNext)
16287         FIXME("Unexpected pNext\n");
16288 }
16289
16290 static inline void convert_VkPerformanceCounterKHR_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out)
16291 {
16292     if (!in) return;
16293
16294     out->unit = in->unit;
16295     out->scope = in->scope;
16296     out->storage = in->storage;
16297     memcpy(out->uuid, in->uuid, VK_UUID_SIZE * sizeof(uint8_t));
16298 }
16299
16300 static inline VkPerformanceCounterKHR *convert_VkPerformanceCounterKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterKHR32 *in, uint32_t count)
16301 {
16302     VkPerformanceCounterKHR *out;
16303     unsigned int i;
16304
16305     if (!in || !count) return NULL;
16306
16307     out = conversion_context_alloc(ctx, count * sizeof(*out));
16308     for (i = 0; i < count; i++)
16309     {
16310         convert_VkPerformanceCounterKHR_win32_to_host(&in[i], &out[i]);
16311     }
16312
16313     return out;
16314 }
16315
16316 static inline void convert_VkPerformanceCounterKHR_array_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out, uint32_t count)
16317 {
16318     unsigned int i;
16319
16320     if (!in) return;
16321
16322     for (i = 0; i < count; i++)
16323     {
16324         convert_VkPerformanceCounterKHR_host_to_win32(&in[i], &out[i]);
16325     }
16326 }
16327
16328 static inline void convert_VkPerformanceCounterDescriptionKHR_win32_to_host(const VkPerformanceCounterDescriptionKHR32 *in, VkPerformanceCounterDescriptionKHR *out)
16329 {
16330     if (!in) return;
16331
16332     out->sType = in->sType;
16333     out->pNext = NULL;
16334     if (in->pNext)
16335         FIXME("Unexpected pNext\n");
16336 }
16337
16338 static inline void convert_VkPerformanceCounterDescriptionKHR_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out)
16339 {
16340     if (!in) return;
16341
16342     out->flags = in->flags;
16343     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
16344     memcpy(out->category, in->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
16345     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
16346 }
16347
16348 static inline VkPerformanceCounterDescriptionKHR *convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterDescriptionKHR32 *in, uint32_t count)
16349 {
16350     VkPerformanceCounterDescriptionKHR *out;
16351     unsigned int i;
16352
16353     if (!in || !count) return NULL;
16354
16355     out = conversion_context_alloc(ctx, count * sizeof(*out));
16356     for (i = 0; i < count; i++)
16357     {
16358         convert_VkPerformanceCounterDescriptionKHR_win32_to_host(&in[i], &out[i]);
16359     }
16360
16361     return out;
16362 }
16363
16364 static inline void convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out, uint32_t count)
16365 {
16366     unsigned int i;
16367
16368     if (!in) return;
16369
16370     for (i = 0; i < count; i++)
16371     {
16372         convert_VkPerformanceCounterDescriptionKHR_host_to_win32(&in[i], &out[i]);
16373     }
16374 }
16375
16376 static inline void convert_VkMappedMemoryRange_win32_to_host(const VkMappedMemoryRange32 *in, VkMappedMemoryRange *out)
16377 {
16378     if (!in) return;
16379
16380     out->sType = in->sType;
16381     out->pNext = NULL;
16382     out->memory = in->memory;
16383     out->offset = in->offset;
16384     out->size = in->size;
16385     if (in->pNext)
16386         FIXME("Unexpected pNext\n");
16387 }
16388
16389 static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win32_to_host(struct conversion_context *ctx, const VkMappedMemoryRange32 *in, uint32_t count)
16390 {
16391     VkMappedMemoryRange *out;
16392     unsigned int i;
16393
16394     if (!in || !count) return NULL;
16395
16396     out = conversion_context_alloc(ctx, count * sizeof(*out));
16397     for (i = 0; i < count; i++)
16398     {
16399         convert_VkMappedMemoryRange_win32_to_host(&in[i], &out[i]);
16400     }
16401
16402     return out;
16403 }
16404
16405 static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host(const VkAccelerationStructureBuildSizesInfoKHR32 *in, VkAccelerationStructureBuildSizesInfoKHR *out)
16406 {
16407     if (!in) return;
16408
16409     out->sType = in->sType;
16410     out->pNext = NULL;
16411     out->accelerationStructureSize = in->accelerationStructureSize;
16412     out->updateScratchSize = in->updateScratchSize;
16413     out->buildScratchSize = in->buildScratchSize;
16414     if (in->pNext)
16415         FIXME("Unexpected pNext\n");
16416 }
16417
16418 static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(const VkAccelerationStructureBuildSizesInfoKHR *in, VkAccelerationStructureBuildSizesInfoKHR32 *out)
16419 {
16420     if (!in) return;
16421
16422     out->accelerationStructureSize = in->accelerationStructureSize;
16423     out->updateScratchSize = in->updateScratchSize;
16424     out->buildScratchSize = in->buildScratchSize;
16425 }
16426
16427 static inline void convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host(const VkAccelerationStructureDeviceAddressInfoKHR32 *in, VkAccelerationStructureDeviceAddressInfoKHR *out)
16428 {
16429     if (!in) return;
16430
16431     out->sType = in->sType;
16432     out->pNext = NULL;
16433     out->accelerationStructure = in->accelerationStructure;
16434     if (in->pNext)
16435         FIXME("Unexpected pNext\n");
16436 }
16437
16438 static inline void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host(const VkAccelerationStructureMemoryRequirementsInfoNV32 *in, VkAccelerationStructureMemoryRequirementsInfoNV *out)
16439 {
16440     if (!in) return;
16441
16442     out->sType = in->sType;
16443     out->pNext = NULL;
16444     out->type = in->type;
16445     out->accelerationStructure = in->accelerationStructure;
16446     if (in->pNext)
16447         FIXME("Unexpected pNext\n");
16448 }
16449
16450 static inline void convert_VkMemoryRequirements_host_to_win32(const VkMemoryRequirements *in, VkMemoryRequirements32 *out)
16451 {
16452     if (!in) return;
16453
16454     out->size = in->size;
16455     out->alignment = in->alignment;
16456     out->memoryTypeBits = in->memoryTypeBits;
16457 }
16458
16459 static inline void convert_VkMemoryRequirements2KHR_win32_to_host(const VkMemoryRequirements2KHR32 *in, VkMemoryRequirements2KHR *out)
16460 {
16461     if (!in) return;
16462
16463     out->sType = in->sType;
16464     out->pNext = NULL;
16465     if (in->pNext)
16466         FIXME("Unexpected pNext\n");
16467 }
16468
16469 static inline void convert_VkMemoryRequirements2KHR_host_to_win32(const VkMemoryRequirements2KHR *in, VkMemoryRequirements2KHR32 *out)
16470 {
16471     if (!in) return;
16472
16473     convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
16474 }
16475
16476 static inline void convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_win32_to_host(const VkAccelerationStructureCaptureDescriptorDataInfoEXT32 *in, VkAccelerationStructureCaptureDescriptorDataInfoEXT *out)
16477 {
16478     if (!in) return;
16479
16480     out->sType = in->sType;
16481     out->pNext = NULL;
16482     out->accelerationStructure = in->accelerationStructure;
16483     out->accelerationStructureNV = in->accelerationStructureNV;
16484     if (in->pNext)
16485         FIXME("Unexpected pNext\n");
16486 }
16487
16488 static inline void convert_VkBufferDeviceAddressInfo_win32_to_host(const VkBufferDeviceAddressInfo32 *in, VkBufferDeviceAddressInfo *out)
16489 {
16490     if (!in) return;
16491
16492     out->sType = in->sType;
16493     out->pNext = NULL;
16494     out->buffer = in->buffer;
16495     if (in->pNext)
16496         FIXME("Unexpected pNext\n");
16497 }
16498
16499 static inline void convert_VkBufferMemoryRequirementsInfo2_win32_to_host(const VkBufferMemoryRequirementsInfo232 *in, VkBufferMemoryRequirementsInfo2 *out)
16500 {
16501     if (!in) return;
16502
16503     out->sType = in->sType;
16504     out->pNext = NULL;
16505     out->buffer = in->buffer;
16506     if (in->pNext)
16507         FIXME("Unexpected pNext\n");
16508 }
16509
16510 static inline void convert_VkMemoryRequirements2_win32_to_host(struct conversion_context *ctx, const VkMemoryRequirements232 *in, VkMemoryRequirements2 *out)
16511 {
16512     const VkBaseInStructure32 *in_header;
16513     VkBaseOutStructure *out_header = (void *)out;
16514
16515     if (!in) return;
16516
16517     out->sType = in->sType;
16518     out->pNext = NULL;
16519
16520     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16521     {
16522         switch (in_header->sType)
16523         {
16524         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
16525         {
16526             VkMemoryDedicatedRequirements *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16527             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
16528             out_ext->pNext = NULL;
16529             out_header->pNext = (void *)out_ext;
16530             out_header = (void *)out_ext;
16531             break;
16532         }
16533         default:
16534             FIXME("Unhandled sType %u.", in_header->sType);
16535             break;
16536         }
16537     }
16538 }
16539
16540 static inline void convert_VkMemoryRequirements2_host_to_win32(const VkMemoryRequirements2 *in, VkMemoryRequirements232 *out)
16541 {
16542     const VkBaseInStructure *in_header;
16543     VkBaseOutStructure32 *out_header = (void *)out;
16544
16545     if (!in) return;
16546
16547     convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
16548
16549     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
16550     {
16551         switch (in_header->sType)
16552         {
16553         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
16554         {
16555             VkMemoryDedicatedRequirements32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
16556             const VkMemoryDedicatedRequirements *in_ext = (const VkMemoryDedicatedRequirements *)in_header;
16557             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
16558             out_ext->prefersDedicatedAllocation = in_ext->prefersDedicatedAllocation;
16559             out_ext->requiresDedicatedAllocation = in_ext->requiresDedicatedAllocation;
16560             out_header = (void *)out_ext;
16561             break;
16562         }
16563         default:
16564             break;
16565         }
16566     }
16567 }
16568
16569 static inline void convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host(const VkBufferCaptureDescriptorDataInfoEXT32 *in, VkBufferCaptureDescriptorDataInfoEXT *out)
16570 {
16571     if (!in) return;
16572
16573     out->sType = in->sType;
16574     out->pNext = NULL;
16575     out->buffer = in->buffer;
16576     if (in->pNext)
16577         FIXME("Unexpected pNext\n");
16578 }
16579
16580 static inline void convert_VkCalibratedTimestampInfoEXT_win32_to_host(const VkCalibratedTimestampInfoEXT32 *in, VkCalibratedTimestampInfoEXT *out)
16581 {
16582     if (!in) return;
16583
16584     out->sType = in->sType;
16585     out->pNext = NULL;
16586     out->timeDomain = in->timeDomain;
16587     if (in->pNext)
16588         FIXME("Unexpected pNext\n");
16589 }
16590
16591 static inline const VkCalibratedTimestampInfoEXT *convert_VkCalibratedTimestampInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoEXT32 *in, uint32_t count)
16592 {
16593     VkCalibratedTimestampInfoEXT *out;
16594     unsigned int i;
16595
16596     if (!in || !count) return NULL;
16597
16598     out = conversion_context_alloc(ctx, count * sizeof(*out));
16599     for (i = 0; i < count; i++)
16600     {
16601         convert_VkCalibratedTimestampInfoEXT_win32_to_host(&in[i], &out[i]);
16602     }
16603
16604     return out;
16605 }
16606
16607 static inline void convert_VkDescriptorAddressInfoEXT_win32_to_host(const VkDescriptorAddressInfoEXT32 *in, VkDescriptorAddressInfoEXT *out)
16608 {
16609     if (!in) return;
16610
16611     out->sType = in->sType;
16612     out->pNext = NULL;
16613     out->address = in->address;
16614     out->range = in->range;
16615     out->format = in->format;
16616     if (in->pNext)
16617         FIXME("Unexpected pNext\n");
16618 }
16619
16620 static inline const VkDescriptorAddressInfoEXT *convert_VkDescriptorAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorAddressInfoEXT32 *in, uint32_t count)
16621 {
16622     VkDescriptorAddressInfoEXT *out;
16623     unsigned int i;
16624
16625     if (!in || !count) return NULL;
16626
16627     out = conversion_context_alloc(ctx, count * sizeof(*out));
16628     for (i = 0; i < count; i++)
16629     {
16630         convert_VkDescriptorAddressInfoEXT_win32_to_host(&in[i], &out[i]);
16631     }
16632
16633     return out;
16634 }
16635
16636 static inline void convert_VkDescriptorDataEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorDataEXT32 *in, VkDescriptorDataEXT *out, VkFlags selector)
16637 {
16638     if (!in) return;
16639
16640     if (selector == VK_DESCRIPTOR_TYPE_SAMPLER)
16641         out->pSampler = (const VkSampler *)UlongToPtr(in->pSampler);
16642     if (selector == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
16643         out->pCombinedImageSampler = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pCombinedImageSampler), 1);
16644     if (selector == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
16645         out->pInputAttachmentImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pInputAttachmentImage), 1);
16646     if (selector == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE)
16647         out->pSampledImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pSampledImage), 1);
16648     if (selector == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
16649         out->pStorageImage = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pStorageImage), 1);
16650     if (selector == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER)
16651         out->pUniformTexelBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pUniformTexelBuffer), 1);
16652     if (selector == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)
16653         out->pStorageTexelBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pStorageTexelBuffer), 1);
16654     if (selector == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER)
16655         out->pUniformBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pUniformBuffer), 1);
16656     if (selector == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
16657         out->pStorageBuffer = convert_VkDescriptorAddressInfoEXT_array_win32_to_host(ctx, (const VkDescriptorAddressInfoEXT32 *)UlongToPtr(in->pStorageBuffer), 1);
16658     if (selector == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR || selector == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV)
16659         out->accelerationStructure = in->accelerationStructure;
16660 }
16661
16662 static inline void convert_VkDescriptorGetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorGetInfoEXT32 *in, VkDescriptorGetInfoEXT *out)
16663 {
16664     if (!in) return;
16665
16666     out->sType = in->sType;
16667     out->pNext = NULL;
16668     out->type = in->type;
16669     convert_VkDescriptorDataEXT_win32_to_host(ctx, &in->data, &out->data, in->type);
16670     if (in->pNext)
16671         FIXME("Unexpected pNext\n");
16672 }
16673
16674 static inline void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(const VkDescriptorSetBindingReferenceVALVE32 *in, VkDescriptorSetBindingReferenceVALVE *out)
16675 {
16676     if (!in) return;
16677
16678     out->sType = in->sType;
16679     out->pNext = NULL;
16680     out->descriptorSetLayout = in->descriptorSetLayout;
16681     out->binding = in->binding;
16682     if (in->pNext)
16683         FIXME("Unexpected pNext\n");
16684 }
16685
16686 static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host(const VkDescriptorSetLayoutHostMappingInfoVALVE32 *in, VkDescriptorSetLayoutHostMappingInfoVALVE *out)
16687 {
16688     if (!in) return;
16689
16690     out->sType = in->sType;
16691     out->pNext = NULL;
16692     out->descriptorOffset = in->descriptorOffset;
16693     out->descriptorSize = in->descriptorSize;
16694     if (in->pNext)
16695         FIXME("Unexpected pNext\n");
16696 }
16697
16698 static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(const VkDescriptorSetLayoutHostMappingInfoVALVE *in, VkDescriptorSetLayoutHostMappingInfoVALVE32 *out)
16699 {
16700     if (!in) return;
16701
16702     out->descriptorOffset = in->descriptorOffset;
16703     out->descriptorSize = in->descriptorSize;
16704 }
16705
16706 static inline void convert_VkDescriptorSetLayoutSupport_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutSupport32 *in, VkDescriptorSetLayoutSupport *out)
16707 {
16708     const VkBaseInStructure32 *in_header;
16709     VkBaseOutStructure *out_header = (void *)out;
16710
16711     if (!in) return;
16712
16713     out->sType = in->sType;
16714     out->pNext = NULL;
16715
16716     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
16717     {
16718         switch (in_header->sType)
16719         {
16720         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
16721         {
16722             VkDescriptorSetVariableDescriptorCountLayoutSupport *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
16723             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
16724             out_ext->pNext = NULL;
16725             out_header->pNext = (void *)out_ext;
16726             out_header = (void *)out_ext;
16727             break;
16728         }
16729         default:
16730             FIXME("Unhandled sType %u.", in_header->sType);
16731             break;
16732         }
16733     }
16734 }
16735
16736 static inline void convert_VkDescriptorSetLayoutSupport_host_to_win32(const VkDescriptorSetLayoutSupport *in, VkDescriptorSetLayoutSupport32 *out)
16737 {
16738     const VkBaseInStructure *in_header;
16739     VkBaseOutStructure32 *out_header = (void *)out;
16740
16741     if (!in) return;
16742
16743     out->supported = in->supported;
16744
16745     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
16746     {
16747         switch (in_header->sType)
16748         {
16749         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
16750         {
16751             VkDescriptorSetVariableDescriptorCountLayoutSupport32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT);
16752             const VkDescriptorSetVariableDescriptorCountLayoutSupport *in_ext = (const VkDescriptorSetVariableDescriptorCountLayoutSupport *)in_header;
16753             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
16754             out_ext->maxVariableDescriptorCount = in_ext->maxVariableDescriptorCount;
16755             out_header = (void *)out_ext;
16756             break;
16757         }
16758         default:
16759             break;
16760         }
16761     }
16762 }
16763
16764 static inline void convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(const VkAccelerationStructureVersionInfoKHR32 *in, VkAccelerationStructureVersionInfoKHR *out)
16765 {
16766     if (!in) return;
16767
16768     out->sType = in->sType;
16769     out->pNext = NULL;
16770     out->pVersionData = (const uint8_t *)UlongToPtr(in->pVersionData);
16771     if (in->pNext)
16772         FIXME("Unexpected pNext\n");
16773 }
16774
16775 static inline const VkBufferCreateInfo *convert_VkBufferCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, uint32_t count)
16776 {
16777     VkBufferCreateInfo *out;
16778     unsigned int i;
16779
16780     if (!in || !count) return NULL;
16781
16782     out = conversion_context_alloc(ctx, count * sizeof(*out));
16783     for (i = 0; i < count; i++)
16784     {
16785         convert_VkBufferCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
16786     }
16787
16788     return out;
16789 }
16790
16791 static inline void convert_VkDeviceBufferMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceBufferMemoryRequirements32 *in, VkDeviceBufferMemoryRequirements *out)
16792 {
16793     if (!in) return;
16794
16795     out->sType = in->sType;
16796     out->pNext = NULL;
16797     out->pCreateInfo = convert_VkBufferCreateInfo_array_win32_to_host(ctx, (const VkBufferCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1);
16798     if (in->pNext)
16799         FIXME("Unexpected pNext\n");
16800 }
16801
16802 static inline void convert_VkDeviceFaultCountsEXT_win32_to_host(const VkDeviceFaultCountsEXT32 *in, VkDeviceFaultCountsEXT *out)
16803 {
16804     if (!in) return;
16805
16806     out->sType = in->sType;
16807     out->pNext = NULL;
16808     out->addressInfoCount = in->addressInfoCount;
16809     out->vendorInfoCount = in->vendorInfoCount;
16810     out->vendorBinarySize = in->vendorBinarySize;
16811     if (in->pNext)
16812         FIXME("Unexpected pNext\n");
16813 }
16814
16815 static inline void convert_VkDeviceFaultCountsEXT_host_to_win32(const VkDeviceFaultCountsEXT *in, VkDeviceFaultCountsEXT32 *out)
16816 {
16817     if (!in) return;
16818
16819     out->addressInfoCount = in->addressInfoCount;
16820     out->vendorInfoCount = in->vendorInfoCount;
16821     out->vendorBinarySize = in->vendorBinarySize;
16822 }
16823
16824 static inline void convert_VkDeviceFaultAddressInfoEXT_win32_to_host(const VkDeviceFaultAddressInfoEXT32 *in, VkDeviceFaultAddressInfoEXT *out)
16825 {
16826     if (!in) return;
16827
16828     out->addressType = in->addressType;
16829     out->reportedAddress = in->reportedAddress;
16830     out->addressPrecision = in->addressPrecision;
16831 }
16832
16833 static inline void convert_VkDeviceFaultAddressInfoEXT_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out)
16834 {
16835     if (!in) return;
16836
16837     out->addressType = in->addressType;
16838     out->reportedAddress = in->reportedAddress;
16839     out->addressPrecision = in->addressPrecision;
16840 }
16841
16842 static inline VkDeviceFaultAddressInfoEXT *convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultAddressInfoEXT32 *in, uint32_t count)
16843 {
16844     VkDeviceFaultAddressInfoEXT *out;
16845     unsigned int i;
16846
16847     if (!in || !count) return NULL;
16848
16849     out = conversion_context_alloc(ctx, count * sizeof(*out));
16850     for (i = 0; i < count; i++)
16851     {
16852         convert_VkDeviceFaultAddressInfoEXT_win32_to_host(&in[i], &out[i]);
16853     }
16854
16855     return out;
16856 }
16857
16858 static inline void convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out, uint32_t count)
16859 {
16860     unsigned int i;
16861
16862     if (!in) return;
16863
16864     for (i = 0; i < count; i++)
16865     {
16866         convert_VkDeviceFaultAddressInfoEXT_host_to_win32(&in[i], &out[i]);
16867     }
16868 }
16869
16870 static inline void convert_VkDeviceFaultVendorInfoEXT_win32_to_host(const VkDeviceFaultVendorInfoEXT32 *in, VkDeviceFaultVendorInfoEXT *out)
16871 {
16872     if (!in) return;
16873
16874     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
16875     out->vendorFaultCode = in->vendorFaultCode;
16876     out->vendorFaultData = in->vendorFaultData;
16877 }
16878
16879 static inline void convert_VkDeviceFaultVendorInfoEXT_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out)
16880 {
16881     if (!in) return;
16882
16883     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
16884     out->vendorFaultCode = in->vendorFaultCode;
16885     out->vendorFaultData = in->vendorFaultData;
16886 }
16887
16888 static inline VkDeviceFaultVendorInfoEXT *convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultVendorInfoEXT32 *in, uint32_t count)
16889 {
16890     VkDeviceFaultVendorInfoEXT *out;
16891     unsigned int i;
16892
16893     if (!in || !count) return NULL;
16894
16895     out = conversion_context_alloc(ctx, count * sizeof(*out));
16896     for (i = 0; i < count; i++)
16897     {
16898         convert_VkDeviceFaultVendorInfoEXT_win32_to_host(&in[i], &out[i]);
16899     }
16900
16901     return out;
16902 }
16903
16904 static inline void convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out, uint32_t count)
16905 {
16906     unsigned int i;
16907
16908     if (!in) return;
16909
16910     for (i = 0; i < count; i++)
16911     {
16912         convert_VkDeviceFaultVendorInfoEXT_host_to_win32(&in[i], &out[i]);
16913     }
16914 }
16915
16916 static inline void convert_VkDeviceFaultInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultInfoEXT32 *in, VkDeviceFaultInfoEXT *out)
16917 {
16918     if (!in) return;
16919
16920     out->sType = in->sType;
16921     out->pNext = NULL;
16922     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
16923     out->pAddressInfos = convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(in->pAddressInfos), 1);
16924     out->pVendorInfos = convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(in->pVendorInfos), 1);
16925     out->pVendorBinaryData = (void *)UlongToPtr(in->pVendorBinaryData);
16926     if (in->pNext)
16927         FIXME("Unexpected pNext\n");
16928 }
16929
16930 static inline void convert_VkDeviceFaultInfoEXT_host_to_win32(const VkDeviceFaultInfoEXT *in, VkDeviceFaultInfoEXT32 *out)
16931 {
16932     if (!in) return;
16933
16934     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
16935     convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(in->pAddressInfos, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(out->pAddressInfos), 1);
16936     convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(in->pVendorInfos, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(out->pVendorInfos), 1);
16937     out->pVendorBinaryData = PtrToUlong(in->pVendorBinaryData);
16938 }
16939
16940 static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host(const VkDeviceGroupPresentCapabilitiesKHR32 *in, VkDeviceGroupPresentCapabilitiesKHR *out)
16941 {
16942     if (!in) return;
16943
16944     out->sType = in->sType;
16945     out->pNext = NULL;
16946     if (in->pNext)
16947         FIXME("Unexpected pNext\n");
16948 }
16949
16950 static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(const VkDeviceGroupPresentCapabilitiesKHR *in, VkDeviceGroupPresentCapabilitiesKHR32 *out)
16951 {
16952     if (!in) return;
16953
16954     memcpy(out->presentMask, in->presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
16955     out->modes = in->modes;
16956 }
16957
16958 static inline const VkImageCreateInfo *convert_VkImageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, uint32_t count)
16959 {
16960     VkImageCreateInfo *out;
16961     unsigned int i;
16962
16963     if (!in || !count) return NULL;
16964
16965     out = conversion_context_alloc(ctx, count * sizeof(*out));
16966     for (i = 0; i < count; i++)
16967     {
16968         convert_VkImageCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
16969     }
16970
16971     return out;
16972 }
16973
16974 static inline void convert_VkDeviceImageMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceImageMemoryRequirements32 *in, VkDeviceImageMemoryRequirements *out)
16975 {
16976     if (!in) return;
16977
16978     out->sType = in->sType;
16979     out->pNext = NULL;
16980     out->pCreateInfo = convert_VkImageCreateInfo_array_win32_to_host(ctx, (const VkImageCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1);
16981     out->planeAspect = in->planeAspect;
16982     if (in->pNext)
16983         FIXME("Unexpected pNext\n");
16984 }
16985
16986 static inline void convert_VkSparseImageMemoryRequirements_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out)
16987 {
16988     if (!in) return;
16989
16990     out->formatProperties = in->formatProperties;
16991     out->imageMipTailFirstLod = in->imageMipTailFirstLod;
16992     out->imageMipTailSize = in->imageMipTailSize;
16993     out->imageMipTailOffset = in->imageMipTailOffset;
16994     out->imageMipTailStride = in->imageMipTailStride;
16995 }
16996
16997 static inline void convert_VkSparseImageMemoryRequirements2_win32_to_host(const VkSparseImageMemoryRequirements232 *in, VkSparseImageMemoryRequirements2 *out)
16998 {
16999     if (!in) return;
17000
17001     out->sType = in->sType;
17002     out->pNext = NULL;
17003     if (in->pNext)
17004         FIXME("Unexpected pNext\n");
17005 }
17006
17007 static inline void convert_VkSparseImageMemoryRequirements2_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out)
17008 {
17009     if (!in) return;
17010
17011     convert_VkSparseImageMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
17012 }
17013
17014 static inline VkSparseImageMemoryRequirements2 *convert_VkSparseImageMemoryRequirements2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryRequirements232 *in, uint32_t count)
17015 {
17016     VkSparseImageMemoryRequirements2 *out;
17017     unsigned int i;
17018
17019     if (!in || !count) return NULL;
17020
17021     out = conversion_context_alloc(ctx, count * sizeof(*out));
17022     for (i = 0; i < count; i++)
17023     {
17024         convert_VkSparseImageMemoryRequirements2_win32_to_host(&in[i], &out[i]);
17025     }
17026
17027     return out;
17028 }
17029
17030 static inline void convert_VkSparseImageMemoryRequirements2_array_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out, uint32_t count)
17031 {
17032     unsigned int i;
17033
17034     if (!in) return;
17035
17036     for (i = 0; i < count; i++)
17037     {
17038         convert_VkSparseImageMemoryRequirements2_host_to_win32(&in[i], &out[i]);
17039     }
17040 }
17041
17042 static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo32 *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out)
17043 {
17044     if (!in) return;
17045
17046     out->sType = in->sType;
17047     out->pNext = NULL;
17048     out->memory = in->memory;
17049     if (in->pNext)
17050         FIXME("Unexpected pNext\n");
17051 }
17052
17053 static inline void convert_VkMicromapVersionInfoEXT_win32_to_host(const VkMicromapVersionInfoEXT32 *in, VkMicromapVersionInfoEXT *out)
17054 {
17055     if (!in) return;
17056
17057     out->sType = in->sType;
17058     out->pNext = NULL;
17059     out->pVersionData = (const uint8_t *)UlongToPtr(in->pVersionData);
17060     if (in->pNext)
17061         FIXME("Unexpected pNext\n");
17062 }
17063
17064 static inline void convert_VkDeviceQueueInfo2_win32_to_host(const VkDeviceQueueInfo232 *in, VkDeviceQueueInfo2 *out)
17065 {
17066     if (!in) return;
17067
17068     out->sType = in->sType;
17069     out->pNext = NULL;
17070     out->flags = in->flags;
17071     out->queueFamilyIndex = in->queueFamilyIndex;
17072     out->queueIndex = in->queueIndex;
17073     if (in->pNext)
17074         FIXME("Unexpected pNext\n");
17075 }
17076
17077 static inline void convert_VkTilePropertiesQCOM_win32_to_host(const VkTilePropertiesQCOM32 *in, VkTilePropertiesQCOM *out)
17078 {
17079     if (!in) return;
17080
17081     out->sType = in->sType;
17082     out->pNext = NULL;
17083     out->tileSize = in->tileSize;
17084     out->apronSize = in->apronSize;
17085     out->origin = in->origin;
17086     if (in->pNext)
17087         FIXME("Unexpected pNext\n");
17088 }
17089
17090 static inline void convert_VkTilePropertiesQCOM_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out)
17091 {
17092     if (!in) return;
17093
17094     out->tileSize = in->tileSize;
17095     out->apronSize = in->apronSize;
17096     out->origin = in->origin;
17097 }
17098
17099 static inline VkTilePropertiesQCOM *convert_VkTilePropertiesQCOM_array_win32_to_host(struct conversion_context *ctx, const VkTilePropertiesQCOM32 *in, uint32_t count)
17100 {
17101     VkTilePropertiesQCOM *out;
17102     unsigned int i;
17103
17104     if (!in || !count) return NULL;
17105
17106     out = conversion_context_alloc(ctx, count * sizeof(*out));
17107     for (i = 0; i < count; i++)
17108     {
17109         convert_VkTilePropertiesQCOM_win32_to_host(&in[i], &out[i]);
17110     }
17111
17112     return out;
17113 }
17114
17115 static inline void convert_VkTilePropertiesQCOM_array_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out, uint32_t count)
17116 {
17117     unsigned int i;
17118
17119     if (!in) return;
17120
17121     for (i = 0; i < count; i++)
17122     {
17123         convert_VkTilePropertiesQCOM_host_to_win32(&in[i], &out[i]);
17124     }
17125 }
17126
17127 static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV32 *in, VkGeneratedCommandsMemoryRequirementsInfoNV *out)
17128 {
17129     if (!in) return;
17130
17131     out->sType = in->sType;
17132     out->pNext = NULL;
17133     out->pipelineBindPoint = in->pipelineBindPoint;
17134     out->pipeline = in->pipeline;
17135     out->indirectCommandsLayout = in->indirectCommandsLayout;
17136     out->maxSequencesCount = in->maxSequencesCount;
17137     if (in->pNext)
17138         FIXME("Unexpected pNext\n");
17139 }
17140
17141 static inline void convert_VkImageMemoryRequirementsInfo2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryRequirementsInfo232 *in, VkImageMemoryRequirementsInfo2 *out)
17142 {
17143     const VkBaseInStructure32 *in_header;
17144     VkBaseOutStructure *out_header = (void *)out;
17145
17146     if (!in) return;
17147
17148     out->sType = in->sType;
17149     out->pNext = NULL;
17150     out->image = in->image;
17151
17152     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17153     {
17154         switch (in_header->sType)
17155         {
17156         case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
17157         {
17158             VkImagePlaneMemoryRequirementsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17159             const VkImagePlaneMemoryRequirementsInfo32 *in_ext = (const VkImagePlaneMemoryRequirementsInfo32 *)in_header;
17160             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
17161             out_ext->pNext = NULL;
17162             out_ext->planeAspect = in_ext->planeAspect;
17163             out_header->pNext = (void *)out_ext;
17164             out_header = (void *)out_ext;
17165             break;
17166         }
17167         default:
17168             FIXME("Unhandled sType %u.", in_header->sType);
17169             break;
17170         }
17171     }
17172 }
17173
17174 static inline void convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageCaptureDescriptorDataInfoEXT32 *in, VkImageCaptureDescriptorDataInfoEXT *out)
17175 {
17176     if (!in) return;
17177
17178     out->sType = in->sType;
17179     out->pNext = NULL;
17180     out->image = in->image;
17181     if (in->pNext)
17182         FIXME("Unexpected pNext\n");
17183 }
17184
17185 static inline void convert_VkSparseImageMemoryRequirements_array_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out, uint32_t count)
17186 {
17187     unsigned int i;
17188
17189     if (!in) return;
17190
17191     for (i = 0; i < count; i++)
17192     {
17193         convert_VkSparseImageMemoryRequirements_host_to_win32(&in[i], &out[i]);
17194     }
17195 }
17196
17197 static inline void convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(const VkImageSparseMemoryRequirementsInfo232 *in, VkImageSparseMemoryRequirementsInfo2 *out)
17198 {
17199     if (!in) return;
17200
17201     out->sType = in->sType;
17202     out->pNext = NULL;
17203     out->image = in->image;
17204     if (in->pNext)
17205         FIXME("Unexpected pNext\n");
17206 }
17207
17208 static inline void convert_VkSubresourceLayout_host_to_win32(const VkSubresourceLayout *in, VkSubresourceLayout32 *out)
17209 {
17210     if (!in) return;
17211
17212     out->offset = in->offset;
17213     out->size = in->size;
17214     out->rowPitch = in->rowPitch;
17215     out->arrayPitch = in->arrayPitch;
17216     out->depthPitch = in->depthPitch;
17217 }
17218
17219 static inline void convert_VkImageSubresource2EXT_win32_to_host(const VkImageSubresource2EXT32 *in, VkImageSubresource2EXT *out)
17220 {
17221     if (!in) return;
17222
17223     out->sType = in->sType;
17224     out->pNext = NULL;
17225     out->imageSubresource = in->imageSubresource;
17226     if (in->pNext)
17227         FIXME("Unexpected pNext\n");
17228 }
17229
17230 static inline void convert_VkSubresourceLayout2EXT_win32_to_host(struct conversion_context *ctx, const VkSubresourceLayout2EXT32 *in, VkSubresourceLayout2EXT *out)
17231 {
17232     const VkBaseInStructure32 *in_header;
17233     VkBaseOutStructure *out_header = (void *)out;
17234
17235     if (!in) return;
17236
17237     out->sType = in->sType;
17238     out->pNext = NULL;
17239
17240     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17241     {
17242         switch (in_header->sType)
17243         {
17244         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
17245         {
17246             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17247             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
17248             out_ext->pNext = NULL;
17249             out_header->pNext = (void *)out_ext;
17250             out_header = (void *)out_ext;
17251             break;
17252         }
17253         default:
17254             FIXME("Unhandled sType %u.", in_header->sType);
17255             break;
17256         }
17257     }
17258 }
17259
17260 static inline void convert_VkSubresourceLayout2EXT_host_to_win32(const VkSubresourceLayout2EXT *in, VkSubresourceLayout2EXT32 *out)
17261 {
17262     const VkBaseInStructure *in_header;
17263     VkBaseOutStructure32 *out_header = (void *)out;
17264
17265     if (!in) return;
17266
17267     convert_VkSubresourceLayout_host_to_win32(&in->subresourceLayout, &out->subresourceLayout);
17268
17269     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
17270     {
17271         switch (in_header->sType)
17272         {
17273         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
17274         {
17275             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
17276             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
17277             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
17278             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
17279             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
17280             out_header = (void *)out_ext;
17281             break;
17282         }
17283         default:
17284             break;
17285         }
17286     }
17287 }
17288
17289 static inline void convert_VkImageViewAddressPropertiesNVX_win32_to_host(const VkImageViewAddressPropertiesNVX32 *in, VkImageViewAddressPropertiesNVX *out)
17290 {
17291     if (!in) return;
17292
17293     out->sType = in->sType;
17294     out->pNext = NULL;
17295     if (in->pNext)
17296         FIXME("Unexpected pNext\n");
17297 }
17298
17299 static inline void convert_VkImageViewAddressPropertiesNVX_host_to_win32(const VkImageViewAddressPropertiesNVX *in, VkImageViewAddressPropertiesNVX32 *out)
17300 {
17301     if (!in) return;
17302
17303     out->deviceAddress = in->deviceAddress;
17304     out->size = in->size;
17305 }
17306
17307 static inline void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageViewHandleInfoNVX32 *in, VkImageViewHandleInfoNVX *out)
17308 {
17309     if (!in) return;
17310
17311     out->sType = in->sType;
17312     out->pNext = NULL;
17313     out->imageView = in->imageView;
17314     out->descriptorType = in->descriptorType;
17315     out->sampler = in->sampler;
17316     if (in->pNext)
17317         FIXME("Unexpected pNext\n");
17318 }
17319
17320 static inline void convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageViewCaptureDescriptorDataInfoEXT32 *in, VkImageViewCaptureDescriptorDataInfoEXT *out)
17321 {
17322     if (!in) return;
17323
17324     out->sType = in->sType;
17325     out->pNext = NULL;
17326     out->imageView = in->imageView;
17327     if (in->pNext)
17328         FIXME("Unexpected pNext\n");
17329 }
17330
17331 static inline void convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(const VkMemoryHostPointerPropertiesEXT32 *in, VkMemoryHostPointerPropertiesEXT *out)
17332 {
17333     if (!in) return;
17334
17335     out->sType = in->sType;
17336     out->pNext = NULL;
17337     if (in->pNext)
17338         FIXME("Unexpected pNext\n");
17339 }
17340
17341 static inline void convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(const VkMemoryHostPointerPropertiesEXT *in, VkMemoryHostPointerPropertiesEXT32 *out)
17342 {
17343     if (!in) return;
17344
17345     out->memoryTypeBits = in->memoryTypeBits;
17346 }
17347
17348 static inline void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMicromapBuildSizesInfoEXT32 *in, VkMicromapBuildSizesInfoEXT *out)
17349 {
17350     if (!in) return;
17351
17352     out->sType = in->sType;
17353     out->pNext = NULL;
17354     out->micromapSize = in->micromapSize;
17355     out->buildScratchSize = in->buildScratchSize;
17356     out->discardable = in->discardable;
17357     if (in->pNext)
17358         FIXME("Unexpected pNext\n");
17359 }
17360
17361 static inline void convert_VkMicromapBuildSizesInfoEXT_host_to_win32(const VkMicromapBuildSizesInfoEXT *in, VkMicromapBuildSizesInfoEXT32 *out)
17362 {
17363     if (!in) return;
17364
17365     out->micromapSize = in->micromapSize;
17366     out->buildScratchSize = in->buildScratchSize;
17367     out->discardable = in->discardable;
17368 }
17369
17370 static inline void convert_VkPerformanceValueDataINTEL_win32_to_host(const VkPerformanceValueDataINTEL32 *in, VkPerformanceValueDataINTEL *out, VkFlags selector)
17371 {
17372     if (!in) return;
17373
17374     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL)
17375         out->value32 = in->value32;
17376     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL)
17377         out->value64 = in->value64;
17378     if (selector == VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL)
17379         out->valueFloat = in->valueFloat;
17380     if (selector == VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL)
17381         out->valueBool = in->valueBool;
17382     if (selector == VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL)
17383         out->valueString = (const char *)UlongToPtr(in->valueString);
17384 }
17385
17386 static inline void convert_VkPerformanceValueDataINTEL_host_to_win32(const VkPerformanceValueDataINTEL *in, VkPerformanceValueDataINTEL32 *out, VkFlags selector)
17387 {
17388     if (!in) return;
17389
17390     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL)
17391         out->value32 = in->value32;
17392     if (selector == VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL)
17393         out->value64 = in->value64;
17394     if (selector == VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL)
17395         out->valueFloat = in->valueFloat;
17396     if (selector == VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL)
17397         out->valueBool = in->valueBool;
17398 }
17399
17400 static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerformanceValueINTEL *in, VkPerformanceValueINTEL32 *out)
17401 {
17402     if (!in) return;
17403
17404     out->type = in->type;
17405     convert_VkPerformanceValueDataINTEL_host_to_win32(&in->data, &out->data, in->type);
17406 }
17407
17408 static inline void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const VkCooperativeMatrixPropertiesNV32 *in, VkCooperativeMatrixPropertiesNV *out)
17409 {
17410     if (!in) return;
17411
17412     out->sType = in->sType;
17413     out->pNext = NULL;
17414     if (in->pNext)
17415         FIXME("Unexpected pNext\n");
17416 }
17417
17418 static inline void convert_VkCooperativeMatrixPropertiesNV_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out)
17419 {
17420     if (!in) return;
17421
17422     out->MSize = in->MSize;
17423     out->NSize = in->NSize;
17424     out->KSize = in->KSize;
17425     out->AType = in->AType;
17426     out->BType = in->BType;
17427     out->CType = in->CType;
17428     out->DType = in->DType;
17429     out->scope = in->scope;
17430 }
17431
17432 static inline VkCooperativeMatrixPropertiesNV *convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesNV32 *in, uint32_t count)
17433 {
17434     VkCooperativeMatrixPropertiesNV *out;
17435     unsigned int i;
17436
17437     if (!in || !count) return NULL;
17438
17439     out = conversion_context_alloc(ctx, count * sizeof(*out));
17440     for (i = 0; i < count; i++)
17441     {
17442         convert_VkCooperativeMatrixPropertiesNV_win32_to_host(&in[i], &out[i]);
17443     }
17444
17445     return out;
17446 }
17447
17448 static inline void convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out, uint32_t count)
17449 {
17450     unsigned int i;
17451
17452     if (!in) return;
17453
17454     for (i = 0; i < count; i++)
17455     {
17456         convert_VkCooperativeMatrixPropertiesNV_host_to_win32(&in[i], &out[i]);
17457     }
17458 }
17459
17460 static inline void convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(const VkPhysicalDeviceExternalBufferInfo32 *in, VkPhysicalDeviceExternalBufferInfo *out)
17461 {
17462     if (!in) return;
17463
17464     out->sType = in->sType;
17465     out->pNext = NULL;
17466     out->flags = in->flags;
17467     out->usage = in->usage;
17468     out->handleType = in->handleType;
17469     if (in->pNext)
17470         FIXME("Unexpected pNext\n");
17471 }
17472
17473 static inline void convert_VkExternalBufferProperties_win32_to_host(const VkExternalBufferProperties32 *in, VkExternalBufferProperties *out)
17474 {
17475     if (!in) return;
17476
17477     out->sType = in->sType;
17478     out->pNext = NULL;
17479     if (in->pNext)
17480         FIXME("Unexpected pNext\n");
17481 }
17482
17483 static inline void convert_VkExternalBufferProperties_host_to_win32(const VkExternalBufferProperties *in, VkExternalBufferProperties32 *out)
17484 {
17485     if (!in) return;
17486
17487     out->externalMemoryProperties = in->externalMemoryProperties;
17488 }
17489
17490 static inline void convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(const VkPhysicalDeviceExternalFenceInfo32 *in, VkPhysicalDeviceExternalFenceInfo *out)
17491 {
17492     if (!in) return;
17493
17494     out->sType = in->sType;
17495     out->pNext = NULL;
17496     out->handleType = in->handleType;
17497     if (in->pNext)
17498         FIXME("Unexpected pNext\n");
17499 }
17500
17501 static inline void convert_VkExternalFenceProperties_win32_to_host(const VkExternalFenceProperties32 *in, VkExternalFenceProperties *out)
17502 {
17503     if (!in) return;
17504
17505     out->sType = in->sType;
17506     out->pNext = NULL;
17507     if (in->pNext)
17508         FIXME("Unexpected pNext\n");
17509 }
17510
17511 static inline void convert_VkExternalFenceProperties_host_to_win32(const VkExternalFenceProperties *in, VkExternalFenceProperties32 *out)
17512 {
17513     if (!in) return;
17514
17515     out->exportFromImportedHandleTypes = in->exportFromImportedHandleTypes;
17516     out->compatibleHandleTypes = in->compatibleHandleTypes;
17517     out->externalFenceFeatures = in->externalFenceFeatures;
17518 }
17519
17520 static inline void convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalSemaphoreInfo32 *in, VkPhysicalDeviceExternalSemaphoreInfo *out)
17521 {
17522     const VkBaseInStructure32 *in_header;
17523     VkBaseOutStructure *out_header = (void *)out;
17524
17525     if (!in) return;
17526
17527     out->sType = in->sType;
17528     out->pNext = NULL;
17529     out->handleType = in->handleType;
17530
17531     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17532     {
17533         switch (in_header->sType)
17534         {
17535         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
17536         {
17537             VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17538             const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header;
17539             out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
17540             out_ext->pNext = NULL;
17541             out_ext->semaphoreType = in_ext->semaphoreType;
17542             out_ext->initialValue = in_ext->initialValue;
17543             out_header->pNext = (void *)out_ext;
17544             out_header = (void *)out_ext;
17545             break;
17546         }
17547         default:
17548             FIXME("Unhandled sType %u.", in_header->sType);
17549             break;
17550         }
17551     }
17552 }
17553
17554 static inline void convert_VkExternalSemaphoreProperties_win32_to_host(const VkExternalSemaphoreProperties32 *in, VkExternalSemaphoreProperties *out)
17555 {
17556     if (!in) return;
17557
17558     out->sType = in->sType;
17559     out->pNext = NULL;
17560     if (in->pNext)
17561         FIXME("Unexpected pNext\n");
17562 }
17563
17564 static inline void convert_VkExternalSemaphoreProperties_host_to_win32(const VkExternalSemaphoreProperties *in, VkExternalSemaphoreProperties32 *out)
17565 {
17566     if (!in) return;
17567
17568     out->exportFromImportedHandleTypes = in->exportFromImportedHandleTypes;
17569     out->compatibleHandleTypes = in->compatibleHandleTypes;
17570     out->externalSemaphoreFeatures = in->externalSemaphoreFeatures;
17571 }
17572
17573 static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFeatures232 *in, VkPhysicalDeviceFeatures2 *out)
17574 {
17575     const VkBaseInStructure32 *in_header;
17576     VkBaseOutStructure *out_header = (void *)out;
17577
17578     if (!in) return;
17579
17580     out->sType = in->sType;
17581     out->pNext = NULL;
17582     out->features = in->features;
17583
17584     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
17585     {
17586         switch (in_header->sType)
17587         {
17588         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
17589         {
17590             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17591             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header;
17592             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
17593             out_ext->pNext = NULL;
17594             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
17595             out_header->pNext = (void *)out_ext;
17596             out_header = (void *)out_ext;
17597             break;
17598         }
17599         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
17600         {
17601             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17602             const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header;
17603             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
17604             out_ext->pNext = NULL;
17605             out_ext->privateData = in_ext->privateData;
17606             out_header->pNext = (void *)out_ext;
17607             out_header = (void *)out_ext;
17608             break;
17609         }
17610         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
17611         {
17612             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17613             const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header;
17614             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
17615             out_ext->pNext = NULL;
17616             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
17617             out_ext->variablePointers = in_ext->variablePointers;
17618             out_header->pNext = (void *)out_ext;
17619             out_header = (void *)out_ext;
17620             break;
17621         }
17622         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
17623         {
17624             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17625             const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header;
17626             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
17627             out_ext->pNext = NULL;
17628             out_ext->multiview = in_ext->multiview;
17629             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
17630             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
17631             out_header->pNext = (void *)out_ext;
17632             out_header = (void *)out_ext;
17633             break;
17634         }
17635         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
17636         {
17637             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17638             const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header;
17639             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
17640             out_ext->pNext = NULL;
17641             out_ext->presentId = in_ext->presentId;
17642             out_header->pNext = (void *)out_ext;
17643             out_header = (void *)out_ext;
17644             break;
17645         }
17646         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
17647         {
17648             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17649             const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header;
17650             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
17651             out_ext->pNext = NULL;
17652             out_ext->presentWait = in_ext->presentWait;
17653             out_header->pNext = (void *)out_ext;
17654             out_header = (void *)out_ext;
17655             break;
17656         }
17657         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
17658         {
17659             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17660             const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header;
17661             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
17662             out_ext->pNext = NULL;
17663             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
17664             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
17665             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
17666             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
17667             out_header->pNext = (void *)out_ext;
17668             out_header = (void *)out_ext;
17669             break;
17670         }
17671         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
17672         {
17673             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17674             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header;
17675             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
17676             out_ext->pNext = NULL;
17677             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
17678             out_header->pNext = (void *)out_ext;
17679             out_header = (void *)out_ext;
17680             break;
17681         }
17682         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
17683         {
17684             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17685             const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header;
17686             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
17687             out_ext->pNext = NULL;
17688             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
17689             out_header->pNext = (void *)out_ext;
17690             out_header = (void *)out_ext;
17691             break;
17692         }
17693         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
17694         {
17695             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17696             const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header;
17697             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
17698             out_ext->pNext = NULL;
17699             out_ext->protectedMemory = in_ext->protectedMemory;
17700             out_header->pNext = (void *)out_ext;
17701             out_header = (void *)out_ext;
17702             break;
17703         }
17704         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
17705         {
17706             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17707             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *)in_header;
17708             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
17709             out_ext->pNext = NULL;
17710             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
17711             out_header->pNext = (void *)out_ext;
17712             out_header = (void *)out_ext;
17713             break;
17714         }
17715         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
17716         {
17717             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17718             const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header;
17719             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
17720             out_ext->pNext = NULL;
17721             out_ext->multiDraw = in_ext->multiDraw;
17722             out_header->pNext = (void *)out_ext;
17723             out_header = (void *)out_ext;
17724             break;
17725         }
17726         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
17727         {
17728             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17729             const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header;
17730             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
17731             out_ext->pNext = NULL;
17732             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
17733             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
17734             out_header->pNext = (void *)out_ext;
17735             out_header = (void *)out_ext;
17736             break;
17737         }
17738         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
17739         {
17740             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17741             const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header;
17742             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
17743             out_ext->pNext = NULL;
17744             out_ext->maintenance4 = in_ext->maintenance4;
17745             out_header->pNext = (void *)out_ext;
17746             out_header = (void *)out_ext;
17747             break;
17748         }
17749         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
17750         {
17751             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17752             const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header;
17753             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
17754             out_ext->pNext = NULL;
17755             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
17756             out_header->pNext = (void *)out_ext;
17757             out_header = (void *)out_ext;
17758             break;
17759         }
17760         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
17761         {
17762             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17763             const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header;
17764             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
17765             out_ext->pNext = NULL;
17766             out_ext->shaderFloat16 = in_ext->shaderFloat16;
17767             out_ext->shaderInt8 = in_ext->shaderInt8;
17768             out_header->pNext = (void *)out_ext;
17769             out_header = (void *)out_ext;
17770             break;
17771         }
17772         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
17773         {
17774             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17775             const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header;
17776             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
17777             out_ext->pNext = NULL;
17778             out_ext->hostQueryReset = in_ext->hostQueryReset;
17779             out_header->pNext = (void *)out_ext;
17780             out_header = (void *)out_ext;
17781             break;
17782         }
17783         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
17784         {
17785             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17786             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *)in_header;
17787             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
17788             out_ext->pNext = NULL;
17789             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
17790             out_header->pNext = (void *)out_ext;
17791             out_header = (void *)out_ext;
17792             break;
17793         }
17794         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
17795         {
17796             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17797             const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header;
17798             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
17799             out_ext->pNext = NULL;
17800             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
17801             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
17802             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
17803             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
17804             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
17805             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
17806             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
17807             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
17808             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
17809             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
17810             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
17811             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
17812             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
17813             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
17814             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
17815             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
17816             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
17817             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
17818             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
17819             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
17820             out_header->pNext = (void *)out_ext;
17821             out_header = (void *)out_ext;
17822             break;
17823         }
17824         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
17825         {
17826             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17827             const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header;
17828             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
17829             out_ext->pNext = NULL;
17830             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
17831             out_header->pNext = (void *)out_ext;
17832             out_header = (void *)out_ext;
17833             break;
17834         }
17835         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
17836         {
17837             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17838             const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header;
17839             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
17840             out_ext->pNext = NULL;
17841             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
17842             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
17843             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
17844             out_header->pNext = (void *)out_ext;
17845             out_header = (void *)out_ext;
17846             break;
17847         }
17848         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
17849         {
17850             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17851             const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header;
17852             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
17853             out_ext->pNext = NULL;
17854             out_ext->conditionalRendering = in_ext->conditionalRendering;
17855             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
17856             out_header->pNext = (void *)out_ext;
17857             out_header = (void *)out_ext;
17858             break;
17859         }
17860         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
17861         {
17862             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17863             const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header;
17864             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
17865             out_ext->pNext = NULL;
17866             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
17867             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
17868             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
17869             out_header->pNext = (void *)out_ext;
17870             out_header = (void *)out_ext;
17871             break;
17872         }
17873         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
17874         {
17875             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17876             const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header;
17877             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
17878             out_ext->pNext = NULL;
17879             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
17880             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
17881             out_header->pNext = (void *)out_ext;
17882             out_header = (void *)out_ext;
17883             break;
17884         }
17885         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
17886         {
17887             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17888             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header;
17889             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
17890             out_ext->pNext = NULL;
17891             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
17892             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
17893             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
17894             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
17895             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
17896             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
17897             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
17898             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
17899             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
17900             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
17901             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
17902             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
17903             out_header->pNext = (void *)out_ext;
17904             out_header = (void *)out_ext;
17905             break;
17906         }
17907         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
17908         {
17909             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17910             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header;
17911             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
17912             out_ext->pNext = NULL;
17913             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
17914             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
17915             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
17916             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
17917             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
17918             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
17919             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
17920             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
17921             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
17922             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
17923             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
17924             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
17925             out_header->pNext = (void *)out_ext;
17926             out_header = (void *)out_ext;
17927             break;
17928         }
17929         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
17930         {
17931             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17932             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *)in_header;
17933             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
17934             out_ext->pNext = NULL;
17935             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
17936             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
17937             out_header->pNext = (void *)out_ext;
17938             out_header = (void *)out_ext;
17939             break;
17940         }
17941         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
17942         {
17943             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17944             const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header;
17945             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
17946             out_ext->pNext = NULL;
17947             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
17948             out_header->pNext = (void *)out_ext;
17949             out_header = (void *)out_ext;
17950             break;
17951         }
17952         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
17953         {
17954             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17955             const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header;
17956             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
17957             out_ext->pNext = NULL;
17958             out_ext->transformFeedback = in_ext->transformFeedback;
17959             out_ext->geometryStreams = in_ext->geometryStreams;
17960             out_header->pNext = (void *)out_ext;
17961             out_header = (void *)out_ext;
17962             break;
17963         }
17964         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
17965         {
17966             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17967             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header;
17968             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
17969             out_ext->pNext = NULL;
17970             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
17971             out_header->pNext = (void *)out_ext;
17972             out_header = (void *)out_ext;
17973             break;
17974         }
17975         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
17976         {
17977             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17978             const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header;
17979             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
17980             out_ext->pNext = NULL;
17981             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
17982             out_header->pNext = (void *)out_ext;
17983             out_header = (void *)out_ext;
17984             break;
17985         }
17986         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
17987         {
17988             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
17989             const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header;
17990             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
17991             out_ext->pNext = NULL;
17992             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
17993             out_header->pNext = (void *)out_ext;
17994             out_header = (void *)out_ext;
17995             break;
17996         }
17997         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
17998         {
17999             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18000             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *)in_header;
18001             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
18002             out_ext->pNext = NULL;
18003             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
18004             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
18005             out_header->pNext = (void *)out_ext;
18006             out_header = (void *)out_ext;
18007             break;
18008         }
18009         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
18010         {
18011             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18012             const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header;
18013             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
18014             out_ext->pNext = NULL;
18015             out_ext->imageFootprint = in_ext->imageFootprint;
18016             out_header->pNext = (void *)out_ext;
18017             out_header = (void *)out_ext;
18018             break;
18019         }
18020         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
18021         {
18022             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18023             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header;
18024             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
18025             out_ext->pNext = NULL;
18026             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
18027             out_header->pNext = (void *)out_ext;
18028             out_header = (void *)out_ext;
18029             break;
18030         }
18031         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
18032         {
18033             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18034             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header;
18035             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
18036             out_ext->pNext = NULL;
18037             out_ext->indirectCopy = in_ext->indirectCopy;
18038             out_header->pNext = (void *)out_ext;
18039             out_header = (void *)out_ext;
18040             break;
18041         }
18042         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
18043         {
18044             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18045             const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header;
18046             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
18047             out_ext->pNext = NULL;
18048             out_ext->memoryDecompression = in_ext->memoryDecompression;
18049             out_header->pNext = (void *)out_ext;
18050             out_header = (void *)out_ext;
18051             break;
18052         }
18053         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
18054         {
18055             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18056             const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header;
18057             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
18058             out_ext->pNext = NULL;
18059             out_ext->shadingRateImage = in_ext->shadingRateImage;
18060             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
18061             out_header->pNext = (void *)out_ext;
18062             out_header = (void *)out_ext;
18063             break;
18064         }
18065         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
18066         {
18067             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18068             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header;
18069             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
18070             out_ext->pNext = NULL;
18071             out_ext->invocationMask = in_ext->invocationMask;
18072             out_header->pNext = (void *)out_ext;
18073             out_header = (void *)out_ext;
18074             break;
18075         }
18076         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
18077         {
18078             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18079             const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header;
18080             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
18081             out_ext->pNext = NULL;
18082             out_ext->taskShader = in_ext->taskShader;
18083             out_ext->meshShader = in_ext->meshShader;
18084             out_header->pNext = (void *)out_ext;
18085             out_header = (void *)out_ext;
18086             break;
18087         }
18088         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
18089         {
18090             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18091             const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header;
18092             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
18093             out_ext->pNext = NULL;
18094             out_ext->taskShader = in_ext->taskShader;
18095             out_ext->meshShader = in_ext->meshShader;
18096             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
18097             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
18098             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
18099             out_header->pNext = (void *)out_ext;
18100             out_header = (void *)out_ext;
18101             break;
18102         }
18103         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
18104         {
18105             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18106             const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header;
18107             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
18108             out_ext->pNext = NULL;
18109             out_ext->accelerationStructure = in_ext->accelerationStructure;
18110             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
18111             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
18112             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
18113             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
18114             out_header->pNext = (void *)out_ext;
18115             out_header = (void *)out_ext;
18116             break;
18117         }
18118         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
18119         {
18120             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18121             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header;
18122             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
18123             out_ext->pNext = NULL;
18124             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
18125             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
18126             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
18127             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
18128             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
18129             out_header->pNext = (void *)out_ext;
18130             out_header = (void *)out_ext;
18131             break;
18132         }
18133         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
18134         {
18135             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18136             const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header;
18137             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
18138             out_ext->pNext = NULL;
18139             out_ext->rayQuery = in_ext->rayQuery;
18140             out_header->pNext = (void *)out_ext;
18141             out_header = (void *)out_ext;
18142             break;
18143         }
18144         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
18145         {
18146             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18147             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header;
18148             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
18149             out_ext->pNext = NULL;
18150             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
18151             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
18152             out_header->pNext = (void *)out_ext;
18153             out_header = (void *)out_ext;
18154             break;
18155         }
18156         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
18157         {
18158             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18159             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header;
18160             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
18161             out_ext->pNext = NULL;
18162             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
18163             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
18164             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
18165             out_header->pNext = (void *)out_ext;
18166             out_header = (void *)out_ext;
18167             break;
18168         }
18169         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
18170         {
18171             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18172             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header;
18173             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
18174             out_ext->pNext = NULL;
18175             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
18176             out_header->pNext = (void *)out_ext;
18177             out_header = (void *)out_ext;
18178             break;
18179         }
18180         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
18181         {
18182             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18183             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *)in_header;
18184             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
18185             out_ext->pNext = NULL;
18186             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
18187             out_header->pNext = (void *)out_ext;
18188             out_header = (void *)out_ext;
18189             break;
18190         }
18191         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
18192         {
18193             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18194             const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header;
18195             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
18196             out_ext->pNext = NULL;
18197             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
18198             out_header->pNext = (void *)out_ext;
18199             out_header = (void *)out_ext;
18200             break;
18201         }
18202         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
18203         {
18204             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18205             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header;
18206             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
18207             out_ext->pNext = NULL;
18208             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
18209             out_header->pNext = (void *)out_ext;
18210             out_header = (void *)out_ext;
18211             break;
18212         }
18213         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
18214         {
18215             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18216             const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header;
18217             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
18218             out_ext->pNext = NULL;
18219             out_ext->depthClipEnable = in_ext->depthClipEnable;
18220             out_header->pNext = (void *)out_ext;
18221             out_header = (void *)out_ext;
18222             break;
18223         }
18224         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
18225         {
18226             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18227             const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header;
18228             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
18229             out_ext->pNext = NULL;
18230             out_ext->memoryPriority = in_ext->memoryPriority;
18231             out_header->pNext = (void *)out_ext;
18232             out_header = (void *)out_ext;
18233             break;
18234         }
18235         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
18236         {
18237             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18238             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header;
18239             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
18240             out_ext->pNext = NULL;
18241             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
18242             out_header->pNext = (void *)out_ext;
18243             out_header = (void *)out_ext;
18244             break;
18245         }
18246         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
18247         {
18248             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18249             const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header;
18250             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
18251             out_ext->pNext = NULL;
18252             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
18253             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
18254             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
18255             out_header->pNext = (void *)out_ext;
18256             out_header = (void *)out_ext;
18257             break;
18258         }
18259         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
18260         {
18261             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18262             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header;
18263             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
18264             out_ext->pNext = NULL;
18265             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
18266             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
18267             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
18268             out_header->pNext = (void *)out_ext;
18269             out_header = (void *)out_ext;
18270             break;
18271         }
18272         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
18273         {
18274             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18275             const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header;
18276             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
18277             out_ext->pNext = NULL;
18278             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
18279             out_header->pNext = (void *)out_ext;
18280             out_header = (void *)out_ext;
18281             break;
18282         }
18283         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
18284         {
18285             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18286             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header;
18287             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
18288             out_ext->pNext = NULL;
18289             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
18290             out_header->pNext = (void *)out_ext;
18291             out_header = (void *)out_ext;
18292             break;
18293         }
18294         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
18295         {
18296             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18297             const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header;
18298             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
18299             out_ext->pNext = NULL;
18300             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
18301             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
18302             out_header->pNext = (void *)out_ext;
18303             out_header = (void *)out_ext;
18304             break;
18305         }
18306         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
18307         {
18308             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18309             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header;
18310             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
18311             out_ext->pNext = NULL;
18312             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
18313             out_header->pNext = (void *)out_ext;
18314             out_header = (void *)out_ext;
18315             break;
18316         }
18317         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
18318         {
18319             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18320             const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header;
18321             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
18322             out_ext->pNext = NULL;
18323             out_ext->presentBarrier = in_ext->presentBarrier;
18324             out_header->pNext = (void *)out_ext;
18325             out_header = (void *)out_ext;
18326             break;
18327         }
18328         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
18329         {
18330             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18331             const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header;
18332             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
18333             out_ext->pNext = NULL;
18334             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
18335             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
18336             out_header->pNext = (void *)out_ext;
18337             out_header = (void *)out_ext;
18338             break;
18339         }
18340         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
18341         {
18342             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18343             const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header;
18344             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
18345             out_ext->pNext = NULL;
18346             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
18347             out_header->pNext = (void *)out_ext;
18348             out_header = (void *)out_ext;
18349             break;
18350         }
18351         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
18352         {
18353             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18354             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header;
18355             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
18356             out_ext->pNext = NULL;
18357             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
18358             out_header->pNext = (void *)out_ext;
18359             out_header = (void *)out_ext;
18360             break;
18361         }
18362         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
18363         {
18364             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18365             const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header;
18366             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
18367             out_ext->pNext = NULL;
18368             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
18369             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
18370             out_header->pNext = (void *)out_ext;
18371             out_header = (void *)out_ext;
18372             break;
18373         }
18374         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
18375         {
18376             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18377             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *)in_header;
18378             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
18379             out_ext->pNext = NULL;
18380             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
18381             out_header->pNext = (void *)out_ext;
18382             out_header = (void *)out_ext;
18383             break;
18384         }
18385         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
18386         {
18387             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18388             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header;
18389             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
18390             out_ext->pNext = NULL;
18391             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
18392             out_header->pNext = (void *)out_ext;
18393             out_header = (void *)out_ext;
18394             break;
18395         }
18396         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
18397         {
18398             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18399             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header;
18400             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
18401             out_ext->pNext = NULL;
18402             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
18403             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
18404             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
18405             out_header->pNext = (void *)out_ext;
18406             out_header = (void *)out_ext;
18407             break;
18408         }
18409         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
18410         {
18411             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18412             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header;
18413             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
18414             out_ext->pNext = NULL;
18415             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
18416             out_header->pNext = (void *)out_ext;
18417             out_header = (void *)out_ext;
18418             break;
18419         }
18420         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
18421         {
18422             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18423             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header;
18424             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
18425             out_ext->pNext = NULL;
18426             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
18427             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
18428             out_header->pNext = (void *)out_ext;
18429             out_header = (void *)out_ext;
18430             break;
18431         }
18432         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
18433         {
18434             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18435             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header;
18436             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
18437             out_ext->pNext = NULL;
18438             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
18439             out_header->pNext = (void *)out_ext;
18440             out_header = (void *)out_ext;
18441             break;
18442         }
18443         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
18444         {
18445             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18446             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header;
18447             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
18448             out_ext->pNext = NULL;
18449             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
18450             out_header->pNext = (void *)out_ext;
18451             out_header = (void *)out_ext;
18452             break;
18453         }
18454         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
18455         {
18456             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18457             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header;
18458             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
18459             out_ext->pNext = NULL;
18460             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
18461             out_header->pNext = (void *)out_ext;
18462             out_header = (void *)out_ext;
18463             break;
18464         }
18465         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
18466         {
18467             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18468             const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header;
18469             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
18470             out_ext->pNext = NULL;
18471             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
18472             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
18473             out_header->pNext = (void *)out_ext;
18474             out_header = (void *)out_ext;
18475             break;
18476         }
18477         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
18478         {
18479             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18480             const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *)in_header;
18481             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
18482             out_ext->pNext = NULL;
18483             out_ext->rectangularLines = in_ext->rectangularLines;
18484             out_ext->bresenhamLines = in_ext->bresenhamLines;
18485             out_ext->smoothLines = in_ext->smoothLines;
18486             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
18487             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
18488             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
18489             out_header->pNext = (void *)out_ext;
18490             out_header = (void *)out_ext;
18491             break;
18492         }
18493         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
18494         {
18495             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18496             const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header;
18497             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
18498             out_ext->pNext = NULL;
18499             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
18500             out_header->pNext = (void *)out_ext;
18501             out_header = (void *)out_ext;
18502             break;
18503         }
18504         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
18505         {
18506             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18507             const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header;
18508             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
18509             out_ext->pNext = NULL;
18510             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
18511             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
18512             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
18513             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
18514             out_ext->multiview = in_ext->multiview;
18515             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
18516             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
18517             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
18518             out_ext->variablePointers = in_ext->variablePointers;
18519             out_ext->protectedMemory = in_ext->protectedMemory;
18520             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
18521             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
18522             out_header->pNext = (void *)out_ext;
18523             out_header = (void *)out_ext;
18524             break;
18525         }
18526         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
18527         {
18528             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18529             const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header;
18530             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
18531             out_ext->pNext = NULL;
18532             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
18533             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
18534             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
18535             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
18536             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
18537             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
18538             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
18539             out_ext->shaderFloat16 = in_ext->shaderFloat16;
18540             out_ext->shaderInt8 = in_ext->shaderInt8;
18541             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
18542             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
18543             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
18544             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
18545             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
18546             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
18547             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
18548             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
18549             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
18550             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
18551             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
18552             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
18553             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
18554             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
18555             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
18556             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
18557             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
18558             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
18559             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
18560             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
18561             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
18562             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
18563             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
18564             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
18565             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
18566             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
18567             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
18568             out_ext->hostQueryReset = in_ext->hostQueryReset;
18569             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
18570             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
18571             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
18572             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
18573             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
18574             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
18575             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
18576             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
18577             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
18578             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
18579             out_header->pNext = (void *)out_ext;
18580             out_header = (void *)out_ext;
18581             break;
18582         }
18583         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
18584         {
18585             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18586             const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header;
18587             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
18588             out_ext->pNext = NULL;
18589             out_ext->robustImageAccess = in_ext->robustImageAccess;
18590             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
18591             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
18592             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
18593             out_ext->privateData = in_ext->privateData;
18594             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
18595             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
18596             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
18597             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
18598             out_ext->synchronization2 = in_ext->synchronization2;
18599             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
18600             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
18601             out_ext->dynamicRendering = in_ext->dynamicRendering;
18602             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
18603             out_ext->maintenance4 = in_ext->maintenance4;
18604             out_header->pNext = (void *)out_ext;
18605             out_header = (void *)out_ext;
18606             break;
18607         }
18608         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
18609         {
18610             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18611             const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header;
18612             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
18613             out_ext->pNext = NULL;
18614             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
18615             out_header->pNext = (void *)out_ext;
18616             out_header = (void *)out_ext;
18617             break;
18618         }
18619         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
18620         {
18621             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18622             const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header;
18623             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
18624             out_ext->pNext = NULL;
18625             out_ext->customBorderColors = in_ext->customBorderColors;
18626             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
18627             out_header->pNext = (void *)out_ext;
18628             out_header = (void *)out_ext;
18629             break;
18630         }
18631         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
18632         {
18633             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18634             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header;
18635             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
18636             out_ext->pNext = NULL;
18637             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
18638             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
18639             out_header->pNext = (void *)out_ext;
18640             out_header = (void *)out_ext;
18641             break;
18642         }
18643         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
18644         {
18645             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18646             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header;
18647             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
18648             out_ext->pNext = NULL;
18649             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
18650             out_header->pNext = (void *)out_ext;
18651             out_header = (void *)out_ext;
18652             break;
18653         }
18654         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
18655         {
18656             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18657             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header;
18658             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
18659             out_ext->pNext = NULL;
18660             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
18661             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
18662             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
18663             out_header->pNext = (void *)out_ext;
18664             out_header = (void *)out_ext;
18665             break;
18666         }
18667         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
18668         {
18669             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18670             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header;
18671             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
18672             out_ext->pNext = NULL;
18673             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
18674             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
18675             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
18676             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
18677             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
18678             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
18679             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
18680             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
18681             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
18682             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
18683             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
18684             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
18685             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
18686             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
18687             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
18688             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
18689             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
18690             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
18691             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
18692             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
18693             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
18694             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
18695             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
18696             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
18697             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
18698             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
18699             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
18700             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
18701             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
18702             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
18703             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
18704             out_header->pNext = (void *)out_ext;
18705             out_header = (void *)out_ext;
18706             break;
18707         }
18708         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
18709         {
18710             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18711             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header;
18712             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
18713             out_ext->pNext = NULL;
18714             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
18715             out_header->pNext = (void *)out_ext;
18716             out_header = (void *)out_ext;
18717             break;
18718         }
18719         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
18720         {
18721             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18722             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header;
18723             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
18724             out_ext->pNext = NULL;
18725             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
18726             out_header->pNext = (void *)out_ext;
18727             out_header = (void *)out_ext;
18728             break;
18729         }
18730         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
18731         {
18732             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18733             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header;
18734             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
18735             out_ext->pNext = NULL;
18736             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
18737             out_header->pNext = (void *)out_ext;
18738             out_header = (void *)out_ext;
18739             break;
18740         }
18741         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
18742         {
18743             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18744             const VkPhysicalDeviceRobustness2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT32 *)in_header;
18745             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
18746             out_ext->pNext = NULL;
18747             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
18748             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
18749             out_ext->nullDescriptor = in_ext->nullDescriptor;
18750             out_header->pNext = (void *)out_ext;
18751             out_header = (void *)out_ext;
18752             break;
18753         }
18754         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
18755         {
18756             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18757             const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header;
18758             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
18759             out_ext->pNext = NULL;
18760             out_ext->robustImageAccess = in_ext->robustImageAccess;
18761             out_header->pNext = (void *)out_ext;
18762             out_header = (void *)out_ext;
18763             break;
18764         }
18765         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
18766         {
18767             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18768             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header;
18769             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
18770             out_ext->pNext = NULL;
18771             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
18772             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
18773             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
18774             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
18775             out_header->pNext = (void *)out_ext;
18776             out_header = (void *)out_ext;
18777             break;
18778         }
18779         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
18780         {
18781             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18782             const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header;
18783             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
18784             out_ext->pNext = NULL;
18785             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
18786             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
18787             out_header->pNext = (void *)out_ext;
18788             out_header = (void *)out_ext;
18789             break;
18790         }
18791         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
18792         {
18793             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18794             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header;
18795             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
18796             out_ext->pNext = NULL;
18797             out_ext->subpassShading = in_ext->subpassShading;
18798             out_header->pNext = (void *)out_ext;
18799             out_header = (void *)out_ext;
18800             break;
18801         }
18802         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
18803         {
18804             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18805             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header;
18806             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
18807             out_ext->pNext = NULL;
18808             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
18809             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
18810             out_header->pNext = (void *)out_ext;
18811             out_header = (void *)out_ext;
18812             break;
18813         }
18814         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
18815         {
18816             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18817             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header;
18818             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
18819             out_ext->pNext = NULL;
18820             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
18821             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
18822             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
18823             out_header->pNext = (void *)out_ext;
18824             out_header = (void *)out_ext;
18825             break;
18826         }
18827         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
18828         {
18829             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18830             const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header;
18831             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
18832             out_ext->pNext = NULL;
18833             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
18834             out_header->pNext = (void *)out_ext;
18835             out_header = (void *)out_ext;
18836             break;
18837         }
18838         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
18839         {
18840             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18841             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header;
18842             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
18843             out_ext->pNext = NULL;
18844             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
18845             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
18846             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
18847             out_header->pNext = (void *)out_ext;
18848             out_header = (void *)out_ext;
18849             break;
18850         }
18851         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
18852         {
18853             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18854             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header;
18855             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
18856             out_ext->pNext = NULL;
18857             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
18858             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
18859             out_header->pNext = (void *)out_ext;
18860             out_header = (void *)out_ext;
18861             break;
18862         }
18863         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
18864         {
18865             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18866             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header;
18867             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
18868             out_ext->pNext = NULL;
18869             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
18870             out_header->pNext = (void *)out_ext;
18871             out_header = (void *)out_ext;
18872             break;
18873         }
18874         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
18875         {
18876             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18877             const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header;
18878             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
18879             out_ext->pNext = NULL;
18880             out_ext->depthClipControl = in_ext->depthClipControl;
18881             out_header->pNext = (void *)out_ext;
18882             out_header = (void *)out_ext;
18883             break;
18884         }
18885         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
18886         {
18887             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18888             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header;
18889             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
18890             out_ext->pNext = NULL;
18891             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
18892             out_header->pNext = (void *)out_ext;
18893             out_header = (void *)out_ext;
18894             break;
18895         }
18896         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
18897         {
18898             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18899             const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header;
18900             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
18901             out_ext->pNext = NULL;
18902             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
18903             out_header->pNext = (void *)out_ext;
18904             out_header = (void *)out_ext;
18905             break;
18906         }
18907         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
18908         {
18909             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18910             const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header;
18911             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
18912             out_ext->pNext = NULL;
18913             out_ext->synchronization2 = in_ext->synchronization2;
18914             out_header->pNext = (void *)out_ext;
18915             out_header = (void *)out_ext;
18916             break;
18917         }
18918         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
18919         {
18920             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18921             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header;
18922             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
18923             out_ext->pNext = NULL;
18924             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
18925             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
18926             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
18927             out_header->pNext = (void *)out_ext;
18928             out_header = (void *)out_ext;
18929             break;
18930         }
18931         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
18932         {
18933             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18934             const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header;
18935             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
18936             out_ext->pNext = NULL;
18937             out_ext->legacyDithering = in_ext->legacyDithering;
18938             out_header->pNext = (void *)out_ext;
18939             out_header = (void *)out_ext;
18940             break;
18941         }
18942         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
18943         {
18944             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18945             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header;
18946             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
18947             out_ext->pNext = NULL;
18948             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
18949             out_header->pNext = (void *)out_ext;
18950             out_header = (void *)out_ext;
18951             break;
18952         }
18953         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
18954         {
18955             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18956             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *)in_header;
18957             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
18958             out_ext->pNext = NULL;
18959             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
18960             out_header->pNext = (void *)out_ext;
18961             out_header = (void *)out_ext;
18962             break;
18963         }
18964         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
18965         {
18966             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18967             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header;
18968             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
18969             out_ext->pNext = NULL;
18970             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
18971             out_header->pNext = (void *)out_ext;
18972             out_header = (void *)out_ext;
18973             break;
18974         }
18975         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
18976         {
18977             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18978             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header;
18979             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
18980             out_ext->pNext = NULL;
18981             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
18982             out_header->pNext = (void *)out_ext;
18983             out_header = (void *)out_ext;
18984             break;
18985         }
18986         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
18987         {
18988             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
18989             const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *)in_header;
18990             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
18991             out_ext->pNext = NULL;
18992             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
18993             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
18994             out_header->pNext = (void *)out_ext;
18995             out_header = (void *)out_ext;
18996             break;
18997         }
18998         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
18999         {
19000             VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19001             const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header;
19002             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
19003             out_ext->pNext = NULL;
19004             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
19005             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
19006             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
19007             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
19008             out_header->pNext = (void *)out_ext;
19009             out_header = (void *)out_ext;
19010             break;
19011         }
19012         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
19013         {
19014             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19015             const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header;
19016             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
19017             out_ext->pNext = NULL;
19018             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
19019             out_header->pNext = (void *)out_ext;
19020             out_header = (void *)out_ext;
19021             break;
19022         }
19023         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
19024         {
19025             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19026             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header;
19027             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
19028             out_ext->pNext = NULL;
19029             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
19030             out_header->pNext = (void *)out_ext;
19031             out_header = (void *)out_ext;
19032             break;
19033         }
19034         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
19035         {
19036             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19037             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header;
19038             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
19039             out_ext->pNext = NULL;
19040             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
19041             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
19042             out_header->pNext = (void *)out_ext;
19043             out_header = (void *)out_ext;
19044             break;
19045         }
19046         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
19047         {
19048             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19049             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header;
19050             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
19051             out_ext->pNext = NULL;
19052             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
19053             out_header->pNext = (void *)out_ext;
19054             out_header = (void *)out_ext;
19055             break;
19056         }
19057         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
19058         {
19059             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19060             const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header;
19061             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
19062             out_ext->pNext = NULL;
19063             out_ext->dynamicRendering = in_ext->dynamicRendering;
19064             out_header->pNext = (void *)out_ext;
19065             out_header = (void *)out_ext;
19066             break;
19067         }
19068         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
19069         {
19070             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19071             const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header;
19072             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
19073             out_ext->pNext = NULL;
19074             out_ext->minLod = in_ext->minLod;
19075             out_header->pNext = (void *)out_ext;
19076             out_header = (void *)out_ext;
19077             break;
19078         }
19079         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
19080         {
19081             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19082             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header;
19083             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
19084             out_ext->pNext = NULL;
19085             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
19086             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
19087             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
19088             out_header->pNext = (void *)out_ext;
19089             out_header = (void *)out_ext;
19090             break;
19091         }
19092         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
19093         {
19094             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19095             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header;
19096             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
19097             out_ext->pNext = NULL;
19098             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
19099             out_header->pNext = (void *)out_ext;
19100             out_header = (void *)out_ext;
19101             break;
19102         }
19103         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
19104         {
19105             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19106             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header;
19107             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
19108             out_ext->pNext = NULL;
19109             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
19110             out_header->pNext = (void *)out_ext;
19111             out_header = (void *)out_ext;
19112             break;
19113         }
19114         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
19115         {
19116             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19117             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header;
19118             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
19119             out_ext->pNext = NULL;
19120             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
19121             out_header->pNext = (void *)out_ext;
19122             out_header = (void *)out_ext;
19123             break;
19124         }
19125         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
19126         {
19127             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19128             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header;
19129             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
19130             out_ext->pNext = NULL;
19131             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
19132             out_header->pNext = (void *)out_ext;
19133             out_header = (void *)out_ext;
19134             break;
19135         }
19136         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
19137         {
19138             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19139             const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header;
19140             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
19141             out_ext->pNext = NULL;
19142             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
19143             out_header->pNext = (void *)out_ext;
19144             out_header = (void *)out_ext;
19145             break;
19146         }
19147         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
19148         {
19149             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19150             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header;
19151             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
19152             out_ext->pNext = NULL;
19153             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
19154             out_header->pNext = (void *)out_ext;
19155             out_header = (void *)out_ext;
19156             break;
19157         }
19158         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
19159         {
19160             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19161             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header;
19162             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
19163             out_ext->pNext = NULL;
19164             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
19165             out_header->pNext = (void *)out_ext;
19166             out_header = (void *)out_ext;
19167             break;
19168         }
19169         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
19170         {
19171             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19172             const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header;
19173             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
19174             out_ext->pNext = NULL;
19175             out_ext->micromap = in_ext->micromap;
19176             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
19177             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
19178             out_header->pNext = (void *)out_ext;
19179             out_header = (void *)out_ext;
19180             break;
19181         }
19182         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
19183         {
19184             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19185             const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header;
19186             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
19187             out_ext->pNext = NULL;
19188             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
19189             out_header->pNext = (void *)out_ext;
19190             out_header = (void *)out_ext;
19191             break;
19192         }
19193         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
19194         {
19195             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19196             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header;
19197             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
19198             out_ext->pNext = NULL;
19199             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
19200             out_header->pNext = (void *)out_ext;
19201             out_header = (void *)out_ext;
19202             break;
19203         }
19204         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
19205         {
19206             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19207             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header;
19208             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
19209             out_ext->pNext = NULL;
19210             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
19211             out_header->pNext = (void *)out_ext;
19212             out_header = (void *)out_ext;
19213             break;
19214         }
19215         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
19216         {
19217             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19218             const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *)in_header;
19219             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
19220             out_ext->pNext = NULL;
19221             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
19222             out_header->pNext = (void *)out_ext;
19223             out_header = (void *)out_ext;
19224             break;
19225         }
19226         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
19227         {
19228             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19229             const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header;
19230             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
19231             out_ext->pNext = NULL;
19232             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
19233             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
19234             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
19235             out_header->pNext = (void *)out_ext;
19236             out_header = (void *)out_ext;
19237             break;
19238         }
19239         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
19240         {
19241             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19242             const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header;
19243             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
19244             out_ext->pNext = NULL;
19245             out_ext->tileProperties = in_ext->tileProperties;
19246             out_header->pNext = (void *)out_ext;
19247             out_header = (void *)out_ext;
19248             break;
19249         }
19250         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
19251         {
19252             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19253             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header;
19254             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
19255             out_ext->pNext = NULL;
19256             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
19257             out_header->pNext = (void *)out_ext;
19258             out_header = (void *)out_ext;
19259             break;
19260         }
19261         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
19262         {
19263             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19264             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *)in_header;
19265             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
19266             out_ext->pNext = NULL;
19267             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
19268             out_header->pNext = (void *)out_ext;
19269             out_header = (void *)out_ext;
19270             break;
19271         }
19272         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
19273         {
19274             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19275             const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header;
19276             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
19277             out_ext->pNext = NULL;
19278             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
19279             out_header->pNext = (void *)out_ext;
19280             out_header = (void *)out_ext;
19281             break;
19282         }
19283         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
19284         {
19285             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19286             const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header;
19287             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
19288             out_ext->pNext = NULL;
19289             out_ext->opticalFlow = in_ext->opticalFlow;
19290             out_header->pNext = (void *)out_ext;
19291             out_header = (void *)out_ext;
19292             break;
19293         }
19294         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
19295         {
19296             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19297             const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header;
19298             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
19299             out_ext->pNext = NULL;
19300             out_ext->deviceFault = in_ext->deviceFault;
19301             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
19302             out_header->pNext = (void *)out_ext;
19303             out_header = (void *)out_ext;
19304             break;
19305         }
19306         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
19307         {
19308             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19309             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header;
19310             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
19311             out_ext->pNext = NULL;
19312             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
19313             out_header->pNext = (void *)out_ext;
19314             out_header = (void *)out_ext;
19315             break;
19316         }
19317         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
19318         {
19319             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
19320             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header;
19321             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
19322             out_ext->pNext = NULL;
19323             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
19324             out_header->pNext = (void *)out_ext;
19325             out_header = (void *)out_ext;
19326             break;
19327         }
19328         default:
19329             FIXME("Unhandled sType %u.", in_header->sType);
19330             break;
19331         }
19332     }
19333 }
19334
19335 static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDeviceFeatures2 *in, VkPhysicalDeviceFeatures232 *out)
19336 {
19337     const VkBaseInStructure *in_header;
19338     VkBaseOutStructure32 *out_header = (void *)out;
19339
19340     if (!in) return;
19341
19342     out->features = in->features;
19343
19344     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
19345     {
19346         switch (in_header->sType)
19347         {
19348         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
19349         {
19350             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV);
19351             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
19352             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
19353             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
19354             out_header = (void *)out_ext;
19355             break;
19356         }
19357         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
19358         {
19359             VkPhysicalDevicePrivateDataFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES);
19360             const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
19361             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
19362             out_ext->privateData = in_ext->privateData;
19363             out_header = (void *)out_ext;
19364             break;
19365         }
19366         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
19367         {
19368             VkPhysicalDeviceVariablePointersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
19369             const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
19370             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
19371             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
19372             out_ext->variablePointers = in_ext->variablePointers;
19373             out_header = (void *)out_ext;
19374             break;
19375         }
19376         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
19377         {
19378             VkPhysicalDeviceMultiviewFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
19379             const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
19380             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
19381             out_ext->multiview = in_ext->multiview;
19382             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
19383             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
19384             out_header = (void *)out_ext;
19385             break;
19386         }
19387         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
19388         {
19389             VkPhysicalDevicePresentIdFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR);
19390             const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
19391             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
19392             out_ext->presentId = in_ext->presentId;
19393             out_header = (void *)out_ext;
19394             break;
19395         }
19396         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
19397         {
19398             VkPhysicalDevicePresentWaitFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR);
19399             const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
19400             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
19401             out_ext->presentWait = in_ext->presentWait;
19402             out_header = (void *)out_ext;
19403             break;
19404         }
19405         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
19406         {
19407             VkPhysicalDevice16BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
19408             const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
19409             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
19410             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
19411             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
19412             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
19413             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
19414             out_header = (void *)out_ext;
19415             break;
19416         }
19417         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
19418         {
19419             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
19420             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
19421             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
19422             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
19423             out_header = (void *)out_ext;
19424             break;
19425         }
19426         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
19427         {
19428             VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
19429             const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
19430             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
19431             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
19432             out_header = (void *)out_ext;
19433             break;
19434         }
19435         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
19436         {
19437             VkPhysicalDeviceProtectedMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
19438             const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
19439             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
19440             out_ext->protectedMemory = in_ext->protectedMemory;
19441             out_header = (void *)out_ext;
19442             break;
19443         }
19444         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
19445         {
19446             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT);
19447             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
19448             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
19449             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
19450             out_header = (void *)out_ext;
19451             break;
19452         }
19453         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
19454         {
19455             VkPhysicalDeviceMultiDrawFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT);
19456             const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
19457             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
19458             out_ext->multiDraw = in_ext->multiDraw;
19459             out_header = (void *)out_ext;
19460             break;
19461         }
19462         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
19463         {
19464             VkPhysicalDeviceInlineUniformBlockFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES);
19465             const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
19466             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
19467             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
19468             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
19469             out_header = (void *)out_ext;
19470             break;
19471         }
19472         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
19473         {
19474             VkPhysicalDeviceMaintenance4Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES);
19475             const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
19476             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
19477             out_ext->maintenance4 = in_ext->maintenance4;
19478             out_header = (void *)out_ext;
19479             break;
19480         }
19481         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
19482         {
19483             VkPhysicalDeviceShaderDrawParametersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
19484             const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
19485             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
19486             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
19487             out_header = (void *)out_ext;
19488             break;
19489         }
19490         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
19491         {
19492             VkPhysicalDeviceShaderFloat16Int8Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
19493             const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
19494             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
19495             out_ext->shaderFloat16 = in_ext->shaderFloat16;
19496             out_ext->shaderInt8 = in_ext->shaderInt8;
19497             out_header = (void *)out_ext;
19498             break;
19499         }
19500         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
19501         {
19502             VkPhysicalDeviceHostQueryResetFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
19503             const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
19504             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
19505             out_ext->hostQueryReset = in_ext->hostQueryReset;
19506             out_header = (void *)out_ext;
19507             break;
19508         }
19509         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
19510         {
19511             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR);
19512             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *)in_header;
19513             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
19514             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
19515             out_header = (void *)out_ext;
19516             break;
19517         }
19518         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
19519         {
19520             VkPhysicalDeviceDescriptorIndexingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
19521             const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
19522             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
19523             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
19524             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
19525             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
19526             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
19527             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
19528             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
19529             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
19530             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
19531             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
19532             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
19533             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
19534             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
19535             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
19536             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
19537             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
19538             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
19539             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
19540             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
19541             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
19542             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
19543             out_header = (void *)out_ext;
19544             break;
19545         }
19546         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
19547         {
19548             VkPhysicalDeviceTimelineSemaphoreFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
19549             const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
19550             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
19551             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
19552             out_header = (void *)out_ext;
19553             break;
19554         }
19555         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
19556         {
19557             VkPhysicalDevice8BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
19558             const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
19559             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
19560             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
19561             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
19562             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
19563             out_header = (void *)out_ext;
19564             break;
19565         }
19566         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
19567         {
19568             VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT);
19569             const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
19570             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
19571             out_ext->conditionalRendering = in_ext->conditionalRendering;
19572             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
19573             out_header = (void *)out_ext;
19574             break;
19575         }
19576         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
19577         {
19578             VkPhysicalDeviceVulkanMemoryModelFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
19579             const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
19580             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
19581             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
19582             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
19583             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
19584             out_header = (void *)out_ext;
19585             break;
19586         }
19587         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
19588         {
19589             VkPhysicalDeviceShaderAtomicInt64Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
19590             const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
19591             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
19592             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
19593             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
19594             out_header = (void *)out_ext;
19595             break;
19596         }
19597         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
19598         {
19599             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT);
19600             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
19601             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
19602             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
19603             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
19604             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
19605             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
19606             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
19607             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
19608             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
19609             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
19610             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
19611             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
19612             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
19613             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
19614             out_header = (void *)out_ext;
19615             break;
19616         }
19617         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
19618         {
19619             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT);
19620             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
19621             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
19622             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
19623             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
19624             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
19625             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
19626             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
19627             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
19628             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
19629             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
19630             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
19631             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
19632             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
19633             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
19634             out_header = (void *)out_ext;
19635             break;
19636         }
19637         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
19638         {
19639             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT);
19640             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header;
19641             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
19642             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
19643             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
19644             out_header = (void *)out_ext;
19645             break;
19646         }
19647         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
19648         {
19649             VkPhysicalDeviceASTCDecodeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT);
19650             const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
19651             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
19652             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
19653             out_header = (void *)out_ext;
19654             break;
19655         }
19656         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
19657         {
19658             VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
19659             const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
19660             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
19661             out_ext->transformFeedback = in_ext->transformFeedback;
19662             out_ext->geometryStreams = in_ext->geometryStreams;
19663             out_header = (void *)out_ext;
19664             break;
19665         }
19666         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
19667         {
19668             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV);
19669             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
19670             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
19671             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
19672             out_header = (void *)out_ext;
19673             break;
19674         }
19675         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
19676         {
19677             VkPhysicalDeviceExclusiveScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV);
19678             const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
19679             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
19680             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
19681             out_header = (void *)out_ext;
19682             break;
19683         }
19684         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
19685         {
19686             VkPhysicalDeviceCornerSampledImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV);
19687             const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
19688             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
19689             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
19690             out_header = (void *)out_ext;
19691             break;
19692         }
19693         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
19694         {
19695             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV);
19696             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header;
19697             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
19698             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
19699             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
19700             out_header = (void *)out_ext;
19701             break;
19702         }
19703         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
19704         {
19705             VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV);
19706             const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
19707             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
19708             out_ext->imageFootprint = in_ext->imageFootprint;
19709             out_header = (void *)out_ext;
19710             break;
19711         }
19712         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
19713         {
19714             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV);
19715             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
19716             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
19717             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
19718             out_header = (void *)out_ext;
19719             break;
19720         }
19721         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
19722         {
19723             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV);
19724             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
19725             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
19726             out_ext->indirectCopy = in_ext->indirectCopy;
19727             out_header = (void *)out_ext;
19728             break;
19729         }
19730         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
19731         {
19732             VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV);
19733             const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
19734             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
19735             out_ext->memoryDecompression = in_ext->memoryDecompression;
19736             out_header = (void *)out_ext;
19737             break;
19738         }
19739         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
19740         {
19741             VkPhysicalDeviceShadingRateImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV);
19742             const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
19743             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
19744             out_ext->shadingRateImage = in_ext->shadingRateImage;
19745             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
19746             out_header = (void *)out_ext;
19747             break;
19748         }
19749         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
19750         {
19751             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI);
19752             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
19753             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
19754             out_ext->invocationMask = in_ext->invocationMask;
19755             out_header = (void *)out_ext;
19756             break;
19757         }
19758         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
19759         {
19760             VkPhysicalDeviceMeshShaderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV);
19761             const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
19762             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
19763             out_ext->taskShader = in_ext->taskShader;
19764             out_ext->meshShader = in_ext->meshShader;
19765             out_header = (void *)out_ext;
19766             break;
19767         }
19768         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
19769         {
19770             VkPhysicalDeviceMeshShaderFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT);
19771             const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
19772             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
19773             out_ext->taskShader = in_ext->taskShader;
19774             out_ext->meshShader = in_ext->meshShader;
19775             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
19776             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
19777             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
19778             out_header = (void *)out_ext;
19779             break;
19780         }
19781         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
19782         {
19783             VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR);
19784             const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
19785             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
19786             out_ext->accelerationStructure = in_ext->accelerationStructure;
19787             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
19788             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
19789             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
19790             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
19791             out_header = (void *)out_ext;
19792             break;
19793         }
19794         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
19795         {
19796             VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR);
19797             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
19798             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
19799             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
19800             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
19801             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
19802             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
19803             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
19804             out_header = (void *)out_ext;
19805             break;
19806         }
19807         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
19808         {
19809             VkPhysicalDeviceRayQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR);
19810             const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
19811             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
19812             out_ext->rayQuery = in_ext->rayQuery;
19813             out_header = (void *)out_ext;
19814             break;
19815         }
19816         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
19817         {
19818             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR);
19819             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
19820             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
19821             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
19822             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
19823             out_header = (void *)out_ext;
19824             break;
19825         }
19826         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
19827         {
19828             VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT);
19829             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
19830             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
19831             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
19832             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
19833             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
19834             out_header = (void *)out_ext;
19835             break;
19836         }
19837         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
19838         {
19839             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT);
19840             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
19841             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
19842             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
19843             out_header = (void *)out_ext;
19844             break;
19845         }
19846         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
19847         {
19848             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM);
19849             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *)in_header;
19850             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
19851             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
19852             out_header = (void *)out_ext;
19853             break;
19854         }
19855         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
19856         {
19857             VkPhysicalDeviceScalarBlockLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
19858             const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
19859             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
19860             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
19861             out_header = (void *)out_ext;
19862             break;
19863         }
19864         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
19865         {
19866             VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
19867             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
19868             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
19869             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
19870             out_header = (void *)out_ext;
19871             break;
19872         }
19873         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
19874         {
19875             VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
19876             const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
19877             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
19878             out_ext->depthClipEnable = in_ext->depthClipEnable;
19879             out_header = (void *)out_ext;
19880             break;
19881         }
19882         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
19883         {
19884             VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT);
19885             const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
19886             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
19887             out_ext->memoryPriority = in_ext->memoryPriority;
19888             out_header = (void *)out_ext;
19889             break;
19890         }
19891         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
19892         {
19893             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT);
19894             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
19895             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
19896             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
19897             out_header = (void *)out_ext;
19898             break;
19899         }
19900         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
19901         {
19902             VkPhysicalDeviceBufferDeviceAddressFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
19903             const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
19904             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
19905             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
19906             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
19907             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
19908             out_header = (void *)out_ext;
19909             break;
19910         }
19911         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
19912         {
19913             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT);
19914             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
19915             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
19916             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
19917             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
19918             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
19919             out_header = (void *)out_ext;
19920             break;
19921         }
19922         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
19923         {
19924             VkPhysicalDeviceImagelessFramebufferFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
19925             const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
19926             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
19927             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
19928             out_header = (void *)out_ext;
19929             break;
19930         }
19931         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
19932         {
19933             VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES);
19934             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
19935             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
19936             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
19937             out_header = (void *)out_ext;
19938             break;
19939         }
19940         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
19941         {
19942             VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV);
19943             const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
19944             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
19945             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
19946             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
19947             out_header = (void *)out_ext;
19948             break;
19949         }
19950         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
19951         {
19952             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT);
19953             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
19954             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
19955             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
19956             out_header = (void *)out_ext;
19957             break;
19958         }
19959         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
19960         {
19961             VkPhysicalDevicePresentBarrierFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV);
19962             const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
19963             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
19964             out_ext->presentBarrier = in_ext->presentBarrier;
19965             out_header = (void *)out_ext;
19966             break;
19967         }
19968         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
19969         {
19970             VkPhysicalDevicePerformanceQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR);
19971             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
19972             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
19973             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
19974             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
19975             out_header = (void *)out_ext;
19976             break;
19977         }
19978         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
19979         {
19980             VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV);
19981             const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
19982             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
19983             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
19984             out_header = (void *)out_ext;
19985             break;
19986         }
19987         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
19988         {
19989             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL);
19990             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
19991             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
19992             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
19993             out_header = (void *)out_ext;
19994             break;
19995         }
19996         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
19997         {
19998             VkPhysicalDeviceShaderClockFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR);
19999             const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
20000             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
20001             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
20002             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
20003             out_header = (void *)out_ext;
20004             break;
20005         }
20006         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
20007         {
20008             VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT);
20009             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header;
20010             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
20011             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
20012             out_header = (void *)out_ext;
20013             break;
20014         }
20015         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
20016         {
20017             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV);
20018             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
20019             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
20020             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
20021             out_header = (void *)out_ext;
20022             break;
20023         }
20024         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
20025         {
20026             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT);
20027             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
20028             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
20029             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
20030             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
20031             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
20032             out_header = (void *)out_ext;
20033             break;
20034         }
20035         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
20036         {
20037             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
20038             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
20039             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
20040             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
20041             out_header = (void *)out_ext;
20042             break;
20043         }
20044         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
20045         {
20046             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT);
20047             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
20048             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
20049             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
20050             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
20051             out_header = (void *)out_ext;
20052             break;
20053         }
20054         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
20055         {
20056             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR);
20057             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
20058             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
20059             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
20060             out_header = (void *)out_ext;
20061             break;
20062         }
20063         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
20064         {
20065             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES);
20066             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
20067             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
20068             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
20069             out_header = (void *)out_ext;
20070             break;
20071         }
20072         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
20073         {
20074             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT);
20075             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
20076             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
20077             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
20078             out_header = (void *)out_ext;
20079             break;
20080         }
20081         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
20082         {
20083             VkPhysicalDeviceSubgroupSizeControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES);
20084             const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
20085             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
20086             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
20087             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
20088             out_header = (void *)out_ext;
20089             break;
20090         }
20091         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
20092         {
20093             VkPhysicalDeviceLineRasterizationFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT);
20094             const VkPhysicalDeviceLineRasterizationFeaturesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header;
20095             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
20096             out_ext->rectangularLines = in_ext->rectangularLines;
20097             out_ext->bresenhamLines = in_ext->bresenhamLines;
20098             out_ext->smoothLines = in_ext->smoothLines;
20099             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
20100             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
20101             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
20102             out_header = (void *)out_ext;
20103             break;
20104         }
20105         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
20106         {
20107             VkPhysicalDevicePipelineCreationCacheControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES);
20108             const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
20109             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
20110             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
20111             out_header = (void *)out_ext;
20112             break;
20113         }
20114         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
20115         {
20116             VkPhysicalDeviceVulkan11Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
20117             const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
20118             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
20119             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
20120             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
20121             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
20122             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
20123             out_ext->multiview = in_ext->multiview;
20124             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
20125             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
20126             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
20127             out_ext->variablePointers = in_ext->variablePointers;
20128             out_ext->protectedMemory = in_ext->protectedMemory;
20129             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
20130             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
20131             out_header = (void *)out_ext;
20132             break;
20133         }
20134         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
20135         {
20136             VkPhysicalDeviceVulkan12Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
20137             const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
20138             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
20139             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
20140             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
20141             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
20142             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
20143             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
20144             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
20145             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
20146             out_ext->shaderFloat16 = in_ext->shaderFloat16;
20147             out_ext->shaderInt8 = in_ext->shaderInt8;
20148             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
20149             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
20150             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
20151             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
20152             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
20153             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
20154             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
20155             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
20156             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
20157             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
20158             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
20159             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
20160             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
20161             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
20162             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
20163             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
20164             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
20165             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
20166             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
20167             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
20168             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
20169             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
20170             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
20171             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
20172             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
20173             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
20174             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
20175             out_ext->hostQueryReset = in_ext->hostQueryReset;
20176             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
20177             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
20178             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
20179             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
20180             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
20181             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
20182             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
20183             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
20184             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
20185             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
20186             out_header = (void *)out_ext;
20187             break;
20188         }
20189         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
20190         {
20191             VkPhysicalDeviceVulkan13Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
20192             const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
20193             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
20194             out_ext->robustImageAccess = in_ext->robustImageAccess;
20195             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
20196             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
20197             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
20198             out_ext->privateData = in_ext->privateData;
20199             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
20200             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
20201             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
20202             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
20203             out_ext->synchronization2 = in_ext->synchronization2;
20204             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
20205             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
20206             out_ext->dynamicRendering = in_ext->dynamicRendering;
20207             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
20208             out_ext->maintenance4 = in_ext->maintenance4;
20209             out_header = (void *)out_ext;
20210             break;
20211         }
20212         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
20213         {
20214             VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD);
20215             const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
20216             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
20217             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
20218             out_header = (void *)out_ext;
20219             break;
20220         }
20221         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
20222         {
20223             VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT);
20224             const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
20225             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
20226             out_ext->customBorderColors = in_ext->customBorderColors;
20227             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
20228             out_header = (void *)out_ext;
20229             break;
20230         }
20231         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
20232         {
20233             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT);
20234             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
20235             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
20236             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
20237             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
20238             out_header = (void *)out_ext;
20239             break;
20240         }
20241         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
20242         {
20243             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT);
20244             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
20245             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
20246             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
20247             out_header = (void *)out_ext;
20248             break;
20249         }
20250         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
20251         {
20252             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT);
20253             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
20254             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
20255             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
20256             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
20257             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
20258             out_header = (void *)out_ext;
20259             break;
20260         }
20261         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
20262         {
20263             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT);
20264             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
20265             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
20266             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
20267             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
20268             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
20269             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
20270             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
20271             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
20272             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
20273             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
20274             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
20275             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
20276             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
20277             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
20278             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
20279             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
20280             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
20281             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
20282             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
20283             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
20284             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
20285             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
20286             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
20287             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
20288             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
20289             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
20290             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
20291             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
20292             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
20293             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
20294             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
20295             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
20296             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
20297             out_header = (void *)out_ext;
20298             break;
20299         }
20300         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
20301         {
20302             VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV);
20303             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
20304             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
20305             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
20306             out_header = (void *)out_ext;
20307             break;
20308         }
20309         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
20310         {
20311             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES);
20312             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
20313             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
20314             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
20315             out_header = (void *)out_ext;
20316             break;
20317         }
20318         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
20319         {
20320             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR);
20321             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
20322             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
20323             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
20324             out_header = (void *)out_ext;
20325             break;
20326         }
20327         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
20328         {
20329             VkPhysicalDeviceRobustness2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT);
20330             const VkPhysicalDeviceRobustness2FeaturesEXT *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT *)in_header;
20331             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
20332             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
20333             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
20334             out_ext->nullDescriptor = in_ext->nullDescriptor;
20335             out_header = (void *)out_ext;
20336             break;
20337         }
20338         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
20339         {
20340             VkPhysicalDeviceImageRobustnessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES);
20341             const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
20342             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
20343             out_ext->robustImageAccess = in_ext->robustImageAccess;
20344             out_header = (void *)out_ext;
20345             break;
20346         }
20347         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
20348         {
20349             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR);
20350             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
20351             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
20352             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
20353             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
20354             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
20355             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
20356             out_header = (void *)out_ext;
20357             break;
20358         }
20359         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
20360         {
20361             VkPhysicalDevice4444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT);
20362             const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
20363             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
20364             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
20365             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
20366             out_header = (void *)out_ext;
20367             break;
20368         }
20369         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
20370         {
20371             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI);
20372             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
20373             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
20374             out_ext->subpassShading = in_ext->subpassShading;
20375             out_header = (void *)out_ext;
20376             break;
20377         }
20378         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
20379         {
20380             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT);
20381             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
20382             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
20383             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
20384             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
20385             out_header = (void *)out_ext;
20386             break;
20387         }
20388         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
20389         {
20390             VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR);
20391             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
20392             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
20393             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
20394             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
20395             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
20396             out_header = (void *)out_ext;
20397             break;
20398         }
20399         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
20400         {
20401             VkPhysicalDeviceShaderTerminateInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES);
20402             const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
20403             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
20404             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
20405             out_header = (void *)out_ext;
20406             break;
20407         }
20408         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
20409         {
20410             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV);
20411             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
20412             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
20413             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
20414             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
20415             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
20416             out_header = (void *)out_ext;
20417             break;
20418         }
20419         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
20420         {
20421             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT);
20422             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
20423             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
20424             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
20425             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
20426             out_header = (void *)out_ext;
20427             break;
20428         }
20429         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
20430         {
20431             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT);
20432             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
20433             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
20434             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
20435             out_header = (void *)out_ext;
20436             break;
20437         }
20438         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
20439         {
20440             VkPhysicalDeviceDepthClipControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT);
20441             const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
20442             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
20443             out_ext->depthClipControl = in_ext->depthClipControl;
20444             out_header = (void *)out_ext;
20445             break;
20446         }
20447         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
20448         {
20449             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT);
20450             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
20451             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
20452             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
20453             out_header = (void *)out_ext;
20454             break;
20455         }
20456         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
20457         {
20458             VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT);
20459             const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
20460             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
20461             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
20462             out_header = (void *)out_ext;
20463             break;
20464         }
20465         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
20466         {
20467             VkPhysicalDeviceSynchronization2Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES);
20468             const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
20469             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
20470             out_ext->synchronization2 = in_ext->synchronization2;
20471             out_header = (void *)out_ext;
20472             break;
20473         }
20474         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
20475         {
20476             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT);
20477             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
20478             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
20479             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
20480             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
20481             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
20482             out_header = (void *)out_ext;
20483             break;
20484         }
20485         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
20486         {
20487             VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT);
20488             const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
20489             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
20490             out_ext->legacyDithering = in_ext->legacyDithering;
20491             out_header = (void *)out_ext;
20492             break;
20493         }
20494         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
20495         {
20496             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT);
20497             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
20498             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
20499             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
20500             out_header = (void *)out_ext;
20501             break;
20502         }
20503         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
20504         {
20505             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT);
20506             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)in_header;
20507             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
20508             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
20509             out_header = (void *)out_ext;
20510             break;
20511         }
20512         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
20513         {
20514             VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV);
20515             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
20516             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
20517             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
20518             out_header = (void *)out_ext;
20519             break;
20520         }
20521         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
20522         {
20523             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT);
20524             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
20525             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
20526             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
20527             out_header = (void *)out_ext;
20528             break;
20529         }
20530         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
20531         {
20532             VkPhysicalDeviceProvokingVertexFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT);
20533             const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
20534             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
20535             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
20536             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
20537             out_header = (void *)out_ext;
20538             break;
20539         }
20540         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
20541         {
20542             VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT);
20543             const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header;
20544             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
20545             out_ext->descriptorBuffer = in_ext->descriptorBuffer;
20546             out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay;
20547             out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored;
20548             out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors;
20549             out_header = (void *)out_ext;
20550             break;
20551         }
20552         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
20553         {
20554             VkPhysicalDeviceShaderIntegerDotProductFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES);
20555             const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
20556             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
20557             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
20558             out_header = (void *)out_ext;
20559             break;
20560         }
20561         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
20562         {
20563             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR);
20564             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
20565             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
20566             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
20567             out_header = (void *)out_ext;
20568             break;
20569         }
20570         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
20571         {
20572             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV);
20573             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
20574             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
20575             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
20576             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
20577             out_header = (void *)out_ext;
20578             break;
20579         }
20580         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
20581         {
20582             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT);
20583             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
20584             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
20585             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
20586             out_header = (void *)out_ext;
20587             break;
20588         }
20589         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
20590         {
20591             VkPhysicalDeviceDynamicRenderingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES);
20592             const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
20593             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
20594             out_ext->dynamicRendering = in_ext->dynamicRendering;
20595             out_header = (void *)out_ext;
20596             break;
20597         }
20598         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
20599         {
20600             VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT);
20601             const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
20602             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
20603             out_ext->minLod = in_ext->minLod;
20604             out_header = (void *)out_ext;
20605             break;
20606         }
20607         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
20608         {
20609             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT);
20610             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
20611             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
20612             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
20613             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
20614             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
20615             out_header = (void *)out_ext;
20616             break;
20617         }
20618         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
20619         {
20620             VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV);
20621             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
20622             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
20623             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
20624             out_header = (void *)out_ext;
20625             break;
20626         }
20627         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
20628         {
20629             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT);
20630             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
20631             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
20632             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
20633             out_header = (void *)out_ext;
20634             break;
20635         }
20636         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
20637         {
20638             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE);
20639             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
20640             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
20641             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
20642             out_header = (void *)out_ext;
20643             break;
20644         }
20645         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
20646         {
20647             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT);
20648             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
20649             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
20650             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
20651             out_header = (void *)out_ext;
20652             break;
20653         }
20654         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
20655         {
20656             VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT);
20657             const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
20658             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
20659             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
20660             out_header = (void *)out_ext;
20661             break;
20662         }
20663         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
20664         {
20665             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT);
20666             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
20667             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
20668             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
20669             out_header = (void *)out_ext;
20670             break;
20671         }
20672         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
20673         {
20674             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT);
20675             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
20676             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
20677             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
20678             out_header = (void *)out_ext;
20679             break;
20680         }
20681         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
20682         {
20683             VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT);
20684             const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
20685             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
20686             out_ext->micromap = in_ext->micromap;
20687             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
20688             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
20689             out_header = (void *)out_ext;
20690             break;
20691         }
20692         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
20693         {
20694             VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT);
20695             const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
20696             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
20697             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
20698             out_header = (void *)out_ext;
20699             break;
20700         }
20701         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
20702         {
20703             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD);
20704             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header;
20705             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
20706             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
20707             out_header = (void *)out_ext;
20708             break;
20709         }
20710         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
20711         {
20712             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT);
20713             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
20714             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
20715             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
20716             out_header = (void *)out_ext;
20717             break;
20718         }
20719         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
20720         {
20721             VkPhysicalDevicePipelineRobustnessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT);
20722             const VkPhysicalDevicePipelineRobustnessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT *)in_header;
20723             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
20724             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
20725             out_header = (void *)out_ext;
20726             break;
20727         }
20728         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
20729         {
20730             VkPhysicalDeviceImageProcessingFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM);
20731             const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
20732             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
20733             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
20734             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
20735             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
20736             out_header = (void *)out_ext;
20737             break;
20738         }
20739         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
20740         {
20741             VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM);
20742             const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
20743             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
20744             out_ext->tileProperties = in_ext->tileProperties;
20745             out_header = (void *)out_ext;
20746             break;
20747         }
20748         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
20749         {
20750             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT);
20751             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
20752             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
20753             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
20754             out_header = (void *)out_ext;
20755             break;
20756         }
20757         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
20758         {
20759             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT);
20760             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *)in_header;
20761             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
20762             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
20763             out_header = (void *)out_ext;
20764             break;
20765         }
20766         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
20767         {
20768             VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT);
20769             const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
20770             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
20771             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
20772             out_header = (void *)out_ext;
20773             break;
20774         }
20775         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
20776         {
20777             VkPhysicalDeviceOpticalFlowFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV);
20778             const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
20779             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
20780             out_ext->opticalFlow = in_ext->opticalFlow;
20781             out_header = (void *)out_ext;
20782             break;
20783         }
20784         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
20785         {
20786             VkPhysicalDeviceFaultFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT);
20787             const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
20788             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
20789             out_ext->deviceFault = in_ext->deviceFault;
20790             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
20791             out_header = (void *)out_ext;
20792             break;
20793         }
20794         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
20795         {
20796             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM);
20797             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
20798             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
20799             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
20800             out_header = (void *)out_ext;
20801             break;
20802         }
20803         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
20804         {
20805             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV);
20806             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
20807             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
20808             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
20809             out_header = (void *)out_ext;
20810             break;
20811         }
20812         default:
20813             break;
20814         }
20815     }
20816 }
20817
20818 static inline void convert_VkFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkFormatProperties232 *in, VkFormatProperties2 *out)
20819 {
20820     const VkBaseInStructure32 *in_header;
20821     VkBaseOutStructure *out_header = (void *)out;
20822
20823     if (!in) return;
20824
20825     out->sType = in->sType;
20826     out->pNext = NULL;
20827
20828     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
20829     {
20830         switch (in_header->sType)
20831         {
20832         case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
20833         {
20834             VkSubpassResolvePerformanceQueryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20835             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
20836             out_ext->pNext = NULL;
20837             out_header->pNext = (void *)out_ext;
20838             out_header = (void *)out_ext;
20839             break;
20840         }
20841         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
20842         {
20843             VkFormatProperties3 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20844             out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
20845             out_ext->pNext = NULL;
20846             out_header->pNext = (void *)out_ext;
20847             out_header = (void *)out_ext;
20848             break;
20849         }
20850         default:
20851             FIXME("Unhandled sType %u.", in_header->sType);
20852             break;
20853         }
20854     }
20855 }
20856
20857 static inline void convert_VkFormatProperties2_host_to_win32(const VkFormatProperties2 *in, VkFormatProperties232 *out)
20858 {
20859     const VkBaseInStructure *in_header;
20860     VkBaseOutStructure32 *out_header = (void *)out;
20861
20862     if (!in) return;
20863
20864     out->formatProperties = in->formatProperties;
20865
20866     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
20867     {
20868         switch (in_header->sType)
20869         {
20870         case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
20871         {
20872             VkSubpassResolvePerformanceQueryEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT);
20873             const VkSubpassResolvePerformanceQueryEXT *in_ext = (const VkSubpassResolvePerformanceQueryEXT *)in_header;
20874             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
20875             out_ext->optimal = in_ext->optimal;
20876             out_header = (void *)out_ext;
20877             break;
20878         }
20879         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
20880         {
20881             VkFormatProperties332 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3);
20882             const VkFormatProperties3 *in_ext = (const VkFormatProperties3 *)in_header;
20883             out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
20884             out_ext->linearTilingFeatures = in_ext->linearTilingFeatures;
20885             out_ext->optimalTilingFeatures = in_ext->optimalTilingFeatures;
20886             out_ext->bufferFeatures = in_ext->bufferFeatures;
20887             out_header = (void *)out_ext;
20888             break;
20889         }
20890         default:
20891             break;
20892         }
20893     }
20894 }
20895
20896 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(const VkPhysicalDeviceFragmentShadingRateKHR32 *in, VkPhysicalDeviceFragmentShadingRateKHR *out)
20897 {
20898     if (!in) return;
20899
20900     out->sType = in->sType;
20901     out->pNext = NULL;
20902     if (in->pNext)
20903         FIXME("Unexpected pNext\n");
20904 }
20905
20906 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out)
20907 {
20908     if (!in) return;
20909
20910     out->sampleCounts = in->sampleCounts;
20911     out->fragmentSize = in->fragmentSize;
20912 }
20913
20914 static inline VkPhysicalDeviceFragmentShadingRateKHR *convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFragmentShadingRateKHR32 *in, uint32_t count)
20915 {
20916     VkPhysicalDeviceFragmentShadingRateKHR *out;
20917     unsigned int i;
20918
20919     if (!in || !count) return NULL;
20920
20921     out = conversion_context_alloc(ctx, count * sizeof(*out));
20922     for (i = 0; i < count; i++)
20923     {
20924         convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(&in[i], &out[i]);
20925     }
20926
20927     return out;
20928 }
20929
20930 static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out, uint32_t count)
20931 {
20932     unsigned int i;
20933
20934     if (!in) return;
20935
20936     for (i = 0; i < count; i++)
20937     {
20938         convert_VkPhysicalDeviceFragmentShadingRateKHR_host_to_win32(&in[i], &out[i]);
20939     }
20940 }
20941
20942 static inline void convert_VkImageFormatProperties_host_to_win32(const VkImageFormatProperties *in, VkImageFormatProperties32 *out)
20943 {
20944     if (!in) return;
20945
20946     out->maxExtent = in->maxExtent;
20947     out->maxMipLevels = in->maxMipLevels;
20948     out->maxArrayLayers = in->maxArrayLayers;
20949     out->sampleCounts = in->sampleCounts;
20950     out->maxResourceSize = in->maxResourceSize;
20951 }
20952
20953 static inline void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceImageFormatInfo232 *in, VkPhysicalDeviceImageFormatInfo2 *out)
20954 {
20955     const VkBaseInStructure32 *in_header;
20956     VkBaseOutStructure *out_header = (void *)out;
20957
20958     if (!in) return;
20959
20960     out->sType = in->sType;
20961     out->pNext = NULL;
20962     out->format = in->format;
20963     out->type = in->type;
20964     out->tiling = in->tiling;
20965     out->usage = in->usage;
20966     out->flags = in->flags;
20967
20968     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
20969     {
20970         switch (in_header->sType)
20971         {
20972         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
20973         {
20974             VkPhysicalDeviceExternalImageFormatInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20975             const VkPhysicalDeviceExternalImageFormatInfo32 *in_ext = (const VkPhysicalDeviceExternalImageFormatInfo32 *)in_header;
20976             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
20977             out_ext->pNext = NULL;
20978             out_ext->handleType = in_ext->handleType;
20979             out_header->pNext = (void *)out_ext;
20980             out_header = (void *)out_ext;
20981             break;
20982         }
20983         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
20984         {
20985             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20986             const VkImageFormatListCreateInfo32 *in_ext = (const VkImageFormatListCreateInfo32 *)in_header;
20987             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
20988             out_ext->pNext = NULL;
20989             out_ext->viewFormatCount = in_ext->viewFormatCount;
20990             out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
20991             out_header->pNext = (void *)out_ext;
20992             out_header = (void *)out_ext;
20993             break;
20994         }
20995         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
20996         {
20997             VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
20998             const VkImageStencilUsageCreateInfo32 *in_ext = (const VkImageStencilUsageCreateInfo32 *)in_header;
20999             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
21000             out_ext->pNext = NULL;
21001             out_ext->stencilUsage = in_ext->stencilUsage;
21002             out_header->pNext = (void *)out_ext;
21003             out_header = (void *)out_ext;
21004             break;
21005         }
21006         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
21007         {
21008             VkPhysicalDeviceImageViewImageFormatInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21009             const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *in_ext = (const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *)in_header;
21010             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT;
21011             out_ext->pNext = NULL;
21012             out_ext->imageViewType = in_ext->imageViewType;
21013             out_header->pNext = (void *)out_ext;
21014             out_header = (void *)out_ext;
21015             break;
21016         }
21017         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
21018         {
21019             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21020             const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header;
21021             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
21022             out_ext->pNext = NULL;
21023             out_ext->flags = in_ext->flags;
21024             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
21025             out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
21026             out_header->pNext = (void *)out_ext;
21027             out_header = (void *)out_ext;
21028             break;
21029         }
21030         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
21031         {
21032             VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21033             const VkOpticalFlowImageFormatInfoNV32 *in_ext = (const VkOpticalFlowImageFormatInfoNV32 *)in_header;
21034             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
21035             out_ext->pNext = NULL;
21036             out_ext->usage = in_ext->usage;
21037             out_header->pNext = (void *)out_ext;
21038             out_header = (void *)out_ext;
21039             break;
21040         }
21041         default:
21042             FIXME("Unhandled sType %u.", in_header->sType);
21043             break;
21044         }
21045     }
21046 }
21047
21048 static inline void convert_VkImageFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkImageFormatProperties232 *in, VkImageFormatProperties2 *out)
21049 {
21050     const VkBaseInStructure32 *in_header;
21051     VkBaseOutStructure *out_header = (void *)out;
21052
21053     if (!in) return;
21054
21055     out->sType = in->sType;
21056     out->pNext = NULL;
21057
21058     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
21059     {
21060         switch (in_header->sType)
21061         {
21062         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
21063         {
21064             VkExternalImageFormatProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21065             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
21066             out_ext->pNext = NULL;
21067             out_header->pNext = (void *)out_ext;
21068             out_header = (void *)out_ext;
21069             break;
21070         }
21071         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
21072         {
21073             VkSamplerYcbcrConversionImageFormatProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21074             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
21075             out_ext->pNext = NULL;
21076             out_header->pNext = (void *)out_ext;
21077             out_header = (void *)out_ext;
21078             break;
21079         }
21080         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
21081         {
21082             VkTextureLODGatherFormatPropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21083             out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
21084             out_ext->pNext = NULL;
21085             out_header->pNext = (void *)out_ext;
21086             out_header = (void *)out_ext;
21087             break;
21088         }
21089         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
21090         {
21091             VkFilterCubicImageViewImageFormatPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21092             out_ext->sType = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT;
21093             out_ext->pNext = NULL;
21094             out_header->pNext = (void *)out_ext;
21095             out_header = (void *)out_ext;
21096             break;
21097         }
21098         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
21099         {
21100             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21101             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
21102             out_ext->pNext = NULL;
21103             out_header->pNext = (void *)out_ext;
21104             out_header = (void *)out_ext;
21105             break;
21106         }
21107         default:
21108             FIXME("Unhandled sType %u.", in_header->sType);
21109             break;
21110         }
21111     }
21112 }
21113
21114 static inline void convert_VkImageFormatProperties2_host_to_win32(const VkImageFormatProperties2 *in, VkImageFormatProperties232 *out)
21115 {
21116     const VkBaseInStructure *in_header;
21117     VkBaseOutStructure32 *out_header = (void *)out;
21118
21119     if (!in) return;
21120
21121     convert_VkImageFormatProperties_host_to_win32(&in->imageFormatProperties, &out->imageFormatProperties);
21122
21123     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
21124     {
21125         switch (in_header->sType)
21126         {
21127         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
21128         {
21129             VkExternalImageFormatProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
21130             const VkExternalImageFormatProperties *in_ext = (const VkExternalImageFormatProperties *)in_header;
21131             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
21132             out_ext->externalMemoryProperties = in_ext->externalMemoryProperties;
21133             out_header = (void *)out_ext;
21134             break;
21135         }
21136         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
21137         {
21138             VkSamplerYcbcrConversionImageFormatProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
21139             const VkSamplerYcbcrConversionImageFormatProperties *in_ext = (const VkSamplerYcbcrConversionImageFormatProperties *)in_header;
21140             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
21141             out_ext->combinedImageSamplerDescriptorCount = in_ext->combinedImageSamplerDescriptorCount;
21142             out_header = (void *)out_ext;
21143             break;
21144         }
21145         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
21146         {
21147             VkTextureLODGatherFormatPropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD);
21148             const VkTextureLODGatherFormatPropertiesAMD *in_ext = (const VkTextureLODGatherFormatPropertiesAMD *)in_header;
21149             out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
21150             out_ext->supportsTextureGatherLODBiasAMD = in_ext->supportsTextureGatherLODBiasAMD;
21151             out_header = (void *)out_ext;
21152             break;
21153         }
21154         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
21155         {
21156             VkFilterCubicImageViewImageFormatPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT);
21157             const VkFilterCubicImageViewImageFormatPropertiesEXT *in_ext = (const VkFilterCubicImageViewImageFormatPropertiesEXT *)in_header;
21158             out_ext->sType = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT;
21159             out_ext->filterCubic = in_ext->filterCubic;
21160             out_ext->filterCubicMinmax = in_ext->filterCubicMinmax;
21161             out_header = (void *)out_ext;
21162             break;
21163         }
21164         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
21165         {
21166             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
21167             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
21168             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
21169             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
21170             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
21171             out_header = (void *)out_ext;
21172             break;
21173         }
21174         default:
21175             break;
21176         }
21177     }
21178 }
21179
21180 static inline void convert_VkMemoryHeap_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out)
21181 {
21182     if (!in) return;
21183
21184     out->size = in->size;
21185     out->flags = in->flags;
21186 }
21187
21188 static inline void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out, uint32_t count)
21189 {
21190     unsigned int i;
21191
21192     if (!in) return;
21193
21194     for (i = 0; i < count; i++)
21195     {
21196         convert_VkMemoryHeap_host_to_win32(&in[i], &out[i]);
21197     }
21198 }
21199
21200 static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win32(const VkPhysicalDeviceMemoryProperties *in, VkPhysicalDeviceMemoryProperties32 *out)
21201 {
21202     if (!in) return;
21203
21204     out->memoryTypeCount = in->memoryTypeCount;
21205     memcpy(out->memoryTypes, in->memoryTypes, VK_MAX_MEMORY_TYPES * sizeof(VkMemoryType));
21206     out->memoryHeapCount = in->memoryHeapCount;
21207     convert_VkMemoryHeap_array_host_to_win32(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
21208 }
21209
21210 static inline void convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceMemoryProperties232 *in, VkPhysicalDeviceMemoryProperties2 *out)
21211 {
21212     const VkBaseInStructure32 *in_header;
21213     VkBaseOutStructure *out_header = (void *)out;
21214
21215     if (!in) return;
21216
21217     out->sType = in->sType;
21218     out->pNext = NULL;
21219
21220     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
21221     {
21222         switch (in_header->sType)
21223         {
21224         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
21225         {
21226             VkPhysicalDeviceMemoryBudgetPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21227             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
21228             out_ext->pNext = NULL;
21229             out_header->pNext = (void *)out_ext;
21230             out_header = (void *)out_ext;
21231             break;
21232         }
21233         default:
21234             FIXME("Unhandled sType %u.", in_header->sType);
21235             break;
21236         }
21237     }
21238 }
21239
21240 static inline void convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(const VkPhysicalDeviceMemoryProperties2 *in, VkPhysicalDeviceMemoryProperties232 *out)
21241 {
21242     const VkBaseInStructure *in_header;
21243     VkBaseOutStructure32 *out_header = (void *)out;
21244
21245     if (!in) return;
21246
21247     convert_VkPhysicalDeviceMemoryProperties_host_to_win32(&in->memoryProperties, &out->memoryProperties);
21248
21249     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
21250     {
21251         switch (in_header->sType)
21252         {
21253         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
21254         {
21255             VkPhysicalDeviceMemoryBudgetPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT);
21256             const VkPhysicalDeviceMemoryBudgetPropertiesEXT *in_ext = (const VkPhysicalDeviceMemoryBudgetPropertiesEXT *)in_header;
21257             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
21258             memcpy(out_ext->heapBudget, in_ext->heapBudget, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
21259             memcpy(out_ext->heapUsage, in_ext->heapUsage, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
21260             out_header = (void *)out_ext;
21261             break;
21262         }
21263         default:
21264             break;
21265         }
21266     }
21267 }
21268
21269 static inline void convert_VkMultisamplePropertiesEXT_win32_to_host(const VkMultisamplePropertiesEXT32 *in, VkMultisamplePropertiesEXT *out)
21270 {
21271     if (!in) return;
21272
21273     out->sType = in->sType;
21274     out->pNext = NULL;
21275     if (in->pNext)
21276         FIXME("Unexpected pNext\n");
21277 }
21278
21279 static inline void convert_VkMultisamplePropertiesEXT_host_to_win32(const VkMultisamplePropertiesEXT *in, VkMultisamplePropertiesEXT32 *out)
21280 {
21281     if (!in) return;
21282
21283     out->maxSampleLocationGridSize = in->maxSampleLocationGridSize;
21284 }
21285
21286 static inline void convert_VkOpticalFlowImageFormatInfoNV_win32_to_host(const VkOpticalFlowImageFormatInfoNV32 *in, VkOpticalFlowImageFormatInfoNV *out)
21287 {
21288     if (!in) return;
21289
21290     out->sType = in->sType;
21291     out->pNext = NULL;
21292     out->usage = in->usage;
21293     if (in->pNext)
21294         FIXME("Unexpected pNext\n");
21295 }
21296
21297 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(const VkOpticalFlowImageFormatPropertiesNV32 *in, VkOpticalFlowImageFormatPropertiesNV *out)
21298 {
21299     if (!in) return;
21300
21301     out->sType = in->sType;
21302     out->pNext = NULL;
21303     if (in->pNext)
21304         FIXME("Unexpected pNext\n");
21305 }
21306
21307 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out)
21308 {
21309     if (!in) return;
21310
21311     out->format = in->format;
21312 }
21313
21314 static inline VkOpticalFlowImageFormatPropertiesNV *convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowImageFormatPropertiesNV32 *in, uint32_t count)
21315 {
21316     VkOpticalFlowImageFormatPropertiesNV *out;
21317     unsigned int i;
21318
21319     if (!in || !count) return NULL;
21320
21321     out = conversion_context_alloc(ctx, count * sizeof(*out));
21322     for (i = 0; i < count; i++)
21323     {
21324         convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(&in[i], &out[i]);
21325     }
21326
21327     return out;
21328 }
21329
21330 static inline void convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out, uint32_t count)
21331 {
21332     unsigned int i;
21333
21334     if (!in) return;
21335
21336     for (i = 0; i < count; i++)
21337     {
21338         convert_VkOpticalFlowImageFormatPropertiesNV_host_to_win32(&in[i], &out[i]);
21339     }
21340 }
21341
21342 static inline void convert_VkPhysicalDeviceLimits_host_to_win32(const VkPhysicalDeviceLimits *in, VkPhysicalDeviceLimits32 *out)
21343 {
21344     if (!in) return;
21345
21346     out->maxImageDimension1D = in->maxImageDimension1D;
21347     out->maxImageDimension2D = in->maxImageDimension2D;
21348     out->maxImageDimension3D = in->maxImageDimension3D;
21349     out->maxImageDimensionCube = in->maxImageDimensionCube;
21350     out->maxImageArrayLayers = in->maxImageArrayLayers;
21351     out->maxTexelBufferElements = in->maxTexelBufferElements;
21352     out->maxUniformBufferRange = in->maxUniformBufferRange;
21353     out->maxStorageBufferRange = in->maxStorageBufferRange;
21354     out->maxPushConstantsSize = in->maxPushConstantsSize;
21355     out->maxMemoryAllocationCount = in->maxMemoryAllocationCount;
21356     out->maxSamplerAllocationCount = in->maxSamplerAllocationCount;
21357     out->bufferImageGranularity = in->bufferImageGranularity;
21358     out->sparseAddressSpaceSize = in->sparseAddressSpaceSize;
21359     out->maxBoundDescriptorSets = in->maxBoundDescriptorSets;
21360     out->maxPerStageDescriptorSamplers = in->maxPerStageDescriptorSamplers;
21361     out->maxPerStageDescriptorUniformBuffers = in->maxPerStageDescriptorUniformBuffers;
21362     out->maxPerStageDescriptorStorageBuffers = in->maxPerStageDescriptorStorageBuffers;
21363     out->maxPerStageDescriptorSampledImages = in->maxPerStageDescriptorSampledImages;
21364     out->maxPerStageDescriptorStorageImages = in->maxPerStageDescriptorStorageImages;
21365     out->maxPerStageDescriptorInputAttachments = in->maxPerStageDescriptorInputAttachments;
21366     out->maxPerStageResources = in->maxPerStageResources;
21367     out->maxDescriptorSetSamplers = in->maxDescriptorSetSamplers;
21368     out->maxDescriptorSetUniformBuffers = in->maxDescriptorSetUniformBuffers;
21369     out->maxDescriptorSetUniformBuffersDynamic = in->maxDescriptorSetUniformBuffersDynamic;
21370     out->maxDescriptorSetStorageBuffers = in->maxDescriptorSetStorageBuffers;
21371     out->maxDescriptorSetStorageBuffersDynamic = in->maxDescriptorSetStorageBuffersDynamic;
21372     out->maxDescriptorSetSampledImages = in->maxDescriptorSetSampledImages;
21373     out->maxDescriptorSetStorageImages = in->maxDescriptorSetStorageImages;
21374     out->maxDescriptorSetInputAttachments = in->maxDescriptorSetInputAttachments;
21375     out->maxVertexInputAttributes = in->maxVertexInputAttributes;
21376     out->maxVertexInputBindings = in->maxVertexInputBindings;
21377     out->maxVertexInputAttributeOffset = in->maxVertexInputAttributeOffset;
21378     out->maxVertexInputBindingStride = in->maxVertexInputBindingStride;
21379     out->maxVertexOutputComponents = in->maxVertexOutputComponents;
21380     out->maxTessellationGenerationLevel = in->maxTessellationGenerationLevel;
21381     out->maxTessellationPatchSize = in->maxTessellationPatchSize;
21382     out->maxTessellationControlPerVertexInputComponents = in->maxTessellationControlPerVertexInputComponents;
21383     out->maxTessellationControlPerVertexOutputComponents = in->maxTessellationControlPerVertexOutputComponents;
21384     out->maxTessellationControlPerPatchOutputComponents = in->maxTessellationControlPerPatchOutputComponents;
21385     out->maxTessellationControlTotalOutputComponents = in->maxTessellationControlTotalOutputComponents;
21386     out->maxTessellationEvaluationInputComponents = in->maxTessellationEvaluationInputComponents;
21387     out->maxTessellationEvaluationOutputComponents = in->maxTessellationEvaluationOutputComponents;
21388     out->maxGeometryShaderInvocations = in->maxGeometryShaderInvocations;
21389     out->maxGeometryInputComponents = in->maxGeometryInputComponents;
21390     out->maxGeometryOutputComponents = in->maxGeometryOutputComponents;
21391     out->maxGeometryOutputVertices = in->maxGeometryOutputVertices;
21392     out->maxGeometryTotalOutputComponents = in->maxGeometryTotalOutputComponents;
21393     out->maxFragmentInputComponents = in->maxFragmentInputComponents;
21394     out->maxFragmentOutputAttachments = in->maxFragmentOutputAttachments;
21395     out->maxFragmentDualSrcAttachments = in->maxFragmentDualSrcAttachments;
21396     out->maxFragmentCombinedOutputResources = in->maxFragmentCombinedOutputResources;
21397     out->maxComputeSharedMemorySize = in->maxComputeSharedMemorySize;
21398     memcpy(out->maxComputeWorkGroupCount, in->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
21399     out->maxComputeWorkGroupInvocations = in->maxComputeWorkGroupInvocations;
21400     memcpy(out->maxComputeWorkGroupSize, in->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
21401     out->subPixelPrecisionBits = in->subPixelPrecisionBits;
21402     out->subTexelPrecisionBits = in->subTexelPrecisionBits;
21403     out->mipmapPrecisionBits = in->mipmapPrecisionBits;
21404     out->maxDrawIndexedIndexValue = in->maxDrawIndexedIndexValue;
21405     out->maxDrawIndirectCount = in->maxDrawIndirectCount;
21406     out->maxSamplerLodBias = in->maxSamplerLodBias;
21407     out->maxSamplerAnisotropy = in->maxSamplerAnisotropy;
21408     out->maxViewports = in->maxViewports;
21409     memcpy(out->maxViewportDimensions, in->maxViewportDimensions, 2 * sizeof(uint32_t));
21410     memcpy(out->viewportBoundsRange, in->viewportBoundsRange, 2 * sizeof(float));
21411     out->viewportSubPixelBits = in->viewportSubPixelBits;
21412     out->minMemoryMapAlignment = in->minMemoryMapAlignment;
21413     out->minTexelBufferOffsetAlignment = in->minTexelBufferOffsetAlignment;
21414     out->minUniformBufferOffsetAlignment = in->minUniformBufferOffsetAlignment;
21415     out->minStorageBufferOffsetAlignment = in->minStorageBufferOffsetAlignment;
21416     out->minTexelOffset = in->minTexelOffset;
21417     out->maxTexelOffset = in->maxTexelOffset;
21418     out->minTexelGatherOffset = in->minTexelGatherOffset;
21419     out->maxTexelGatherOffset = in->maxTexelGatherOffset;
21420     out->minInterpolationOffset = in->minInterpolationOffset;
21421     out->maxInterpolationOffset = in->maxInterpolationOffset;
21422     out->subPixelInterpolationOffsetBits = in->subPixelInterpolationOffsetBits;
21423     out->maxFramebufferWidth = in->maxFramebufferWidth;
21424     out->maxFramebufferHeight = in->maxFramebufferHeight;
21425     out->maxFramebufferLayers = in->maxFramebufferLayers;
21426     out->framebufferColorSampleCounts = in->framebufferColorSampleCounts;
21427     out->framebufferDepthSampleCounts = in->framebufferDepthSampleCounts;
21428     out->framebufferStencilSampleCounts = in->framebufferStencilSampleCounts;
21429     out->framebufferNoAttachmentsSampleCounts = in->framebufferNoAttachmentsSampleCounts;
21430     out->maxColorAttachments = in->maxColorAttachments;
21431     out->sampledImageColorSampleCounts = in->sampledImageColorSampleCounts;
21432     out->sampledImageIntegerSampleCounts = in->sampledImageIntegerSampleCounts;
21433     out->sampledImageDepthSampleCounts = in->sampledImageDepthSampleCounts;
21434     out->sampledImageStencilSampleCounts = in->sampledImageStencilSampleCounts;
21435     out->storageImageSampleCounts = in->storageImageSampleCounts;
21436     out->maxSampleMaskWords = in->maxSampleMaskWords;
21437     out->timestampComputeAndGraphics = in->timestampComputeAndGraphics;
21438     out->timestampPeriod = in->timestampPeriod;
21439     out->maxClipDistances = in->maxClipDistances;
21440     out->maxCullDistances = in->maxCullDistances;
21441     out->maxCombinedClipAndCullDistances = in->maxCombinedClipAndCullDistances;
21442     out->discreteQueuePriorities = in->discreteQueuePriorities;
21443     memcpy(out->pointSizeRange, in->pointSizeRange, 2 * sizeof(float));
21444     memcpy(out->lineWidthRange, in->lineWidthRange, 2 * sizeof(float));
21445     out->pointSizeGranularity = in->pointSizeGranularity;
21446     out->lineWidthGranularity = in->lineWidthGranularity;
21447     out->strictLines = in->strictLines;
21448     out->standardSampleLocations = in->standardSampleLocations;
21449     out->optimalBufferCopyOffsetAlignment = in->optimalBufferCopyOffsetAlignment;
21450     out->optimalBufferCopyRowPitchAlignment = in->optimalBufferCopyRowPitchAlignment;
21451     out->nonCoherentAtomSize = in->nonCoherentAtomSize;
21452 }
21453
21454 static inline void convert_VkPhysicalDeviceProperties_host_to_win32(const VkPhysicalDeviceProperties *in, VkPhysicalDeviceProperties32 *out)
21455 {
21456     if (!in) return;
21457
21458     out->apiVersion = in->apiVersion;
21459     out->driverVersion = in->driverVersion;
21460     out->vendorID = in->vendorID;
21461     out->deviceID = in->deviceID;
21462     out->deviceType = in->deviceType;
21463     memcpy(out->deviceName, in->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
21464     memcpy(out->pipelineCacheUUID, in->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
21465     convert_VkPhysicalDeviceLimits_host_to_win32(&in->limits, &out->limits);
21466     out->sparseProperties = in->sparseProperties;
21467 }
21468
21469 static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceProperties232 *in, VkPhysicalDeviceProperties2 *out)
21470 {
21471     const VkBaseInStructure32 *in_header;
21472     VkBaseOutStructure *out_header = (void *)out;
21473
21474     if (!in) return;
21475
21476     out->sType = in->sType;
21477     out->pNext = NULL;
21478
21479     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
21480     {
21481         switch (in_header->sType)
21482         {
21483         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
21484         {
21485             VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21486             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
21487             out_ext->pNext = NULL;
21488             out_header->pNext = (void *)out_ext;
21489             out_header = (void *)out_ext;
21490             break;
21491         }
21492         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
21493         {
21494             VkPhysicalDeviceMultiDrawPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21495             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
21496             out_ext->pNext = NULL;
21497             out_header->pNext = (void *)out_ext;
21498             out_header = (void *)out_ext;
21499             break;
21500         }
21501         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
21502         {
21503             VkPhysicalDevicePushDescriptorPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21504             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
21505             out_ext->pNext = NULL;
21506             out_header->pNext = (void *)out_ext;
21507             out_header = (void *)out_ext;
21508             break;
21509         }
21510         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
21511         {
21512             VkPhysicalDeviceDriverProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21513             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
21514             out_ext->pNext = NULL;
21515             out_header->pNext = (void *)out_ext;
21516             out_header = (void *)out_ext;
21517             break;
21518         }
21519         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
21520         {
21521             VkPhysicalDeviceIDProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21522             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
21523             out_ext->pNext = NULL;
21524             out_header->pNext = (void *)out_ext;
21525             out_header = (void *)out_ext;
21526             break;
21527         }
21528         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
21529         {
21530             VkPhysicalDeviceMultiviewProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21531             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
21532             out_ext->pNext = NULL;
21533             out_header->pNext = (void *)out_ext;
21534             out_header = (void *)out_ext;
21535             break;
21536         }
21537         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
21538         {
21539             VkPhysicalDeviceDiscardRectanglePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21540             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
21541             out_ext->pNext = NULL;
21542             out_header->pNext = (void *)out_ext;
21543             out_header = (void *)out_ext;
21544             break;
21545         }
21546         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
21547         {
21548             VkPhysicalDeviceSubgroupProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21549             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
21550             out_ext->pNext = NULL;
21551             out_header->pNext = (void *)out_ext;
21552             out_header = (void *)out_ext;
21553             break;
21554         }
21555         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
21556         {
21557             VkPhysicalDevicePointClippingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21558             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
21559             out_ext->pNext = NULL;
21560             out_header->pNext = (void *)out_ext;
21561             out_header = (void *)out_ext;
21562             break;
21563         }
21564         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
21565         {
21566             VkPhysicalDeviceProtectedMemoryProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21567             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
21568             out_ext->pNext = NULL;
21569             out_header->pNext = (void *)out_ext;
21570             out_header = (void *)out_ext;
21571             break;
21572         }
21573         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
21574         {
21575             VkPhysicalDeviceSamplerFilterMinmaxProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21576             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
21577             out_ext->pNext = NULL;
21578             out_header->pNext = (void *)out_ext;
21579             out_header = (void *)out_ext;
21580             break;
21581         }
21582         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
21583         {
21584             VkPhysicalDeviceSampleLocationsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21585             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
21586             out_ext->pNext = NULL;
21587             out_header->pNext = (void *)out_ext;
21588             out_header = (void *)out_ext;
21589             break;
21590         }
21591         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
21592         {
21593             VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21594             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
21595             out_ext->pNext = NULL;
21596             out_header->pNext = (void *)out_ext;
21597             out_header = (void *)out_ext;
21598             break;
21599         }
21600         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
21601         {
21602             VkPhysicalDeviceInlineUniformBlockProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21603             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
21604             out_ext->pNext = NULL;
21605             out_header->pNext = (void *)out_ext;
21606             out_header = (void *)out_ext;
21607             break;
21608         }
21609         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
21610         {
21611             VkPhysicalDeviceMaintenance3Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21612             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
21613             out_ext->pNext = NULL;
21614             out_header->pNext = (void *)out_ext;
21615             out_header = (void *)out_ext;
21616             break;
21617         }
21618         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
21619         {
21620             VkPhysicalDeviceMaintenance4Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21621             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
21622             out_ext->pNext = NULL;
21623             out_header->pNext = (void *)out_ext;
21624             out_header = (void *)out_ext;
21625             break;
21626         }
21627         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
21628         {
21629             VkPhysicalDeviceFloatControlsProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21630             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
21631             out_ext->pNext = NULL;
21632             out_header->pNext = (void *)out_ext;
21633             out_header = (void *)out_ext;
21634             break;
21635         }
21636         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
21637         {
21638             VkPhysicalDeviceExternalMemoryHostPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21639             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
21640             out_ext->pNext = NULL;
21641             out_header->pNext = (void *)out_ext;
21642             out_header = (void *)out_ext;
21643             break;
21644         }
21645         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
21646         {
21647             VkPhysicalDeviceConservativeRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21648             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
21649             out_ext->pNext = NULL;
21650             out_header->pNext = (void *)out_ext;
21651             out_header = (void *)out_ext;
21652             break;
21653         }
21654         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
21655         {
21656             VkPhysicalDeviceShaderCorePropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21657             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
21658             out_ext->pNext = NULL;
21659             out_header->pNext = (void *)out_ext;
21660             out_header = (void *)out_ext;
21661             break;
21662         }
21663         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
21664         {
21665             VkPhysicalDeviceShaderCoreProperties2AMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21666             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
21667             out_ext->pNext = NULL;
21668             out_header->pNext = (void *)out_ext;
21669             out_header = (void *)out_ext;
21670             break;
21671         }
21672         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
21673         {
21674             VkPhysicalDeviceDescriptorIndexingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21675             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
21676             out_ext->pNext = NULL;
21677             out_header->pNext = (void *)out_ext;
21678             out_header = (void *)out_ext;
21679             break;
21680         }
21681         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
21682         {
21683             VkPhysicalDeviceTimelineSemaphoreProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21684             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
21685             out_ext->pNext = NULL;
21686             out_header->pNext = (void *)out_ext;
21687             out_header = (void *)out_ext;
21688             break;
21689         }
21690         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
21691         {
21692             VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21693             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
21694             out_ext->pNext = NULL;
21695             out_header->pNext = (void *)out_ext;
21696             out_header = (void *)out_ext;
21697             break;
21698         }
21699         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
21700         {
21701             VkPhysicalDevicePCIBusInfoPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21702             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
21703             out_ext->pNext = NULL;
21704             out_header->pNext = (void *)out_ext;
21705             out_header = (void *)out_ext;
21706             break;
21707         }
21708         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
21709         {
21710             VkPhysicalDeviceDepthStencilResolveProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21711             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
21712             out_ext->pNext = NULL;
21713             out_header->pNext = (void *)out_ext;
21714             out_header = (void *)out_ext;
21715             break;
21716         }
21717         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
21718         {
21719             VkPhysicalDeviceTransformFeedbackPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21720             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
21721             out_ext->pNext = NULL;
21722             out_header->pNext = (void *)out_ext;
21723             out_header = (void *)out_ext;
21724             break;
21725         }
21726         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
21727         {
21728             VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21729             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
21730             out_ext->pNext = NULL;
21731             out_header->pNext = (void *)out_ext;
21732             out_header = (void *)out_ext;
21733             break;
21734         }
21735         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
21736         {
21737             VkPhysicalDeviceMemoryDecompressionPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21738             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
21739             out_ext->pNext = NULL;
21740             out_header->pNext = (void *)out_ext;
21741             out_header = (void *)out_ext;
21742             break;
21743         }
21744         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
21745         {
21746             VkPhysicalDeviceShadingRateImagePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21747             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
21748             out_ext->pNext = NULL;
21749             out_header->pNext = (void *)out_ext;
21750             out_header = (void *)out_ext;
21751             break;
21752         }
21753         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
21754         {
21755             VkPhysicalDeviceMeshShaderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21756             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
21757             out_ext->pNext = NULL;
21758             out_header->pNext = (void *)out_ext;
21759             out_header = (void *)out_ext;
21760             break;
21761         }
21762         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
21763         {
21764             VkPhysicalDeviceMeshShaderPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21765             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
21766             out_ext->pNext = NULL;
21767             out_header->pNext = (void *)out_ext;
21768             out_header = (void *)out_ext;
21769             break;
21770         }
21771         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
21772         {
21773             VkPhysicalDeviceAccelerationStructurePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21774             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
21775             out_ext->pNext = NULL;
21776             out_header->pNext = (void *)out_ext;
21777             out_header = (void *)out_ext;
21778             break;
21779         }
21780         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
21781         {
21782             VkPhysicalDeviceRayTracingPipelinePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21783             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
21784             out_ext->pNext = NULL;
21785             out_header->pNext = (void *)out_ext;
21786             out_header = (void *)out_ext;
21787             break;
21788         }
21789         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
21790         {
21791             VkPhysicalDeviceRayTracingPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21792             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
21793             out_ext->pNext = NULL;
21794             out_header->pNext = (void *)out_ext;
21795             out_header = (void *)out_ext;
21796             break;
21797         }
21798         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
21799         {
21800             VkPhysicalDeviceFragmentDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21801             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
21802             out_ext->pNext = NULL;
21803             out_header->pNext = (void *)out_ext;
21804             out_header = (void *)out_ext;
21805             break;
21806         }
21807         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
21808         {
21809             VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21810             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
21811             out_ext->pNext = NULL;
21812             out_header->pNext = (void *)out_ext;
21813             out_header = (void *)out_ext;
21814             break;
21815         }
21816         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
21817         {
21818             VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21819             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM;
21820             out_ext->pNext = NULL;
21821             out_header->pNext = (void *)out_ext;
21822             out_header = (void *)out_ext;
21823             break;
21824         }
21825         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
21826         {
21827             VkPhysicalDeviceCooperativeMatrixPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21828             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
21829             out_ext->pNext = NULL;
21830             out_header->pNext = (void *)out_ext;
21831             out_header = (void *)out_ext;
21832             break;
21833         }
21834         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
21835         {
21836             VkPhysicalDevicePerformanceQueryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21837             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
21838             out_ext->pNext = NULL;
21839             out_header->pNext = (void *)out_ext;
21840             out_header = (void *)out_ext;
21841             break;
21842         }
21843         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
21844         {
21845             VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21846             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
21847             out_ext->pNext = NULL;
21848             out_header->pNext = (void *)out_ext;
21849             out_header = (void *)out_ext;
21850             break;
21851         }
21852         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
21853         {
21854             VkPhysicalDeviceTexelBufferAlignmentProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21855             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
21856             out_ext->pNext = NULL;
21857             out_header->pNext = (void *)out_ext;
21858             out_header = (void *)out_ext;
21859             break;
21860         }
21861         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
21862         {
21863             VkPhysicalDeviceSubgroupSizeControlProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21864             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
21865             out_ext->pNext = NULL;
21866             out_header->pNext = (void *)out_ext;
21867             out_header = (void *)out_ext;
21868             break;
21869         }
21870         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
21871         {
21872             VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21873             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
21874             out_ext->pNext = NULL;
21875             out_header->pNext = (void *)out_ext;
21876             out_header = (void *)out_ext;
21877             break;
21878         }
21879         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
21880         {
21881             VkPhysicalDeviceLineRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21882             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
21883             out_ext->pNext = NULL;
21884             out_header->pNext = (void *)out_ext;
21885             out_header = (void *)out_ext;
21886             break;
21887         }
21888         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
21889         {
21890             VkPhysicalDeviceVulkan11Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21891             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
21892             out_ext->pNext = NULL;
21893             out_header->pNext = (void *)out_ext;
21894             out_header = (void *)out_ext;
21895             break;
21896         }
21897         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
21898         {
21899             VkPhysicalDeviceVulkan12Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21900             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
21901             out_ext->pNext = NULL;
21902             out_header->pNext = (void *)out_ext;
21903             out_header = (void *)out_ext;
21904             break;
21905         }
21906         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
21907         {
21908             VkPhysicalDeviceVulkan13Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21909             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
21910             out_ext->pNext = NULL;
21911             out_header->pNext = (void *)out_ext;
21912             out_header = (void *)out_ext;
21913             break;
21914         }
21915         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
21916         {
21917             VkPhysicalDeviceCustomBorderColorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21918             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
21919             out_ext->pNext = NULL;
21920             out_header->pNext = (void *)out_ext;
21921             out_header = (void *)out_ext;
21922             break;
21923         }
21924         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
21925         {
21926             VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21927             const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *)in_header;
21928             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
21929             out_ext->pNext = NULL;
21930             out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted;
21931             out_header->pNext = (void *)out_ext;
21932             out_header = (void *)out_ext;
21933             break;
21934         }
21935         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
21936         {
21937             VkPhysicalDeviceRobustness2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21938             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
21939             out_ext->pNext = NULL;
21940             out_header->pNext = (void *)out_ext;
21941             out_header = (void *)out_ext;
21942             break;
21943         }
21944         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
21945         {
21946             VkPhysicalDeviceFragmentShadingRatePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21947             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
21948             out_ext->pNext = NULL;
21949             out_header->pNext = (void *)out_ext;
21950             out_header = (void *)out_ext;
21951             break;
21952         }
21953         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
21954         {
21955             VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21956             const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *)in_header;
21957             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
21958             out_ext->pNext = NULL;
21959             out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount;
21960             out_header->pNext = (void *)out_ext;
21961             out_header = (void *)out_ext;
21962             break;
21963         }
21964         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
21965         {
21966             VkPhysicalDeviceProvokingVertexPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21967             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
21968             out_ext->pNext = NULL;
21969             out_header->pNext = (void *)out_ext;
21970             out_header = (void *)out_ext;
21971             break;
21972         }
21973         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
21974         {
21975             VkPhysicalDeviceDescriptorBufferPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21976             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
21977             out_ext->pNext = NULL;
21978             out_header->pNext = (void *)out_ext;
21979             out_header = (void *)out_ext;
21980             break;
21981         }
21982         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
21983         {
21984             VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21985             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
21986             out_ext->pNext = NULL;
21987             out_header->pNext = (void *)out_ext;
21988             out_header = (void *)out_ext;
21989             break;
21990         }
21991         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
21992         {
21993             VkPhysicalDeviceShaderIntegerDotProductProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
21994             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
21995             out_ext->pNext = NULL;
21996             out_header->pNext = (void *)out_ext;
21997             out_header = (void *)out_ext;
21998             break;
21999         }
22000         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
22001         {
22002             VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22003             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
22004             out_ext->pNext = NULL;
22005             out_header->pNext = (void *)out_ext;
22006             out_header = (void *)out_ext;
22007             break;
22008         }
22009         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
22010         {
22011             VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22012             const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *)in_header;
22013             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
22014             out_ext->pNext = NULL;
22015             out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking;
22016             out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration;
22017             out_header->pNext = (void *)out_ext;
22018             out_header = (void *)out_ext;
22019             break;
22020         }
22021         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
22022         {
22023             VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22024             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
22025             out_ext->pNext = NULL;
22026             out_header->pNext = (void *)out_ext;
22027             out_header = (void *)out_ext;
22028             break;
22029         }
22030         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
22031         {
22032             VkPhysicalDeviceOpacityMicromapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22033             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
22034             out_ext->pNext = NULL;
22035             out_header->pNext = (void *)out_ext;
22036             out_header = (void *)out_ext;
22037             break;
22038         }
22039         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
22040         {
22041             VkPhysicalDevicePipelineRobustnessPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22042             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT;
22043             out_ext->pNext = NULL;
22044             out_header->pNext = (void *)out_ext;
22045             out_header = (void *)out_ext;
22046             break;
22047         }
22048         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
22049         {
22050             VkPhysicalDeviceImageProcessingPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22051             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
22052             out_ext->pNext = NULL;
22053             out_header->pNext = (void *)out_ext;
22054             out_header = (void *)out_ext;
22055             break;
22056         }
22057         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
22058         {
22059             VkPhysicalDeviceOpticalFlowPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22060             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
22061             out_ext->pNext = NULL;
22062             out_header->pNext = (void *)out_ext;
22063             out_header = (void *)out_ext;
22064             break;
22065         }
22066         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
22067         {
22068             VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22069             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
22070             out_ext->pNext = NULL;
22071             out_header->pNext = (void *)out_ext;
22072             out_header = (void *)out_ext;
22073             break;
22074         }
22075         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
22076         {
22077             VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
22078             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
22079             out_ext->pNext = NULL;
22080             out_header->pNext = (void *)out_ext;
22081             out_header = (void *)out_ext;
22082             break;
22083         }
22084         default:
22085             FIXME("Unhandled sType %u.", in_header->sType);
22086             break;
22087         }
22088     }
22089 }
22090
22091 static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDeviceProperties2 *in, VkPhysicalDeviceProperties232 *out)
22092 {
22093     const VkBaseInStructure *in_header;
22094     VkBaseOutStructure32 *out_header = (void *)out;
22095
22096     if (!in) return;
22097
22098     convert_VkPhysicalDeviceProperties_host_to_win32(&in->properties, &out->properties);
22099
22100     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
22101     {
22102         switch (in_header->sType)
22103         {
22104         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
22105         {
22106             VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV);
22107             const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *)in_header;
22108             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
22109             out_ext->maxGraphicsShaderGroupCount = in_ext->maxGraphicsShaderGroupCount;
22110             out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount;
22111             out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount;
22112             out_ext->maxIndirectCommandsStreamCount = in_ext->maxIndirectCommandsStreamCount;
22113             out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset;
22114             out_ext->maxIndirectCommandsStreamStride = in_ext->maxIndirectCommandsStreamStride;
22115             out_ext->minSequencesCountBufferOffsetAlignment = in_ext->minSequencesCountBufferOffsetAlignment;
22116             out_ext->minSequencesIndexBufferOffsetAlignment = in_ext->minSequencesIndexBufferOffsetAlignment;
22117             out_ext->minIndirectCommandsBufferOffsetAlignment = in_ext->minIndirectCommandsBufferOffsetAlignment;
22118             out_header = (void *)out_ext;
22119             break;
22120         }
22121         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
22122         {
22123             VkPhysicalDeviceMultiDrawPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT);
22124             const VkPhysicalDeviceMultiDrawPropertiesEXT *in_ext = (const VkPhysicalDeviceMultiDrawPropertiesEXT *)in_header;
22125             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
22126             out_ext->maxMultiDrawCount = in_ext->maxMultiDrawCount;
22127             out_header = (void *)out_ext;
22128             break;
22129         }
22130         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
22131         {
22132             VkPhysicalDevicePushDescriptorPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR);
22133             const VkPhysicalDevicePushDescriptorPropertiesKHR *in_ext = (const VkPhysicalDevicePushDescriptorPropertiesKHR *)in_header;
22134             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
22135             out_ext->maxPushDescriptors = in_ext->maxPushDescriptors;
22136             out_header = (void *)out_ext;
22137             break;
22138         }
22139         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
22140         {
22141             VkPhysicalDeviceDriverProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
22142             const VkPhysicalDeviceDriverProperties *in_ext = (const VkPhysicalDeviceDriverProperties *)in_header;
22143             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
22144             out_ext->driverID = in_ext->driverID;
22145             memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
22146             memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
22147             out_ext->conformanceVersion = in_ext->conformanceVersion;
22148             out_header = (void *)out_ext;
22149             break;
22150         }
22151         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
22152         {
22153             VkPhysicalDeviceIDProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
22154             const VkPhysicalDeviceIDProperties *in_ext = (const VkPhysicalDeviceIDProperties *)in_header;
22155             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
22156             memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
22157             memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
22158             memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
22159             out_ext->deviceNodeMask = in_ext->deviceNodeMask;
22160             out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
22161             out_header = (void *)out_ext;
22162             break;
22163         }
22164         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
22165         {
22166             VkPhysicalDeviceMultiviewProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
22167             const VkPhysicalDeviceMultiviewProperties *in_ext = (const VkPhysicalDeviceMultiviewProperties *)in_header;
22168             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
22169             out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
22170             out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
22171             out_header = (void *)out_ext;
22172             break;
22173         }
22174         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
22175         {
22176             VkPhysicalDeviceDiscardRectanglePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT);
22177             const VkPhysicalDeviceDiscardRectanglePropertiesEXT *in_ext = (const VkPhysicalDeviceDiscardRectanglePropertiesEXT *)in_header;
22178             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
22179             out_ext->maxDiscardRectangles = in_ext->maxDiscardRectangles;
22180             out_header = (void *)out_ext;
22181             break;
22182         }
22183         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
22184         {
22185             VkPhysicalDeviceSubgroupProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
22186             const VkPhysicalDeviceSubgroupProperties *in_ext = (const VkPhysicalDeviceSubgroupProperties *)in_header;
22187             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
22188             out_ext->subgroupSize = in_ext->subgroupSize;
22189             out_ext->supportedStages = in_ext->supportedStages;
22190             out_ext->supportedOperations = in_ext->supportedOperations;
22191             out_ext->quadOperationsInAllStages = in_ext->quadOperationsInAllStages;
22192             out_header = (void *)out_ext;
22193             break;
22194         }
22195         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
22196         {
22197             VkPhysicalDevicePointClippingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
22198             const VkPhysicalDevicePointClippingProperties *in_ext = (const VkPhysicalDevicePointClippingProperties *)in_header;
22199             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
22200             out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
22201             out_header = (void *)out_ext;
22202             break;
22203         }
22204         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
22205         {
22206             VkPhysicalDeviceProtectedMemoryProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
22207             const VkPhysicalDeviceProtectedMemoryProperties *in_ext = (const VkPhysicalDeviceProtectedMemoryProperties *)in_header;
22208             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
22209             out_ext->protectedNoFault = in_ext->protectedNoFault;
22210             out_header = (void *)out_ext;
22211             break;
22212         }
22213         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
22214         {
22215             VkPhysicalDeviceSamplerFilterMinmaxProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
22216             const VkPhysicalDeviceSamplerFilterMinmaxProperties *in_ext = (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)in_header;
22217             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
22218             out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
22219             out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
22220             out_header = (void *)out_ext;
22221             break;
22222         }
22223         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
22224         {
22225             VkPhysicalDeviceSampleLocationsPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT);
22226             const VkPhysicalDeviceSampleLocationsPropertiesEXT *in_ext = (const VkPhysicalDeviceSampleLocationsPropertiesEXT *)in_header;
22227             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
22228             out_ext->sampleLocationSampleCounts = in_ext->sampleLocationSampleCounts;
22229             out_ext->maxSampleLocationGridSize = in_ext->maxSampleLocationGridSize;
22230             memcpy(out_ext->sampleLocationCoordinateRange, in_ext->sampleLocationCoordinateRange, 2 * sizeof(float));
22231             out_ext->sampleLocationSubPixelBits = in_ext->sampleLocationSubPixelBits;
22232             out_ext->variableSampleLocations = in_ext->variableSampleLocations;
22233             out_header = (void *)out_ext;
22234             break;
22235         }
22236         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
22237         {
22238             VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT);
22239             const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)in_header;
22240             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
22241             out_ext->advancedBlendMaxColorAttachments = in_ext->advancedBlendMaxColorAttachments;
22242             out_ext->advancedBlendIndependentBlend = in_ext->advancedBlendIndependentBlend;
22243             out_ext->advancedBlendNonPremultipliedSrcColor = in_ext->advancedBlendNonPremultipliedSrcColor;
22244             out_ext->advancedBlendNonPremultipliedDstColor = in_ext->advancedBlendNonPremultipliedDstColor;
22245             out_ext->advancedBlendCorrelatedOverlap = in_ext->advancedBlendCorrelatedOverlap;
22246             out_ext->advancedBlendAllOperations = in_ext->advancedBlendAllOperations;
22247             out_header = (void *)out_ext;
22248             break;
22249         }
22250         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
22251         {
22252             VkPhysicalDeviceInlineUniformBlockProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES);
22253             const VkPhysicalDeviceInlineUniformBlockProperties *in_ext = (const VkPhysicalDeviceInlineUniformBlockProperties *)in_header;
22254             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
22255             out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
22256             out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
22257             out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
22258             out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
22259             out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
22260             out_header = (void *)out_ext;
22261             break;
22262         }
22263         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
22264         {
22265             VkPhysicalDeviceMaintenance3Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
22266             const VkPhysicalDeviceMaintenance3Properties *in_ext = (const VkPhysicalDeviceMaintenance3Properties *)in_header;
22267             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
22268             out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
22269             out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
22270             out_header = (void *)out_ext;
22271             break;
22272         }
22273         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
22274         {
22275             VkPhysicalDeviceMaintenance4Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES);
22276             const VkPhysicalDeviceMaintenance4Properties *in_ext = (const VkPhysicalDeviceMaintenance4Properties *)in_header;
22277             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
22278             out_ext->maxBufferSize = in_ext->maxBufferSize;
22279             out_header = (void *)out_ext;
22280             break;
22281         }
22282         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
22283         {
22284             VkPhysicalDeviceFloatControlsProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
22285             const VkPhysicalDeviceFloatControlsProperties *in_ext = (const VkPhysicalDeviceFloatControlsProperties *)in_header;
22286             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
22287             out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence;
22288             out_ext->roundingModeIndependence = in_ext->roundingModeIndependence;
22289             out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16;
22290             out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32;
22291             out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64;
22292             out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16;
22293             out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32;
22294             out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64;
22295             out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16;
22296             out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32;
22297             out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64;
22298             out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16;
22299             out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32;
22300             out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64;
22301             out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16;
22302             out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32;
22303             out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64;
22304             out_header = (void *)out_ext;
22305             break;
22306         }
22307         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
22308         {
22309             VkPhysicalDeviceExternalMemoryHostPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT);
22310             const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *in_ext = (const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *)in_header;
22311             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
22312             out_ext->minImportedHostPointerAlignment = in_ext->minImportedHostPointerAlignment;
22313             out_header = (void *)out_ext;
22314             break;
22315         }
22316         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
22317         {
22318             VkPhysicalDeviceConservativeRasterizationPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT);
22319             const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)in_header;
22320             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
22321             out_ext->primitiveOverestimationSize = in_ext->primitiveOverestimationSize;
22322             out_ext->maxExtraPrimitiveOverestimationSize = in_ext->maxExtraPrimitiveOverestimationSize;
22323             out_ext->extraPrimitiveOverestimationSizeGranularity = in_ext->extraPrimitiveOverestimationSizeGranularity;
22324             out_ext->primitiveUnderestimation = in_ext->primitiveUnderestimation;
22325             out_ext->conservativePointAndLineRasterization = in_ext->conservativePointAndLineRasterization;
22326             out_ext->degenerateTrianglesRasterized = in_ext->degenerateTrianglesRasterized;
22327             out_ext->degenerateLinesRasterized = in_ext->degenerateLinesRasterized;
22328             out_ext->fullyCoveredFragmentShaderInputVariable = in_ext->fullyCoveredFragmentShaderInputVariable;
22329             out_ext->conservativeRasterizationPostDepthCoverage = in_ext->conservativeRasterizationPostDepthCoverage;
22330             out_header = (void *)out_ext;
22331             break;
22332         }
22333         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
22334         {
22335             VkPhysicalDeviceShaderCorePropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD);
22336             const VkPhysicalDeviceShaderCorePropertiesAMD *in_ext = (const VkPhysicalDeviceShaderCorePropertiesAMD *)in_header;
22337             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
22338             out_ext->shaderEngineCount = in_ext->shaderEngineCount;
22339             out_ext->shaderArraysPerEngineCount = in_ext->shaderArraysPerEngineCount;
22340             out_ext->computeUnitsPerShaderArray = in_ext->computeUnitsPerShaderArray;
22341             out_ext->simdPerComputeUnit = in_ext->simdPerComputeUnit;
22342             out_ext->wavefrontsPerSimd = in_ext->wavefrontsPerSimd;
22343             out_ext->wavefrontSize = in_ext->wavefrontSize;
22344             out_ext->sgprsPerSimd = in_ext->sgprsPerSimd;
22345             out_ext->minSgprAllocation = in_ext->minSgprAllocation;
22346             out_ext->maxSgprAllocation = in_ext->maxSgprAllocation;
22347             out_ext->sgprAllocationGranularity = in_ext->sgprAllocationGranularity;
22348             out_ext->vgprsPerSimd = in_ext->vgprsPerSimd;
22349             out_ext->minVgprAllocation = in_ext->minVgprAllocation;
22350             out_ext->maxVgprAllocation = in_ext->maxVgprAllocation;
22351             out_ext->vgprAllocationGranularity = in_ext->vgprAllocationGranularity;
22352             out_header = (void *)out_ext;
22353             break;
22354         }
22355         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
22356         {
22357             VkPhysicalDeviceShaderCoreProperties2AMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD);
22358             const VkPhysicalDeviceShaderCoreProperties2AMD *in_ext = (const VkPhysicalDeviceShaderCoreProperties2AMD *)in_header;
22359             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
22360             out_ext->shaderCoreFeatures = in_ext->shaderCoreFeatures;
22361             out_ext->activeComputeUnitCount = in_ext->activeComputeUnitCount;
22362             out_header = (void *)out_ext;
22363             break;
22364         }
22365         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
22366         {
22367             VkPhysicalDeviceDescriptorIndexingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
22368             const VkPhysicalDeviceDescriptorIndexingProperties *in_ext = (const VkPhysicalDeviceDescriptorIndexingProperties *)in_header;
22369             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
22370             out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
22371             out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
22372             out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
22373             out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
22374             out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
22375             out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
22376             out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
22377             out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
22378             out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
22379             out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
22380             out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
22381             out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
22382             out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
22383             out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
22384             out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
22385             out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
22386             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
22387             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
22388             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
22389             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
22390             out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
22391             out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
22392             out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
22393             out_header = (void *)out_ext;
22394             break;
22395         }
22396         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
22397         {
22398             VkPhysicalDeviceTimelineSemaphoreProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
22399             const VkPhysicalDeviceTimelineSemaphoreProperties *in_ext = (const VkPhysicalDeviceTimelineSemaphoreProperties *)in_header;
22400             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
22401             out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
22402             out_header = (void *)out_ext;
22403             break;
22404         }
22405         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
22406         {
22407             VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT);
22408             const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)in_header;
22409             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
22410             out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor;
22411             out_header = (void *)out_ext;
22412             break;
22413         }
22414         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
22415         {
22416             VkPhysicalDevicePCIBusInfoPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT);
22417             const VkPhysicalDevicePCIBusInfoPropertiesEXT *in_ext = (const VkPhysicalDevicePCIBusInfoPropertiesEXT *)in_header;
22418             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
22419             out_ext->pciDomain = in_ext->pciDomain;
22420             out_ext->pciBus = in_ext->pciBus;
22421             out_ext->pciDevice = in_ext->pciDevice;
22422             out_ext->pciFunction = in_ext->pciFunction;
22423             out_header = (void *)out_ext;
22424             break;
22425         }
22426         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
22427         {
22428             VkPhysicalDeviceDepthStencilResolveProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
22429             const VkPhysicalDeviceDepthStencilResolveProperties *in_ext = (const VkPhysicalDeviceDepthStencilResolveProperties *)in_header;
22430             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
22431             out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
22432             out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
22433             out_ext->independentResolveNone = in_ext->independentResolveNone;
22434             out_ext->independentResolve = in_ext->independentResolve;
22435             out_header = (void *)out_ext;
22436             break;
22437         }
22438         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
22439         {
22440             VkPhysicalDeviceTransformFeedbackPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
22441             const VkPhysicalDeviceTransformFeedbackPropertiesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)in_header;
22442             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
22443             out_ext->maxTransformFeedbackStreams = in_ext->maxTransformFeedbackStreams;
22444             out_ext->maxTransformFeedbackBuffers = in_ext->maxTransformFeedbackBuffers;
22445             out_ext->maxTransformFeedbackBufferSize = in_ext->maxTransformFeedbackBufferSize;
22446             out_ext->maxTransformFeedbackStreamDataSize = in_ext->maxTransformFeedbackStreamDataSize;
22447             out_ext->maxTransformFeedbackBufferDataSize = in_ext->maxTransformFeedbackBufferDataSize;
22448             out_ext->maxTransformFeedbackBufferDataStride = in_ext->maxTransformFeedbackBufferDataStride;
22449             out_ext->transformFeedbackQueries = in_ext->transformFeedbackQueries;
22450             out_ext->transformFeedbackStreamsLinesTriangles = in_ext->transformFeedbackStreamsLinesTriangles;
22451             out_ext->transformFeedbackRasterizationStreamSelect = in_ext->transformFeedbackRasterizationStreamSelect;
22452             out_ext->transformFeedbackDraw = in_ext->transformFeedbackDraw;
22453             out_header = (void *)out_ext;
22454             break;
22455         }
22456         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
22457         {
22458             VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV);
22459             const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *)in_header;
22460             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
22461             out_ext->supportedQueues = in_ext->supportedQueues;
22462             out_header = (void *)out_ext;
22463             break;
22464         }
22465         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
22466         {
22467             VkPhysicalDeviceMemoryDecompressionPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV);
22468             const VkPhysicalDeviceMemoryDecompressionPropertiesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionPropertiesNV *)in_header;
22469             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
22470             out_ext->decompressionMethods = in_ext->decompressionMethods;
22471             out_ext->maxDecompressionIndirectCount = in_ext->maxDecompressionIndirectCount;
22472             out_header = (void *)out_ext;
22473             break;
22474         }
22475         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
22476         {
22477             VkPhysicalDeviceShadingRateImagePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV);
22478             const VkPhysicalDeviceShadingRateImagePropertiesNV *in_ext = (const VkPhysicalDeviceShadingRateImagePropertiesNV *)in_header;
22479             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
22480             out_ext->shadingRateTexelSize = in_ext->shadingRateTexelSize;
22481             out_ext->shadingRatePaletteSize = in_ext->shadingRatePaletteSize;
22482             out_ext->shadingRateMaxCoarseSamples = in_ext->shadingRateMaxCoarseSamples;
22483             out_header = (void *)out_ext;
22484             break;
22485         }
22486         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
22487         {
22488             VkPhysicalDeviceMeshShaderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV);
22489             const VkPhysicalDeviceMeshShaderPropertiesNV *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesNV *)in_header;
22490             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
22491             out_ext->maxDrawMeshTasksCount = in_ext->maxDrawMeshTasksCount;
22492             out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations;
22493             memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
22494             out_ext->maxTaskTotalMemorySize = in_ext->maxTaskTotalMemorySize;
22495             out_ext->maxTaskOutputCount = in_ext->maxTaskOutputCount;
22496             out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations;
22497             memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
22498             out_ext->maxMeshTotalMemorySize = in_ext->maxMeshTotalMemorySize;
22499             out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices;
22500             out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives;
22501             out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount;
22502             out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity;
22503             out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity;
22504             out_header = (void *)out_ext;
22505             break;
22506         }
22507         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
22508         {
22509             VkPhysicalDeviceMeshShaderPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT);
22510             const VkPhysicalDeviceMeshShaderPropertiesEXT *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesEXT *)in_header;
22511             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
22512             out_ext->maxTaskWorkGroupTotalCount = in_ext->maxTaskWorkGroupTotalCount;
22513             memcpy(out_ext->maxTaskWorkGroupCount, in_ext->maxTaskWorkGroupCount, 3 * sizeof(uint32_t));
22514             out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations;
22515             memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
22516             out_ext->maxTaskPayloadSize = in_ext->maxTaskPayloadSize;
22517             out_ext->maxTaskSharedMemorySize = in_ext->maxTaskSharedMemorySize;
22518             out_ext->maxTaskPayloadAndSharedMemorySize = in_ext->maxTaskPayloadAndSharedMemorySize;
22519             out_ext->maxMeshWorkGroupTotalCount = in_ext->maxMeshWorkGroupTotalCount;
22520             memcpy(out_ext->maxMeshWorkGroupCount, in_ext->maxMeshWorkGroupCount, 3 * sizeof(uint32_t));
22521             out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations;
22522             memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
22523             out_ext->maxMeshSharedMemorySize = in_ext->maxMeshSharedMemorySize;
22524             out_ext->maxMeshPayloadAndSharedMemorySize = in_ext->maxMeshPayloadAndSharedMemorySize;
22525             out_ext->maxMeshOutputMemorySize = in_ext->maxMeshOutputMemorySize;
22526             out_ext->maxMeshPayloadAndOutputMemorySize = in_ext->maxMeshPayloadAndOutputMemorySize;
22527             out_ext->maxMeshOutputComponents = in_ext->maxMeshOutputComponents;
22528             out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices;
22529             out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives;
22530             out_ext->maxMeshOutputLayers = in_ext->maxMeshOutputLayers;
22531             out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount;
22532             out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity;
22533             out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity;
22534             out_ext->maxPreferredTaskWorkGroupInvocations = in_ext->maxPreferredTaskWorkGroupInvocations;
22535             out_ext->maxPreferredMeshWorkGroupInvocations = in_ext->maxPreferredMeshWorkGroupInvocations;
22536             out_ext->prefersLocalInvocationVertexOutput = in_ext->prefersLocalInvocationVertexOutput;
22537             out_ext->prefersLocalInvocationPrimitiveOutput = in_ext->prefersLocalInvocationPrimitiveOutput;
22538             out_ext->prefersCompactVertexOutput = in_ext->prefersCompactVertexOutput;
22539             out_ext->prefersCompactPrimitiveOutput = in_ext->prefersCompactPrimitiveOutput;
22540             out_header = (void *)out_ext;
22541             break;
22542         }
22543         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
22544         {
22545             VkPhysicalDeviceAccelerationStructurePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR);
22546             const VkPhysicalDeviceAccelerationStructurePropertiesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructurePropertiesKHR *)in_header;
22547             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
22548             out_ext->maxGeometryCount = in_ext->maxGeometryCount;
22549             out_ext->maxInstanceCount = in_ext->maxInstanceCount;
22550             out_ext->maxPrimitiveCount = in_ext->maxPrimitiveCount;
22551             out_ext->maxPerStageDescriptorAccelerationStructures = in_ext->maxPerStageDescriptorAccelerationStructures;
22552             out_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures = in_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
22553             out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
22554             out_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures = in_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures;
22555             out_ext->minAccelerationStructureScratchOffsetAlignment = in_ext->minAccelerationStructureScratchOffsetAlignment;
22556             out_header = (void *)out_ext;
22557             break;
22558         }
22559         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
22560         {
22561             VkPhysicalDeviceRayTracingPipelinePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR);
22562             const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *)in_header;
22563             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
22564             out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
22565             out_ext->maxRayRecursionDepth = in_ext->maxRayRecursionDepth;
22566             out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
22567             out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
22568             out_ext->shaderGroupHandleCaptureReplaySize = in_ext->shaderGroupHandleCaptureReplaySize;
22569             out_ext->maxRayDispatchInvocationCount = in_ext->maxRayDispatchInvocationCount;
22570             out_ext->shaderGroupHandleAlignment = in_ext->shaderGroupHandleAlignment;
22571             out_ext->maxRayHitAttributeSize = in_ext->maxRayHitAttributeSize;
22572             out_header = (void *)out_ext;
22573             break;
22574         }
22575         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
22576         {
22577             VkPhysicalDeviceRayTracingPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV);
22578             const VkPhysicalDeviceRayTracingPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingPropertiesNV *)in_header;
22579             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
22580             out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
22581             out_ext->maxRecursionDepth = in_ext->maxRecursionDepth;
22582             out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
22583             out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
22584             out_ext->maxGeometryCount = in_ext->maxGeometryCount;
22585             out_ext->maxInstanceCount = in_ext->maxInstanceCount;
22586             out_ext->maxTriangleCount = in_ext->maxTriangleCount;
22587             out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
22588             out_header = (void *)out_ext;
22589             break;
22590         }
22591         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
22592         {
22593             VkPhysicalDeviceFragmentDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT);
22594             const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *)in_header;
22595             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
22596             out_ext->minFragmentDensityTexelSize = in_ext->minFragmentDensityTexelSize;
22597             out_ext->maxFragmentDensityTexelSize = in_ext->maxFragmentDensityTexelSize;
22598             out_ext->fragmentDensityInvocations = in_ext->fragmentDensityInvocations;
22599             out_header = (void *)out_ext;
22600             break;
22601         }
22602         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
22603         {
22604             VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT);
22605             const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *)in_header;
22606             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
22607             out_ext->subsampledLoads = in_ext->subsampledLoads;
22608             out_ext->subsampledCoarseReconstructionEarlyAccess = in_ext->subsampledCoarseReconstructionEarlyAccess;
22609             out_ext->maxSubsampledArrayLayers = in_ext->maxSubsampledArrayLayers;
22610             out_ext->maxDescriptorSetSubsampledSamplers = in_ext->maxDescriptorSetSubsampledSamplers;
22611             out_header = (void *)out_ext;
22612             break;
22613         }
22614         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
22615         {
22616             VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM);
22617             const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *)in_header;
22618             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM;
22619             out_ext->fragmentDensityOffsetGranularity = in_ext->fragmentDensityOffsetGranularity;
22620             out_header = (void *)out_ext;
22621             break;
22622         }
22623         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
22624         {
22625             VkPhysicalDeviceCooperativeMatrixPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV);
22626             const VkPhysicalDeviceCooperativeMatrixPropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesNV *)in_header;
22627             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
22628             out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages;
22629             out_header = (void *)out_ext;
22630             break;
22631         }
22632         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
22633         {
22634             VkPhysicalDevicePerformanceQueryPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR);
22635             const VkPhysicalDevicePerformanceQueryPropertiesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryPropertiesKHR *)in_header;
22636             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
22637             out_ext->allowCommandBufferQueryCopies = in_ext->allowCommandBufferQueryCopies;
22638             out_header = (void *)out_ext;
22639             break;
22640         }
22641         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
22642         {
22643             VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV);
22644             const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *)in_header;
22645             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
22646             out_ext->shaderSMCount = in_ext->shaderSMCount;
22647             out_ext->shaderWarpsPerSM = in_ext->shaderWarpsPerSM;
22648             out_header = (void *)out_ext;
22649             break;
22650         }
22651         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
22652         {
22653             VkPhysicalDeviceTexelBufferAlignmentProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES);
22654             const VkPhysicalDeviceTexelBufferAlignmentProperties *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentProperties *)in_header;
22655             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
22656             out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
22657             out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
22658             out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
22659             out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
22660             out_header = (void *)out_ext;
22661             break;
22662         }
22663         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
22664         {
22665             VkPhysicalDeviceSubgroupSizeControlProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
22666             const VkPhysicalDeviceSubgroupSizeControlProperties *in_ext = (const VkPhysicalDeviceSubgroupSizeControlProperties *)in_header;
22667             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
22668             out_ext->minSubgroupSize = in_ext->minSubgroupSize;
22669             out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
22670             out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
22671             out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
22672             out_header = (void *)out_ext;
22673             break;
22674         }
22675         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
22676         {
22677             VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI);
22678             const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *)in_header;
22679             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
22680             out_ext->maxSubpassShadingWorkgroupSizeAspectRatio = in_ext->maxSubpassShadingWorkgroupSizeAspectRatio;
22681             out_header = (void *)out_ext;
22682             break;
22683         }
22684         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
22685         {
22686             VkPhysicalDeviceLineRasterizationPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT);
22687             const VkPhysicalDeviceLineRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationPropertiesEXT *)in_header;
22688             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
22689             out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits;
22690             out_header = (void *)out_ext;
22691             break;
22692         }
22693         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
22694         {
22695             VkPhysicalDeviceVulkan11Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
22696             const VkPhysicalDeviceVulkan11Properties *in_ext = (const VkPhysicalDeviceVulkan11Properties *)in_header;
22697             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
22698             memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
22699             memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
22700             memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
22701             out_ext->deviceNodeMask = in_ext->deviceNodeMask;
22702             out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
22703             out_ext->subgroupSize = in_ext->subgroupSize;
22704             out_ext->subgroupSupportedStages = in_ext->subgroupSupportedStages;
22705             out_ext->subgroupSupportedOperations = in_ext->subgroupSupportedOperations;
22706             out_ext->subgroupQuadOperationsInAllStages = in_ext->subgroupQuadOperationsInAllStages;
22707             out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
22708             out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
22709             out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
22710             out_ext->protectedNoFault = in_ext->protectedNoFault;
22711             out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
22712             out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
22713             out_header = (void *)out_ext;
22714             break;
22715         }
22716         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
22717         {
22718             VkPhysicalDeviceVulkan12Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
22719             const VkPhysicalDeviceVulkan12Properties *in_ext = (const VkPhysicalDeviceVulkan12Properties *)in_header;
22720             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
22721             out_ext->driverID = in_ext->driverID;
22722             memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
22723             memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
22724             out_ext->conformanceVersion = in_ext->conformanceVersion;
22725             out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence;
22726             out_ext->roundingModeIndependence = in_ext->roundingModeIndependence;
22727             out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16;
22728             out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32;
22729             out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64;
22730             out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16;
22731             out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32;
22732             out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64;
22733             out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16;
22734             out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32;
22735             out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64;
22736             out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16;
22737             out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32;
22738             out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64;
22739             out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16;
22740             out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32;
22741             out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64;
22742             out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
22743             out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
22744             out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
22745             out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
22746             out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
22747             out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
22748             out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
22749             out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
22750             out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
22751             out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
22752             out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
22753             out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
22754             out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
22755             out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
22756             out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
22757             out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
22758             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
22759             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
22760             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
22761             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
22762             out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
22763             out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
22764             out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
22765             out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
22766             out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
22767             out_ext->independentResolveNone = in_ext->independentResolveNone;
22768             out_ext->independentResolve = in_ext->independentResolve;
22769             out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
22770             out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
22771             out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
22772             out_ext->framebufferIntegerColorSampleCounts = in_ext->framebufferIntegerColorSampleCounts;
22773             out_header = (void *)out_ext;
22774             break;
22775         }
22776         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
22777         {
22778             VkPhysicalDeviceVulkan13Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES);
22779             const VkPhysicalDeviceVulkan13Properties *in_ext = (const VkPhysicalDeviceVulkan13Properties *)in_header;
22780             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
22781             out_ext->minSubgroupSize = in_ext->minSubgroupSize;
22782             out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
22783             out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
22784             out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
22785             out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
22786             out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
22787             out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
22788             out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
22789             out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
22790             out_ext->maxInlineUniformTotalSize = in_ext->maxInlineUniformTotalSize;
22791             out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated;
22792             out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated;
22793             out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated;
22794             out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated;
22795             out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated;
22796             out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
22797             out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated;
22798             out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated;
22799             out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated;
22800             out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated;
22801             out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated;
22802             out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated;
22803             out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated;
22804             out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated;
22805             out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated;
22806             out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
22807             out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
22808             out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
22809             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
22810             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
22811             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
22812             out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
22813             out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
22814             out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
22815             out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
22816             out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
22817             out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
22818             out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
22819             out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
22820             out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
22821             out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
22822             out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
22823             out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
22824             out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
22825             out_ext->maxBufferSize = in_ext->maxBufferSize;
22826             out_header = (void *)out_ext;
22827             break;
22828         }
22829         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
22830         {
22831             VkPhysicalDeviceCustomBorderColorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT);
22832             const VkPhysicalDeviceCustomBorderColorPropertiesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)in_header;
22833             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
22834             out_ext->maxCustomBorderColorSamplers = in_ext->maxCustomBorderColorSamplers;
22835             out_header = (void *)out_ext;
22836             break;
22837         }
22838         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
22839         {
22840             VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT);
22841             const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)in_header;
22842             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
22843             out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted;
22844             out_header = (void *)out_ext;
22845             break;
22846         }
22847         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
22848         {
22849             VkPhysicalDeviceRobustness2PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT);
22850             const VkPhysicalDeviceRobustness2PropertiesEXT *in_ext = (const VkPhysicalDeviceRobustness2PropertiesEXT *)in_header;
22851             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
22852             out_ext->robustStorageBufferAccessSizeAlignment = in_ext->robustStorageBufferAccessSizeAlignment;
22853             out_ext->robustUniformBufferAccessSizeAlignment = in_ext->robustUniformBufferAccessSizeAlignment;
22854             out_header = (void *)out_ext;
22855             break;
22856         }
22857         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
22858         {
22859             VkPhysicalDeviceFragmentShadingRatePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR);
22860             const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)in_header;
22861             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
22862             out_ext->minFragmentShadingRateAttachmentTexelSize = in_ext->minFragmentShadingRateAttachmentTexelSize;
22863             out_ext->maxFragmentShadingRateAttachmentTexelSize = in_ext->maxFragmentShadingRateAttachmentTexelSize;
22864             out_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio = in_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
22865             out_ext->primitiveFragmentShadingRateWithMultipleViewports = in_ext->primitiveFragmentShadingRateWithMultipleViewports;
22866             out_ext->layeredShadingRateAttachments = in_ext->layeredShadingRateAttachments;
22867             out_ext->fragmentShadingRateNonTrivialCombinerOps = in_ext->fragmentShadingRateNonTrivialCombinerOps;
22868             out_ext->maxFragmentSize = in_ext->maxFragmentSize;
22869             out_ext->maxFragmentSizeAspectRatio = in_ext->maxFragmentSizeAspectRatio;
22870             out_ext->maxFragmentShadingRateCoverageSamples = in_ext->maxFragmentShadingRateCoverageSamples;
22871             out_ext->maxFragmentShadingRateRasterizationSamples = in_ext->maxFragmentShadingRateRasterizationSamples;
22872             out_ext->fragmentShadingRateWithShaderDepthStencilWrites = in_ext->fragmentShadingRateWithShaderDepthStencilWrites;
22873             out_ext->fragmentShadingRateWithSampleMask = in_ext->fragmentShadingRateWithSampleMask;
22874             out_ext->fragmentShadingRateWithShaderSampleMask = in_ext->fragmentShadingRateWithShaderSampleMask;
22875             out_ext->fragmentShadingRateWithConservativeRasterization = in_ext->fragmentShadingRateWithConservativeRasterization;
22876             out_ext->fragmentShadingRateWithFragmentShaderInterlock = in_ext->fragmentShadingRateWithFragmentShaderInterlock;
22877             out_ext->fragmentShadingRateWithCustomSampleLocations = in_ext->fragmentShadingRateWithCustomSampleLocations;
22878             out_ext->fragmentShadingRateStrictMultiplyCombiner = in_ext->fragmentShadingRateStrictMultiplyCombiner;
22879             out_header = (void *)out_ext;
22880             break;
22881         }
22882         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
22883         {
22884             VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV);
22885             const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *)in_header;
22886             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
22887             out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount;
22888             out_header = (void *)out_ext;
22889             break;
22890         }
22891         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
22892         {
22893             VkPhysicalDeviceProvokingVertexPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT);
22894             const VkPhysicalDeviceProvokingVertexPropertiesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)in_header;
22895             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
22896             out_ext->provokingVertexModePerPipeline = in_ext->provokingVertexModePerPipeline;
22897             out_ext->transformFeedbackPreservesTriangleFanProvokingVertex = in_ext->transformFeedbackPreservesTriangleFanProvokingVertex;
22898             out_header = (void *)out_ext;
22899             break;
22900         }
22901         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
22902         {
22903             VkPhysicalDeviceDescriptorBufferPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT);
22904             const VkPhysicalDeviceDescriptorBufferPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferPropertiesEXT *)in_header;
22905             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
22906             out_ext->combinedImageSamplerDescriptorSingleArray = in_ext->combinedImageSamplerDescriptorSingleArray;
22907             out_ext->bufferlessPushDescriptors = in_ext->bufferlessPushDescriptors;
22908             out_ext->allowSamplerImageViewPostSubmitCreation = in_ext->allowSamplerImageViewPostSubmitCreation;
22909             out_ext->descriptorBufferOffsetAlignment = in_ext->descriptorBufferOffsetAlignment;
22910             out_ext->maxDescriptorBufferBindings = in_ext->maxDescriptorBufferBindings;
22911             out_ext->maxResourceDescriptorBufferBindings = in_ext->maxResourceDescriptorBufferBindings;
22912             out_ext->maxSamplerDescriptorBufferBindings = in_ext->maxSamplerDescriptorBufferBindings;
22913             out_ext->maxEmbeddedImmutableSamplerBindings = in_ext->maxEmbeddedImmutableSamplerBindings;
22914             out_ext->maxEmbeddedImmutableSamplers = in_ext->maxEmbeddedImmutableSamplers;
22915             out_ext->bufferCaptureReplayDescriptorDataSize = in_ext->bufferCaptureReplayDescriptorDataSize;
22916             out_ext->imageCaptureReplayDescriptorDataSize = in_ext->imageCaptureReplayDescriptorDataSize;
22917             out_ext->imageViewCaptureReplayDescriptorDataSize = in_ext->imageViewCaptureReplayDescriptorDataSize;
22918             out_ext->samplerCaptureReplayDescriptorDataSize = in_ext->samplerCaptureReplayDescriptorDataSize;
22919             out_ext->accelerationStructureCaptureReplayDescriptorDataSize = in_ext->accelerationStructureCaptureReplayDescriptorDataSize;
22920             out_ext->samplerDescriptorSize = in_ext->samplerDescriptorSize;
22921             out_ext->combinedImageSamplerDescriptorSize = in_ext->combinedImageSamplerDescriptorSize;
22922             out_ext->sampledImageDescriptorSize = in_ext->sampledImageDescriptorSize;
22923             out_ext->storageImageDescriptorSize = in_ext->storageImageDescriptorSize;
22924             out_ext->uniformTexelBufferDescriptorSize = in_ext->uniformTexelBufferDescriptorSize;
22925             out_ext->robustUniformTexelBufferDescriptorSize = in_ext->robustUniformTexelBufferDescriptorSize;
22926             out_ext->storageTexelBufferDescriptorSize = in_ext->storageTexelBufferDescriptorSize;
22927             out_ext->robustStorageTexelBufferDescriptorSize = in_ext->robustStorageTexelBufferDescriptorSize;
22928             out_ext->uniformBufferDescriptorSize = in_ext->uniformBufferDescriptorSize;
22929             out_ext->robustUniformBufferDescriptorSize = in_ext->robustUniformBufferDescriptorSize;
22930             out_ext->storageBufferDescriptorSize = in_ext->storageBufferDescriptorSize;
22931             out_ext->robustStorageBufferDescriptorSize = in_ext->robustStorageBufferDescriptorSize;
22932             out_ext->inputAttachmentDescriptorSize = in_ext->inputAttachmentDescriptorSize;
22933             out_ext->accelerationStructureDescriptorSize = in_ext->accelerationStructureDescriptorSize;
22934             out_ext->maxSamplerDescriptorBufferRange = in_ext->maxSamplerDescriptorBufferRange;
22935             out_ext->maxResourceDescriptorBufferRange = in_ext->maxResourceDescriptorBufferRange;
22936             out_ext->samplerDescriptorBufferAddressSpaceSize = in_ext->samplerDescriptorBufferAddressSpaceSize;
22937             out_ext->resourceDescriptorBufferAddressSpaceSize = in_ext->resourceDescriptorBufferAddressSpaceSize;
22938             out_ext->descriptorBufferAddressSpaceSize = in_ext->descriptorBufferAddressSpaceSize;
22939             out_header = (void *)out_ext;
22940             break;
22941         }
22942         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
22943         {
22944             VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT);
22945             const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *)in_header;
22946             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
22947             out_ext->combinedImageSamplerDensityMapDescriptorSize = in_ext->combinedImageSamplerDensityMapDescriptorSize;
22948             out_header = (void *)out_ext;
22949             break;
22950         }
22951         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
22952         {
22953             VkPhysicalDeviceShaderIntegerDotProductProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES);
22954             const VkPhysicalDeviceShaderIntegerDotProductProperties *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductProperties *)in_header;
22955             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
22956             out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated;
22957             out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated;
22958             out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated;
22959             out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated;
22960             out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated;
22961             out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
22962             out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated;
22963             out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated;
22964             out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated;
22965             out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated;
22966             out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated;
22967             out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated;
22968             out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated;
22969             out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated;
22970             out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated;
22971             out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
22972             out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
22973             out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
22974             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
22975             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
22976             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
22977             out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
22978             out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
22979             out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
22980             out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
22981             out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
22982             out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
22983             out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
22984             out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
22985             out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
22986             out_header = (void *)out_ext;
22987             break;
22988         }
22989         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
22990         {
22991             VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR);
22992             const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *)in_header;
22993             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
22994             out_ext->triStripVertexOrderIndependentOfProvokingVertex = in_ext->triStripVertexOrderIndependentOfProvokingVertex;
22995             out_header = (void *)out_ext;
22996             break;
22997         }
22998         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
22999         {
23000             VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT);
23001             const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)in_header;
23002             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
23003             out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking;
23004             out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration;
23005             out_header = (void *)out_ext;
23006             break;
23007         }
23008         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
23009         {
23010             VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT);
23011             const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *)in_header;
23012             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
23013             memcpy(out_ext->shaderModuleIdentifierAlgorithmUUID, in_ext->shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE * sizeof(uint8_t));
23014             out_header = (void *)out_ext;
23015             break;
23016         }
23017         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
23018         {
23019             VkPhysicalDeviceOpacityMicromapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT);
23020             const VkPhysicalDeviceOpacityMicromapPropertiesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapPropertiesEXT *)in_header;
23021             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
23022             out_ext->maxOpacity2StateSubdivisionLevel = in_ext->maxOpacity2StateSubdivisionLevel;
23023             out_ext->maxOpacity4StateSubdivisionLevel = in_ext->maxOpacity4StateSubdivisionLevel;
23024             out_header = (void *)out_ext;
23025             break;
23026         }
23027         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
23028         {
23029             VkPhysicalDevicePipelineRobustnessPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT);
23030             const VkPhysicalDevicePipelineRobustnessPropertiesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessPropertiesEXT *)in_header;
23031             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT;
23032             out_ext->defaultRobustnessStorageBuffers = in_ext->defaultRobustnessStorageBuffers;
23033             out_ext->defaultRobustnessUniformBuffers = in_ext->defaultRobustnessUniformBuffers;
23034             out_ext->defaultRobustnessVertexInputs = in_ext->defaultRobustnessVertexInputs;
23035             out_ext->defaultRobustnessImages = in_ext->defaultRobustnessImages;
23036             out_header = (void *)out_ext;
23037             break;
23038         }
23039         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
23040         {
23041             VkPhysicalDeviceImageProcessingPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM);
23042             const VkPhysicalDeviceImageProcessingPropertiesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingPropertiesQCOM *)in_header;
23043             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
23044             out_ext->maxWeightFilterPhases = in_ext->maxWeightFilterPhases;
23045             out_ext->maxWeightFilterDimension = in_ext->maxWeightFilterDimension;
23046             out_ext->maxBlockMatchRegion = in_ext->maxBlockMatchRegion;
23047             out_ext->maxBoxFilterBlockSize = in_ext->maxBoxFilterBlockSize;
23048             out_header = (void *)out_ext;
23049             break;
23050         }
23051         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
23052         {
23053             VkPhysicalDeviceOpticalFlowPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV);
23054             const VkPhysicalDeviceOpticalFlowPropertiesNV *in_ext = (const VkPhysicalDeviceOpticalFlowPropertiesNV *)in_header;
23055             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
23056             out_ext->supportedOutputGridSizes = in_ext->supportedOutputGridSizes;
23057             out_ext->supportedHintGridSizes = in_ext->supportedHintGridSizes;
23058             out_ext->hintSupported = in_ext->hintSupported;
23059             out_ext->costSupported = in_ext->costSupported;
23060             out_ext->bidirectionalFlowSupported = in_ext->bidirectionalFlowSupported;
23061             out_ext->globalFlowSupported = in_ext->globalFlowSupported;
23062             out_ext->minWidth = in_ext->minWidth;
23063             out_ext->minHeight = in_ext->minHeight;
23064             out_ext->maxWidth = in_ext->maxWidth;
23065             out_ext->maxHeight = in_ext->maxHeight;
23066             out_ext->maxNumRegionsOfInterest = in_ext->maxNumRegionsOfInterest;
23067             out_header = (void *)out_ext;
23068             break;
23069         }
23070         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
23071         {
23072             VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM);
23073             const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *)in_header;
23074             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
23075             out_ext->shaderCoreMask = in_ext->shaderCoreMask;
23076             out_ext->shaderCoreCount = in_ext->shaderCoreCount;
23077             out_ext->shaderWarpsPerCore = in_ext->shaderWarpsPerCore;
23078             out_header = (void *)out_ext;
23079             break;
23080         }
23081         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
23082         {
23083             VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV);
23084             const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *)in_header;
23085             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
23086             out_ext->rayTracingInvocationReorderReorderingHint = in_ext->rayTracingInvocationReorderReorderingHint;
23087             out_header = (void *)out_ext;
23088             break;
23089         }
23090         default:
23091             break;
23092         }
23093     }
23094 }
23095
23096 static inline void convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(const VkQueryPoolPerformanceCreateInfoKHR32 *in, VkQueryPoolPerformanceCreateInfoKHR *out)
23097 {
23098     if (!in) return;
23099
23100     out->sType = in->sType;
23101     out->pNext = NULL;
23102     out->queueFamilyIndex = in->queueFamilyIndex;
23103     out->counterIndexCount = in->counterIndexCount;
23104     out->pCounterIndices = (const uint32_t *)UlongToPtr(in->pCounterIndices);
23105     if (in->pNext)
23106         FIXME("Unexpected pNext\n");
23107 }
23108
23109 static inline void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, VkQueueFamilyProperties2 *out)
23110 {
23111     const VkBaseInStructure32 *in_header;
23112     VkBaseOutStructure *out_header = (void *)out;
23113
23114     if (!in) return;
23115
23116     out->sType = in->sType;
23117     out->pNext = NULL;
23118
23119     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
23120     {
23121         switch (in_header->sType)
23122         {
23123         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
23124         {
23125             VkQueueFamilyGlobalPriorityPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23126             const VkQueueFamilyGlobalPriorityPropertiesKHR32 *in_ext = (const VkQueueFamilyGlobalPriorityPropertiesKHR32 *)in_header;
23127             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
23128             out_ext->pNext = NULL;
23129             out_ext->priorityCount = in_ext->priorityCount;
23130             memcpy(out_ext->priorities, in_ext->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
23131             out_header->pNext = (void *)out_ext;
23132             out_header = (void *)out_ext;
23133             break;
23134         }
23135         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
23136         {
23137             VkQueueFamilyCheckpointPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23138             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
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_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
23145         {
23146             VkQueueFamilyCheckpointProperties2NV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23147             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
23148             out_ext->pNext = NULL;
23149             out_header->pNext = (void *)out_ext;
23150             out_header = (void *)out_ext;
23151             break;
23152         }
23153         default:
23154             FIXME("Unhandled sType %u.", in_header->sType);
23155             break;
23156         }
23157     }
23158 }
23159
23160 static inline void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out)
23161 {
23162     const VkBaseInStructure *in_header;
23163     VkBaseOutStructure32 *out_header = (void *)out;
23164
23165     if (!in) return;
23166
23167     out->queueFamilyProperties = in->queueFamilyProperties;
23168
23169     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
23170     {
23171         switch (in_header->sType)
23172         {
23173         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
23174         {
23175             VkQueueFamilyGlobalPriorityPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR);
23176             const VkQueueFamilyGlobalPriorityPropertiesKHR *in_ext = (const VkQueueFamilyGlobalPriorityPropertiesKHR *)in_header;
23177             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
23178             out_ext->priorityCount = in_ext->priorityCount;
23179             memcpy(out_ext->priorities, in_ext->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
23180             out_header = (void *)out_ext;
23181             break;
23182         }
23183         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
23184         {
23185             VkQueueFamilyCheckpointPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV);
23186             const VkQueueFamilyCheckpointPropertiesNV *in_ext = (const VkQueueFamilyCheckpointPropertiesNV *)in_header;
23187             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
23188             out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask;
23189             out_header = (void *)out_ext;
23190             break;
23191         }
23192         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
23193         {
23194             VkQueueFamilyCheckpointProperties2NV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV);
23195             const VkQueueFamilyCheckpointProperties2NV *in_ext = (const VkQueueFamilyCheckpointProperties2NV *)in_header;
23196             out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
23197             out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask;
23198             out_header = (void *)out_ext;
23199             break;
23200         }
23201         default:
23202             break;
23203         }
23204     }
23205 }
23206
23207 static inline VkQueueFamilyProperties2 *convert_VkQueueFamilyProperties2_array_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, uint32_t count)
23208 {
23209     VkQueueFamilyProperties2 *out;
23210     unsigned int i;
23211
23212     if (!in || !count) return NULL;
23213
23214     out = conversion_context_alloc(ctx, count * sizeof(*out));
23215     for (i = 0; i < count; i++)
23216     {
23217         convert_VkQueueFamilyProperties2_win32_to_host(ctx, &in[i], &out[i]);
23218     }
23219
23220     return out;
23221 }
23222
23223 static inline void convert_VkQueueFamilyProperties2_array_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out, uint32_t count)
23224 {
23225     unsigned int i;
23226
23227     if (!in) return;
23228
23229     for (i = 0; i < count; i++)
23230     {
23231         convert_VkQueueFamilyProperties2_host_to_win32(&in[i], &out[i]);
23232     }
23233 }
23234
23235 static inline void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(const VkPhysicalDeviceSparseImageFormatInfo232 *in, VkPhysicalDeviceSparseImageFormatInfo2 *out)
23236 {
23237     if (!in) return;
23238
23239     out->sType = in->sType;
23240     out->pNext = NULL;
23241     out->format = in->format;
23242     out->type = in->type;
23243     out->samples = in->samples;
23244     out->usage = in->usage;
23245     out->tiling = in->tiling;
23246     if (in->pNext)
23247         FIXME("Unexpected pNext\n");
23248 }
23249
23250 static inline void convert_VkSparseImageFormatProperties2_win32_to_host(const VkSparseImageFormatProperties232 *in, VkSparseImageFormatProperties2 *out)
23251 {
23252     if (!in) return;
23253
23254     out->sType = in->sType;
23255     out->pNext = NULL;
23256     if (in->pNext)
23257         FIXME("Unexpected pNext\n");
23258 }
23259
23260 static inline void convert_VkSparseImageFormatProperties2_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out)
23261 {
23262     if (!in) return;
23263
23264     out->properties = in->properties;
23265 }
23266
23267 static inline VkSparseImageFormatProperties2 *convert_VkSparseImageFormatProperties2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageFormatProperties232 *in, uint32_t count)
23268 {
23269     VkSparseImageFormatProperties2 *out;
23270     unsigned int i;
23271
23272     if (!in || !count) return NULL;
23273
23274     out = conversion_context_alloc(ctx, count * sizeof(*out));
23275     for (i = 0; i < count; i++)
23276     {
23277         convert_VkSparseImageFormatProperties2_win32_to_host(&in[i], &out[i]);
23278     }
23279
23280     return out;
23281 }
23282
23283 static inline void convert_VkSparseImageFormatProperties2_array_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out, uint32_t count)
23284 {
23285     unsigned int i;
23286
23287     if (!in) return;
23288
23289     for (i = 0; i < count; i++)
23290     {
23291         convert_VkSparseImageFormatProperties2_host_to_win32(&in[i], &out[i]);
23292     }
23293 }
23294
23295 static inline void convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(const VkFramebufferMixedSamplesCombinationNV32 *in, VkFramebufferMixedSamplesCombinationNV *out)
23296 {
23297     if (!in) return;
23298
23299     out->sType = in->sType;
23300     out->pNext = NULL;
23301     if (in->pNext)
23302         FIXME("Unexpected pNext\n");
23303 }
23304
23305 static inline void convert_VkFramebufferMixedSamplesCombinationNV_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out)
23306 {
23307     if (!in) return;
23308
23309     out->coverageReductionMode = in->coverageReductionMode;
23310     out->rasterizationSamples = in->rasterizationSamples;
23311     out->depthStencilSamples = in->depthStencilSamples;
23312     out->colorSamples = in->colorSamples;
23313 }
23314
23315 static inline VkFramebufferMixedSamplesCombinationNV *convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferMixedSamplesCombinationNV32 *in, uint32_t count)
23316 {
23317     VkFramebufferMixedSamplesCombinationNV *out;
23318     unsigned int i;
23319
23320     if (!in || !count) return NULL;
23321
23322     out = conversion_context_alloc(ctx, count * sizeof(*out));
23323     for (i = 0; i < count; i++)
23324     {
23325         convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(&in[i], &out[i]);
23326     }
23327
23328     return out;
23329 }
23330
23331 static inline void convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out, uint32_t count)
23332 {
23333     unsigned int i;
23334
23335     if (!in) return;
23336
23337     for (i = 0; i < count; i++)
23338     {
23339         convert_VkFramebufferMixedSamplesCombinationNV_host_to_win32(&in[i], &out[i]);
23340     }
23341 }
23342
23343 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
23344 {
23345     if (!in) return;
23346
23347     out->sType = in->sType;
23348     out->pNext = NULL;
23349     out->surface = in->surface;
23350     if (in->pNext)
23351         FIXME("Unexpected pNext\n");
23352 }
23353
23354 static inline void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceCapabilities2KHR32 *in, VkSurfaceCapabilities2KHR *out)
23355 {
23356     const VkBaseInStructure32 *in_header;
23357     VkBaseOutStructure *out_header = (void *)out;
23358
23359     if (!in) return;
23360
23361     out->sType = in->sType;
23362     out->pNext = NULL;
23363
23364     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
23365     {
23366         switch (in_header->sType)
23367         {
23368         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
23369         {
23370             VkSurfaceCapabilitiesPresentBarrierNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23371             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV;
23372             out_ext->pNext = NULL;
23373             out_header->pNext = (void *)out_ext;
23374             out_header = (void *)out_ext;
23375             break;
23376         }
23377         default:
23378             FIXME("Unhandled sType %u.", in_header->sType);
23379             break;
23380         }
23381     }
23382 }
23383
23384 static inline void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapabilities2KHR *in, VkSurfaceCapabilities2KHR32 *out)
23385 {
23386     const VkBaseInStructure *in_header;
23387     VkBaseOutStructure32 *out_header = (void *)out;
23388
23389     if (!in) return;
23390
23391     out->surfaceCapabilities = in->surfaceCapabilities;
23392
23393     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
23394     {
23395         switch (in_header->sType)
23396         {
23397         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
23398         {
23399             VkSurfaceCapabilitiesPresentBarrierNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV);
23400             const VkSurfaceCapabilitiesPresentBarrierNV *in_ext = (const VkSurfaceCapabilitiesPresentBarrierNV *)in_header;
23401             out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV;
23402             out_ext->presentBarrierSupported = in_ext->presentBarrierSupported;
23403             out_header = (void *)out_ext;
23404             break;
23405         }
23406         default:
23407             break;
23408         }
23409     }
23410 }
23411
23412 #ifdef _WIN64
23413 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win64_to_host(const VkPhysicalDeviceSurfaceInfo2KHR *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
23414 {
23415     if (!in) return;
23416
23417     out->sType = in->sType;
23418     out->pNext = in->pNext;
23419     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
23420 }
23421 #endif /* _WIN64 */
23422
23423 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host(const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
23424 {
23425     if (!in) return;
23426
23427     out->sType = in->sType;
23428     out->pNext = NULL;
23429     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
23430     if (in->pNext)
23431         FIXME("Unexpected pNext\n");
23432 }
23433
23434 static inline void convert_VkSurfaceFormat2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, VkSurfaceFormat2KHR *out)
23435 {
23436     const VkBaseInStructure32 *in_header;
23437     VkBaseOutStructure *out_header = (void *)out;
23438
23439     if (!in) return;
23440
23441     out->sType = in->sType;
23442     out->pNext = NULL;
23443
23444     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
23445     {
23446         switch (in_header->sType)
23447         {
23448         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
23449         {
23450             VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
23451             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
23452             out_ext->pNext = NULL;
23453             out_header->pNext = (void *)out_ext;
23454             out_header = (void *)out_ext;
23455             break;
23456         }
23457         default:
23458             FIXME("Unhandled sType %u.", in_header->sType);
23459             break;
23460         }
23461     }
23462 }
23463
23464 static inline void convert_VkSurfaceFormat2KHR_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out)
23465 {
23466     const VkBaseInStructure *in_header;
23467     VkBaseOutStructure32 *out_header = (void *)out;
23468
23469     if (!in) return;
23470
23471     out->surfaceFormat = in->surfaceFormat;
23472
23473     for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext)
23474     {
23475         switch (in_header->sType)
23476         {
23477         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
23478         {
23479             VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
23480             const VkImageCompressionPropertiesEXT *in_ext = (const VkImageCompressionPropertiesEXT *)in_header;
23481             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT;
23482             out_ext->imageCompressionFlags = in_ext->imageCompressionFlags;
23483             out_ext->imageCompressionFixedRateFlags = in_ext->imageCompressionFixedRateFlags;
23484             out_header = (void *)out_ext;
23485             break;
23486         }
23487         default:
23488             break;
23489         }
23490     }
23491 }
23492
23493 static inline VkSurfaceFormat2KHR *convert_VkSurfaceFormat2KHR_array_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, uint32_t count)
23494 {
23495     VkSurfaceFormat2KHR *out;
23496     unsigned int i;
23497
23498     if (!in || !count) return NULL;
23499
23500     out = conversion_context_alloc(ctx, count * sizeof(*out));
23501     for (i = 0; i < count; i++)
23502     {
23503         convert_VkSurfaceFormat2KHR_win32_to_host(ctx, &in[i], &out[i]);
23504     }
23505
23506     return out;
23507 }
23508
23509 static inline void convert_VkSurfaceFormat2KHR_array_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out, uint32_t count)
23510 {
23511     unsigned int i;
23512
23513     if (!in) return;
23514
23515     for (i = 0; i < count; i++)
23516     {
23517         convert_VkSurfaceFormat2KHR_host_to_win32(&in[i], &out[i]);
23518     }
23519 }
23520
23521 static inline void convert_VkPhysicalDeviceToolProperties_win32_to_host(const VkPhysicalDeviceToolProperties32 *in, VkPhysicalDeviceToolProperties *out)
23522 {
23523     if (!in) return;
23524
23525     out->sType = in->sType;
23526     out->pNext = NULL;
23527     if (in->pNext)
23528         FIXME("Unexpected pNext\n");
23529 }
23530
23531 static inline void convert_VkPhysicalDeviceToolProperties_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out)
23532 {
23533     if (!in) return;
23534
23535     memcpy(out->name, in->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
23536     memcpy(out->version, in->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
23537     out->purposes = in->purposes;
23538     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
23539     memcpy(out->layer, in->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
23540 }
23541
23542 static inline VkPhysicalDeviceToolProperties *convert_VkPhysicalDeviceToolProperties_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceToolProperties32 *in, uint32_t count)
23543 {
23544     VkPhysicalDeviceToolProperties *out;
23545     unsigned int i;
23546
23547     if (!in || !count) return NULL;
23548
23549     out = conversion_context_alloc(ctx, count * sizeof(*out));
23550     for (i = 0; i < count; i++)
23551     {
23552         convert_VkPhysicalDeviceToolProperties_win32_to_host(&in[i], &out[i]);
23553     }
23554
23555     return out;
23556 }
23557
23558 static inline void convert_VkPhysicalDeviceToolProperties_array_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out, uint32_t count)
23559 {
23560     unsigned int i;
23561
23562     if (!in) return;
23563
23564     for (i = 0; i < count; i++)
23565     {
23566         convert_VkPhysicalDeviceToolProperties_host_to_win32(&in[i], &out[i]);
23567     }
23568 }
23569
23570 static inline void convert_VkPipelineExecutableInfoKHR_win32_to_host(const VkPipelineExecutableInfoKHR32 *in, VkPipelineExecutableInfoKHR *out)
23571 {
23572     if (!in) return;
23573
23574     out->sType = in->sType;
23575     out->pNext = NULL;
23576     out->pipeline = in->pipeline;
23577     out->executableIndex = in->executableIndex;
23578     if (in->pNext)
23579         FIXME("Unexpected pNext\n");
23580 }
23581
23582 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_win32_to_host(const VkPipelineExecutableInternalRepresentationKHR32 *in, VkPipelineExecutableInternalRepresentationKHR *out)
23583 {
23584     if (!in) return;
23585
23586     out->sType = in->sType;
23587     out->pNext = NULL;
23588     if (in->pNext)
23589         FIXME("Unexpected pNext\n");
23590 }
23591
23592 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out)
23593 {
23594     if (!in) return;
23595
23596     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
23597     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
23598     out->isText = in->isText;
23599     out->dataSize = in->dataSize;
23600     out->pData = PtrToUlong(in->pData);
23601 }
23602
23603 static inline VkPipelineExecutableInternalRepresentationKHR *convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableInternalRepresentationKHR32 *in, uint32_t count)
23604 {
23605     VkPipelineExecutableInternalRepresentationKHR *out;
23606     unsigned int i;
23607
23608     if (!in || !count) return NULL;
23609
23610     out = conversion_context_alloc(ctx, count * sizeof(*out));
23611     for (i = 0; i < count; i++)
23612     {
23613         convert_VkPipelineExecutableInternalRepresentationKHR_win32_to_host(&in[i], &out[i]);
23614     }
23615
23616     return out;
23617 }
23618
23619 static inline void convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out, uint32_t count)
23620 {
23621     unsigned int i;
23622
23623     if (!in) return;
23624
23625     for (i = 0; i < count; i++)
23626     {
23627         convert_VkPipelineExecutableInternalRepresentationKHR_host_to_win32(&in[i], &out[i]);
23628     }
23629 }
23630
23631 static inline void convert_VkPipelineInfoKHR_win32_to_host(const VkPipelineInfoKHR32 *in, VkPipelineInfoKHR *out)
23632 {
23633     if (!in) return;
23634
23635     out->sType = in->sType;
23636     out->pNext = NULL;
23637     out->pipeline = in->pipeline;
23638     if (in->pNext)
23639         FIXME("Unexpected pNext\n");
23640 }
23641
23642 static inline void convert_VkPipelineExecutablePropertiesKHR_win32_to_host(const VkPipelineExecutablePropertiesKHR32 *in, VkPipelineExecutablePropertiesKHR *out)
23643 {
23644     if (!in) return;
23645
23646     out->sType = in->sType;
23647     out->pNext = NULL;
23648     if (in->pNext)
23649         FIXME("Unexpected pNext\n");
23650 }
23651
23652 static inline void convert_VkPipelineExecutablePropertiesKHR_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out)
23653 {
23654     if (!in) return;
23655
23656     out->stages = in->stages;
23657     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
23658     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
23659     out->subgroupSize = in->subgroupSize;
23660 }
23661
23662 static inline VkPipelineExecutablePropertiesKHR *convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutablePropertiesKHR32 *in, uint32_t count)
23663 {
23664     VkPipelineExecutablePropertiesKHR *out;
23665     unsigned int i;
23666
23667     if (!in || !count) return NULL;
23668
23669     out = conversion_context_alloc(ctx, count * sizeof(*out));
23670     for (i = 0; i < count; i++)
23671     {
23672         convert_VkPipelineExecutablePropertiesKHR_win32_to_host(&in[i], &out[i]);
23673     }
23674
23675     return out;
23676 }
23677
23678 static inline void convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out, uint32_t count)
23679 {
23680     unsigned int i;
23681
23682     if (!in) return;
23683
23684     for (i = 0; i < count; i++)
23685     {
23686         convert_VkPipelineExecutablePropertiesKHR_host_to_win32(&in[i], &out[i]);
23687     }
23688 }
23689
23690 static inline void convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(const VkPipelineExecutableStatisticValueKHR *in, VkPipelineExecutableStatisticValueKHR32 *out, VkFlags selector)
23691 {
23692     if (!in) return;
23693
23694     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR)
23695         out->b32 = in->b32;
23696     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR)
23697         out->i64 = in->i64;
23698     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR)
23699         out->u64 = in->u64;
23700     if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR)
23701         out->f64 = in->f64;
23702 }
23703
23704 static inline void convert_VkPipelineExecutableStatisticKHR_win32_to_host(const VkPipelineExecutableStatisticKHR32 *in, VkPipelineExecutableStatisticKHR *out)
23705 {
23706     if (!in) return;
23707
23708     out->sType = in->sType;
23709     out->pNext = NULL;
23710     if (in->pNext)
23711         FIXME("Unexpected pNext\n");
23712 }
23713
23714 static inline void convert_VkPipelineExecutableStatisticKHR_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out)
23715 {
23716     if (!in) return;
23717
23718     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
23719     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
23720     out->format = in->format;
23721     convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(&in->value, &out->value, in->format);
23722 }
23723
23724 static inline VkPipelineExecutableStatisticKHR *convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableStatisticKHR32 *in, uint32_t count)
23725 {
23726     VkPipelineExecutableStatisticKHR *out;
23727     unsigned int i;
23728
23729     if (!in || !count) return NULL;
23730
23731     out = conversion_context_alloc(ctx, count * sizeof(*out));
23732     for (i = 0; i < count; i++)
23733     {
23734         convert_VkPipelineExecutableStatisticKHR_win32_to_host(&in[i], &out[i]);
23735     }
23736
23737     return out;
23738 }
23739
23740 static inline void convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out, uint32_t count)
23741 {
23742     unsigned int i;
23743
23744     if (!in) return;
23745
23746     for (i = 0; i < count; i++)
23747     {
23748         convert_VkPipelineExecutableStatisticKHR_host_to_win32(&in[i], &out[i]);
23749     }
23750 }
23751
23752 static inline void convert_VkPipelineInfoEXT_win32_to_host(const VkPipelineInfoEXT32 *in, VkPipelineInfoEXT *out)
23753 {
23754     if (!in) return;
23755
23756     out->sType = in->sType;
23757     out->pNext = NULL;
23758     out->pipeline = in->pipeline;
23759     if (in->pNext)
23760         FIXME("Unexpected pNext\n");
23761 }
23762
23763 static inline void convert_VkCheckpointData2NV_win32_to_host(const VkCheckpointData2NV32 *in, VkCheckpointData2NV *out)
23764 {
23765     if (!in) return;
23766
23767     out->sType = in->sType;
23768     out->pNext = NULL;
23769     if (in->pNext)
23770         FIXME("Unexpected pNext\n");
23771 }
23772
23773 static inline void convert_VkCheckpointData2NV_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out)
23774 {
23775     if (!in) return;
23776
23777     out->stage = in->stage;
23778     out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker);
23779 }
23780
23781 static inline VkCheckpointData2NV *convert_VkCheckpointData2NV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointData2NV32 *in, uint32_t count)
23782 {
23783     VkCheckpointData2NV *out;
23784     unsigned int i;
23785
23786     if (!in || !count) return NULL;
23787
23788     out = conversion_context_alloc(ctx, count * sizeof(*out));
23789     for (i = 0; i < count; i++)
23790     {
23791         convert_VkCheckpointData2NV_win32_to_host(&in[i], &out[i]);
23792     }
23793
23794     return out;
23795 }
23796
23797 static inline void convert_VkCheckpointData2NV_array_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out, uint32_t count)
23798 {
23799     unsigned int i;
23800
23801     if (!in) return;
23802
23803     for (i = 0; i < count; i++)
23804     {
23805         convert_VkCheckpointData2NV_host_to_win32(&in[i], &out[i]);
23806     }
23807 }
23808
23809 static inline void convert_VkCheckpointDataNV_win32_to_host(const VkCheckpointDataNV32 *in, VkCheckpointDataNV *out)
23810 {
23811     if (!in) return;
23812
23813     out->sType = in->sType;
23814     out->pNext = NULL;
23815     if (in->pNext)
23816         FIXME("Unexpected pNext\n");
23817 }
23818
23819 static inline void convert_VkCheckpointDataNV_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out)
23820 {
23821     if (!in) return;
23822
23823     out->stage = in->stage;
23824     out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker);
23825 }
23826
23827 static inline VkCheckpointDataNV *convert_VkCheckpointDataNV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointDataNV32 *in, uint32_t count)
23828 {
23829     VkCheckpointDataNV *out;
23830     unsigned int i;
23831
23832     if (!in || !count) return NULL;
23833
23834     out = conversion_context_alloc(ctx, count * sizeof(*out));
23835     for (i = 0; i < count; i++)
23836     {
23837         convert_VkCheckpointDataNV_win32_to_host(&in[i], &out[i]);
23838     }
23839
23840     return out;
23841 }
23842
23843 static inline void convert_VkCheckpointDataNV_array_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out, uint32_t count)
23844 {
23845     unsigned int i;
23846
23847     if (!in) return;
23848
23849     for (i = 0; i < count; i++)
23850     {
23851         convert_VkCheckpointDataNV_host_to_win32(&in[i], &out[i]);
23852     }
23853 }
23854
23855 static inline void convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host(const VkSamplerCaptureDescriptorDataInfoEXT32 *in, VkSamplerCaptureDescriptorDataInfoEXT *out)
23856 {
23857     if (!in) return;
23858
23859     out->sType = in->sType;
23860     out->pNext = NULL;
23861     out->sampler = in->sampler;
23862     if (in->pNext)
23863         FIXME("Unexpected pNext\n");
23864 }
23865
23866 static inline void convert_VkShaderModuleIdentifierEXT_win32_to_host(const VkShaderModuleIdentifierEXT32 *in, VkShaderModuleIdentifierEXT *out)
23867 {
23868     if (!in) return;
23869
23870     out->sType = in->sType;
23871     out->pNext = NULL;
23872     if (in->pNext)
23873         FIXME("Unexpected pNext\n");
23874 }
23875
23876 static inline void convert_VkShaderModuleIdentifierEXT_host_to_win32(const VkShaderModuleIdentifierEXT *in, VkShaderModuleIdentifierEXT32 *out)
23877 {
23878     if (!in) return;
23879
23880     out->identifierSize = in->identifierSize;
23881     memcpy(out->identifier, in->identifier, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t));
23882 }
23883
23884 static inline void convert_VkInitializePerformanceApiInfoINTEL_win32_to_host(const VkInitializePerformanceApiInfoINTEL32 *in, VkInitializePerformanceApiInfoINTEL *out)
23885 {
23886     if (!in) return;
23887
23888     out->sType = in->sType;
23889     out->pNext = NULL;
23890     out->pUserData = (void *)UlongToPtr(in->pUserData);
23891     if (in->pNext)
23892         FIXME("Unexpected pNext\n");
23893 }
23894
23895 static inline void convert_VkSparseMemoryBind_win32_to_host(const VkSparseMemoryBind32 *in, VkSparseMemoryBind *out)
23896 {
23897     if (!in) return;
23898
23899     out->resourceOffset = in->resourceOffset;
23900     out->size = in->size;
23901     out->memory = in->memory;
23902     out->memoryOffset = in->memoryOffset;
23903     out->flags = in->flags;
23904 }
23905
23906 static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseMemoryBind32 *in, uint32_t count)
23907 {
23908     VkSparseMemoryBind *out;
23909     unsigned int i;
23910
23911     if (!in || !count) return NULL;
23912
23913     out = conversion_context_alloc(ctx, count * sizeof(*out));
23914     for (i = 0; i < count; i++)
23915     {
23916         convert_VkSparseMemoryBind_win32_to_host(&in[i], &out[i]);
23917     }
23918
23919     return out;
23920 }
23921
23922 static inline void convert_VkSparseBufferMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, VkSparseBufferMemoryBindInfo *out)
23923 {
23924     if (!in) return;
23925
23926     out->buffer = in->buffer;
23927     out->bindCount = in->bindCount;
23928     out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
23929 }
23930
23931 static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, uint32_t count)
23932 {
23933     VkSparseBufferMemoryBindInfo *out;
23934     unsigned int i;
23935
23936     if (!in || !count) return NULL;
23937
23938     out = conversion_context_alloc(ctx, count * sizeof(*out));
23939     for (i = 0; i < count; i++)
23940     {
23941         convert_VkSparseBufferMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
23942     }
23943
23944     return out;
23945 }
23946
23947 static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, VkSparseImageOpaqueMemoryBindInfo *out)
23948 {
23949     if (!in) return;
23950
23951     out->image = in->image;
23952     out->bindCount = in->bindCount;
23953     out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
23954 }
23955
23956 static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, uint32_t count)
23957 {
23958     VkSparseImageOpaqueMemoryBindInfo *out;
23959     unsigned int i;
23960
23961     if (!in || !count) return NULL;
23962
23963     out = conversion_context_alloc(ctx, count * sizeof(*out));
23964     for (i = 0; i < count; i++)
23965     {
23966         convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
23967     }
23968
23969     return out;
23970 }
23971
23972 static inline void convert_VkSparseImageMemoryBind_win32_to_host(const VkSparseImageMemoryBind32 *in, VkSparseImageMemoryBind *out)
23973 {
23974     if (!in) return;
23975
23976     out->subresource = in->subresource;
23977     out->offset = in->offset;
23978     out->extent = in->extent;
23979     out->memory = in->memory;
23980     out->memoryOffset = in->memoryOffset;
23981     out->flags = in->flags;
23982 }
23983
23984 static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind32 *in, uint32_t count)
23985 {
23986     VkSparseImageMemoryBind *out;
23987     unsigned int i;
23988
23989     if (!in || !count) return NULL;
23990
23991     out = conversion_context_alloc(ctx, count * sizeof(*out));
23992     for (i = 0; i < count; i++)
23993     {
23994         convert_VkSparseImageMemoryBind_win32_to_host(&in[i], &out[i]);
23995     }
23996
23997     return out;
23998 }
23999
24000 static inline void convert_VkSparseImageMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, VkSparseImageMemoryBindInfo *out)
24001 {
24002     if (!in) return;
24003
24004     out->image = in->image;
24005     out->bindCount = in->bindCount;
24006     out->pBinds = convert_VkSparseImageMemoryBind_array_win32_to_host(ctx, (const VkSparseImageMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
24007 }
24008
24009 static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, uint32_t count)
24010 {
24011     VkSparseImageMemoryBindInfo *out;
24012     unsigned int i;
24013
24014     if (!in || !count) return NULL;
24015
24016     out = conversion_context_alloc(ctx, count * sizeof(*out));
24017     for (i = 0; i < count; i++)
24018     {
24019         convert_VkSparseImageMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
24020     }
24021
24022     return out;
24023 }
24024
24025 static inline void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, VkBindSparseInfo *out)
24026 {
24027     const VkBaseInStructure32 *in_header;
24028     VkBaseOutStructure *out_header = (void *)out;
24029
24030     if (!in) return;
24031
24032     out->sType = in->sType;
24033     out->pNext = NULL;
24034     out->waitSemaphoreCount = in->waitSemaphoreCount;
24035     out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
24036     out->bufferBindCount = in->bufferBindCount;
24037     out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseBufferMemoryBindInfo32 *)UlongToPtr(in->pBufferBinds), in->bufferBindCount);
24038     out->imageOpaqueBindCount = in->imageOpaqueBindCount;
24039     out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseImageOpaqueMemoryBindInfo32 *)UlongToPtr(in->pImageOpaqueBinds), in->imageOpaqueBindCount);
24040     out->imageBindCount = in->imageBindCount;
24041     out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseImageMemoryBindInfo32 *)UlongToPtr(in->pImageBinds), in->imageBindCount);
24042     out->signalSemaphoreCount = in->signalSemaphoreCount;
24043     out->pSignalSemaphores = (const VkSemaphore *)UlongToPtr(in->pSignalSemaphores);
24044
24045     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24046     {
24047         switch (in_header->sType)
24048         {
24049         case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
24050         {
24051             VkDeviceGroupBindSparseInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24052             const VkDeviceGroupBindSparseInfo32 *in_ext = (const VkDeviceGroupBindSparseInfo32 *)in_header;
24053             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO;
24054             out_ext->pNext = NULL;
24055             out_ext->resourceDeviceIndex = in_ext->resourceDeviceIndex;
24056             out_ext->memoryDeviceIndex = in_ext->memoryDeviceIndex;
24057             out_header->pNext = (void *)out_ext;
24058             out_header = (void *)out_ext;
24059             break;
24060         }
24061         case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
24062         {
24063             VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24064             const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header;
24065             out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
24066             out_ext->pNext = NULL;
24067             out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
24068             out_ext->pWaitSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pWaitSemaphoreValues);
24069             out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
24070             out_ext->pSignalSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pSignalSemaphoreValues);
24071             out_header->pNext = (void *)out_ext;
24072             out_header = (void *)out_ext;
24073             break;
24074         }
24075         default:
24076             FIXME("Unhandled sType %u.", in_header->sType);
24077             break;
24078         }
24079     }
24080 }
24081
24082 static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, uint32_t count)
24083 {
24084     VkBindSparseInfo *out;
24085     unsigned int i;
24086
24087     if (!in || !count) return NULL;
24088
24089     out = conversion_context_alloc(ctx, count * sizeof(*out));
24090     for (i = 0; i < count; i++)
24091     {
24092         convert_VkBindSparseInfo_win32_to_host(ctx, &in[i], &out[i]);
24093     }
24094
24095     return out;
24096 }
24097
24098 static inline void convert_VkPresentRegionKHR_win32_to_host(const VkPresentRegionKHR32 *in, VkPresentRegionKHR *out)
24099 {
24100     if (!in) return;
24101
24102     out->rectangleCount = in->rectangleCount;
24103     out->pRectangles = (const VkRectLayerKHR *)UlongToPtr(in->pRectangles);
24104 }
24105
24106 static inline const VkPresentRegionKHR *convert_VkPresentRegionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPresentRegionKHR32 *in, uint32_t count)
24107 {
24108     VkPresentRegionKHR *out;
24109     unsigned int i;
24110
24111     if (!in || !count) return NULL;
24112
24113     out = conversion_context_alloc(ctx, count * sizeof(*out));
24114     for (i = 0; i < count; i++)
24115     {
24116         convert_VkPresentRegionKHR_win32_to_host(&in[i], &out[i]);
24117     }
24118
24119     return out;
24120 }
24121
24122 static inline void convert_VkPresentInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPresentInfoKHR32 *in, VkPresentInfoKHR *out)
24123 {
24124     const VkBaseInStructure32 *in_header;
24125     VkBaseOutStructure *out_header = (void *)out;
24126
24127     if (!in) return;
24128
24129     out->sType = in->sType;
24130     out->pNext = NULL;
24131     out->waitSemaphoreCount = in->waitSemaphoreCount;
24132     out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
24133     out->swapchainCount = in->swapchainCount;
24134     out->pSwapchains = (const VkSwapchainKHR *)UlongToPtr(in->pSwapchains);
24135     out->pImageIndices = (const uint32_t *)UlongToPtr(in->pImageIndices);
24136     out->pResults = (VkResult *)UlongToPtr(in->pResults);
24137
24138     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24139     {
24140         switch (in_header->sType)
24141         {
24142         case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
24143         {
24144             VkPresentRegionsKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24145             const VkPresentRegionsKHR32 *in_ext = (const VkPresentRegionsKHR32 *)in_header;
24146             out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR;
24147             out_ext->pNext = NULL;
24148             out_ext->swapchainCount = in_ext->swapchainCount;
24149             out_ext->pRegions = convert_VkPresentRegionKHR_array_win32_to_host(ctx, (const VkPresentRegionKHR32 *)UlongToPtr(in_ext->pRegions), in_ext->swapchainCount);
24150             out_header->pNext = (void *)out_ext;
24151             out_header = (void *)out_ext;
24152             break;
24153         }
24154         case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
24155         {
24156             VkDeviceGroupPresentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24157             const VkDeviceGroupPresentInfoKHR32 *in_ext = (const VkDeviceGroupPresentInfoKHR32 *)in_header;
24158             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR;
24159             out_ext->pNext = NULL;
24160             out_ext->swapchainCount = in_ext->swapchainCount;
24161             out_ext->pDeviceMasks = (const uint32_t *)UlongToPtr(in_ext->pDeviceMasks);
24162             out_ext->mode = in_ext->mode;
24163             out_header->pNext = (void *)out_ext;
24164             out_header = (void *)out_ext;
24165             break;
24166         }
24167         case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
24168         {
24169             VkPresentIdKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24170             const VkPresentIdKHR32 *in_ext = (const VkPresentIdKHR32 *)in_header;
24171             out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR;
24172             out_ext->pNext = NULL;
24173             out_ext->swapchainCount = in_ext->swapchainCount;
24174             out_ext->pPresentIds = (const uint64_t *)UlongToPtr(in_ext->pPresentIds);
24175             out_header->pNext = (void *)out_ext;
24176             out_header = (void *)out_ext;
24177             break;
24178         }
24179         default:
24180             FIXME("Unhandled sType %u.", in_header->sType);
24181             break;
24182         }
24183     }
24184 }
24185
24186 #ifdef _WIN64
24187 static inline void convert_VkSubmitInfo_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, VkSubmitInfo *out)
24188 {
24189     if (!in) return;
24190
24191     out->sType = in->sType;
24192     out->pNext = in->pNext;
24193     out->waitSemaphoreCount = in->waitSemaphoreCount;
24194     out->pWaitSemaphores = in->pWaitSemaphores;
24195     out->pWaitDstStageMask = in->pWaitDstStageMask;
24196     out->commandBufferCount = in->commandBufferCount;
24197     out->pCommandBuffers = convert_VkCommandBuffer_array_win64_to_host(ctx, in->pCommandBuffers, in->commandBufferCount);
24198     out->signalSemaphoreCount = in->signalSemaphoreCount;
24199     out->pSignalSemaphores = in->pSignalSemaphores;
24200 }
24201 #endif /* _WIN64 */
24202
24203 static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, VkSubmitInfo *out)
24204 {
24205     const VkBaseInStructure32 *in_header;
24206     VkBaseOutStructure *out_header = (void *)out;
24207
24208     if (!in) return;
24209
24210     out->sType = in->sType;
24211     out->pNext = NULL;
24212     out->waitSemaphoreCount = in->waitSemaphoreCount;
24213     out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
24214     out->pWaitDstStageMask = (const VkPipelineStageFlags *)UlongToPtr(in->pWaitDstStageMask);
24215     out->commandBufferCount = in->commandBufferCount;
24216     out->pCommandBuffers = convert_VkCommandBuffer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->pCommandBuffers), in->commandBufferCount);
24217     out->signalSemaphoreCount = in->signalSemaphoreCount;
24218     out->pSignalSemaphores = (const VkSemaphore *)UlongToPtr(in->pSignalSemaphores);
24219
24220     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24221     {
24222         switch (in_header->sType)
24223         {
24224         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
24225         {
24226             VkDeviceGroupSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24227             const VkDeviceGroupSubmitInfo32 *in_ext = (const VkDeviceGroupSubmitInfo32 *)in_header;
24228             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO;
24229             out_ext->pNext = NULL;
24230             out_ext->waitSemaphoreCount = in_ext->waitSemaphoreCount;
24231             out_ext->pWaitSemaphoreDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pWaitSemaphoreDeviceIndices);
24232             out_ext->commandBufferCount = in_ext->commandBufferCount;
24233             out_ext->pCommandBufferDeviceMasks = (const uint32_t *)UlongToPtr(in_ext->pCommandBufferDeviceMasks);
24234             out_ext->signalSemaphoreCount = in_ext->signalSemaphoreCount;
24235             out_ext->pSignalSemaphoreDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pSignalSemaphoreDeviceIndices);
24236             out_header->pNext = (void *)out_ext;
24237             out_header = (void *)out_ext;
24238             break;
24239         }
24240         case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
24241         {
24242             VkProtectedSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24243             const VkProtectedSubmitInfo32 *in_ext = (const VkProtectedSubmitInfo32 *)in_header;
24244             out_ext->sType = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO;
24245             out_ext->pNext = NULL;
24246             out_ext->protectedSubmit = in_ext->protectedSubmit;
24247             out_header->pNext = (void *)out_ext;
24248             out_header = (void *)out_ext;
24249             break;
24250         }
24251         case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
24252         {
24253             VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24254             const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header;
24255             out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
24256             out_ext->pNext = NULL;
24257             out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
24258             out_ext->pWaitSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pWaitSemaphoreValues);
24259             out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
24260             out_ext->pSignalSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pSignalSemaphoreValues);
24261             out_header->pNext = (void *)out_ext;
24262             out_header = (void *)out_ext;
24263             break;
24264         }
24265         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
24266         {
24267             VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24268             const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header;
24269             out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
24270             out_ext->pNext = NULL;
24271             out_ext->counterPassIndex = in_ext->counterPassIndex;
24272             out_header->pNext = (void *)out_ext;
24273             out_header = (void *)out_ext;
24274             break;
24275         }
24276         default:
24277             FIXME("Unhandled sType %u.", in_header->sType);
24278             break;
24279         }
24280     }
24281 }
24282
24283 #ifdef _WIN64
24284 static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, uint32_t count)
24285 {
24286     VkSubmitInfo *out;
24287     unsigned int i;
24288
24289     if (!in || !count) return NULL;
24290
24291     out = conversion_context_alloc(ctx, count * sizeof(*out));
24292     for (i = 0; i < count; i++)
24293     {
24294         convert_VkSubmitInfo_win64_to_host(ctx, &in[i], &out[i]);
24295     }
24296
24297     return out;
24298 }
24299 #endif /* _WIN64 */
24300
24301 static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, uint32_t count)
24302 {
24303     VkSubmitInfo *out;
24304     unsigned int i;
24305
24306     if (!in || !count) return NULL;
24307
24308     out = conversion_context_alloc(ctx, count * sizeof(*out));
24309     for (i = 0; i < count; i++)
24310     {
24311         convert_VkSubmitInfo_win32_to_host(ctx, &in[i], &out[i]);
24312     }
24313
24314     return out;
24315 }
24316
24317 static inline void convert_VkSemaphoreSubmitInfo_win32_to_host(const VkSemaphoreSubmitInfo32 *in, VkSemaphoreSubmitInfo *out)
24318 {
24319     if (!in) return;
24320
24321     out->sType = in->sType;
24322     out->pNext = NULL;
24323     out->semaphore = in->semaphore;
24324     out->value = in->value;
24325     out->stageMask = in->stageMask;
24326     out->deviceIndex = in->deviceIndex;
24327     if (in->pNext)
24328         FIXME("Unexpected pNext\n");
24329 }
24330
24331 static inline const VkSemaphoreSubmitInfo *convert_VkSemaphoreSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSemaphoreSubmitInfo32 *in, uint32_t count)
24332 {
24333     VkSemaphoreSubmitInfo *out;
24334     unsigned int i;
24335
24336     if (!in || !count) return NULL;
24337
24338     out = conversion_context_alloc(ctx, count * sizeof(*out));
24339     for (i = 0; i < count; i++)
24340     {
24341         convert_VkSemaphoreSubmitInfo_win32_to_host(&in[i], &out[i]);
24342     }
24343
24344     return out;
24345 }
24346
24347 #ifdef _WIN64
24348 static inline void convert_VkCommandBufferSubmitInfo_win64_to_host(const VkCommandBufferSubmitInfo *in, VkCommandBufferSubmitInfo *out)
24349 {
24350     if (!in) return;
24351
24352     out->sType = in->sType;
24353     out->pNext = in->pNext;
24354     out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->command_buffer;
24355     out->deviceMask = in->deviceMask;
24356 }
24357 #endif /* _WIN64 */
24358
24359 static inline void convert_VkCommandBufferSubmitInfo_win32_to_host(const VkCommandBufferSubmitInfo32 *in, VkCommandBufferSubmitInfo *out)
24360 {
24361     if (!in) return;
24362
24363     out->sType = in->sType;
24364     out->pNext = NULL;
24365     out->commandBuffer = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(in->commandBuffer))->command_buffer;
24366     out->deviceMask = in->deviceMask;
24367     if (in->pNext)
24368         FIXME("Unexpected pNext\n");
24369 }
24370
24371 #ifdef _WIN64
24372 static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo *in, uint32_t count)
24373 {
24374     VkCommandBufferSubmitInfo *out;
24375     unsigned int i;
24376
24377     if (!in || !count) return NULL;
24378
24379     out = conversion_context_alloc(ctx, count * sizeof(*out));
24380     for (i = 0; i < count; i++)
24381     {
24382         convert_VkCommandBufferSubmitInfo_win64_to_host(&in[i], &out[i]);
24383     }
24384
24385     return out;
24386 }
24387 #endif /* _WIN64 */
24388
24389 static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo32 *in, uint32_t count)
24390 {
24391     VkCommandBufferSubmitInfo *out;
24392     unsigned int i;
24393
24394     if (!in || !count) return NULL;
24395
24396     out = conversion_context_alloc(ctx, count * sizeof(*out));
24397     for (i = 0; i < count; i++)
24398     {
24399         convert_VkCommandBufferSubmitInfo_win32_to_host(&in[i], &out[i]);
24400     }
24401
24402     return out;
24403 }
24404
24405 #ifdef _WIN64
24406 static inline void convert_VkSubmitInfo2_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, VkSubmitInfo2 *out)
24407 {
24408     if (!in) return;
24409
24410     out->sType = in->sType;
24411     out->pNext = in->pNext;
24412     out->flags = in->flags;
24413     out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
24414     out->pWaitSemaphoreInfos = in->pWaitSemaphoreInfos;
24415     out->commandBufferInfoCount = in->commandBufferInfoCount;
24416     out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win64_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount);
24417     out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
24418     out->pSignalSemaphoreInfos = in->pSignalSemaphoreInfos;
24419 }
24420 #endif /* _WIN64 */
24421
24422 static inline void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, VkSubmitInfo2 *out)
24423 {
24424     const VkBaseInStructure32 *in_header;
24425     VkBaseOutStructure *out_header = (void *)out;
24426
24427     if (!in) return;
24428
24429     out->sType = in->sType;
24430     out->pNext = NULL;
24431     out->flags = in->flags;
24432     out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
24433     out->pWaitSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, (const VkSemaphoreSubmitInfo32 *)UlongToPtr(in->pWaitSemaphoreInfos), in->waitSemaphoreInfoCount);
24434     out->commandBufferInfoCount = in->commandBufferInfoCount;
24435     out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win32_to_host(ctx, (const VkCommandBufferSubmitInfo32 *)UlongToPtr(in->pCommandBufferInfos), in->commandBufferInfoCount);
24436     out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
24437     out->pSignalSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, (const VkSemaphoreSubmitInfo32 *)UlongToPtr(in->pSignalSemaphoreInfos), in->signalSemaphoreInfoCount);
24438
24439     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24440     {
24441         switch (in_header->sType)
24442         {
24443         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
24444         {
24445             VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24446             const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header;
24447             out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
24448             out_ext->pNext = NULL;
24449             out_ext->counterPassIndex = in_ext->counterPassIndex;
24450             out_header->pNext = (void *)out_ext;
24451             out_header = (void *)out_ext;
24452             break;
24453         }
24454         default:
24455             FIXME("Unhandled sType %u.", in_header->sType);
24456             break;
24457         }
24458     }
24459 }
24460
24461 #ifdef _WIN64
24462 static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, uint32_t count)
24463 {
24464     VkSubmitInfo2 *out;
24465     unsigned int i;
24466
24467     if (!in || !count) return NULL;
24468
24469     out = conversion_context_alloc(ctx, count * sizeof(*out));
24470     for (i = 0; i < count; i++)
24471     {
24472         convert_VkSubmitInfo2_win64_to_host(ctx, &in[i], &out[i]);
24473     }
24474
24475     return out;
24476 }
24477 #endif /* _WIN64 */
24478
24479 static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, uint32_t count)
24480 {
24481     VkSubmitInfo2 *out;
24482     unsigned int i;
24483
24484     if (!in || !count) return NULL;
24485
24486     out = conversion_context_alloc(ctx, count * sizeof(*out));
24487     for (i = 0; i < count; i++)
24488     {
24489         convert_VkSubmitInfo2_win32_to_host(ctx, &in[i], &out[i]);
24490     }
24491
24492     return out;
24493 }
24494
24495 #ifdef _WIN64
24496 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(const VkDebugUtilsObjectNameInfoEXT *in, VkDebugUtilsObjectNameInfoEXT *out)
24497 {
24498     if (!in) return;
24499
24500     out->sType = in->sType;
24501     out->pNext = in->pNext;
24502     out->objectType = in->objectType;
24503     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
24504     out->pObjectName = in->pObjectName;
24505 }
24506 #endif /* _WIN64 */
24507
24508 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(const VkDebugUtilsObjectNameInfoEXT32 *in, VkDebugUtilsObjectNameInfoEXT *out)
24509 {
24510     if (!in) return;
24511
24512     out->sType = in->sType;
24513     out->pNext = NULL;
24514     out->objectType = in->objectType;
24515     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
24516     out->pObjectName = (const char *)UlongToPtr(in->pObjectName);
24517     if (in->pNext)
24518         FIXME("Unexpected pNext\n");
24519 }
24520
24521 #ifdef _WIN64
24522 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(const VkDebugUtilsObjectTagInfoEXT *in, VkDebugUtilsObjectTagInfoEXT *out)
24523 {
24524     if (!in) return;
24525
24526     out->sType = in->sType;
24527     out->pNext = in->pNext;
24528     out->objectType = in->objectType;
24529     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
24530     out->tagName = in->tagName;
24531     out->tagSize = in->tagSize;
24532     out->pTag = in->pTag;
24533 }
24534 #endif /* _WIN64 */
24535
24536 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(const VkDebugUtilsObjectTagInfoEXT32 *in, VkDebugUtilsObjectTagInfoEXT *out)
24537 {
24538     if (!in) return;
24539
24540     out->sType = in->sType;
24541     out->pNext = NULL;
24542     out->objectType = in->objectType;
24543     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
24544     out->tagName = in->tagName;
24545     out->tagSize = in->tagSize;
24546     out->pTag = (const void *)UlongToPtr(in->pTag);
24547     if (in->pNext)
24548         FIXME("Unexpected pNext\n");
24549 }
24550
24551 static inline void convert_VkSemaphoreSignalInfo_win32_to_host(const VkSemaphoreSignalInfo32 *in, VkSemaphoreSignalInfo *out)
24552 {
24553     if (!in) return;
24554
24555     out->sType = in->sType;
24556     out->pNext = NULL;
24557     out->semaphore = in->semaphore;
24558     out->value = in->value;
24559     if (in->pNext)
24560         FIXME("Unexpected pNext\n");
24561 }
24562
24563 static inline const VkDebugUtilsLabelEXT *convert_VkDebugUtilsLabelEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsLabelEXT32 *in, uint32_t count)
24564 {
24565     VkDebugUtilsLabelEXT *out;
24566     unsigned int i;
24567
24568     if (!in || !count) return NULL;
24569
24570     out = conversion_context_alloc(ctx, count * sizeof(*out));
24571     for (i = 0; i < count; i++)
24572     {
24573         convert_VkDebugUtilsLabelEXT_win32_to_host(&in[i], &out[i]);
24574     }
24575
24576     return out;
24577 }
24578
24579 #ifdef _WIN64
24580 static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT *in, uint32_t count)
24581 {
24582     VkDebugUtilsObjectNameInfoEXT *out;
24583     unsigned int i;
24584
24585     if (!in || !count) return NULL;
24586
24587     out = conversion_context_alloc(ctx, count * sizeof(*out));
24588     for (i = 0; i < count; i++)
24589     {
24590         convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(&in[i], &out[i]);
24591     }
24592
24593     return out;
24594 }
24595 #endif /* _WIN64 */
24596
24597 static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT32 *in, uint32_t count)
24598 {
24599     VkDebugUtilsObjectNameInfoEXT *out;
24600     unsigned int i;
24601
24602     if (!in || !count) return NULL;
24603
24604     out = conversion_context_alloc(ctx, count * sizeof(*out));
24605     for (i = 0; i < count; i++)
24606     {
24607         convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(&in[i], &out[i]);
24608     }
24609
24610     return out;
24611 }
24612
24613 #ifdef _WIN64
24614 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT *in, VkDebugUtilsMessengerCallbackDataEXT *out)
24615 {
24616     if (!in) return;
24617
24618     out->sType = in->sType;
24619     out->pNext = in->pNext;
24620     out->flags = in->flags;
24621     out->pMessageIdName = in->pMessageIdName;
24622     out->messageIdNumber = in->messageIdNumber;
24623     out->pMessage = in->pMessage;
24624     out->queueLabelCount = in->queueLabelCount;
24625     out->pQueueLabels = in->pQueueLabels;
24626     out->cmdBufLabelCount = in->cmdBufLabelCount;
24627     out->pCmdBufLabels = in->pCmdBufLabels;
24628     out->objectCount = in->objectCount;
24629     out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(ctx, in->pObjects, in->objectCount);
24630 }
24631 #endif /* _WIN64 */
24632
24633 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT32 *in, VkDebugUtilsMessengerCallbackDataEXT *out)
24634 {
24635     const VkBaseInStructure32 *in_header;
24636     VkBaseOutStructure *out_header = (void *)out;
24637
24638     if (!in) return;
24639
24640     out->sType = in->sType;
24641     out->pNext = NULL;
24642     out->flags = in->flags;
24643     out->pMessageIdName = (const char *)UlongToPtr(in->pMessageIdName);
24644     out->messageIdNumber = in->messageIdNumber;
24645     out->pMessage = (const char *)UlongToPtr(in->pMessage);
24646     out->queueLabelCount = in->queueLabelCount;
24647     out->pQueueLabels = convert_VkDebugUtilsLabelEXT_array_win32_to_host(ctx, (const VkDebugUtilsLabelEXT32 *)UlongToPtr(in->pQueueLabels), in->queueLabelCount);
24648     out->cmdBufLabelCount = in->cmdBufLabelCount;
24649     out->pCmdBufLabels = convert_VkDebugUtilsLabelEXT_array_win32_to_host(ctx, (const VkDebugUtilsLabelEXT32 *)UlongToPtr(in->pCmdBufLabels), in->cmdBufLabelCount);
24650     out->objectCount = in->objectCount;
24651     out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(ctx, (const VkDebugUtilsObjectNameInfoEXT32 *)UlongToPtr(in->pObjects), in->objectCount);
24652
24653     for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
24654     {
24655         switch (in_header->sType)
24656         {
24657         case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
24658         {
24659             VkDeviceAddressBindingCallbackDataEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
24660             const VkDeviceAddressBindingCallbackDataEXT32 *in_ext = (const VkDeviceAddressBindingCallbackDataEXT32 *)in_header;
24661             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT;
24662             out_ext->pNext = NULL;
24663             out_ext->flags = in_ext->flags;
24664             out_ext->baseAddress = in_ext->baseAddress;
24665             out_ext->size = in_ext->size;
24666             out_ext->bindingType = in_ext->bindingType;
24667             out_header->pNext = (void *)out_ext;
24668             out_header = (void *)out_ext;
24669             break;
24670         }
24671         default:
24672             FIXME("Unhandled sType %u.", in_header->sType);
24673             break;
24674         }
24675     }
24676 }
24677
24678 static inline void convert_VkCopyDescriptorSet_win32_to_host(const VkCopyDescriptorSet32 *in, VkCopyDescriptorSet *out)
24679 {
24680     if (!in) return;
24681
24682     out->sType = in->sType;
24683     out->pNext = NULL;
24684     out->srcSet = in->srcSet;
24685     out->srcBinding = in->srcBinding;
24686     out->srcArrayElement = in->srcArrayElement;
24687     out->dstSet = in->dstSet;
24688     out->dstBinding = in->dstBinding;
24689     out->dstArrayElement = in->dstArrayElement;
24690     out->descriptorCount = in->descriptorCount;
24691     if (in->pNext)
24692         FIXME("Unexpected pNext\n");
24693 }
24694
24695 static inline const VkCopyDescriptorSet *convert_VkCopyDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkCopyDescriptorSet32 *in, uint32_t count)
24696 {
24697     VkCopyDescriptorSet *out;
24698     unsigned int i;
24699
24700     if (!in || !count) return NULL;
24701
24702     out = conversion_context_alloc(ctx, count * sizeof(*out));
24703     for (i = 0; i < count; i++)
24704     {
24705         convert_VkCopyDescriptorSet_win32_to_host(&in[i], &out[i]);
24706     }
24707
24708     return out;
24709 }
24710
24711 static inline void convert_VkSemaphoreWaitInfo_win32_to_host(const VkSemaphoreWaitInfo32 *in, VkSemaphoreWaitInfo *out)
24712 {
24713     if (!in) return;
24714
24715     out->sType = in->sType;
24716     out->pNext = NULL;
24717     out->flags = in->flags;
24718     out->semaphoreCount = in->semaphoreCount;
24719     out->pSemaphores = (const VkSemaphore *)UlongToPtr(in->pSemaphores);
24720     out->pValues = (const uint64_t *)UlongToPtr(in->pValues);
24721     if (in->pNext)
24722         FIXME("Unexpected pNext\n");
24723 }
24724
24725 #ifdef _WIN64
24726 static NTSTATUS thunk64_vkAcquireNextImage2KHR(void *args)
24727 {
24728     struct vkAcquireNextImage2KHR_params *params = args;
24729
24730     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pImageIndex);
24731
24732     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pImageIndex);
24733     return STATUS_SUCCESS;
24734 }
24735 #endif /* _WIN64 */
24736
24737 static NTSTATUS thunk32_vkAcquireNextImage2KHR(void *args)
24738 {
24739     struct
24740     {
24741         PTR32 device;
24742         PTR32 pAcquireInfo;
24743         PTR32 pImageIndex;
24744         VkResult result;
24745     } *params = args;
24746     VkAcquireNextImageInfoKHR pAcquireInfo_host;
24747
24748     TRACE("%#x, %#x, %#x\n", params->device, params->pAcquireInfo, params->pImageIndex);
24749
24750     convert_VkAcquireNextImageInfoKHR_win32_to_host((const VkAcquireNextImageInfoKHR32 *)UlongToPtr(params->pAcquireInfo), &pAcquireInfo_host);
24751     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));
24752     return STATUS_SUCCESS;
24753 }
24754
24755 #ifdef _WIN64
24756 static NTSTATUS thunk64_vkAcquireNextImageKHR(void *args)
24757 {
24758     struct vkAcquireNextImageKHR_params *params = args;
24759
24760     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);
24761
24762     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);
24763     return STATUS_SUCCESS;
24764 }
24765 #endif /* _WIN64 */
24766
24767 static NTSTATUS thunk32_vkAcquireNextImageKHR(void *args)
24768 {
24769     struct
24770     {
24771         PTR32 device;
24772         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
24773         uint64_t DECLSPEC_ALIGN(8) timeout;
24774         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
24775         VkFence DECLSPEC_ALIGN(8) fence;
24776         PTR32 pImageIndex;
24777         VkResult result;
24778     } *params = args;
24779
24780     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);
24781
24782     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));
24783     return STATUS_SUCCESS;
24784 }
24785
24786 #ifdef _WIN64
24787 static NTSTATUS thunk64_vkAcquirePerformanceConfigurationINTEL(void *args)
24788 {
24789     struct vkAcquirePerformanceConfigurationINTEL_params *params = args;
24790
24791     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pConfiguration);
24792
24793     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pConfiguration);
24794     return STATUS_SUCCESS;
24795 }
24796 #endif /* _WIN64 */
24797
24798 static NTSTATUS thunk32_vkAcquirePerformanceConfigurationINTEL(void *args)
24799 {
24800     struct
24801     {
24802         PTR32 device;
24803         PTR32 pAcquireInfo;
24804         PTR32 pConfiguration;
24805         VkResult result;
24806     } *params = args;
24807     VkPerformanceConfigurationAcquireInfoINTEL pAcquireInfo_host;
24808
24809     TRACE("%#x, %#x, %#x\n", params->device, params->pAcquireInfo, params->pConfiguration);
24810
24811     convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host((const VkPerformanceConfigurationAcquireInfoINTEL32 *)UlongToPtr(params->pAcquireInfo), &pAcquireInfo_host);
24812     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));
24813     return STATUS_SUCCESS;
24814 }
24815
24816 #ifdef _WIN64
24817 static NTSTATUS thunk64_vkAcquireProfilingLockKHR(void *args)
24818 {
24819     struct vkAcquireProfilingLockKHR_params *params = args;
24820
24821     TRACE("%p, %p\n", params->device, params->pInfo);
24822
24823     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle(params->device)->device, params->pInfo);
24824     return STATUS_SUCCESS;
24825 }
24826 #endif /* _WIN64 */
24827
24828 static NTSTATUS thunk32_vkAcquireProfilingLockKHR(void *args)
24829 {
24830     struct
24831     {
24832         PTR32 device;
24833         PTR32 pInfo;
24834         VkResult result;
24835     } *params = args;
24836     VkAcquireProfilingLockInfoKHR pInfo_host;
24837
24838     TRACE("%#x, %#x\n", params->device, params->pInfo);
24839
24840     convert_VkAcquireProfilingLockInfoKHR_win32_to_host((const VkAcquireProfilingLockInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
24841     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
24842     return STATUS_SUCCESS;
24843 }
24844
24845 #ifdef _WIN64
24846 static NTSTATUS thunk64_vkAllocateCommandBuffers(void *args)
24847 {
24848     struct vkAllocateCommandBuffers_params *params = args;
24849
24850     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pCommandBuffers);
24851
24852     params->result = wine_vkAllocateCommandBuffers(params->device, params->pAllocateInfo, params->pCommandBuffers);
24853     return STATUS_SUCCESS;
24854 }
24855 #endif /* _WIN64 */
24856
24857 static NTSTATUS thunk32_vkAllocateCommandBuffers(void *args)
24858 {
24859     struct
24860     {
24861         PTR32 device;
24862         PTR32 pAllocateInfo;
24863         PTR32 pCommandBuffers;
24864         VkResult result;
24865     } *params = args;
24866     VkCommandBufferAllocateInfo pAllocateInfo_host;
24867     VkCommandBuffer *pCommandBuffers_host;
24868     struct conversion_context ctx;
24869
24870     TRACE("%#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pCommandBuffers);
24871
24872     init_conversion_context(&ctx);
24873     convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host((const VkCommandBufferAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
24874     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_unwrapped_host(&ctx, (PTR32 *)UlongToPtr(params->pCommandBuffers), ((const VkCommandBufferAllocateInfo32 *)UlongToPtr(params->pAllocateInfo))->commandBufferCount);
24875     params->result = wine_vkAllocateCommandBuffers((VkDevice)UlongToPtr(params->device), &pAllocateInfo_host, pCommandBuffers_host);
24876     free_conversion_context(&ctx);
24877     return STATUS_SUCCESS;
24878 }
24879
24880 #ifdef _WIN64
24881 static NTSTATUS thunk64_vkAllocateDescriptorSets(void *args)
24882 {
24883     struct vkAllocateDescriptorSets_params *params = args;
24884
24885     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pDescriptorSets);
24886
24887     params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle(params->device)->device, params->pAllocateInfo, params->pDescriptorSets);
24888     return STATUS_SUCCESS;
24889 }
24890 #endif /* _WIN64 */
24891
24892 static NTSTATUS thunk32_vkAllocateDescriptorSets(void *args)
24893 {
24894     struct
24895     {
24896         PTR32 device;
24897         PTR32 pAllocateInfo;
24898         PTR32 pDescriptorSets;
24899         VkResult result;
24900     } *params = args;
24901     VkDescriptorSetAllocateInfo pAllocateInfo_host;
24902     struct conversion_context ctx;
24903
24904     TRACE("%#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pDescriptorSets);
24905
24906     init_conversion_context(&ctx);
24907     convert_VkDescriptorSetAllocateInfo_win32_to_host(&ctx, (const VkDescriptorSetAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
24908     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));
24909     free_conversion_context(&ctx);
24910     return STATUS_SUCCESS;
24911 }
24912
24913 #ifdef _WIN64
24914 static NTSTATUS thunk64_vkAllocateMemory(void *args)
24915 {
24916     struct vkAllocateMemory_params *params = args;
24917
24918     TRACE("%p, %p, %p, %p\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
24919
24920     params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateMemory(wine_device_from_handle(params->device)->device, params->pAllocateInfo, NULL, params->pMemory);
24921     return STATUS_SUCCESS;
24922 }
24923 #endif /* _WIN64 */
24924
24925 static NTSTATUS thunk32_vkAllocateMemory(void *args)
24926 {
24927     struct
24928     {
24929         PTR32 device;
24930         PTR32 pAllocateInfo;
24931         PTR32 pAllocator;
24932         PTR32 pMemory;
24933         VkResult result;
24934     } *params = args;
24935     VkMemoryAllocateInfo pAllocateInfo_host;
24936     struct conversion_context ctx;
24937
24938     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
24939
24940     init_conversion_context(&ctx);
24941     convert_VkMemoryAllocateInfo_win32_to_host(&ctx, (const VkMemoryAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
24942     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAllocateMemory(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pAllocateInfo_host, NULL, (VkDeviceMemory *)UlongToPtr(params->pMemory));
24943     free_conversion_context(&ctx);
24944     return STATUS_SUCCESS;
24945 }
24946
24947 #ifdef _WIN64
24948 static NTSTATUS thunk64_vkBeginCommandBuffer(void *args)
24949 {
24950     struct vkBeginCommandBuffer_params *params = args;
24951
24952     TRACE("%p, %p\n", params->commandBuffer, params->pBeginInfo);
24953
24954     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBeginInfo);
24955     return STATUS_SUCCESS;
24956 }
24957 #endif /* _WIN64 */
24958
24959 static NTSTATUS thunk32_vkBeginCommandBuffer(void *args)
24960 {
24961     struct
24962     {
24963         PTR32 commandBuffer;
24964         PTR32 pBeginInfo;
24965         VkResult result;
24966     } *params = args;
24967     VkCommandBufferBeginInfo pBeginInfo_host;
24968     struct conversion_context ctx;
24969
24970     TRACE("%#x, %#x\n", params->commandBuffer, params->pBeginInfo);
24971
24972     init_conversion_context(&ctx);
24973     convert_VkCommandBufferBeginInfo_win32_to_host(&ctx, (const VkCommandBufferBeginInfo32 *)UlongToPtr(params->pBeginInfo), &pBeginInfo_host);
24974     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);
24975     free_conversion_context(&ctx);
24976     return STATUS_SUCCESS;
24977 }
24978
24979 #ifdef _WIN64
24980 static NTSTATUS thunk64_vkBindAccelerationStructureMemoryNV(void *args)
24981 {
24982     struct vkBindAccelerationStructureMemoryNV_params *params = args;
24983
24984     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
24985
24986     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
24987     return STATUS_SUCCESS;
24988 }
24989 #endif /* _WIN64 */
24990
24991 static NTSTATUS thunk32_vkBindAccelerationStructureMemoryNV(void *args)
24992 {
24993     struct
24994     {
24995         PTR32 device;
24996         uint32_t bindInfoCount;
24997         PTR32 pBindInfos;
24998         VkResult result;
24999     } *params = args;
25000     const VkBindAccelerationStructureMemoryInfoNV *pBindInfos_host;
25001     struct conversion_context ctx;
25002
25003     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
25004
25005     init_conversion_context(&ctx);
25006     pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(&ctx, (const VkBindAccelerationStructureMemoryInfoNV32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
25007     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);
25008     free_conversion_context(&ctx);
25009     return STATUS_SUCCESS;
25010 }
25011
25012 #ifdef _WIN64
25013 static NTSTATUS thunk64_vkBindBufferMemory(void *args)
25014 {
25015     struct vkBindBufferMemory_params *params = args;
25016
25017     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));
25018
25019     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory(wine_device_from_handle(params->device)->device, params->buffer, params->memory, params->memoryOffset);
25020     return STATUS_SUCCESS;
25021 }
25022 #endif /* _WIN64 */
25023
25024 static NTSTATUS thunk32_vkBindBufferMemory(void *args)
25025 {
25026     struct
25027     {
25028         PTR32 device;
25029         VkBuffer DECLSPEC_ALIGN(8) buffer;
25030         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
25031         VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
25032         VkResult result;
25033     } *params = args;
25034
25035     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));
25036
25037     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindBufferMemory(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buffer, params->memory, params->memoryOffset);
25038     return STATUS_SUCCESS;
25039 }
25040
25041 #ifdef _WIN64
25042 static NTSTATUS thunk64_vkBindBufferMemory2(void *args)
25043 {
25044     struct vkBindBufferMemory2_params *params = args;
25045
25046     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
25047
25048     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
25049     return STATUS_SUCCESS;
25050 }
25051 #endif /* _WIN64 */
25052
25053 static NTSTATUS thunk32_vkBindBufferMemory2(void *args)
25054 {
25055     struct
25056     {
25057         PTR32 device;
25058         uint32_t bindInfoCount;
25059         PTR32 pBindInfos;
25060         VkResult result;
25061     } *params = args;
25062     const VkBindBufferMemoryInfo *pBindInfos_host;
25063     struct conversion_context ctx;
25064
25065     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
25066
25067     init_conversion_context(&ctx);
25068     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(&ctx, (const VkBindBufferMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
25069     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);
25070     free_conversion_context(&ctx);
25071     return STATUS_SUCCESS;
25072 }
25073
25074 #ifdef _WIN64
25075 static NTSTATUS thunk64_vkBindBufferMemory2KHR(void *args)
25076 {
25077     struct vkBindBufferMemory2KHR_params *params = args;
25078
25079     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
25080
25081     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
25082     return STATUS_SUCCESS;
25083 }
25084 #endif /* _WIN64 */
25085
25086 static NTSTATUS thunk32_vkBindBufferMemory2KHR(void *args)
25087 {
25088     struct
25089     {
25090         PTR32 device;
25091         uint32_t bindInfoCount;
25092         PTR32 pBindInfos;
25093         VkResult result;
25094     } *params = args;
25095     const VkBindBufferMemoryInfo *pBindInfos_host;
25096     struct conversion_context ctx;
25097
25098     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
25099
25100     init_conversion_context(&ctx);
25101     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(&ctx, (const VkBindBufferMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
25102     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);
25103     free_conversion_context(&ctx);
25104     return STATUS_SUCCESS;
25105 }
25106
25107 #ifdef _WIN64
25108 static NTSTATUS thunk64_vkBindImageMemory(void *args)
25109 {
25110     struct vkBindImageMemory_params *params = args;
25111
25112     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));
25113
25114     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory(wine_device_from_handle(params->device)->device, params->image, params->memory, params->memoryOffset);
25115     return STATUS_SUCCESS;
25116 }
25117 #endif /* _WIN64 */
25118
25119 static NTSTATUS thunk32_vkBindImageMemory(void *args)
25120 {
25121     struct
25122     {
25123         PTR32 device;
25124         VkImage DECLSPEC_ALIGN(8) image;
25125         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
25126         VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
25127         VkResult result;
25128     } *params = args;
25129
25130     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));
25131
25132     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindImageMemory(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, params->memory, params->memoryOffset);
25133     return STATUS_SUCCESS;
25134 }
25135
25136 #ifdef _WIN64
25137 static NTSTATUS thunk64_vkBindImageMemory2(void *args)
25138 {
25139     struct vkBindImageMemory2_params *params = args;
25140
25141     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
25142
25143     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
25144     return STATUS_SUCCESS;
25145 }
25146 #endif /* _WIN64 */
25147
25148 static NTSTATUS thunk32_vkBindImageMemory2(void *args)
25149 {
25150     struct
25151     {
25152         PTR32 device;
25153         uint32_t bindInfoCount;
25154         PTR32 pBindInfos;
25155         VkResult result;
25156     } *params = args;
25157     const VkBindImageMemoryInfo *pBindInfos_host;
25158     struct conversion_context ctx;
25159
25160     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
25161
25162     init_conversion_context(&ctx);
25163     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(&ctx, (const VkBindImageMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
25164     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);
25165     free_conversion_context(&ctx);
25166     return STATUS_SUCCESS;
25167 }
25168
25169 #ifdef _WIN64
25170 static NTSTATUS thunk64_vkBindImageMemory2KHR(void *args)
25171 {
25172     struct vkBindImageMemory2KHR_params *params = args;
25173
25174     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
25175
25176     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
25177     return STATUS_SUCCESS;
25178 }
25179 #endif /* _WIN64 */
25180
25181 static NTSTATUS thunk32_vkBindImageMemory2KHR(void *args)
25182 {
25183     struct
25184     {
25185         PTR32 device;
25186         uint32_t bindInfoCount;
25187         PTR32 pBindInfos;
25188         VkResult result;
25189     } *params = args;
25190     const VkBindImageMemoryInfo *pBindInfos_host;
25191     struct conversion_context ctx;
25192
25193     TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);
25194
25195     init_conversion_context(&ctx);
25196     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(&ctx, (const VkBindImageMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
25197     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);
25198     free_conversion_context(&ctx);
25199     return STATUS_SUCCESS;
25200 }
25201
25202 #ifdef _WIN64
25203 static NTSTATUS thunk64_vkBindOpticalFlowSessionImageNV(void *args)
25204 {
25205     struct vkBindOpticalFlowSessionImageNV_params *params = args;
25206
25207     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);
25208
25209     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);
25210     return STATUS_SUCCESS;
25211 }
25212 #endif /* _WIN64 */
25213
25214 static NTSTATUS thunk32_vkBindOpticalFlowSessionImageNV(void *args)
25215 {
25216     struct
25217     {
25218         PTR32 device;
25219         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
25220         VkOpticalFlowSessionBindingPointNV bindingPoint;
25221         VkImageView DECLSPEC_ALIGN(8) view;
25222         VkImageLayout layout;
25223         VkResult result;
25224     } *params = args;
25225
25226     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);
25227
25228     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);
25229     return STATUS_SUCCESS;
25230 }
25231
25232 #ifdef _WIN64
25233 static NTSTATUS thunk64_vkBuildAccelerationStructuresKHR(void *args)
25234 {
25235     struct vkBuildAccelerationStructuresKHR_params *params = args;
25236
25237     TRACE("%p, 0x%s, %u, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);
25238
25239     params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildAccelerationStructuresKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
25240     return STATUS_SUCCESS;
25241 }
25242 #endif /* _WIN64 */
25243
25244 static NTSTATUS thunk32_vkBuildAccelerationStructuresKHR(void *args)
25245 {
25246     struct
25247     {
25248         PTR32 device;
25249         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
25250         uint32_t infoCount;
25251         PTR32 pInfos;
25252         PTR32 ppBuildRangeInfos;
25253         VkResult result;
25254     } *params = args;
25255     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
25256     struct conversion_context ctx;
25257
25258     TRACE("%#x, 0x%s, %u, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);
25259
25260     init_conversion_context(&ctx);
25261     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
25262     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBuildAccelerationStructuresKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, params->infoCount, pInfos_host, (const VkAccelerationStructureBuildRangeInfoKHR * const*)UlongToPtr(params->ppBuildRangeInfos));
25263     free_conversion_context(&ctx);
25264     return STATUS_SUCCESS;
25265 }
25266
25267 #ifdef _WIN64
25268 static NTSTATUS thunk64_vkBuildMicromapsEXT(void *args)
25269 {
25270     struct vkBuildMicromapsEXT_params *params = args;
25271
25272     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
25273
25274     params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildMicromapsEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, params->pInfos);
25275     return STATUS_SUCCESS;
25276 }
25277 #endif /* _WIN64 */
25278
25279 static NTSTATUS thunk32_vkBuildMicromapsEXT(void *args)
25280 {
25281     struct
25282     {
25283         PTR32 device;
25284         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
25285         uint32_t infoCount;
25286         PTR32 pInfos;
25287         VkResult result;
25288     } *params = args;
25289     const VkMicromapBuildInfoEXT *pInfos_host;
25290     struct conversion_context ctx;
25291
25292     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
25293
25294     init_conversion_context(&ctx);
25295     pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(&ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pInfos), params->infoCount);
25296     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBuildMicromapsEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, params->infoCount, pInfos_host);
25297     free_conversion_context(&ctx);
25298     return STATUS_SUCCESS;
25299 }
25300
25301 #ifdef _WIN64
25302 static NTSTATUS thunk64_vkCmdBeginConditionalRenderingEXT(void *args)
25303 {
25304     struct vkCmdBeginConditionalRenderingEXT_params *params = args;
25305
25306     TRACE("%p, %p\n", params->commandBuffer, params->pConditionalRenderingBegin);
25307
25308     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pConditionalRenderingBegin);
25309     return STATUS_SUCCESS;
25310 }
25311 #endif /* _WIN64 */
25312
25313 static NTSTATUS thunk32_vkCmdBeginConditionalRenderingEXT(void *args)
25314 {
25315     struct
25316     {
25317         PTR32 commandBuffer;
25318         PTR32 pConditionalRenderingBegin;
25319     } *params = args;
25320     VkConditionalRenderingBeginInfoEXT pConditionalRenderingBegin_host;
25321
25322     TRACE("%#x, %#x\n", params->commandBuffer, params->pConditionalRenderingBegin);
25323
25324     convert_VkConditionalRenderingBeginInfoEXT_win32_to_host((const VkConditionalRenderingBeginInfoEXT32 *)UlongToPtr(params->pConditionalRenderingBegin), &pConditionalRenderingBegin_host);
25325     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);
25326     return STATUS_SUCCESS;
25327 }
25328
25329 #ifdef _WIN64
25330 static NTSTATUS thunk64_vkCmdBeginDebugUtilsLabelEXT(void *args)
25331 {
25332     struct vkCmdBeginDebugUtilsLabelEXT_params *params = args;
25333
25334     TRACE("%p, %p\n", params->commandBuffer, params->pLabelInfo);
25335
25336     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
25337     return STATUS_SUCCESS;
25338 }
25339 #endif /* _WIN64 */
25340
25341 static NTSTATUS thunk32_vkCmdBeginDebugUtilsLabelEXT(void *args)
25342 {
25343     struct
25344     {
25345         PTR32 commandBuffer;
25346         PTR32 pLabelInfo;
25347     } *params = args;
25348     VkDebugUtilsLabelEXT pLabelInfo_host;
25349
25350     TRACE("%#x, %#x\n", params->commandBuffer, params->pLabelInfo);
25351
25352     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
25353     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);
25354     return STATUS_SUCCESS;
25355 }
25356
25357 #ifdef _WIN64
25358 static NTSTATUS thunk64_vkCmdBeginQuery(void *args)
25359 {
25360     struct vkCmdBeginQuery_params *params = args;
25361
25362     TRACE("%p, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags);
25363
25364     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);
25365     return STATUS_SUCCESS;
25366 }
25367 #endif /* _WIN64 */
25368
25369 static NTSTATUS thunk32_vkCmdBeginQuery(void *args)
25370 {
25371     struct
25372     {
25373         PTR32 commandBuffer;
25374         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
25375         uint32_t query;
25376         VkQueryControlFlags flags;
25377     } *params = args;
25378
25379     TRACE("%#x, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags);
25380
25381     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);
25382     return STATUS_SUCCESS;
25383 }
25384
25385 #ifdef _WIN64
25386 static NTSTATUS thunk64_vkCmdBeginQueryIndexedEXT(void *args)
25387 {
25388     struct vkCmdBeginQueryIndexedEXT_params *params = args;
25389
25390     TRACE("%p, 0x%s, %u, %#x, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags, params->index);
25391
25392     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);
25393     return STATUS_SUCCESS;
25394 }
25395 #endif /* _WIN64 */
25396
25397 static NTSTATUS thunk32_vkCmdBeginQueryIndexedEXT(void *args)
25398 {
25399     struct
25400     {
25401         PTR32 commandBuffer;
25402         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
25403         uint32_t query;
25404         VkQueryControlFlags flags;
25405         uint32_t index;
25406     } *params = args;
25407
25408     TRACE("%#x, 0x%s, %u, %#x, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags, params->index);
25409
25410     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);
25411     return STATUS_SUCCESS;
25412 }
25413
25414 #ifdef _WIN64
25415 static NTSTATUS thunk64_vkCmdBeginRenderPass(void *args)
25416 {
25417     struct vkCmdBeginRenderPass_params *params = args;
25418
25419     TRACE("%p, %p, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->contents);
25420
25421     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->contents);
25422     return STATUS_SUCCESS;
25423 }
25424 #endif /* _WIN64 */
25425
25426 static NTSTATUS thunk32_vkCmdBeginRenderPass(void *args)
25427 {
25428     struct
25429     {
25430         PTR32 commandBuffer;
25431         PTR32 pRenderPassBegin;
25432         VkSubpassContents contents;
25433     } *params = args;
25434     VkRenderPassBeginInfo pRenderPassBegin_host;
25435     struct conversion_context ctx;
25436
25437     TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->contents);
25438
25439     init_conversion_context(&ctx);
25440     convert_VkRenderPassBeginInfo_win32_to_host(&ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
25441     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);
25442     free_conversion_context(&ctx);
25443     return STATUS_SUCCESS;
25444 }
25445
25446 #ifdef _WIN64
25447 static NTSTATUS thunk64_vkCmdBeginRenderPass2(void *args)
25448 {
25449     struct vkCmdBeginRenderPass2_params *params = args;
25450
25451     TRACE("%p, %p, %p\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
25452
25453     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
25454     return STATUS_SUCCESS;
25455 }
25456 #endif /* _WIN64 */
25457
25458 static NTSTATUS thunk32_vkCmdBeginRenderPass2(void *args)
25459 {
25460     struct
25461     {
25462         PTR32 commandBuffer;
25463         PTR32 pRenderPassBegin;
25464         PTR32 pSubpassBeginInfo;
25465     } *params = args;
25466     VkRenderPassBeginInfo pRenderPassBegin_host;
25467     VkSubpassBeginInfo pSubpassBeginInfo_host;
25468     struct conversion_context ctx;
25469
25470     TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
25471
25472     init_conversion_context(&ctx);
25473     convert_VkRenderPassBeginInfo_win32_to_host(&ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
25474     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
25475     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);
25476     free_conversion_context(&ctx);
25477     return STATUS_SUCCESS;
25478 }
25479
25480 #ifdef _WIN64
25481 static NTSTATUS thunk64_vkCmdBeginRenderPass2KHR(void *args)
25482 {
25483     struct vkCmdBeginRenderPass2KHR_params *params = args;
25484
25485     TRACE("%p, %p, %p\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
25486
25487     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
25488     return STATUS_SUCCESS;
25489 }
25490 #endif /* _WIN64 */
25491
25492 static NTSTATUS thunk32_vkCmdBeginRenderPass2KHR(void *args)
25493 {
25494     struct
25495     {
25496         PTR32 commandBuffer;
25497         PTR32 pRenderPassBegin;
25498         PTR32 pSubpassBeginInfo;
25499     } *params = args;
25500     VkRenderPassBeginInfo pRenderPassBegin_host;
25501     VkSubpassBeginInfo pSubpassBeginInfo_host;
25502     struct conversion_context ctx;
25503
25504     TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
25505
25506     init_conversion_context(&ctx);
25507     convert_VkRenderPassBeginInfo_win32_to_host(&ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
25508     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
25509     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);
25510     free_conversion_context(&ctx);
25511     return STATUS_SUCCESS;
25512 }
25513
25514 #ifdef _WIN64
25515 static NTSTATUS thunk64_vkCmdBeginRendering(void *args)
25516 {
25517     struct vkCmdBeginRendering_params *params = args;
25518
25519     TRACE("%p, %p\n", params->commandBuffer, params->pRenderingInfo);
25520
25521     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
25522     return STATUS_SUCCESS;
25523 }
25524 #endif /* _WIN64 */
25525
25526 static NTSTATUS thunk32_vkCmdBeginRendering(void *args)
25527 {
25528     struct
25529     {
25530         PTR32 commandBuffer;
25531         PTR32 pRenderingInfo;
25532     } *params = args;
25533     VkRenderingInfo pRenderingInfo_host;
25534     struct conversion_context ctx;
25535
25536     TRACE("%#x, %#x\n", params->commandBuffer, params->pRenderingInfo);
25537
25538     init_conversion_context(&ctx);
25539     convert_VkRenderingInfo_win32_to_host(&ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
25540     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);
25541     free_conversion_context(&ctx);
25542     return STATUS_SUCCESS;
25543 }
25544
25545 #ifdef _WIN64
25546 static NTSTATUS thunk64_vkCmdBeginRenderingKHR(void *args)
25547 {
25548     struct vkCmdBeginRenderingKHR_params *params = args;
25549
25550     TRACE("%p, %p\n", params->commandBuffer, params->pRenderingInfo);
25551
25552     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
25553     return STATUS_SUCCESS;
25554 }
25555 #endif /* _WIN64 */
25556
25557 static NTSTATUS thunk32_vkCmdBeginRenderingKHR(void *args)
25558 {
25559     struct
25560     {
25561         PTR32 commandBuffer;
25562         PTR32 pRenderingInfo;
25563     } *params = args;
25564     VkRenderingInfo pRenderingInfo_host;
25565     struct conversion_context ctx;
25566
25567     TRACE("%#x, %#x\n", params->commandBuffer, params->pRenderingInfo);
25568
25569     init_conversion_context(&ctx);
25570     convert_VkRenderingInfo_win32_to_host(&ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
25571     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);
25572     free_conversion_context(&ctx);
25573     return STATUS_SUCCESS;
25574 }
25575
25576 #ifdef _WIN64
25577 static NTSTATUS thunk64_vkCmdBeginTransformFeedbackEXT(void *args)
25578 {
25579     struct vkCmdBeginTransformFeedbackEXT_params *params = args;
25580
25581     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
25582
25583     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);
25584     return STATUS_SUCCESS;
25585 }
25586 #endif /* _WIN64 */
25587
25588 static NTSTATUS thunk32_vkCmdBeginTransformFeedbackEXT(void *args)
25589 {
25590     struct
25591     {
25592         PTR32 commandBuffer;
25593         uint32_t firstCounterBuffer;
25594         uint32_t counterBufferCount;
25595         PTR32 pCounterBuffers;
25596         PTR32 pCounterBufferOffsets;
25597     } *params = args;
25598
25599     TRACE("%#x, %u, %u, %#x, %#x\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
25600
25601     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));
25602     return STATUS_SUCCESS;
25603 }
25604
25605 #ifdef _WIN64
25606 static NTSTATUS thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
25607 {
25608     struct vkCmdBindDescriptorBufferEmbeddedSamplersEXT_params *params = args;
25609
25610     TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set);
25611
25612     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);
25613     return STATUS_SUCCESS;
25614 }
25615 #endif /* _WIN64 */
25616
25617 static NTSTATUS thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
25618 {
25619     struct
25620     {
25621         PTR32 commandBuffer;
25622         VkPipelineBindPoint pipelineBindPoint;
25623         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
25624         uint32_t set;
25625     } *params = args;
25626
25627     TRACE("%#x, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set);
25628
25629     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);
25630     return STATUS_SUCCESS;
25631 }
25632
25633 #ifdef _WIN64
25634 static NTSTATUS thunk64_vkCmdBindDescriptorBuffersEXT(void *args)
25635 {
25636     struct vkCmdBindDescriptorBuffersEXT_params *params = args;
25637
25638     TRACE("%p, %u, %p\n", params->commandBuffer, params->bufferCount, params->pBindingInfos);
25639
25640     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorBuffersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->bufferCount, params->pBindingInfos);
25641     return STATUS_SUCCESS;
25642 }
25643 #endif /* _WIN64 */
25644
25645 static NTSTATUS thunk32_vkCmdBindDescriptorBuffersEXT(void *args)
25646 {
25647     struct
25648     {
25649         PTR32 commandBuffer;
25650         uint32_t bufferCount;
25651         PTR32 pBindingInfos;
25652     } *params = args;
25653     const VkDescriptorBufferBindingInfoEXT *pBindingInfos_host;
25654     struct conversion_context ctx;
25655
25656     TRACE("%#x, %u, %#x\n", params->commandBuffer, params->bufferCount, params->pBindingInfos);
25657
25658     init_conversion_context(&ctx);
25659     pBindingInfos_host = convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(&ctx, (const VkDescriptorBufferBindingInfoEXT32 *)UlongToPtr(params->pBindingInfos), params->bufferCount);
25660     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);
25661     free_conversion_context(&ctx);
25662     return STATUS_SUCCESS;
25663 }
25664
25665 #ifdef _WIN64
25666 static NTSTATUS thunk64_vkCmdBindDescriptorSets(void *args)
25667 {
25668     struct vkCmdBindDescriptorSets_params *params = args;
25669
25670     TRACE("%p, %#x, 0x%s, %u, %u, %p, %u, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->firstSet, params->descriptorSetCount, params->pDescriptorSets, params->dynamicOffsetCount, params->pDynamicOffsets);
25671
25672     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);
25673     return STATUS_SUCCESS;
25674 }
25675 #endif /* _WIN64 */
25676
25677 static NTSTATUS thunk32_vkCmdBindDescriptorSets(void *args)
25678 {
25679     struct
25680     {
25681         PTR32 commandBuffer;
25682         VkPipelineBindPoint pipelineBindPoint;
25683         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
25684         uint32_t firstSet;
25685         uint32_t descriptorSetCount;
25686         PTR32 pDescriptorSets;
25687         uint32_t dynamicOffsetCount;
25688         PTR32 pDynamicOffsets;
25689     } *params = args;
25690
25691     TRACE("%#x, %#x, 0x%s, %u, %u, %#x, %u, %#x\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->firstSet, params->descriptorSetCount, params->pDescriptorSets, params->dynamicOffsetCount, params->pDynamicOffsets);
25692
25693     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));
25694     return STATUS_SUCCESS;
25695 }
25696
25697 #ifdef _WIN64
25698 static NTSTATUS thunk64_vkCmdBindIndexBuffer(void *args)
25699 {
25700     struct vkCmdBindIndexBuffer_params *params = args;
25701
25702     TRACE("%p, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->indexType);
25703
25704     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);
25705     return STATUS_SUCCESS;
25706 }
25707 #endif /* _WIN64 */
25708
25709 static NTSTATUS thunk32_vkCmdBindIndexBuffer(void *args)
25710 {
25711     struct
25712     {
25713         PTR32 commandBuffer;
25714         VkBuffer DECLSPEC_ALIGN(8) buffer;
25715         VkDeviceSize DECLSPEC_ALIGN(8) offset;
25716         VkIndexType indexType;
25717     } *params = args;
25718
25719     TRACE("%#x, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->indexType);
25720
25721     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);
25722     return STATUS_SUCCESS;
25723 }
25724
25725 #ifdef _WIN64
25726 static NTSTATUS thunk64_vkCmdBindInvocationMaskHUAWEI(void *args)
25727 {
25728     struct vkCmdBindInvocationMaskHUAWEI_params *params = args;
25729
25730     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
25731
25732     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
25733     return STATUS_SUCCESS;
25734 }
25735 #endif /* _WIN64 */
25736
25737 static NTSTATUS thunk32_vkCmdBindInvocationMaskHUAWEI(void *args)
25738 {
25739     struct
25740     {
25741         PTR32 commandBuffer;
25742         VkImageView DECLSPEC_ALIGN(8) imageView;
25743         VkImageLayout imageLayout;
25744     } *params = args;
25745
25746     TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
25747
25748     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);
25749     return STATUS_SUCCESS;
25750 }
25751
25752 #ifdef _WIN64
25753 static NTSTATUS thunk64_vkCmdBindPipeline(void *args)
25754 {
25755     struct vkCmdBindPipeline_params *params = args;
25756
25757     TRACE("%p, %#x, 0x%s\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline));
25758
25759     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipeline(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline);
25760     return STATUS_SUCCESS;
25761 }
25762 #endif /* _WIN64 */
25763
25764 static NTSTATUS thunk32_vkCmdBindPipeline(void *args)
25765 {
25766     struct
25767     {
25768         PTR32 commandBuffer;
25769         VkPipelineBindPoint pipelineBindPoint;
25770         VkPipeline DECLSPEC_ALIGN(8) pipeline;
25771     } *params = args;
25772
25773     TRACE("%#x, %#x, 0x%s\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline));
25774
25775     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);
25776     return STATUS_SUCCESS;
25777 }
25778
25779 #ifdef _WIN64
25780 static NTSTATUS thunk64_vkCmdBindPipelineShaderGroupNV(void *args)
25781 {
25782     struct vkCmdBindPipelineShaderGroupNV_params *params = args;
25783
25784     TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline), params->groupIndex);
25785
25786     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);
25787     return STATUS_SUCCESS;
25788 }
25789 #endif /* _WIN64 */
25790
25791 static NTSTATUS thunk32_vkCmdBindPipelineShaderGroupNV(void *args)
25792 {
25793     struct
25794     {
25795         PTR32 commandBuffer;
25796         VkPipelineBindPoint pipelineBindPoint;
25797         VkPipeline DECLSPEC_ALIGN(8) pipeline;
25798         uint32_t groupIndex;
25799     } *params = args;
25800
25801     TRACE("%#x, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline), params->groupIndex);
25802
25803     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);
25804     return STATUS_SUCCESS;
25805 }
25806
25807 #ifdef _WIN64
25808 static NTSTATUS thunk64_vkCmdBindShadingRateImageNV(void *args)
25809 {
25810     struct vkCmdBindShadingRateImageNV_params *params = args;
25811
25812     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
25813
25814     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindShadingRateImageNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
25815     return STATUS_SUCCESS;
25816 }
25817 #endif /* _WIN64 */
25818
25819 static NTSTATUS thunk32_vkCmdBindShadingRateImageNV(void *args)
25820 {
25821     struct
25822     {
25823         PTR32 commandBuffer;
25824         VkImageView DECLSPEC_ALIGN(8) imageView;
25825         VkImageLayout imageLayout;
25826     } *params = args;
25827
25828     TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
25829
25830     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);
25831     return STATUS_SUCCESS;
25832 }
25833
25834 #ifdef _WIN64
25835 static NTSTATUS thunk64_vkCmdBindTransformFeedbackBuffersEXT(void *args)
25836 {
25837     struct vkCmdBindTransformFeedbackBuffersEXT_params *params = args;
25838
25839     TRACE("%p, %u, %u, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);
25840
25841     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);
25842     return STATUS_SUCCESS;
25843 }
25844 #endif /* _WIN64 */
25845
25846 static NTSTATUS thunk32_vkCmdBindTransformFeedbackBuffersEXT(void *args)
25847 {
25848     struct
25849     {
25850         PTR32 commandBuffer;
25851         uint32_t firstBinding;
25852         uint32_t bindingCount;
25853         PTR32 pBuffers;
25854         PTR32 pOffsets;
25855         PTR32 pSizes;
25856     } *params = args;
25857
25858     TRACE("%#x, %u, %u, %#x, %#x, %#x\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);
25859
25860     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));
25861     return STATUS_SUCCESS;
25862 }
25863
25864 #ifdef _WIN64
25865 static NTSTATUS thunk64_vkCmdBindVertexBuffers(void *args)
25866 {
25867     struct vkCmdBindVertexBuffers_params *params = args;
25868
25869     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);
25870
25871     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);
25872     return STATUS_SUCCESS;
25873 }
25874 #endif /* _WIN64 */
25875
25876 static NTSTATUS thunk32_vkCmdBindVertexBuffers(void *args)
25877 {
25878     struct
25879     {
25880         PTR32 commandBuffer;
25881         uint32_t firstBinding;
25882         uint32_t bindingCount;
25883         PTR32 pBuffers;
25884         PTR32 pOffsets;
25885     } *params = args;
25886
25887     TRACE("%#x, %u, %u, %#x, %#x\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);
25888
25889     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));
25890     return STATUS_SUCCESS;
25891 }
25892
25893 #ifdef _WIN64
25894 static NTSTATUS thunk64_vkCmdBindVertexBuffers2(void *args)
25895 {
25896     struct vkCmdBindVertexBuffers2_params *params = args;
25897
25898     TRACE("%p, %u, %u, %p, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
25899
25900     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);
25901     return STATUS_SUCCESS;
25902 }
25903 #endif /* _WIN64 */
25904
25905 static NTSTATUS thunk32_vkCmdBindVertexBuffers2(void *args)
25906 {
25907     struct
25908     {
25909         PTR32 commandBuffer;
25910         uint32_t firstBinding;
25911         uint32_t bindingCount;
25912         PTR32 pBuffers;
25913         PTR32 pOffsets;
25914         PTR32 pSizes;
25915         PTR32 pStrides;
25916     } *params = args;
25917
25918     TRACE("%#x, %u, %u, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
25919
25920     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));
25921     return STATUS_SUCCESS;
25922 }
25923
25924 #ifdef _WIN64
25925 static NTSTATUS thunk64_vkCmdBindVertexBuffers2EXT(void *args)
25926 {
25927     struct vkCmdBindVertexBuffers2EXT_params *params = args;
25928
25929     TRACE("%p, %u, %u, %p, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
25930
25931     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);
25932     return STATUS_SUCCESS;
25933 }
25934 #endif /* _WIN64 */
25935
25936 static NTSTATUS thunk32_vkCmdBindVertexBuffers2EXT(void *args)
25937 {
25938     struct
25939     {
25940         PTR32 commandBuffer;
25941         uint32_t firstBinding;
25942         uint32_t bindingCount;
25943         PTR32 pBuffers;
25944         PTR32 pOffsets;
25945         PTR32 pSizes;
25946         PTR32 pStrides;
25947     } *params = args;
25948
25949     TRACE("%#x, %u, %u, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
25950
25951     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));
25952     return STATUS_SUCCESS;
25953 }
25954
25955 #ifdef _WIN64
25956 static NTSTATUS thunk64_vkCmdBlitImage(void *args)
25957 {
25958     struct vkCmdBlitImage_params *params = args;
25959
25960     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions, params->filter);
25961
25962     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);
25963     return STATUS_SUCCESS;
25964 }
25965 #endif /* _WIN64 */
25966
25967 static NTSTATUS thunk32_vkCmdBlitImage(void *args)
25968 {
25969     struct
25970     {
25971         PTR32 commandBuffer;
25972         VkImage DECLSPEC_ALIGN(8) srcImage;
25973         VkImageLayout srcImageLayout;
25974         VkImage DECLSPEC_ALIGN(8) dstImage;
25975         VkImageLayout dstImageLayout;
25976         uint32_t regionCount;
25977         PTR32 pRegions;
25978         VkFilter filter;
25979     } *params = args;
25980
25981     TRACE("%#x, 0x%s, %#x, 0x%s, %#x, %u, %#x, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions, params->filter);
25982
25983     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);
25984     return STATUS_SUCCESS;
25985 }
25986
25987 #ifdef _WIN64
25988 static NTSTATUS thunk64_vkCmdBlitImage2(void *args)
25989 {
25990     struct vkCmdBlitImage2_params *params = args;
25991
25992     TRACE("%p, %p\n", params->commandBuffer, params->pBlitImageInfo);
25993
25994     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
25995     return STATUS_SUCCESS;
25996 }
25997 #endif /* _WIN64 */
25998
25999 static NTSTATUS thunk32_vkCmdBlitImage2(void *args)
26000 {
26001     struct
26002     {
26003         PTR32 commandBuffer;
26004         PTR32 pBlitImageInfo;
26005     } *params = args;
26006     VkBlitImageInfo2 pBlitImageInfo_host;
26007     struct conversion_context ctx;
26008
26009     TRACE("%#x, %#x\n", params->commandBuffer, params->pBlitImageInfo);
26010
26011     init_conversion_context(&ctx);
26012     convert_VkBlitImageInfo2_win32_to_host(&ctx, (const VkBlitImageInfo232 *)UlongToPtr(params->pBlitImageInfo), &pBlitImageInfo_host);
26013     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);
26014     free_conversion_context(&ctx);
26015     return STATUS_SUCCESS;
26016 }
26017
26018 #ifdef _WIN64
26019 static NTSTATUS thunk64_vkCmdBlitImage2KHR(void *args)
26020 {
26021     struct vkCmdBlitImage2KHR_params *params = args;
26022
26023     TRACE("%p, %p\n", params->commandBuffer, params->pBlitImageInfo);
26024
26025     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
26026     return STATUS_SUCCESS;
26027 }
26028 #endif /* _WIN64 */
26029
26030 static NTSTATUS thunk32_vkCmdBlitImage2KHR(void *args)
26031 {
26032     struct
26033     {
26034         PTR32 commandBuffer;
26035         PTR32 pBlitImageInfo;
26036     } *params = args;
26037     VkBlitImageInfo2 pBlitImageInfo_host;
26038     struct conversion_context ctx;
26039
26040     TRACE("%#x, %#x\n", params->commandBuffer, params->pBlitImageInfo);
26041
26042     init_conversion_context(&ctx);
26043     convert_VkBlitImageInfo2_win32_to_host(&ctx, (const VkBlitImageInfo232 *)UlongToPtr(params->pBlitImageInfo), &pBlitImageInfo_host);
26044     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);
26045     free_conversion_context(&ctx);
26046     return STATUS_SUCCESS;
26047 }
26048
26049 #ifdef _WIN64
26050 static NTSTATUS thunk64_vkCmdBuildAccelerationStructureNV(void *args)
26051 {
26052     struct vkCmdBuildAccelerationStructureNV_params *params = args;
26053
26054     TRACE("%p, %p, 0x%s, 0x%s, %u, 0x%s, 0x%s, 0x%s, 0x%s\n", params->commandBuffer, params->pInfo, wine_dbgstr_longlong(params->instanceData), wine_dbgstr_longlong(params->instanceOffset), params->update, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), wine_dbgstr_longlong(params->scratch), wine_dbgstr_longlong(params->scratchOffset));
26055
26056     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);
26057     return STATUS_SUCCESS;
26058 }
26059 #endif /* _WIN64 */
26060
26061 static NTSTATUS thunk32_vkCmdBuildAccelerationStructureNV(void *args)
26062 {
26063     struct
26064     {
26065         PTR32 commandBuffer;
26066         PTR32 pInfo;
26067         VkBuffer DECLSPEC_ALIGN(8) instanceData;
26068         VkDeviceSize DECLSPEC_ALIGN(8) instanceOffset;
26069         VkBool32 update;
26070         VkAccelerationStructureNV DECLSPEC_ALIGN(8) dst;
26071         VkAccelerationStructureNV DECLSPEC_ALIGN(8) src;
26072         VkBuffer DECLSPEC_ALIGN(8) scratch;
26073         VkDeviceSize DECLSPEC_ALIGN(8) scratchOffset;
26074     } *params = args;
26075     VkAccelerationStructureInfoNV pInfo_host;
26076     struct conversion_context ctx;
26077
26078     TRACE("%#x, %#x, 0x%s, 0x%s, %u, 0x%s, 0x%s, 0x%s, 0x%s\n", params->commandBuffer, params->pInfo, wine_dbgstr_longlong(params->instanceData), wine_dbgstr_longlong(params->instanceOffset), params->update, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), wine_dbgstr_longlong(params->scratch), wine_dbgstr_longlong(params->scratchOffset));
26079
26080     init_conversion_context(&ctx);
26081     convert_VkAccelerationStructureInfoNV_win32_to_host(&ctx, (const VkAccelerationStructureInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
26082     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);
26083     free_conversion_context(&ctx);
26084     return STATUS_SUCCESS;
26085 }
26086
26087 #ifdef _WIN64
26088 static NTSTATUS thunk64_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
26089 {
26090     struct vkCmdBuildAccelerationStructuresIndirectKHR_params *params = args;
26091
26092     TRACE("%p, %u, %p, %p, %p, %p\n", params->commandBuffer, params->infoCount, params->pInfos, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
26093
26094     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);
26095     return STATUS_SUCCESS;
26096 }
26097 #endif /* _WIN64 */
26098
26099 static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
26100 {
26101     struct
26102     {
26103         PTR32 commandBuffer;
26104         uint32_t infoCount;
26105         PTR32 pInfos;
26106         PTR32 pIndirectDeviceAddresses;
26107         PTR32 pIndirectStrides;
26108         PTR32 ppMaxPrimitiveCounts;
26109     } *params = args;
26110     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
26111     struct conversion_context ctx;
26112
26113     TRACE("%#x, %u, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->infoCount, params->pInfos, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
26114
26115     init_conversion_context(&ctx);
26116     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
26117     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));
26118     free_conversion_context(&ctx);
26119     return STATUS_SUCCESS;
26120 }
26121
26122 #ifdef _WIN64
26123 static NTSTATUS thunk64_vkCmdBuildAccelerationStructuresKHR(void *args)
26124 {
26125     struct vkCmdBuildAccelerationStructuresKHR_params *params = args;
26126
26127     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
26128
26129     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);
26130     return STATUS_SUCCESS;
26131 }
26132 #endif /* _WIN64 */
26133
26134 static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresKHR(void *args)
26135 {
26136     struct
26137     {
26138         PTR32 commandBuffer;
26139         uint32_t infoCount;
26140         PTR32 pInfos;
26141         PTR32 ppBuildRangeInfos;
26142     } *params = args;
26143     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
26144     struct conversion_context ctx;
26145
26146     TRACE("%#x, %u, %#x, %#x\n", params->commandBuffer, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
26147
26148     init_conversion_context(&ctx);
26149     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
26150     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));
26151     free_conversion_context(&ctx);
26152     return STATUS_SUCCESS;
26153 }
26154
26155 #ifdef _WIN64
26156 static NTSTATUS thunk64_vkCmdBuildMicromapsEXT(void *args)
26157 {
26158     struct vkCmdBuildMicromapsEXT_params *params = args;
26159
26160     TRACE("%p, %u, %p\n", params->commandBuffer, params->infoCount, params->pInfos);
26161
26162     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos);
26163     return STATUS_SUCCESS;
26164 }
26165 #endif /* _WIN64 */
26166
26167 static NTSTATUS thunk32_vkCmdBuildMicromapsEXT(void *args)
26168 {
26169     struct
26170     {
26171         PTR32 commandBuffer;
26172         uint32_t infoCount;
26173         PTR32 pInfos;
26174     } *params = args;
26175     const VkMicromapBuildInfoEXT *pInfos_host;
26176     struct conversion_context ctx;
26177
26178     TRACE("%#x, %u, %#x\n", params->commandBuffer, params->infoCount, params->pInfos);
26179
26180     init_conversion_context(&ctx);
26181     pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(&ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pInfos), params->infoCount);
26182     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);
26183     free_conversion_context(&ctx);
26184     return STATUS_SUCCESS;
26185 }
26186
26187 #ifdef _WIN64
26188 static NTSTATUS thunk64_vkCmdClearAttachments(void *args)
26189 {
26190     struct vkCmdClearAttachments_params *params = args;
26191
26192     TRACE("%p, %u, %p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);
26193
26194     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);
26195     return STATUS_SUCCESS;
26196 }
26197 #endif /* _WIN64 */
26198
26199 static NTSTATUS thunk32_vkCmdClearAttachments(void *args)
26200 {
26201     struct
26202     {
26203         PTR32 commandBuffer;
26204         uint32_t attachmentCount;
26205         PTR32 pAttachments;
26206         uint32_t rectCount;
26207         PTR32 pRects;
26208     } *params = args;
26209
26210     TRACE("%#x, %u, %#x, %u, %#x\n", params->commandBuffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);
26211
26212     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));
26213     return STATUS_SUCCESS;
26214 }
26215
26216 #ifdef _WIN64
26217 static NTSTATUS thunk64_vkCmdClearColorImage(void *args)
26218 {
26219     struct vkCmdClearColorImage_params *params = args;
26220
26221     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pColor, params->rangeCount, params->pRanges);
26222
26223     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);
26224     return STATUS_SUCCESS;
26225 }
26226 #endif /* _WIN64 */
26227
26228 static NTSTATUS thunk32_vkCmdClearColorImage(void *args)
26229 {
26230     struct
26231     {
26232         PTR32 commandBuffer;
26233         VkImage DECLSPEC_ALIGN(8) image;
26234         VkImageLayout imageLayout;
26235         PTR32 pColor;
26236         uint32_t rangeCount;
26237         PTR32 pRanges;
26238     } *params = args;
26239
26240     TRACE("%#x, 0x%s, %#x, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pColor, params->rangeCount, params->pRanges);
26241
26242     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));
26243     return STATUS_SUCCESS;
26244 }
26245
26246 #ifdef _WIN64
26247 static NTSTATUS thunk64_vkCmdClearDepthStencilImage(void *args)
26248 {
26249     struct vkCmdClearDepthStencilImage_params *params = args;
26250
26251     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);
26252
26253     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);
26254     return STATUS_SUCCESS;
26255 }
26256 #endif /* _WIN64 */
26257
26258 static NTSTATUS thunk32_vkCmdClearDepthStencilImage(void *args)
26259 {
26260     struct
26261     {
26262         PTR32 commandBuffer;
26263         VkImage DECLSPEC_ALIGN(8) image;
26264         VkImageLayout imageLayout;
26265         PTR32 pDepthStencil;
26266         uint32_t rangeCount;
26267         PTR32 pRanges;
26268     } *params = args;
26269
26270     TRACE("%#x, 0x%s, %#x, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);
26271
26272     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));
26273     return STATUS_SUCCESS;
26274 }
26275
26276 #ifdef _WIN64
26277 static NTSTATUS thunk64_vkCmdCopyAccelerationStructureKHR(void *args)
26278 {
26279     struct vkCmdCopyAccelerationStructureKHR_params *params = args;
26280
26281     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
26282
26283     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
26284     return STATUS_SUCCESS;
26285 }
26286 #endif /* _WIN64 */
26287
26288 static NTSTATUS thunk32_vkCmdCopyAccelerationStructureKHR(void *args)
26289 {
26290     struct
26291     {
26292         PTR32 commandBuffer;
26293         PTR32 pInfo;
26294     } *params = args;
26295     VkCopyAccelerationStructureInfoKHR pInfo_host;
26296
26297     TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);
26298
26299     convert_VkCopyAccelerationStructureInfoKHR_win32_to_host((const VkCopyAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
26300     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);
26301     return STATUS_SUCCESS;
26302 }
26303
26304 #ifdef _WIN64
26305 static NTSTATUS thunk64_vkCmdCopyAccelerationStructureNV(void *args)
26306 {
26307     struct vkCmdCopyAccelerationStructureNV_params *params = args;
26308
26309     TRACE("%p, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), params->mode);
26310
26311     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);
26312     return STATUS_SUCCESS;
26313 }
26314 #endif /* _WIN64 */
26315
26316 static NTSTATUS thunk32_vkCmdCopyAccelerationStructureNV(void *args)
26317 {
26318     struct
26319     {
26320         PTR32 commandBuffer;
26321         VkAccelerationStructureNV DECLSPEC_ALIGN(8) dst;
26322         VkAccelerationStructureNV DECLSPEC_ALIGN(8) src;
26323         VkCopyAccelerationStructureModeKHR mode;
26324     } *params = args;
26325
26326     TRACE("%#x, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), params->mode);
26327
26328     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);
26329     return STATUS_SUCCESS;
26330 }
26331
26332 #ifdef _WIN64
26333 static NTSTATUS thunk64_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
26334 {
26335     struct vkCmdCopyAccelerationStructureToMemoryKHR_params *params = args;
26336
26337     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
26338
26339     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
26340     return STATUS_SUCCESS;
26341 }
26342 #endif /* _WIN64 */
26343
26344 static NTSTATUS thunk32_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
26345 {
26346     struct
26347     {
26348         PTR32 commandBuffer;
26349         PTR32 pInfo;
26350     } *params = args;
26351     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;
26352
26353     TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);
26354
26355     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host((const VkCopyAccelerationStructureToMemoryInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
26356     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);
26357     return STATUS_SUCCESS;
26358 }
26359
26360 #ifdef _WIN64
26361 static NTSTATUS thunk64_vkCmdCopyBuffer(void *args)
26362 {
26363     struct vkCmdCopyBuffer_params *params = args;
26364
26365     TRACE("%p, 0x%s, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);
26366
26367     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);
26368     return STATUS_SUCCESS;
26369 }
26370 #endif /* _WIN64 */
26371
26372 static NTSTATUS thunk32_vkCmdCopyBuffer(void *args)
26373 {
26374     struct
26375     {
26376         PTR32 commandBuffer;
26377         VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
26378         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
26379         uint32_t regionCount;
26380         PTR32 pRegions;
26381     } *params = args;
26382     const VkBufferCopy *pRegions_host;
26383     struct conversion_context ctx;
26384
26385     TRACE("%#x, 0x%s, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);
26386
26387     init_conversion_context(&ctx);
26388     pRegions_host = convert_VkBufferCopy_array_win32_to_host(&ctx, (const VkBufferCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
26389     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);
26390     free_conversion_context(&ctx);
26391     return STATUS_SUCCESS;
26392 }
26393
26394 #ifdef _WIN64
26395 static NTSTATUS thunk64_vkCmdCopyBuffer2(void *args)
26396 {
26397     struct vkCmdCopyBuffer2_params *params = args;
26398
26399     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferInfo);
26400
26401     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
26402     return STATUS_SUCCESS;
26403 }
26404 #endif /* _WIN64 */
26405
26406 static NTSTATUS thunk32_vkCmdCopyBuffer2(void *args)
26407 {
26408     struct
26409     {
26410         PTR32 commandBuffer;
26411         PTR32 pCopyBufferInfo;
26412     } *params = args;
26413     VkCopyBufferInfo2 pCopyBufferInfo_host;
26414     struct conversion_context ctx;
26415
26416     TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyBufferInfo);
26417
26418     init_conversion_context(&ctx);
26419     convert_VkCopyBufferInfo2_win32_to_host(&ctx, (const VkCopyBufferInfo232 *)UlongToPtr(params->pCopyBufferInfo), &pCopyBufferInfo_host);
26420     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);
26421     free_conversion_context(&ctx);
26422     return STATUS_SUCCESS;
26423 }
26424
26425 #ifdef _WIN64
26426 static NTSTATUS thunk64_vkCmdCopyBuffer2KHR(void *args)
26427 {
26428     struct vkCmdCopyBuffer2KHR_params *params = args;
26429
26430     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferInfo);
26431
26432     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
26433     return STATUS_SUCCESS;
26434 }
26435 #endif /* _WIN64 */
26436
26437 static NTSTATUS thunk32_vkCmdCopyBuffer2KHR(void *args)
26438 {
26439     struct
26440     {
26441         PTR32 commandBuffer;
26442         PTR32 pCopyBufferInfo;
26443     } *params = args;
26444     VkCopyBufferInfo2 pCopyBufferInfo_host;
26445     struct conversion_context ctx;
26446
26447     TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyBufferInfo);
26448
26449     init_conversion_context(&ctx);
26450     convert_VkCopyBufferInfo2_win32_to_host(&ctx, (const VkCopyBufferInfo232 *)UlongToPtr(params->pCopyBufferInfo), &pCopyBufferInfo_host);
26451     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);
26452     free_conversion_context(&ctx);
26453     return STATUS_SUCCESS;
26454 }
26455
26456 #ifdef _WIN64
26457 static NTSTATUS thunk64_vkCmdCopyBufferToImage(void *args)
26458 {
26459     struct vkCmdCopyBufferToImage_params *params = args;
26460
26461     TRACE("%p, 0x%s, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
26462
26463     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);
26464     return STATUS_SUCCESS;
26465 }
26466 #endif /* _WIN64 */
26467
26468 static NTSTATUS thunk32_vkCmdCopyBufferToImage(void *args)
26469 {
26470     struct
26471     {
26472         PTR32 commandBuffer;
26473         VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
26474         VkImage DECLSPEC_ALIGN(8) dstImage;
26475         VkImageLayout dstImageLayout;
26476         uint32_t regionCount;
26477         PTR32 pRegions;
26478     } *params = args;
26479     const VkBufferImageCopy *pRegions_host;
26480     struct conversion_context ctx;
26481
26482     TRACE("%#x, 0x%s, 0x%s, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
26483
26484     init_conversion_context(&ctx);
26485     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, (const VkBufferImageCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
26486     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);
26487     free_conversion_context(&ctx);
26488     return STATUS_SUCCESS;
26489 }
26490
26491 #ifdef _WIN64
26492 static NTSTATUS thunk64_vkCmdCopyBufferToImage2(void *args)
26493 {
26494     struct vkCmdCopyBufferToImage2_params *params = args;
26495
26496     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferToImageInfo);
26497
26498     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
26499     return STATUS_SUCCESS;
26500 }
26501 #endif /* _WIN64 */
26502
26503 static NTSTATUS thunk32_vkCmdCopyBufferToImage2(void *args)
26504 {
26505     struct
26506     {
26507         PTR32 commandBuffer;
26508         PTR32 pCopyBufferToImageInfo;
26509     } *params = args;
26510     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
26511     struct conversion_context ctx;
26512
26513     TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyBufferToImageInfo);
26514
26515     init_conversion_context(&ctx);
26516     convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, (const VkCopyBufferToImageInfo232 *)UlongToPtr(params->pCopyBufferToImageInfo), &pCopyBufferToImageInfo_host);
26517     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);
26518     free_conversion_context(&ctx);
26519     return STATUS_SUCCESS;
26520 }
26521
26522 #ifdef _WIN64
26523 static NTSTATUS thunk64_vkCmdCopyBufferToImage2KHR(void *args)
26524 {
26525     struct vkCmdCopyBufferToImage2KHR_params *params = args;
26526
26527     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferToImageInfo);
26528
26529     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
26530     return STATUS_SUCCESS;
26531 }
26532 #endif /* _WIN64 */
26533
26534 static NTSTATUS thunk32_vkCmdCopyBufferToImage2KHR(void *args)
26535 {
26536     struct
26537     {
26538         PTR32 commandBuffer;
26539         PTR32 pCopyBufferToImageInfo;
26540     } *params = args;
26541     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
26542     struct conversion_context ctx;
26543
26544     TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyBufferToImageInfo);
26545
26546     init_conversion_context(&ctx);
26547     convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, (const VkCopyBufferToImageInfo232 *)UlongToPtr(params->pCopyBufferToImageInfo), &pCopyBufferToImageInfo_host);
26548     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);
26549     free_conversion_context(&ctx);
26550     return STATUS_SUCCESS;
26551 }
26552
26553 #ifdef _WIN64
26554 static NTSTATUS thunk64_vkCmdCopyImage(void *args)
26555 {
26556     struct vkCmdCopyImage_params *params = args;
26557
26558     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
26559
26560     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);
26561     return STATUS_SUCCESS;
26562 }
26563 #endif /* _WIN64 */
26564
26565 static NTSTATUS thunk32_vkCmdCopyImage(void *args)
26566 {
26567     struct
26568     {
26569         PTR32 commandBuffer;
26570         VkImage DECLSPEC_ALIGN(8) srcImage;
26571         VkImageLayout srcImageLayout;
26572         VkImage DECLSPEC_ALIGN(8) dstImage;
26573         VkImageLayout dstImageLayout;
26574         uint32_t regionCount;
26575         PTR32 pRegions;
26576     } *params = args;
26577
26578     TRACE("%#x, 0x%s, %#x, 0x%s, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
26579
26580     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));
26581     return STATUS_SUCCESS;
26582 }
26583
26584 #ifdef _WIN64
26585 static NTSTATUS thunk64_vkCmdCopyImage2(void *args)
26586 {
26587     struct vkCmdCopyImage2_params *params = args;
26588
26589     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageInfo);
26590
26591     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
26592     return STATUS_SUCCESS;
26593 }
26594 #endif /* _WIN64 */
26595
26596 static NTSTATUS thunk32_vkCmdCopyImage2(void *args)
26597 {
26598     struct
26599     {
26600         PTR32 commandBuffer;
26601         PTR32 pCopyImageInfo;
26602     } *params = args;
26603     VkCopyImageInfo2 pCopyImageInfo_host;
26604     struct conversion_context ctx;
26605
26606     TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyImageInfo);
26607
26608     init_conversion_context(&ctx);
26609     convert_VkCopyImageInfo2_win32_to_host(&ctx, (const VkCopyImageInfo232 *)UlongToPtr(params->pCopyImageInfo), &pCopyImageInfo_host);
26610     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);
26611     free_conversion_context(&ctx);
26612     return STATUS_SUCCESS;
26613 }
26614
26615 #ifdef _WIN64
26616 static NTSTATUS thunk64_vkCmdCopyImage2KHR(void *args)
26617 {
26618     struct vkCmdCopyImage2KHR_params *params = args;
26619
26620     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageInfo);
26621
26622     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
26623     return STATUS_SUCCESS;
26624 }
26625 #endif /* _WIN64 */
26626
26627 static NTSTATUS thunk32_vkCmdCopyImage2KHR(void *args)
26628 {
26629     struct
26630     {
26631         PTR32 commandBuffer;
26632         PTR32 pCopyImageInfo;
26633     } *params = args;
26634     VkCopyImageInfo2 pCopyImageInfo_host;
26635     struct conversion_context ctx;
26636
26637     TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyImageInfo);
26638
26639     init_conversion_context(&ctx);
26640     convert_VkCopyImageInfo2_win32_to_host(&ctx, (const VkCopyImageInfo232 *)UlongToPtr(params->pCopyImageInfo), &pCopyImageInfo_host);
26641     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);
26642     free_conversion_context(&ctx);
26643     return STATUS_SUCCESS;
26644 }
26645
26646 #ifdef _WIN64
26647 static NTSTATUS thunk64_vkCmdCopyImageToBuffer(void *args)
26648 {
26649     struct vkCmdCopyImageToBuffer_params *params = args;
26650
26651     TRACE("%p, 0x%s, %#x, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);
26652
26653     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);
26654     return STATUS_SUCCESS;
26655 }
26656 #endif /* _WIN64 */
26657
26658 static NTSTATUS thunk32_vkCmdCopyImageToBuffer(void *args)
26659 {
26660     struct
26661     {
26662         PTR32 commandBuffer;
26663         VkImage DECLSPEC_ALIGN(8) srcImage;
26664         VkImageLayout srcImageLayout;
26665         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
26666         uint32_t regionCount;
26667         PTR32 pRegions;
26668     } *params = args;
26669     const VkBufferImageCopy *pRegions_host;
26670     struct conversion_context ctx;
26671
26672     TRACE("%#x, 0x%s, %#x, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);
26673
26674     init_conversion_context(&ctx);
26675     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, (const VkBufferImageCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
26676     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);
26677     free_conversion_context(&ctx);
26678     return STATUS_SUCCESS;
26679 }
26680
26681 #ifdef _WIN64
26682 static NTSTATUS thunk64_vkCmdCopyImageToBuffer2(void *args)
26683 {
26684     struct vkCmdCopyImageToBuffer2_params *params = args;
26685
26686     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageToBufferInfo);
26687
26688     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
26689     return STATUS_SUCCESS;
26690 }
26691 #endif /* _WIN64 */
26692
26693 static NTSTATUS thunk32_vkCmdCopyImageToBuffer2(void *args)
26694 {
26695     struct
26696     {
26697         PTR32 commandBuffer;
26698         PTR32 pCopyImageToBufferInfo;
26699     } *params = args;
26700     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
26701     struct conversion_context ctx;
26702
26703     TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyImageToBufferInfo);
26704
26705     init_conversion_context(&ctx);
26706     convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, (const VkCopyImageToBufferInfo232 *)UlongToPtr(params->pCopyImageToBufferInfo), &pCopyImageToBufferInfo_host);
26707     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);
26708     free_conversion_context(&ctx);
26709     return STATUS_SUCCESS;
26710 }
26711
26712 #ifdef _WIN64
26713 static NTSTATUS thunk64_vkCmdCopyImageToBuffer2KHR(void *args)
26714 {
26715     struct vkCmdCopyImageToBuffer2KHR_params *params = args;
26716
26717     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageToBufferInfo);
26718
26719     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
26720     return STATUS_SUCCESS;
26721 }
26722 #endif /* _WIN64 */
26723
26724 static NTSTATUS thunk32_vkCmdCopyImageToBuffer2KHR(void *args)
26725 {
26726     struct
26727     {
26728         PTR32 commandBuffer;
26729         PTR32 pCopyImageToBufferInfo;
26730     } *params = args;
26731     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
26732     struct conversion_context ctx;
26733
26734     TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyImageToBufferInfo);
26735
26736     init_conversion_context(&ctx);
26737     convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, (const VkCopyImageToBufferInfo232 *)UlongToPtr(params->pCopyImageToBufferInfo), &pCopyImageToBufferInfo_host);
26738     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);
26739     free_conversion_context(&ctx);
26740     return STATUS_SUCCESS;
26741 }
26742
26743 #ifdef _WIN64
26744 static NTSTATUS thunk64_vkCmdCopyMemoryIndirectNV(void *args)
26745 {
26746     struct vkCmdCopyMemoryIndirectNV_params *params = args;
26747
26748     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride);
26749
26750     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);
26751     return STATUS_SUCCESS;
26752 }
26753 #endif /* _WIN64 */
26754
26755 static NTSTATUS thunk32_vkCmdCopyMemoryIndirectNV(void *args)
26756 {
26757     struct
26758     {
26759         PTR32 commandBuffer;
26760         VkDeviceAddress DECLSPEC_ALIGN(8) copyBufferAddress;
26761         uint32_t copyCount;
26762         uint32_t stride;
26763     } *params = args;
26764
26765     TRACE("%#x, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride);
26766
26767     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);
26768     return STATUS_SUCCESS;
26769 }
26770
26771 #ifdef _WIN64
26772 static NTSTATUS thunk64_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
26773 {
26774     struct vkCmdCopyMemoryToAccelerationStructureKHR_params *params = args;
26775
26776     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
26777
26778     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
26779     return STATUS_SUCCESS;
26780 }
26781 #endif /* _WIN64 */
26782
26783 static NTSTATUS thunk32_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
26784 {
26785     struct
26786     {
26787         PTR32 commandBuffer;
26788         PTR32 pInfo;
26789     } *params = args;
26790     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;
26791
26792     TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);
26793
26794     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host((const VkCopyMemoryToAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
26795     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);
26796     return STATUS_SUCCESS;
26797 }
26798
26799 #ifdef _WIN64
26800 static NTSTATUS thunk64_vkCmdCopyMemoryToImageIndirectNV(void *args)
26801 {
26802     struct vkCmdCopyMemoryToImageIndirectNV_params *params = args;
26803
26804     TRACE("%p, 0x%s, %u, %u, 0x%s, %#x, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->pImageSubresources);
26805
26806     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);
26807     return STATUS_SUCCESS;
26808 }
26809 #endif /* _WIN64 */
26810
26811 static NTSTATUS thunk32_vkCmdCopyMemoryToImageIndirectNV(void *args)
26812 {
26813     struct
26814     {
26815         PTR32 commandBuffer;
26816         VkDeviceAddress DECLSPEC_ALIGN(8) copyBufferAddress;
26817         uint32_t copyCount;
26818         uint32_t stride;
26819         VkImage DECLSPEC_ALIGN(8) dstImage;
26820         VkImageLayout dstImageLayout;
26821         PTR32 pImageSubresources;
26822     } *params = args;
26823
26824     TRACE("%#x, 0x%s, %u, %u, 0x%s, %#x, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->pImageSubresources);
26825
26826     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));
26827     return STATUS_SUCCESS;
26828 }
26829
26830 #ifdef _WIN64
26831 static NTSTATUS thunk64_vkCmdCopyMemoryToMicromapEXT(void *args)
26832 {
26833     struct vkCmdCopyMemoryToMicromapEXT_params *params = args;
26834
26835     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
26836
26837     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
26838     return STATUS_SUCCESS;
26839 }
26840 #endif /* _WIN64 */
26841
26842 static NTSTATUS thunk32_vkCmdCopyMemoryToMicromapEXT(void *args)
26843 {
26844     struct
26845     {
26846         PTR32 commandBuffer;
26847         PTR32 pInfo;
26848     } *params = args;
26849     VkCopyMemoryToMicromapInfoEXT pInfo_host;
26850
26851     TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);
26852
26853     convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host((const VkCopyMemoryToMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
26854     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);
26855     return STATUS_SUCCESS;
26856 }
26857
26858 #ifdef _WIN64
26859 static NTSTATUS thunk64_vkCmdCopyMicromapEXT(void *args)
26860 {
26861     struct vkCmdCopyMicromapEXT_params *params = args;
26862
26863     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
26864
26865     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
26866     return STATUS_SUCCESS;
26867 }
26868 #endif /* _WIN64 */
26869
26870 static NTSTATUS thunk32_vkCmdCopyMicromapEXT(void *args)
26871 {
26872     struct
26873     {
26874         PTR32 commandBuffer;
26875         PTR32 pInfo;
26876     } *params = args;
26877     VkCopyMicromapInfoEXT pInfo_host;
26878
26879     TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);
26880
26881     convert_VkCopyMicromapInfoEXT_win32_to_host((const VkCopyMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
26882     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);
26883     return STATUS_SUCCESS;
26884 }
26885
26886 #ifdef _WIN64
26887 static NTSTATUS thunk64_vkCmdCopyMicromapToMemoryEXT(void *args)
26888 {
26889     struct vkCmdCopyMicromapToMemoryEXT_params *params = args;
26890
26891     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
26892
26893     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
26894     return STATUS_SUCCESS;
26895 }
26896 #endif /* _WIN64 */
26897
26898 static NTSTATUS thunk32_vkCmdCopyMicromapToMemoryEXT(void *args)
26899 {
26900     struct
26901     {
26902         PTR32 commandBuffer;
26903         PTR32 pInfo;
26904     } *params = args;
26905     VkCopyMicromapToMemoryInfoEXT pInfo_host;
26906
26907     TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);
26908
26909     convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host((const VkCopyMicromapToMemoryInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
26910     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);
26911     return STATUS_SUCCESS;
26912 }
26913
26914 #ifdef _WIN64
26915 static NTSTATUS thunk64_vkCmdCopyQueryPoolResults(void *args)
26916 {
26917     struct vkCmdCopyQueryPoolResults_params *params = args;
26918
26919     TRACE("%p, 0x%s, %u, %u, 0x%s, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->stride), params->flags);
26920
26921     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);
26922     return STATUS_SUCCESS;
26923 }
26924 #endif /* _WIN64 */
26925
26926 static NTSTATUS thunk32_vkCmdCopyQueryPoolResults(void *args)
26927 {
26928     struct
26929     {
26930         PTR32 commandBuffer;
26931         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
26932         uint32_t firstQuery;
26933         uint32_t queryCount;
26934         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
26935         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
26936         VkDeviceSize DECLSPEC_ALIGN(8) stride;
26937         VkQueryResultFlags flags;
26938     } *params = args;
26939
26940     TRACE("%#x, 0x%s, %u, %u, 0x%s, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->stride), params->flags);
26941
26942     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);
26943     return STATUS_SUCCESS;
26944 }
26945
26946 #ifdef _WIN64
26947 static NTSTATUS thunk64_vkCmdCuLaunchKernelNVX(void *args)
26948 {
26949     struct vkCmdCuLaunchKernelNVX_params *params = args;
26950
26951     TRACE("%p, %p\n", params->commandBuffer, params->pLaunchInfo);
26952
26953     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLaunchInfo);
26954     return STATUS_SUCCESS;
26955 }
26956 #endif /* _WIN64 */
26957
26958 static NTSTATUS thunk32_vkCmdCuLaunchKernelNVX(void *args)
26959 {
26960     struct
26961     {
26962         PTR32 commandBuffer;
26963         PTR32 pLaunchInfo;
26964     } *params = args;
26965     VkCuLaunchInfoNVX pLaunchInfo_host;
26966
26967     TRACE("%#x, %#x\n", params->commandBuffer, params->pLaunchInfo);
26968
26969     convert_VkCuLaunchInfoNVX_win32_to_host((const VkCuLaunchInfoNVX32 *)UlongToPtr(params->pLaunchInfo), &pLaunchInfo_host);
26970     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);
26971     return STATUS_SUCCESS;
26972 }
26973
26974 #ifdef _WIN64
26975 static NTSTATUS thunk64_vkCmdDebugMarkerBeginEXT(void *args)
26976 {
26977     struct vkCmdDebugMarkerBeginEXT_params *params = args;
26978
26979     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
26980
26981     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerBeginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
26982     return STATUS_SUCCESS;
26983 }
26984 #endif /* _WIN64 */
26985
26986 static NTSTATUS thunk32_vkCmdDebugMarkerBeginEXT(void *args)
26987 {
26988     struct
26989     {
26990         PTR32 commandBuffer;
26991         PTR32 pMarkerInfo;
26992     } *params = args;
26993     VkDebugMarkerMarkerInfoEXT pMarkerInfo_host;
26994
26995     TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);
26996
26997     convert_VkDebugMarkerMarkerInfoEXT_win32_to_host((const VkDebugMarkerMarkerInfoEXT32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
26998     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);
26999     return STATUS_SUCCESS;
27000 }
27001
27002 #ifdef _WIN64
27003 static NTSTATUS thunk64_vkCmdDebugMarkerEndEXT(void *args)
27004 {
27005     struct vkCmdDebugMarkerEndEXT_params *params = args;
27006
27007     TRACE("%p\n", params->commandBuffer);
27008
27009     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
27010     return STATUS_SUCCESS;
27011 }
27012 #endif /* _WIN64 */
27013
27014 static NTSTATUS thunk32_vkCmdDebugMarkerEndEXT(void *args)
27015 {
27016     struct
27017     {
27018         PTR32 commandBuffer;
27019     } *params = args;
27020
27021     TRACE("%#x\n", params->commandBuffer);
27022
27023     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
27024     return STATUS_SUCCESS;
27025 }
27026
27027 #ifdef _WIN64
27028 static NTSTATUS thunk64_vkCmdDebugMarkerInsertEXT(void *args)
27029 {
27030     struct vkCmdDebugMarkerInsertEXT_params *params = args;
27031
27032     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
27033
27034     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerInsertEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
27035     return STATUS_SUCCESS;
27036 }
27037 #endif /* _WIN64 */
27038
27039 static NTSTATUS thunk32_vkCmdDebugMarkerInsertEXT(void *args)
27040 {
27041     struct
27042     {
27043         PTR32 commandBuffer;
27044         PTR32 pMarkerInfo;
27045     } *params = args;
27046     VkDebugMarkerMarkerInfoEXT pMarkerInfo_host;
27047
27048     TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);
27049
27050     convert_VkDebugMarkerMarkerInfoEXT_win32_to_host((const VkDebugMarkerMarkerInfoEXT32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
27051     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);
27052     return STATUS_SUCCESS;
27053 }
27054
27055 #ifdef _WIN64
27056 static NTSTATUS thunk64_vkCmdDecompressMemoryIndirectCountNV(void *args)
27057 {
27058     struct vkCmdDecompressMemoryIndirectCountNV_params *params = args;
27059
27060     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectCommandsAddress), wine_dbgstr_longlong(params->indirectCommandsCountAddress), params->stride);
27061
27062     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);
27063     return STATUS_SUCCESS;
27064 }
27065 #endif /* _WIN64 */
27066
27067 static NTSTATUS thunk32_vkCmdDecompressMemoryIndirectCountNV(void *args)
27068 {
27069     struct
27070     {
27071         PTR32 commandBuffer;
27072         VkDeviceAddress DECLSPEC_ALIGN(8) indirectCommandsAddress;
27073         VkDeviceAddress DECLSPEC_ALIGN(8) indirectCommandsCountAddress;
27074         uint32_t stride;
27075     } *params = args;
27076
27077     TRACE("%#x, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectCommandsAddress), wine_dbgstr_longlong(params->indirectCommandsCountAddress), params->stride);
27078
27079     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);
27080     return STATUS_SUCCESS;
27081 }
27082
27083 #ifdef _WIN64
27084 static NTSTATUS thunk64_vkCmdDecompressMemoryNV(void *args)
27085 {
27086     struct vkCmdDecompressMemoryNV_params *params = args;
27087
27088     TRACE("%p, %u, %p\n", params->commandBuffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
27089
27090     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
27091     return STATUS_SUCCESS;
27092 }
27093 #endif /* _WIN64 */
27094
27095 static NTSTATUS thunk32_vkCmdDecompressMemoryNV(void *args)
27096 {
27097     struct
27098     {
27099         PTR32 commandBuffer;
27100         uint32_t decompressRegionCount;
27101         PTR32 pDecompressMemoryRegions;
27102     } *params = args;
27103     const VkDecompressMemoryRegionNV *pDecompressMemoryRegions_host;
27104     struct conversion_context ctx;
27105
27106     TRACE("%#x, %u, %#x\n", params->commandBuffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
27107
27108     init_conversion_context(&ctx);
27109     pDecompressMemoryRegions_host = convert_VkDecompressMemoryRegionNV_array_win32_to_host(&ctx, (const VkDecompressMemoryRegionNV32 *)UlongToPtr(params->pDecompressMemoryRegions), params->decompressRegionCount);
27110     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);
27111     free_conversion_context(&ctx);
27112     return STATUS_SUCCESS;
27113 }
27114
27115 #ifdef _WIN64
27116 static NTSTATUS thunk64_vkCmdDispatch(void *args)
27117 {
27118     struct vkCmdDispatch_params *params = args;
27119
27120     TRACE("%p, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
27121
27122     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);
27123     return STATUS_SUCCESS;
27124 }
27125 #endif /* _WIN64 */
27126
27127 static NTSTATUS thunk32_vkCmdDispatch(void *args)
27128 {
27129     struct
27130     {
27131         PTR32 commandBuffer;
27132         uint32_t groupCountX;
27133         uint32_t groupCountY;
27134         uint32_t groupCountZ;
27135     } *params = args;
27136
27137     TRACE("%#x, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
27138
27139     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);
27140     return STATUS_SUCCESS;
27141 }
27142
27143 #ifdef _WIN64
27144 static NTSTATUS thunk64_vkCmdDispatchBase(void *args)
27145 {
27146     struct vkCmdDispatchBase_params *params = args;
27147
27148     TRACE("%p, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
27149
27150     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);
27151     return STATUS_SUCCESS;
27152 }
27153 #endif /* _WIN64 */
27154
27155 static NTSTATUS thunk32_vkCmdDispatchBase(void *args)
27156 {
27157     struct
27158     {
27159         PTR32 commandBuffer;
27160         uint32_t baseGroupX;
27161         uint32_t baseGroupY;
27162         uint32_t baseGroupZ;
27163         uint32_t groupCountX;
27164         uint32_t groupCountY;
27165         uint32_t groupCountZ;
27166     } *params = args;
27167
27168     TRACE("%#x, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
27169
27170     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);
27171     return STATUS_SUCCESS;
27172 }
27173
27174 #ifdef _WIN64
27175 static NTSTATUS thunk64_vkCmdDispatchBaseKHR(void *args)
27176 {
27177     struct vkCmdDispatchBaseKHR_params *params = args;
27178
27179     TRACE("%p, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
27180
27181     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);
27182     return STATUS_SUCCESS;
27183 }
27184 #endif /* _WIN64 */
27185
27186 static NTSTATUS thunk32_vkCmdDispatchBaseKHR(void *args)
27187 {
27188     struct
27189     {
27190         PTR32 commandBuffer;
27191         uint32_t baseGroupX;
27192         uint32_t baseGroupY;
27193         uint32_t baseGroupZ;
27194         uint32_t groupCountX;
27195         uint32_t groupCountY;
27196         uint32_t groupCountZ;
27197     } *params = args;
27198
27199     TRACE("%#x, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
27200
27201     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);
27202     return STATUS_SUCCESS;
27203 }
27204
27205 #ifdef _WIN64
27206 static NTSTATUS thunk64_vkCmdDispatchIndirect(void *args)
27207 {
27208     struct vkCmdDispatchIndirect_params *params = args;
27209
27210     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset));
27211
27212     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset);
27213     return STATUS_SUCCESS;
27214 }
27215 #endif /* _WIN64 */
27216
27217 static NTSTATUS thunk32_vkCmdDispatchIndirect(void *args)
27218 {
27219     struct
27220     {
27221         PTR32 commandBuffer;
27222         VkBuffer DECLSPEC_ALIGN(8) buffer;
27223         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27224     } *params = args;
27225
27226     TRACE("%#x, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset));
27227
27228     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);
27229     return STATUS_SUCCESS;
27230 }
27231
27232 #ifdef _WIN64
27233 static NTSTATUS thunk64_vkCmdDraw(void *args)
27234 {
27235     struct vkCmdDraw_params *params = args;
27236
27237     TRACE("%p, %u, %u, %u, %u\n", params->commandBuffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
27238
27239     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);
27240     return STATUS_SUCCESS;
27241 }
27242 #endif /* _WIN64 */
27243
27244 static NTSTATUS thunk32_vkCmdDraw(void *args)
27245 {
27246     struct
27247     {
27248         PTR32 commandBuffer;
27249         uint32_t vertexCount;
27250         uint32_t instanceCount;
27251         uint32_t firstVertex;
27252         uint32_t firstInstance;
27253     } *params = args;
27254
27255     TRACE("%#x, %u, %u, %u, %u\n", params->commandBuffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
27256
27257     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);
27258     return STATUS_SUCCESS;
27259 }
27260
27261 #ifdef _WIN64
27262 static NTSTATUS thunk64_vkCmdDrawIndexed(void *args)
27263 {
27264     struct vkCmdDrawIndexed_params *params = args;
27265
27266     TRACE("%p, %u, %u, %u, %d, %u\n", params->commandBuffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
27267
27268     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);
27269     return STATUS_SUCCESS;
27270 }
27271 #endif /* _WIN64 */
27272
27273 static NTSTATUS thunk32_vkCmdDrawIndexed(void *args)
27274 {
27275     struct
27276     {
27277         PTR32 commandBuffer;
27278         uint32_t indexCount;
27279         uint32_t instanceCount;
27280         uint32_t firstIndex;
27281         int32_t vertexOffset;
27282         uint32_t firstInstance;
27283     } *params = args;
27284
27285     TRACE("%#x, %u, %u, %u, %d, %u\n", params->commandBuffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
27286
27287     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);
27288     return STATUS_SUCCESS;
27289 }
27290
27291 #ifdef _WIN64
27292 static NTSTATUS thunk64_vkCmdDrawIndexedIndirect(void *args)
27293 {
27294     struct vkCmdDrawIndexedIndirect_params *params = args;
27295
27296     TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27297
27298     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);
27299     return STATUS_SUCCESS;
27300 }
27301 #endif /* _WIN64 */
27302
27303 static NTSTATUS thunk32_vkCmdDrawIndexedIndirect(void *args)
27304 {
27305     struct
27306     {
27307         PTR32 commandBuffer;
27308         VkBuffer DECLSPEC_ALIGN(8) buffer;
27309         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27310         uint32_t drawCount;
27311         uint32_t stride;
27312     } *params = args;
27313
27314     TRACE("%#x, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27315
27316     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);
27317     return STATUS_SUCCESS;
27318 }
27319
27320 #ifdef _WIN64
27321 static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCount(void *args)
27322 {
27323     struct vkCmdDrawIndexedIndirectCount_params *params = args;
27324
27325     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27326
27327     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);
27328     return STATUS_SUCCESS;
27329 }
27330 #endif /* _WIN64 */
27331
27332 static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCount(void *args)
27333 {
27334     struct
27335     {
27336         PTR32 commandBuffer;
27337         VkBuffer DECLSPEC_ALIGN(8) buffer;
27338         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27339         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27340         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27341         uint32_t maxDrawCount;
27342         uint32_t stride;
27343     } *params = args;
27344
27345     TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27346
27347     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);
27348     return STATUS_SUCCESS;
27349 }
27350
27351 #ifdef _WIN64
27352 static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCountAMD(void *args)
27353 {
27354     struct vkCmdDrawIndexedIndirectCountAMD_params *params = args;
27355
27356     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27357
27358     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);
27359     return STATUS_SUCCESS;
27360 }
27361 #endif /* _WIN64 */
27362
27363 static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountAMD(void *args)
27364 {
27365     struct
27366     {
27367         PTR32 commandBuffer;
27368         VkBuffer DECLSPEC_ALIGN(8) buffer;
27369         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27370         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27371         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27372         uint32_t maxDrawCount;
27373         uint32_t stride;
27374     } *params = args;
27375
27376     TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27377
27378     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);
27379     return STATUS_SUCCESS;
27380 }
27381
27382 #ifdef _WIN64
27383 static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCountKHR(void *args)
27384 {
27385     struct vkCmdDrawIndexedIndirectCountKHR_params *params = args;
27386
27387     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27388
27389     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);
27390     return STATUS_SUCCESS;
27391 }
27392 #endif /* _WIN64 */
27393
27394 static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountKHR(void *args)
27395 {
27396     struct
27397     {
27398         PTR32 commandBuffer;
27399         VkBuffer DECLSPEC_ALIGN(8) buffer;
27400         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27401         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27402         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27403         uint32_t maxDrawCount;
27404         uint32_t stride;
27405     } *params = args;
27406
27407     TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27408
27409     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);
27410     return STATUS_SUCCESS;
27411 }
27412
27413 #ifdef _WIN64
27414 static NTSTATUS thunk64_vkCmdDrawIndirect(void *args)
27415 {
27416     struct vkCmdDrawIndirect_params *params = args;
27417
27418     TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27419
27420     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);
27421     return STATUS_SUCCESS;
27422 }
27423 #endif /* _WIN64 */
27424
27425 static NTSTATUS thunk32_vkCmdDrawIndirect(void *args)
27426 {
27427     struct
27428     {
27429         PTR32 commandBuffer;
27430         VkBuffer DECLSPEC_ALIGN(8) buffer;
27431         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27432         uint32_t drawCount;
27433         uint32_t stride;
27434     } *params = args;
27435
27436     TRACE("%#x, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27437
27438     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);
27439     return STATUS_SUCCESS;
27440 }
27441
27442 #ifdef _WIN64
27443 static NTSTATUS thunk64_vkCmdDrawIndirectByteCountEXT(void *args)
27444 {
27445     struct vkCmdDrawIndirectByteCountEXT_params *params = args;
27446
27447     TRACE("%p, %u, %u, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, params->instanceCount, params->firstInstance, wine_dbgstr_longlong(params->counterBuffer), wine_dbgstr_longlong(params->counterBufferOffset), params->counterOffset, params->vertexStride);
27448
27449     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);
27450     return STATUS_SUCCESS;
27451 }
27452 #endif /* _WIN64 */
27453
27454 static NTSTATUS thunk32_vkCmdDrawIndirectByteCountEXT(void *args)
27455 {
27456     struct
27457     {
27458         PTR32 commandBuffer;
27459         uint32_t instanceCount;
27460         uint32_t firstInstance;
27461         VkBuffer DECLSPEC_ALIGN(8) counterBuffer;
27462         VkDeviceSize DECLSPEC_ALIGN(8) counterBufferOffset;
27463         uint32_t counterOffset;
27464         uint32_t vertexStride;
27465     } *params = args;
27466
27467     TRACE("%#x, %u, %u, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, params->instanceCount, params->firstInstance, wine_dbgstr_longlong(params->counterBuffer), wine_dbgstr_longlong(params->counterBufferOffset), params->counterOffset, params->vertexStride);
27468
27469     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);
27470     return STATUS_SUCCESS;
27471 }
27472
27473 #ifdef _WIN64
27474 static NTSTATUS thunk64_vkCmdDrawIndirectCount(void *args)
27475 {
27476     struct vkCmdDrawIndirectCount_params *params = args;
27477
27478     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27479
27480     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);
27481     return STATUS_SUCCESS;
27482 }
27483 #endif /* _WIN64 */
27484
27485 static NTSTATUS thunk32_vkCmdDrawIndirectCount(void *args)
27486 {
27487     struct
27488     {
27489         PTR32 commandBuffer;
27490         VkBuffer DECLSPEC_ALIGN(8) buffer;
27491         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27492         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27493         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27494         uint32_t maxDrawCount;
27495         uint32_t stride;
27496     } *params = args;
27497
27498     TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27499
27500     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);
27501     return STATUS_SUCCESS;
27502 }
27503
27504 #ifdef _WIN64
27505 static NTSTATUS thunk64_vkCmdDrawIndirectCountAMD(void *args)
27506 {
27507     struct vkCmdDrawIndirectCountAMD_params *params = args;
27508
27509     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27510
27511     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);
27512     return STATUS_SUCCESS;
27513 }
27514 #endif /* _WIN64 */
27515
27516 static NTSTATUS thunk32_vkCmdDrawIndirectCountAMD(void *args)
27517 {
27518     struct
27519     {
27520         PTR32 commandBuffer;
27521         VkBuffer DECLSPEC_ALIGN(8) buffer;
27522         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27523         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27524         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27525         uint32_t maxDrawCount;
27526         uint32_t stride;
27527     } *params = args;
27528
27529     TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27530
27531     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);
27532     return STATUS_SUCCESS;
27533 }
27534
27535 #ifdef _WIN64
27536 static NTSTATUS thunk64_vkCmdDrawIndirectCountKHR(void *args)
27537 {
27538     struct vkCmdDrawIndirectCountKHR_params *params = args;
27539
27540     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27541
27542     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);
27543     return STATUS_SUCCESS;
27544 }
27545 #endif /* _WIN64 */
27546
27547 static NTSTATUS thunk32_vkCmdDrawIndirectCountKHR(void *args)
27548 {
27549     struct
27550     {
27551         PTR32 commandBuffer;
27552         VkBuffer DECLSPEC_ALIGN(8) buffer;
27553         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27554         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27555         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27556         uint32_t maxDrawCount;
27557         uint32_t stride;
27558     } *params = args;
27559
27560     TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27561
27562     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);
27563     return STATUS_SUCCESS;
27564 }
27565
27566 #ifdef _WIN64
27567 static NTSTATUS thunk64_vkCmdDrawMeshTasksEXT(void *args)
27568 {
27569     struct vkCmdDrawMeshTasksEXT_params *params = args;
27570
27571     TRACE("%p, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
27572
27573     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);
27574     return STATUS_SUCCESS;
27575 }
27576 #endif /* _WIN64 */
27577
27578 static NTSTATUS thunk32_vkCmdDrawMeshTasksEXT(void *args)
27579 {
27580     struct
27581     {
27582         PTR32 commandBuffer;
27583         uint32_t groupCountX;
27584         uint32_t groupCountY;
27585         uint32_t groupCountZ;
27586     } *params = args;
27587
27588     TRACE("%#x, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
27589
27590     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);
27591     return STATUS_SUCCESS;
27592 }
27593
27594 #ifdef _WIN64
27595 static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
27596 {
27597     struct vkCmdDrawMeshTasksIndirectCountEXT_params *params = args;
27598
27599     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27600
27601     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);
27602     return STATUS_SUCCESS;
27603 }
27604 #endif /* _WIN64 */
27605
27606 static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
27607 {
27608     struct
27609     {
27610         PTR32 commandBuffer;
27611         VkBuffer DECLSPEC_ALIGN(8) buffer;
27612         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27613         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27614         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27615         uint32_t maxDrawCount;
27616         uint32_t stride;
27617     } *params = args;
27618
27619     TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27620
27621     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);
27622     return STATUS_SUCCESS;
27623 }
27624
27625 #ifdef _WIN64
27626 static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectCountNV(void *args)
27627 {
27628     struct vkCmdDrawMeshTasksIndirectCountNV_params *params = args;
27629
27630     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27631
27632     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);
27633     return STATUS_SUCCESS;
27634 }
27635 #endif /* _WIN64 */
27636
27637 static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountNV(void *args)
27638 {
27639     struct
27640     {
27641         PTR32 commandBuffer;
27642         VkBuffer DECLSPEC_ALIGN(8) buffer;
27643         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27644         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
27645         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
27646         uint32_t maxDrawCount;
27647         uint32_t stride;
27648     } *params = args;
27649
27650     TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
27651
27652     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);
27653     return STATUS_SUCCESS;
27654 }
27655
27656 #ifdef _WIN64
27657 static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectEXT(void *args)
27658 {
27659     struct vkCmdDrawMeshTasksIndirectEXT_params *params = args;
27660
27661     TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27662
27663     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);
27664     return STATUS_SUCCESS;
27665 }
27666 #endif /* _WIN64 */
27667
27668 static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectEXT(void *args)
27669 {
27670     struct
27671     {
27672         PTR32 commandBuffer;
27673         VkBuffer DECLSPEC_ALIGN(8) buffer;
27674         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27675         uint32_t drawCount;
27676         uint32_t stride;
27677     } *params = args;
27678
27679     TRACE("%#x, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27680
27681     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);
27682     return STATUS_SUCCESS;
27683 }
27684
27685 #ifdef _WIN64
27686 static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectNV(void *args)
27687 {
27688     struct vkCmdDrawMeshTasksIndirectNV_params *params = args;
27689
27690     TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27691
27692     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);
27693     return STATUS_SUCCESS;
27694 }
27695 #endif /* _WIN64 */
27696
27697 static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectNV(void *args)
27698 {
27699     struct
27700     {
27701         PTR32 commandBuffer;
27702         VkBuffer DECLSPEC_ALIGN(8) buffer;
27703         VkDeviceSize DECLSPEC_ALIGN(8) offset;
27704         uint32_t drawCount;
27705         uint32_t stride;
27706     } *params = args;
27707
27708     TRACE("%#x, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
27709
27710     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);
27711     return STATUS_SUCCESS;
27712 }
27713
27714 #ifdef _WIN64
27715 static NTSTATUS thunk64_vkCmdDrawMeshTasksNV(void *args)
27716 {
27717     struct vkCmdDrawMeshTasksNV_params *params = args;
27718
27719     TRACE("%p, %u, %u\n", params->commandBuffer, params->taskCount, params->firstTask);
27720
27721     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->taskCount, params->firstTask);
27722     return STATUS_SUCCESS;
27723 }
27724 #endif /* _WIN64 */
27725
27726 static NTSTATUS thunk32_vkCmdDrawMeshTasksNV(void *args)
27727 {
27728     struct
27729     {
27730         PTR32 commandBuffer;
27731         uint32_t taskCount;
27732         uint32_t firstTask;
27733     } *params = args;
27734
27735     TRACE("%#x, %u, %u\n", params->commandBuffer, params->taskCount, params->firstTask);
27736
27737     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);
27738     return STATUS_SUCCESS;
27739 }
27740
27741 #ifdef _WIN64
27742 static NTSTATUS thunk64_vkCmdDrawMultiEXT(void *args)
27743 {
27744     struct vkCmdDrawMultiEXT_params *params = args;
27745
27746     TRACE("%p, %u, %p, %u, %u, %u\n", params->commandBuffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);
27747
27748     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);
27749     return STATUS_SUCCESS;
27750 }
27751 #endif /* _WIN64 */
27752
27753 static NTSTATUS thunk32_vkCmdDrawMultiEXT(void *args)
27754 {
27755     struct
27756     {
27757         PTR32 commandBuffer;
27758         uint32_t drawCount;
27759         PTR32 pVertexInfo;
27760         uint32_t instanceCount;
27761         uint32_t firstInstance;
27762         uint32_t stride;
27763     } *params = args;
27764
27765     TRACE("%#x, %u, %#x, %u, %u, %u\n", params->commandBuffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);
27766
27767     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);
27768     return STATUS_SUCCESS;
27769 }
27770
27771 #ifdef _WIN64
27772 static NTSTATUS thunk64_vkCmdDrawMultiIndexedEXT(void *args)
27773 {
27774     struct vkCmdDrawMultiIndexedEXT_params *params = args;
27775
27776     TRACE("%p, %u, %p, %u, %u, %u, %p\n", params->commandBuffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);
27777
27778     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);
27779     return STATUS_SUCCESS;
27780 }
27781 #endif /* _WIN64 */
27782
27783 static NTSTATUS thunk32_vkCmdDrawMultiIndexedEXT(void *args)
27784 {
27785     struct
27786     {
27787         PTR32 commandBuffer;
27788         uint32_t drawCount;
27789         PTR32 pIndexInfo;
27790         uint32_t instanceCount;
27791         uint32_t firstInstance;
27792         uint32_t stride;
27793         PTR32 pVertexOffset;
27794     } *params = args;
27795
27796     TRACE("%#x, %u, %#x, %u, %u, %u, %#x\n", params->commandBuffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);
27797
27798     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));
27799     return STATUS_SUCCESS;
27800 }
27801
27802 #ifdef _WIN64
27803 static NTSTATUS thunk64_vkCmdEndConditionalRenderingEXT(void *args)
27804 {
27805     struct vkCmdEndConditionalRenderingEXT_params *params = args;
27806
27807     TRACE("%p\n", params->commandBuffer);
27808
27809     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
27810     return STATUS_SUCCESS;
27811 }
27812 #endif /* _WIN64 */
27813
27814 static NTSTATUS thunk32_vkCmdEndConditionalRenderingEXT(void *args)
27815 {
27816     struct
27817     {
27818         PTR32 commandBuffer;
27819     } *params = args;
27820
27821     TRACE("%#x\n", params->commandBuffer);
27822
27823     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
27824     return STATUS_SUCCESS;
27825 }
27826
27827 #ifdef _WIN64
27828 static NTSTATUS thunk64_vkCmdEndDebugUtilsLabelEXT(void *args)
27829 {
27830     struct vkCmdEndDebugUtilsLabelEXT_params *params = args;
27831
27832     TRACE("%p\n", params->commandBuffer);
27833
27834     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
27835     return STATUS_SUCCESS;
27836 }
27837 #endif /* _WIN64 */
27838
27839 static NTSTATUS thunk32_vkCmdEndDebugUtilsLabelEXT(void *args)
27840 {
27841     struct
27842     {
27843         PTR32 commandBuffer;
27844     } *params = args;
27845
27846     TRACE("%#x\n", params->commandBuffer);
27847
27848     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
27849     return STATUS_SUCCESS;
27850 }
27851
27852 #ifdef _WIN64
27853 static NTSTATUS thunk64_vkCmdEndQuery(void *args)
27854 {
27855     struct vkCmdEndQuery_params *params = args;
27856
27857     TRACE("%p, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query);
27858
27859     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query);
27860     return STATUS_SUCCESS;
27861 }
27862 #endif /* _WIN64 */
27863
27864 static NTSTATUS thunk32_vkCmdEndQuery(void *args)
27865 {
27866     struct
27867     {
27868         PTR32 commandBuffer;
27869         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
27870         uint32_t query;
27871     } *params = args;
27872
27873     TRACE("%#x, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query);
27874
27875     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);
27876     return STATUS_SUCCESS;
27877 }
27878
27879 #ifdef _WIN64
27880 static NTSTATUS thunk64_vkCmdEndQueryIndexedEXT(void *args)
27881 {
27882     struct vkCmdEndQueryIndexedEXT_params *params = args;
27883
27884     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->index);
27885
27886     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);
27887     return STATUS_SUCCESS;
27888 }
27889 #endif /* _WIN64 */
27890
27891 static NTSTATUS thunk32_vkCmdEndQueryIndexedEXT(void *args)
27892 {
27893     struct
27894     {
27895         PTR32 commandBuffer;
27896         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
27897         uint32_t query;
27898         uint32_t index;
27899     } *params = args;
27900
27901     TRACE("%#x, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->index);
27902
27903     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);
27904     return STATUS_SUCCESS;
27905 }
27906
27907 #ifdef _WIN64
27908 static NTSTATUS thunk64_vkCmdEndRenderPass(void *args)
27909 {
27910     struct vkCmdEndRenderPass_params *params = args;
27911
27912     TRACE("%p\n", params->commandBuffer);
27913
27914     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
27915     return STATUS_SUCCESS;
27916 }
27917 #endif /* _WIN64 */
27918
27919 static NTSTATUS thunk32_vkCmdEndRenderPass(void *args)
27920 {
27921     struct
27922     {
27923         PTR32 commandBuffer;
27924     } *params = args;
27925
27926     TRACE("%#x\n", params->commandBuffer);
27927
27928     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
27929     return STATUS_SUCCESS;
27930 }
27931
27932 #ifdef _WIN64
27933 static NTSTATUS thunk64_vkCmdEndRenderPass2(void *args)
27934 {
27935     struct vkCmdEndRenderPass2_params *params = args;
27936
27937     TRACE("%p, %p\n", params->commandBuffer, params->pSubpassEndInfo);
27938
27939     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
27940     return STATUS_SUCCESS;
27941 }
27942 #endif /* _WIN64 */
27943
27944 static NTSTATUS thunk32_vkCmdEndRenderPass2(void *args)
27945 {
27946     struct
27947     {
27948         PTR32 commandBuffer;
27949         PTR32 pSubpassEndInfo;
27950     } *params = args;
27951     VkSubpassEndInfo pSubpassEndInfo_host;
27952     struct conversion_context ctx;
27953
27954     TRACE("%#x, %#x\n", params->commandBuffer, params->pSubpassEndInfo);
27955
27956     init_conversion_context(&ctx);
27957     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
27958     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);
27959     free_conversion_context(&ctx);
27960     return STATUS_SUCCESS;
27961 }
27962
27963 #ifdef _WIN64
27964 static NTSTATUS thunk64_vkCmdEndRenderPass2KHR(void *args)
27965 {
27966     struct vkCmdEndRenderPass2KHR_params *params = args;
27967
27968     TRACE("%p, %p\n", params->commandBuffer, params->pSubpassEndInfo);
27969
27970     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
27971     return STATUS_SUCCESS;
27972 }
27973 #endif /* _WIN64 */
27974
27975 static NTSTATUS thunk32_vkCmdEndRenderPass2KHR(void *args)
27976 {
27977     struct
27978     {
27979         PTR32 commandBuffer;
27980         PTR32 pSubpassEndInfo;
27981     } *params = args;
27982     VkSubpassEndInfo pSubpassEndInfo_host;
27983     struct conversion_context ctx;
27984
27985     TRACE("%#x, %#x\n", params->commandBuffer, params->pSubpassEndInfo);
27986
27987     init_conversion_context(&ctx);
27988     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
27989     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);
27990     free_conversion_context(&ctx);
27991     return STATUS_SUCCESS;
27992 }
27993
27994 #ifdef _WIN64
27995 static NTSTATUS thunk64_vkCmdEndRendering(void *args)
27996 {
27997     struct vkCmdEndRendering_params *params = args;
27998
27999     TRACE("%p\n", params->commandBuffer);
28000
28001     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
28002     return STATUS_SUCCESS;
28003 }
28004 #endif /* _WIN64 */
28005
28006 static NTSTATUS thunk32_vkCmdEndRendering(void *args)
28007 {
28008     struct
28009     {
28010         PTR32 commandBuffer;
28011     } *params = args;
28012
28013     TRACE("%#x\n", params->commandBuffer);
28014
28015     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
28016     return STATUS_SUCCESS;
28017 }
28018
28019 #ifdef _WIN64
28020 static NTSTATUS thunk64_vkCmdEndRenderingKHR(void *args)
28021 {
28022     struct vkCmdEndRenderingKHR_params *params = args;
28023
28024     TRACE("%p\n", params->commandBuffer);
28025
28026     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
28027     return STATUS_SUCCESS;
28028 }
28029 #endif /* _WIN64 */
28030
28031 static NTSTATUS thunk32_vkCmdEndRenderingKHR(void *args)
28032 {
28033     struct
28034     {
28035         PTR32 commandBuffer;
28036     } *params = args;
28037
28038     TRACE("%#x\n", params->commandBuffer);
28039
28040     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
28041     return STATUS_SUCCESS;
28042 }
28043
28044 #ifdef _WIN64
28045 static NTSTATUS thunk64_vkCmdEndTransformFeedbackEXT(void *args)
28046 {
28047     struct vkCmdEndTransformFeedbackEXT_params *params = args;
28048
28049     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
28050
28051     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);
28052     return STATUS_SUCCESS;
28053 }
28054 #endif /* _WIN64 */
28055
28056 static NTSTATUS thunk32_vkCmdEndTransformFeedbackEXT(void *args)
28057 {
28058     struct
28059     {
28060         PTR32 commandBuffer;
28061         uint32_t firstCounterBuffer;
28062         uint32_t counterBufferCount;
28063         PTR32 pCounterBuffers;
28064         PTR32 pCounterBufferOffsets;
28065     } *params = args;
28066
28067     TRACE("%#x, %u, %u, %#x, %#x\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
28068
28069     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));
28070     return STATUS_SUCCESS;
28071 }
28072
28073 #ifdef _WIN64
28074 static NTSTATUS thunk64_vkCmdExecuteCommands(void *args)
28075 {
28076     struct vkCmdExecuteCommands_params *params = args;
28077     const VkCommandBuffer *pCommandBuffers_host;
28078     struct conversion_context ctx;
28079
28080     TRACE("%p, %u, %p\n", params->commandBuffer, params->commandBufferCount, params->pCommandBuffers);
28081
28082     init_conversion_context(&ctx);
28083     pCommandBuffers_host = convert_VkCommandBuffer_array_win64_to_host(&ctx, params->pCommandBuffers, params->commandBufferCount);
28084     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->commandBufferCount, pCommandBuffers_host);
28085     free_conversion_context(&ctx);
28086     return STATUS_SUCCESS;
28087 }
28088 #endif /* _WIN64 */
28089
28090 static NTSTATUS thunk32_vkCmdExecuteCommands(void *args)
28091 {
28092     struct
28093     {
28094         PTR32 commandBuffer;
28095         uint32_t commandBufferCount;
28096         PTR32 pCommandBuffers;
28097     } *params = args;
28098     const VkCommandBuffer *pCommandBuffers_host;
28099     struct conversion_context ctx;
28100
28101     TRACE("%#x, %u, %#x\n", params->commandBuffer, params->commandBufferCount, params->pCommandBuffers);
28102
28103     init_conversion_context(&ctx);
28104     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_host(&ctx, (const PTR32 *)UlongToPtr(params->pCommandBuffers), params->commandBufferCount);
28105     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);
28106     free_conversion_context(&ctx);
28107     return STATUS_SUCCESS;
28108 }
28109
28110 #ifdef _WIN64
28111 static NTSTATUS thunk64_vkCmdExecuteGeneratedCommandsNV(void *args)
28112 {
28113     struct vkCmdExecuteGeneratedCommandsNV_params *params = args;
28114
28115     TRACE("%p, %u, %p\n", params->commandBuffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
28116
28117     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
28118     return STATUS_SUCCESS;
28119 }
28120 #endif /* _WIN64 */
28121
28122 static NTSTATUS thunk32_vkCmdExecuteGeneratedCommandsNV(void *args)
28123 {
28124     struct
28125     {
28126         PTR32 commandBuffer;
28127         VkBool32 isPreprocessed;
28128         PTR32 pGeneratedCommandsInfo;
28129     } *params = args;
28130     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
28131     struct conversion_context ctx;
28132
28133     TRACE("%#x, %u, %#x\n", params->commandBuffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
28134
28135     init_conversion_context(&ctx);
28136     convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, (const VkGeneratedCommandsInfoNV32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
28137     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);
28138     free_conversion_context(&ctx);
28139     return STATUS_SUCCESS;
28140 }
28141
28142 #ifdef _WIN64
28143 static NTSTATUS thunk64_vkCmdFillBuffer(void *args)
28144 {
28145     struct vkCmdFillBuffer_params *params = args;
28146
28147     TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->size), params->data);
28148
28149     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);
28150     return STATUS_SUCCESS;
28151 }
28152 #endif /* _WIN64 */
28153
28154 static NTSTATUS thunk32_vkCmdFillBuffer(void *args)
28155 {
28156     struct
28157     {
28158         PTR32 commandBuffer;
28159         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
28160         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
28161         VkDeviceSize DECLSPEC_ALIGN(8) size;
28162         uint32_t data;
28163     } *params = args;
28164
28165     TRACE("%#x, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->size), params->data);
28166
28167     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);
28168     return STATUS_SUCCESS;
28169 }
28170
28171 #ifdef _WIN64
28172 static NTSTATUS thunk64_vkCmdInsertDebugUtilsLabelEXT(void *args)
28173 {
28174     struct vkCmdInsertDebugUtilsLabelEXT_params *params = args;
28175
28176     TRACE("%p, %p\n", params->commandBuffer, params->pLabelInfo);
28177
28178     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
28179     return STATUS_SUCCESS;
28180 }
28181 #endif /* _WIN64 */
28182
28183 static NTSTATUS thunk32_vkCmdInsertDebugUtilsLabelEXT(void *args)
28184 {
28185     struct
28186     {
28187         PTR32 commandBuffer;
28188         PTR32 pLabelInfo;
28189     } *params = args;
28190     VkDebugUtilsLabelEXT pLabelInfo_host;
28191
28192     TRACE("%#x, %#x\n", params->commandBuffer, params->pLabelInfo);
28193
28194     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
28195     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);
28196     return STATUS_SUCCESS;
28197 }
28198
28199 #ifdef _WIN64
28200 static NTSTATUS thunk64_vkCmdNextSubpass(void *args)
28201 {
28202     struct vkCmdNextSubpass_params *params = args;
28203
28204     TRACE("%p, %#x\n", params->commandBuffer, params->contents);
28205
28206     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->contents);
28207     return STATUS_SUCCESS;
28208 }
28209 #endif /* _WIN64 */
28210
28211 static NTSTATUS thunk32_vkCmdNextSubpass(void *args)
28212 {
28213     struct
28214     {
28215         PTR32 commandBuffer;
28216         VkSubpassContents contents;
28217     } *params = args;
28218
28219     TRACE("%#x, %#x\n", params->commandBuffer, params->contents);
28220
28221     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);
28222     return STATUS_SUCCESS;
28223 }
28224
28225 #ifdef _WIN64
28226 static NTSTATUS thunk64_vkCmdNextSubpass2(void *args)
28227 {
28228     struct vkCmdNextSubpass2_params *params = args;
28229
28230     TRACE("%p, %p, %p\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
28231
28232     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
28233     return STATUS_SUCCESS;
28234 }
28235 #endif /* _WIN64 */
28236
28237 static NTSTATUS thunk32_vkCmdNextSubpass2(void *args)
28238 {
28239     struct
28240     {
28241         PTR32 commandBuffer;
28242         PTR32 pSubpassBeginInfo;
28243         PTR32 pSubpassEndInfo;
28244     } *params = args;
28245     VkSubpassBeginInfo pSubpassBeginInfo_host;
28246     VkSubpassEndInfo pSubpassEndInfo_host;
28247     struct conversion_context ctx;
28248
28249     TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
28250
28251     init_conversion_context(&ctx);
28252     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
28253     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
28254     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);
28255     free_conversion_context(&ctx);
28256     return STATUS_SUCCESS;
28257 }
28258
28259 #ifdef _WIN64
28260 static NTSTATUS thunk64_vkCmdNextSubpass2KHR(void *args)
28261 {
28262     struct vkCmdNextSubpass2KHR_params *params = args;
28263
28264     TRACE("%p, %p, %p\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
28265
28266     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
28267     return STATUS_SUCCESS;
28268 }
28269 #endif /* _WIN64 */
28270
28271 static NTSTATUS thunk32_vkCmdNextSubpass2KHR(void *args)
28272 {
28273     struct
28274     {
28275         PTR32 commandBuffer;
28276         PTR32 pSubpassBeginInfo;
28277         PTR32 pSubpassEndInfo;
28278     } *params = args;
28279     VkSubpassBeginInfo pSubpassBeginInfo_host;
28280     VkSubpassEndInfo pSubpassEndInfo_host;
28281     struct conversion_context ctx;
28282
28283     TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
28284
28285     init_conversion_context(&ctx);
28286     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
28287     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
28288     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);
28289     free_conversion_context(&ctx);
28290     return STATUS_SUCCESS;
28291 }
28292
28293 #ifdef _WIN64
28294 static NTSTATUS thunk64_vkCmdOpticalFlowExecuteNV(void *args)
28295 {
28296     struct vkCmdOpticalFlowExecuteNV_params *params = args;
28297
28298     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->session), params->pExecuteInfo);
28299
28300     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->session, params->pExecuteInfo);
28301     return STATUS_SUCCESS;
28302 }
28303 #endif /* _WIN64 */
28304
28305 static NTSTATUS thunk32_vkCmdOpticalFlowExecuteNV(void *args)
28306 {
28307     struct
28308     {
28309         PTR32 commandBuffer;
28310         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
28311         PTR32 pExecuteInfo;
28312     } *params = args;
28313     VkOpticalFlowExecuteInfoNV pExecuteInfo_host;
28314
28315     TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->session), params->pExecuteInfo);
28316
28317     convert_VkOpticalFlowExecuteInfoNV_win32_to_host((const VkOpticalFlowExecuteInfoNV32 *)UlongToPtr(params->pExecuteInfo), &pExecuteInfo_host);
28318     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);
28319     return STATUS_SUCCESS;
28320 }
28321
28322 #ifdef _WIN64
28323 static NTSTATUS thunk64_vkCmdPipelineBarrier(void *args)
28324 {
28325     struct vkCmdPipelineBarrier_params *params = args;
28326
28327     TRACE("%p, %#x, %#x, %#x, %u, %p, %u, %p, %u, %p\n", params->commandBuffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
28328
28329     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);
28330     return STATUS_SUCCESS;
28331 }
28332 #endif /* _WIN64 */
28333
28334 static NTSTATUS thunk32_vkCmdPipelineBarrier(void *args)
28335 {
28336     struct
28337     {
28338         PTR32 commandBuffer;
28339         VkPipelineStageFlags srcStageMask;
28340         VkPipelineStageFlags dstStageMask;
28341         VkDependencyFlags dependencyFlags;
28342         uint32_t memoryBarrierCount;
28343         PTR32 pMemoryBarriers;
28344         uint32_t bufferMemoryBarrierCount;
28345         PTR32 pBufferMemoryBarriers;
28346         uint32_t imageMemoryBarrierCount;
28347         PTR32 pImageMemoryBarriers;
28348     } *params = args;
28349     const VkMemoryBarrier *pMemoryBarriers_host;
28350     const VkBufferMemoryBarrier *pBufferMemoryBarriers_host;
28351     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
28352     struct conversion_context ctx;
28353
28354     TRACE("%#x, %#x, %#x, %#x, %u, %#x, %u, %#x, %u, %#x\n", params->commandBuffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
28355
28356     init_conversion_context(&ctx);
28357     pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(&ctx, (const VkMemoryBarrier32 *)UlongToPtr(params->pMemoryBarriers), params->memoryBarrierCount);
28358     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(&ctx, (const VkBufferMemoryBarrier32 *)UlongToPtr(params->pBufferMemoryBarriers), params->bufferMemoryBarrierCount);
28359     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(&ctx, (const VkImageMemoryBarrier32 *)UlongToPtr(params->pImageMemoryBarriers), params->imageMemoryBarrierCount);
28360     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);
28361     free_conversion_context(&ctx);
28362     return STATUS_SUCCESS;
28363 }
28364
28365 #ifdef _WIN64
28366 static NTSTATUS thunk64_vkCmdPipelineBarrier2(void *args)
28367 {
28368     struct vkCmdPipelineBarrier2_params *params = args;
28369
28370     TRACE("%p, %p\n", params->commandBuffer, params->pDependencyInfo);
28371
28372     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
28373     return STATUS_SUCCESS;
28374 }
28375 #endif /* _WIN64 */
28376
28377 static NTSTATUS thunk32_vkCmdPipelineBarrier2(void *args)
28378 {
28379     struct
28380     {
28381         PTR32 commandBuffer;
28382         PTR32 pDependencyInfo;
28383     } *params = args;
28384     VkDependencyInfo pDependencyInfo_host;
28385     struct conversion_context ctx;
28386
28387     TRACE("%#x, %#x\n", params->commandBuffer, params->pDependencyInfo);
28388
28389     init_conversion_context(&ctx);
28390     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
28391     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);
28392     free_conversion_context(&ctx);
28393     return STATUS_SUCCESS;
28394 }
28395
28396 #ifdef _WIN64
28397 static NTSTATUS thunk64_vkCmdPipelineBarrier2KHR(void *args)
28398 {
28399     struct vkCmdPipelineBarrier2KHR_params *params = args;
28400
28401     TRACE("%p, %p\n", params->commandBuffer, params->pDependencyInfo);
28402
28403     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
28404     return STATUS_SUCCESS;
28405 }
28406 #endif /* _WIN64 */
28407
28408 static NTSTATUS thunk32_vkCmdPipelineBarrier2KHR(void *args)
28409 {
28410     struct
28411     {
28412         PTR32 commandBuffer;
28413         PTR32 pDependencyInfo;
28414     } *params = args;
28415     VkDependencyInfo pDependencyInfo_host;
28416     struct conversion_context ctx;
28417
28418     TRACE("%#x, %#x\n", params->commandBuffer, params->pDependencyInfo);
28419
28420     init_conversion_context(&ctx);
28421     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
28422     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);
28423     free_conversion_context(&ctx);
28424     return STATUS_SUCCESS;
28425 }
28426
28427 #ifdef _WIN64
28428 static NTSTATUS thunk64_vkCmdPreprocessGeneratedCommandsNV(void *args)
28429 {
28430     struct vkCmdPreprocessGeneratedCommandsNV_params *params = args;
28431
28432     TRACE("%p, %p\n", params->commandBuffer, params->pGeneratedCommandsInfo);
28433
28434     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pGeneratedCommandsInfo);
28435     return STATUS_SUCCESS;
28436 }
28437 #endif /* _WIN64 */
28438
28439 static NTSTATUS thunk32_vkCmdPreprocessGeneratedCommandsNV(void *args)
28440 {
28441     struct
28442     {
28443         PTR32 commandBuffer;
28444         PTR32 pGeneratedCommandsInfo;
28445     } *params = args;
28446     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
28447     struct conversion_context ctx;
28448
28449     TRACE("%#x, %#x\n", params->commandBuffer, params->pGeneratedCommandsInfo);
28450
28451     init_conversion_context(&ctx);
28452     convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, (const VkGeneratedCommandsInfoNV32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
28453     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);
28454     free_conversion_context(&ctx);
28455     return STATUS_SUCCESS;
28456 }
28457
28458 #ifdef _WIN64
28459 static NTSTATUS thunk64_vkCmdPushConstants(void *args)
28460 {
28461     struct vkCmdPushConstants_params *params = args;
28462
28463     TRACE("%p, 0x%s, %#x, %u, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->layout), params->stageFlags, params->offset, params->size, params->pValues);
28464
28465     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);
28466     return STATUS_SUCCESS;
28467 }
28468 #endif /* _WIN64 */
28469
28470 static NTSTATUS thunk32_vkCmdPushConstants(void *args)
28471 {
28472     struct
28473     {
28474         PTR32 commandBuffer;
28475         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
28476         VkShaderStageFlags stageFlags;
28477         uint32_t offset;
28478         uint32_t size;
28479         PTR32 pValues;
28480     } *params = args;
28481
28482     TRACE("%#x, 0x%s, %#x, %u, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->layout), params->stageFlags, params->offset, params->size, params->pValues);
28483
28484     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));
28485     return STATUS_SUCCESS;
28486 }
28487
28488 #ifdef _WIN64
28489 static NTSTATUS thunk64_vkCmdPushDescriptorSetKHR(void *args)
28490 {
28491     struct vkCmdPushDescriptorSetKHR_params *params = args;
28492
28493     TRACE("%p, %#x, 0x%s, %u, %u, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set, params->descriptorWriteCount, params->pDescriptorWrites);
28494
28495     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);
28496     return STATUS_SUCCESS;
28497 }
28498 #endif /* _WIN64 */
28499
28500 static NTSTATUS thunk32_vkCmdPushDescriptorSetKHR(void *args)
28501 {
28502     struct
28503     {
28504         PTR32 commandBuffer;
28505         VkPipelineBindPoint pipelineBindPoint;
28506         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
28507         uint32_t set;
28508         uint32_t descriptorWriteCount;
28509         PTR32 pDescriptorWrites;
28510     } *params = args;
28511     const VkWriteDescriptorSet *pDescriptorWrites_host;
28512     struct conversion_context ctx;
28513
28514     TRACE("%#x, %#x, 0x%s, %u, %u, %#x\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set, params->descriptorWriteCount, params->pDescriptorWrites);
28515
28516     init_conversion_context(&ctx);
28517     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, (const VkWriteDescriptorSet32 *)UlongToPtr(params->pDescriptorWrites), params->descriptorWriteCount);
28518     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);
28519     free_conversion_context(&ctx);
28520     return STATUS_SUCCESS;
28521 }
28522
28523 #ifdef _WIN64
28524 static NTSTATUS thunk64_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
28525 {
28526     struct vkCmdPushDescriptorSetWithTemplateKHR_params *params = args;
28527
28528     TRACE("%p, 0x%s, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->descriptorUpdateTemplate), wine_dbgstr_longlong(params->layout), params->set, params->pData);
28529
28530     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);
28531     return STATUS_SUCCESS;
28532 }
28533 #endif /* _WIN64 */
28534
28535 static NTSTATUS thunk32_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
28536 {
28537     struct
28538     {
28539         PTR32 commandBuffer;
28540         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
28541         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
28542         uint32_t set;
28543         PTR32 pData;
28544     } *params = args;
28545
28546     TRACE("%#x, 0x%s, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->descriptorUpdateTemplate), wine_dbgstr_longlong(params->layout), params->set, params->pData);
28547
28548     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));
28549     return STATUS_SUCCESS;
28550 }
28551
28552 #ifdef _WIN64
28553 static NTSTATUS thunk64_vkCmdResetEvent(void *args)
28554 {
28555     struct vkCmdResetEvent_params *params = args;
28556
28557     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
28558
28559     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
28560     return STATUS_SUCCESS;
28561 }
28562 #endif /* _WIN64 */
28563
28564 static NTSTATUS thunk32_vkCmdResetEvent(void *args)
28565 {
28566     struct
28567     {
28568         PTR32 commandBuffer;
28569         VkEvent DECLSPEC_ALIGN(8) event;
28570         VkPipelineStageFlags stageMask;
28571     } *params = args;
28572
28573     TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
28574
28575     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);
28576     return STATUS_SUCCESS;
28577 }
28578
28579 #ifdef _WIN64
28580 static NTSTATUS thunk64_vkCmdResetEvent2(void *args)
28581 {
28582     struct vkCmdResetEvent2_params *params = args;
28583
28584     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
28585
28586     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
28587     return STATUS_SUCCESS;
28588 }
28589 #endif /* _WIN64 */
28590
28591 static NTSTATUS thunk32_vkCmdResetEvent2(void *args)
28592 {
28593     struct
28594     {
28595         PTR32 commandBuffer;
28596         VkEvent DECLSPEC_ALIGN(8) event;
28597         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
28598     } *params = args;
28599
28600     TRACE("%#x, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
28601
28602     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);
28603     return STATUS_SUCCESS;
28604 }
28605
28606 #ifdef _WIN64
28607 static NTSTATUS thunk64_vkCmdResetEvent2KHR(void *args)
28608 {
28609     struct vkCmdResetEvent2KHR_params *params = args;
28610
28611     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
28612
28613     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
28614     return STATUS_SUCCESS;
28615 }
28616 #endif /* _WIN64 */
28617
28618 static NTSTATUS thunk32_vkCmdResetEvent2KHR(void *args)
28619 {
28620     struct
28621     {
28622         PTR32 commandBuffer;
28623         VkEvent DECLSPEC_ALIGN(8) event;
28624         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
28625     } *params = args;
28626
28627     TRACE("%#x, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
28628
28629     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);
28630     return STATUS_SUCCESS;
28631 }
28632
28633 #ifdef _WIN64
28634 static NTSTATUS thunk64_vkCmdResetQueryPool(void *args)
28635 {
28636     struct vkCmdResetQueryPool_params *params = args;
28637
28638     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
28639
28640     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);
28641     return STATUS_SUCCESS;
28642 }
28643 #endif /* _WIN64 */
28644
28645 static NTSTATUS thunk32_vkCmdResetQueryPool(void *args)
28646 {
28647     struct
28648     {
28649         PTR32 commandBuffer;
28650         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
28651         uint32_t firstQuery;
28652         uint32_t queryCount;
28653     } *params = args;
28654
28655     TRACE("%#x, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
28656
28657     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);
28658     return STATUS_SUCCESS;
28659 }
28660
28661 #ifdef _WIN64
28662 static NTSTATUS thunk64_vkCmdResolveImage(void *args)
28663 {
28664     struct vkCmdResolveImage_params *params = args;
28665
28666     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
28667
28668     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);
28669     return STATUS_SUCCESS;
28670 }
28671 #endif /* _WIN64 */
28672
28673 static NTSTATUS thunk32_vkCmdResolveImage(void *args)
28674 {
28675     struct
28676     {
28677         PTR32 commandBuffer;
28678         VkImage DECLSPEC_ALIGN(8) srcImage;
28679         VkImageLayout srcImageLayout;
28680         VkImage DECLSPEC_ALIGN(8) dstImage;
28681         VkImageLayout dstImageLayout;
28682         uint32_t regionCount;
28683         PTR32 pRegions;
28684     } *params = args;
28685
28686     TRACE("%#x, 0x%s, %#x, 0x%s, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
28687
28688     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));
28689     return STATUS_SUCCESS;
28690 }
28691
28692 #ifdef _WIN64
28693 static NTSTATUS thunk64_vkCmdResolveImage2(void *args)
28694 {
28695     struct vkCmdResolveImage2_params *params = args;
28696
28697     TRACE("%p, %p\n", params->commandBuffer, params->pResolveImageInfo);
28698
28699     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
28700     return STATUS_SUCCESS;
28701 }
28702 #endif /* _WIN64 */
28703
28704 static NTSTATUS thunk32_vkCmdResolveImage2(void *args)
28705 {
28706     struct
28707     {
28708         PTR32 commandBuffer;
28709         PTR32 pResolveImageInfo;
28710     } *params = args;
28711     VkResolveImageInfo2 pResolveImageInfo_host;
28712     struct conversion_context ctx;
28713
28714     TRACE("%#x, %#x\n", params->commandBuffer, params->pResolveImageInfo);
28715
28716     init_conversion_context(&ctx);
28717     convert_VkResolveImageInfo2_win32_to_host(&ctx, (const VkResolveImageInfo232 *)UlongToPtr(params->pResolveImageInfo), &pResolveImageInfo_host);
28718     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);
28719     free_conversion_context(&ctx);
28720     return STATUS_SUCCESS;
28721 }
28722
28723 #ifdef _WIN64
28724 static NTSTATUS thunk64_vkCmdResolveImage2KHR(void *args)
28725 {
28726     struct vkCmdResolveImage2KHR_params *params = args;
28727
28728     TRACE("%p, %p\n", params->commandBuffer, params->pResolveImageInfo);
28729
28730     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
28731     return STATUS_SUCCESS;
28732 }
28733 #endif /* _WIN64 */
28734
28735 static NTSTATUS thunk32_vkCmdResolveImage2KHR(void *args)
28736 {
28737     struct
28738     {
28739         PTR32 commandBuffer;
28740         PTR32 pResolveImageInfo;
28741     } *params = args;
28742     VkResolveImageInfo2 pResolveImageInfo_host;
28743     struct conversion_context ctx;
28744
28745     TRACE("%#x, %#x\n", params->commandBuffer, params->pResolveImageInfo);
28746
28747     init_conversion_context(&ctx);
28748     convert_VkResolveImageInfo2_win32_to_host(&ctx, (const VkResolveImageInfo232 *)UlongToPtr(params->pResolveImageInfo), &pResolveImageInfo_host);
28749     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);
28750     free_conversion_context(&ctx);
28751     return STATUS_SUCCESS;
28752 }
28753
28754 #ifdef _WIN64
28755 static NTSTATUS thunk64_vkCmdSetAlphaToCoverageEnableEXT(void *args)
28756 {
28757     struct vkCmdSetAlphaToCoverageEnableEXT_params *params = args;
28758
28759     TRACE("%p, %u\n", params->commandBuffer, params->alphaToCoverageEnable);
28760
28761     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToCoverageEnable);
28762     return STATUS_SUCCESS;
28763 }
28764 #endif /* _WIN64 */
28765
28766 static NTSTATUS thunk32_vkCmdSetAlphaToCoverageEnableEXT(void *args)
28767 {
28768     struct
28769     {
28770         PTR32 commandBuffer;
28771         VkBool32 alphaToCoverageEnable;
28772     } *params = args;
28773
28774     TRACE("%#x, %u\n", params->commandBuffer, params->alphaToCoverageEnable);
28775
28776     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);
28777     return STATUS_SUCCESS;
28778 }
28779
28780 #ifdef _WIN64
28781 static NTSTATUS thunk64_vkCmdSetAlphaToOneEnableEXT(void *args)
28782 {
28783     struct vkCmdSetAlphaToOneEnableEXT_params *params = args;
28784
28785     TRACE("%p, %u\n", params->commandBuffer, params->alphaToOneEnable);
28786
28787     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToOneEnable);
28788     return STATUS_SUCCESS;
28789 }
28790 #endif /* _WIN64 */
28791
28792 static NTSTATUS thunk32_vkCmdSetAlphaToOneEnableEXT(void *args)
28793 {
28794     struct
28795     {
28796         PTR32 commandBuffer;
28797         VkBool32 alphaToOneEnable;
28798     } *params = args;
28799
28800     TRACE("%#x, %u\n", params->commandBuffer, params->alphaToOneEnable);
28801
28802     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);
28803     return STATUS_SUCCESS;
28804 }
28805
28806 #ifdef _WIN64
28807 static NTSTATUS thunk64_vkCmdSetBlendConstants(void *args)
28808 {
28809     struct vkCmdSetBlendConstants_params *params = args;
28810
28811     TRACE("%p, %p\n", params->commandBuffer, params->blendConstants);
28812
28813     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->blendConstants);
28814     return STATUS_SUCCESS;
28815 }
28816 #endif /* _WIN64 */
28817
28818 static NTSTATUS thunk32_vkCmdSetBlendConstants(void *args)
28819 {
28820     struct
28821     {
28822         PTR32 commandBuffer;
28823         PTR32 blendConstants;
28824     } *params = args;
28825
28826     TRACE("%#x, %#x\n", params->commandBuffer, params->blendConstants);
28827
28828     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));
28829     return STATUS_SUCCESS;
28830 }
28831
28832 #ifdef _WIN64
28833 static NTSTATUS thunk64_vkCmdSetCheckpointNV(void *args)
28834 {
28835     struct vkCmdSetCheckpointNV_params *params = args;
28836
28837     TRACE("%p, %p\n", params->commandBuffer, params->pCheckpointMarker);
28838
28839     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCheckpointMarker);
28840     return STATUS_SUCCESS;
28841 }
28842 #endif /* _WIN64 */
28843
28844 static NTSTATUS thunk32_vkCmdSetCheckpointNV(void *args)
28845 {
28846     struct
28847     {
28848         PTR32 commandBuffer;
28849         PTR32 pCheckpointMarker;
28850     } *params = args;
28851
28852     TRACE("%#x, %#x\n", params->commandBuffer, params->pCheckpointMarker);
28853
28854     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));
28855     return STATUS_SUCCESS;
28856 }
28857
28858 #ifdef _WIN64
28859 static NTSTATUS thunk64_vkCmdSetCoarseSampleOrderNV(void *args)
28860 {
28861     struct vkCmdSetCoarseSampleOrderNV_params *params = args;
28862
28863     TRACE("%p, %#x, %u, %p\n", params->commandBuffer, params->sampleOrderType, params->customSampleOrderCount, params->pCustomSampleOrders);
28864
28865     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);
28866     return STATUS_SUCCESS;
28867 }
28868 #endif /* _WIN64 */
28869
28870 static NTSTATUS thunk32_vkCmdSetCoarseSampleOrderNV(void *args)
28871 {
28872     struct
28873     {
28874         PTR32 commandBuffer;
28875         VkCoarseSampleOrderTypeNV sampleOrderType;
28876         uint32_t customSampleOrderCount;
28877         PTR32 pCustomSampleOrders;
28878     } *params = args;
28879     const VkCoarseSampleOrderCustomNV *pCustomSampleOrders_host;
28880     struct conversion_context ctx;
28881
28882     TRACE("%#x, %#x, %u, %#x\n", params->commandBuffer, params->sampleOrderType, params->customSampleOrderCount, params->pCustomSampleOrders);
28883
28884     init_conversion_context(&ctx);
28885     pCustomSampleOrders_host = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(&ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(params->pCustomSampleOrders), params->customSampleOrderCount);
28886     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);
28887     free_conversion_context(&ctx);
28888     return STATUS_SUCCESS;
28889 }
28890
28891 #ifdef _WIN64
28892 static NTSTATUS thunk64_vkCmdSetColorBlendAdvancedEXT(void *args)
28893 {
28894     struct vkCmdSetColorBlendAdvancedEXT_params *params = args;
28895
28896     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
28897
28898     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);
28899     return STATUS_SUCCESS;
28900 }
28901 #endif /* _WIN64 */
28902
28903 static NTSTATUS thunk32_vkCmdSetColorBlendAdvancedEXT(void *args)
28904 {
28905     struct
28906     {
28907         PTR32 commandBuffer;
28908         uint32_t firstAttachment;
28909         uint32_t attachmentCount;
28910         PTR32 pColorBlendAdvanced;
28911     } *params = args;
28912
28913     TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
28914
28915     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));
28916     return STATUS_SUCCESS;
28917 }
28918
28919 #ifdef _WIN64
28920 static NTSTATUS thunk64_vkCmdSetColorBlendEnableEXT(void *args)
28921 {
28922     struct vkCmdSetColorBlendEnableEXT_params *params = args;
28923
28924     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
28925
28926     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);
28927     return STATUS_SUCCESS;
28928 }
28929 #endif /* _WIN64 */
28930
28931 static NTSTATUS thunk32_vkCmdSetColorBlendEnableEXT(void *args)
28932 {
28933     struct
28934     {
28935         PTR32 commandBuffer;
28936         uint32_t firstAttachment;
28937         uint32_t attachmentCount;
28938         PTR32 pColorBlendEnables;
28939     } *params = args;
28940
28941     TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
28942
28943     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));
28944     return STATUS_SUCCESS;
28945 }
28946
28947 #ifdef _WIN64
28948 static NTSTATUS thunk64_vkCmdSetColorBlendEquationEXT(void *args)
28949 {
28950     struct vkCmdSetColorBlendEquationEXT_params *params = args;
28951
28952     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
28953
28954     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);
28955     return STATUS_SUCCESS;
28956 }
28957 #endif /* _WIN64 */
28958
28959 static NTSTATUS thunk32_vkCmdSetColorBlendEquationEXT(void *args)
28960 {
28961     struct
28962     {
28963         PTR32 commandBuffer;
28964         uint32_t firstAttachment;
28965         uint32_t attachmentCount;
28966         PTR32 pColorBlendEquations;
28967     } *params = args;
28968
28969     TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
28970
28971     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));
28972     return STATUS_SUCCESS;
28973 }
28974
28975 #ifdef _WIN64
28976 static NTSTATUS thunk64_vkCmdSetColorWriteEnableEXT(void *args)
28977 {
28978     struct vkCmdSetColorWriteEnableEXT_params *params = args;
28979
28980     TRACE("%p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pColorWriteEnables);
28981
28982     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
28983     return STATUS_SUCCESS;
28984 }
28985 #endif /* _WIN64 */
28986
28987 static NTSTATUS thunk32_vkCmdSetColorWriteEnableEXT(void *args)
28988 {
28989     struct
28990     {
28991         PTR32 commandBuffer;
28992         uint32_t attachmentCount;
28993         PTR32 pColorWriteEnables;
28994     } *params = args;
28995
28996     TRACE("%#x, %u, %#x\n", params->commandBuffer, params->attachmentCount, params->pColorWriteEnables);
28997
28998     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));
28999     return STATUS_SUCCESS;
29000 }
29001
29002 #ifdef _WIN64
29003 static NTSTATUS thunk64_vkCmdSetColorWriteMaskEXT(void *args)
29004 {
29005     struct vkCmdSetColorWriteMaskEXT_params *params = args;
29006
29007     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
29008
29009     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);
29010     return STATUS_SUCCESS;
29011 }
29012 #endif /* _WIN64 */
29013
29014 static NTSTATUS thunk32_vkCmdSetColorWriteMaskEXT(void *args)
29015 {
29016     struct
29017     {
29018         PTR32 commandBuffer;
29019         uint32_t firstAttachment;
29020         uint32_t attachmentCount;
29021         PTR32 pColorWriteMasks;
29022     } *params = args;
29023
29024     TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
29025
29026     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));
29027     return STATUS_SUCCESS;
29028 }
29029
29030 #ifdef _WIN64
29031 static NTSTATUS thunk64_vkCmdSetConservativeRasterizationModeEXT(void *args)
29032 {
29033     struct vkCmdSetConservativeRasterizationModeEXT_params *params = args;
29034
29035     TRACE("%p, %#x\n", params->commandBuffer, params->conservativeRasterizationMode);
29036
29037     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->conservativeRasterizationMode);
29038     return STATUS_SUCCESS;
29039 }
29040 #endif /* _WIN64 */
29041
29042 static NTSTATUS thunk32_vkCmdSetConservativeRasterizationModeEXT(void *args)
29043 {
29044     struct
29045     {
29046         PTR32 commandBuffer;
29047         VkConservativeRasterizationModeEXT conservativeRasterizationMode;
29048     } *params = args;
29049
29050     TRACE("%#x, %#x\n", params->commandBuffer, params->conservativeRasterizationMode);
29051
29052     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);
29053     return STATUS_SUCCESS;
29054 }
29055
29056 #ifdef _WIN64
29057 static NTSTATUS thunk64_vkCmdSetCoverageModulationModeNV(void *args)
29058 {
29059     struct vkCmdSetCoverageModulationModeNV_params *params = args;
29060
29061     TRACE("%p, %#x\n", params->commandBuffer, params->coverageModulationMode);
29062
29063     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationMode);
29064     return STATUS_SUCCESS;
29065 }
29066 #endif /* _WIN64 */
29067
29068 static NTSTATUS thunk32_vkCmdSetCoverageModulationModeNV(void *args)
29069 {
29070     struct
29071     {
29072         PTR32 commandBuffer;
29073         VkCoverageModulationModeNV coverageModulationMode;
29074     } *params = args;
29075
29076     TRACE("%#x, %#x\n", params->commandBuffer, params->coverageModulationMode);
29077
29078     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);
29079     return STATUS_SUCCESS;
29080 }
29081
29082 #ifdef _WIN64
29083 static NTSTATUS thunk64_vkCmdSetCoverageModulationTableEnableNV(void *args)
29084 {
29085     struct vkCmdSetCoverageModulationTableEnableNV_params *params = args;
29086
29087     TRACE("%p, %u\n", params->commandBuffer, params->coverageModulationTableEnable);
29088
29089     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableEnable);
29090     return STATUS_SUCCESS;
29091 }
29092 #endif /* _WIN64 */
29093
29094 static NTSTATUS thunk32_vkCmdSetCoverageModulationTableEnableNV(void *args)
29095 {
29096     struct
29097     {
29098         PTR32 commandBuffer;
29099         VkBool32 coverageModulationTableEnable;
29100     } *params = args;
29101
29102     TRACE("%#x, %u\n", params->commandBuffer, params->coverageModulationTableEnable);
29103
29104     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);
29105     return STATUS_SUCCESS;
29106 }
29107
29108 #ifdef _WIN64
29109 static NTSTATUS thunk64_vkCmdSetCoverageModulationTableNV(void *args)
29110 {
29111     struct vkCmdSetCoverageModulationTableNV_params *params = args;
29112
29113     TRACE("%p, %u, %p\n", params->commandBuffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
29114
29115     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
29116     return STATUS_SUCCESS;
29117 }
29118 #endif /* _WIN64 */
29119
29120 static NTSTATUS thunk32_vkCmdSetCoverageModulationTableNV(void *args)
29121 {
29122     struct
29123     {
29124         PTR32 commandBuffer;
29125         uint32_t coverageModulationTableCount;
29126         PTR32 pCoverageModulationTable;
29127     } *params = args;
29128
29129     TRACE("%#x, %u, %#x\n", params->commandBuffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
29130
29131     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));
29132     return STATUS_SUCCESS;
29133 }
29134
29135 #ifdef _WIN64
29136 static NTSTATUS thunk64_vkCmdSetCoverageReductionModeNV(void *args)
29137 {
29138     struct vkCmdSetCoverageReductionModeNV_params *params = args;
29139
29140     TRACE("%p, %#x\n", params->commandBuffer, params->coverageReductionMode);
29141
29142     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageReductionMode);
29143     return STATUS_SUCCESS;
29144 }
29145 #endif /* _WIN64 */
29146
29147 static NTSTATUS thunk32_vkCmdSetCoverageReductionModeNV(void *args)
29148 {
29149     struct
29150     {
29151         PTR32 commandBuffer;
29152         VkCoverageReductionModeNV coverageReductionMode;
29153     } *params = args;
29154
29155     TRACE("%#x, %#x\n", params->commandBuffer, params->coverageReductionMode);
29156
29157     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);
29158     return STATUS_SUCCESS;
29159 }
29160
29161 #ifdef _WIN64
29162 static NTSTATUS thunk64_vkCmdSetCoverageToColorEnableNV(void *args)
29163 {
29164     struct vkCmdSetCoverageToColorEnableNV_params *params = args;
29165
29166     TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorEnable);
29167
29168     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorEnable);
29169     return STATUS_SUCCESS;
29170 }
29171 #endif /* _WIN64 */
29172
29173 static NTSTATUS thunk32_vkCmdSetCoverageToColorEnableNV(void *args)
29174 {
29175     struct
29176     {
29177         PTR32 commandBuffer;
29178         VkBool32 coverageToColorEnable;
29179     } *params = args;
29180
29181     TRACE("%#x, %u\n", params->commandBuffer, params->coverageToColorEnable);
29182
29183     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);
29184     return STATUS_SUCCESS;
29185 }
29186
29187 #ifdef _WIN64
29188 static NTSTATUS thunk64_vkCmdSetCoverageToColorLocationNV(void *args)
29189 {
29190     struct vkCmdSetCoverageToColorLocationNV_params *params = args;
29191
29192     TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorLocation);
29193
29194     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorLocation);
29195     return STATUS_SUCCESS;
29196 }
29197 #endif /* _WIN64 */
29198
29199 static NTSTATUS thunk32_vkCmdSetCoverageToColorLocationNV(void *args)
29200 {
29201     struct
29202     {
29203         PTR32 commandBuffer;
29204         uint32_t coverageToColorLocation;
29205     } *params = args;
29206
29207     TRACE("%#x, %u\n", params->commandBuffer, params->coverageToColorLocation);
29208
29209     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);
29210     return STATUS_SUCCESS;
29211 }
29212
29213 #ifdef _WIN64
29214 static NTSTATUS thunk64_vkCmdSetCullMode(void *args)
29215 {
29216     struct vkCmdSetCullMode_params *params = args;
29217
29218     TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
29219
29220     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
29221     return STATUS_SUCCESS;
29222 }
29223 #endif /* _WIN64 */
29224
29225 static NTSTATUS thunk32_vkCmdSetCullMode(void *args)
29226 {
29227     struct
29228     {
29229         PTR32 commandBuffer;
29230         VkCullModeFlags cullMode;
29231     } *params = args;
29232
29233     TRACE("%#x, %#x\n", params->commandBuffer, params->cullMode);
29234
29235     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);
29236     return STATUS_SUCCESS;
29237 }
29238
29239 #ifdef _WIN64
29240 static NTSTATUS thunk64_vkCmdSetCullModeEXT(void *args)
29241 {
29242     struct vkCmdSetCullModeEXT_params *params = args;
29243
29244     TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
29245
29246     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
29247     return STATUS_SUCCESS;
29248 }
29249 #endif /* _WIN64 */
29250
29251 static NTSTATUS thunk32_vkCmdSetCullModeEXT(void *args)
29252 {
29253     struct
29254     {
29255         PTR32 commandBuffer;
29256         VkCullModeFlags cullMode;
29257     } *params = args;
29258
29259     TRACE("%#x, %#x\n", params->commandBuffer, params->cullMode);
29260
29261     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);
29262     return STATUS_SUCCESS;
29263 }
29264
29265 #ifdef _WIN64
29266 static NTSTATUS thunk64_vkCmdSetDepthBias(void *args)
29267 {
29268     struct vkCmdSetDepthBias_params *params = args;
29269
29270     TRACE("%p, %f, %f, %f\n", params->commandBuffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
29271
29272     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);
29273     return STATUS_SUCCESS;
29274 }
29275 #endif /* _WIN64 */
29276
29277 static NTSTATUS thunk32_vkCmdSetDepthBias(void *args)
29278 {
29279     struct
29280     {
29281         PTR32 commandBuffer;
29282         float depthBiasConstantFactor;
29283         float depthBiasClamp;
29284         float depthBiasSlopeFactor;
29285     } *params = args;
29286
29287     TRACE("%#x, %f, %f, %f\n", params->commandBuffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
29288
29289     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);
29290     return STATUS_SUCCESS;
29291 }
29292
29293 #ifdef _WIN64
29294 static NTSTATUS thunk64_vkCmdSetDepthBiasEnable(void *args)
29295 {
29296     struct vkCmdSetDepthBiasEnable_params *params = args;
29297
29298     TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
29299
29300     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
29301     return STATUS_SUCCESS;
29302 }
29303 #endif /* _WIN64 */
29304
29305 static NTSTATUS thunk32_vkCmdSetDepthBiasEnable(void *args)
29306 {
29307     struct
29308     {
29309         PTR32 commandBuffer;
29310         VkBool32 depthBiasEnable;
29311     } *params = args;
29312
29313     TRACE("%#x, %u\n", params->commandBuffer, params->depthBiasEnable);
29314
29315     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);
29316     return STATUS_SUCCESS;
29317 }
29318
29319 #ifdef _WIN64
29320 static NTSTATUS thunk64_vkCmdSetDepthBiasEnableEXT(void *args)
29321 {
29322     struct vkCmdSetDepthBiasEnableEXT_params *params = args;
29323
29324     TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
29325
29326     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
29327     return STATUS_SUCCESS;
29328 }
29329 #endif /* _WIN64 */
29330
29331 static NTSTATUS thunk32_vkCmdSetDepthBiasEnableEXT(void *args)
29332 {
29333     struct
29334     {
29335         PTR32 commandBuffer;
29336         VkBool32 depthBiasEnable;
29337     } *params = args;
29338
29339     TRACE("%#x, %u\n", params->commandBuffer, params->depthBiasEnable);
29340
29341     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);
29342     return STATUS_SUCCESS;
29343 }
29344
29345 #ifdef _WIN64
29346 static NTSTATUS thunk64_vkCmdSetDepthBounds(void *args)
29347 {
29348     struct vkCmdSetDepthBounds_params *params = args;
29349
29350     TRACE("%p, %f, %f\n", params->commandBuffer, params->minDepthBounds, params->maxDepthBounds);
29351
29352     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
29353     return STATUS_SUCCESS;
29354 }
29355 #endif /* _WIN64 */
29356
29357 static NTSTATUS thunk32_vkCmdSetDepthBounds(void *args)
29358 {
29359     struct
29360     {
29361         PTR32 commandBuffer;
29362         float minDepthBounds;
29363         float maxDepthBounds;
29364     } *params = args;
29365
29366     TRACE("%#x, %f, %f\n", params->commandBuffer, params->minDepthBounds, params->maxDepthBounds);
29367
29368     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);
29369     return STATUS_SUCCESS;
29370 }
29371
29372 #ifdef _WIN64
29373 static NTSTATUS thunk64_vkCmdSetDepthBoundsTestEnable(void *args)
29374 {
29375     struct vkCmdSetDepthBoundsTestEnable_params *params = args;
29376
29377     TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
29378
29379     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
29380     return STATUS_SUCCESS;
29381 }
29382 #endif /* _WIN64 */
29383
29384 static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnable(void *args)
29385 {
29386     struct
29387     {
29388         PTR32 commandBuffer;
29389         VkBool32 depthBoundsTestEnable;
29390     } *params = args;
29391
29392     TRACE("%#x, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
29393
29394     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);
29395     return STATUS_SUCCESS;
29396 }
29397
29398 #ifdef _WIN64
29399 static NTSTATUS thunk64_vkCmdSetDepthBoundsTestEnableEXT(void *args)
29400 {
29401     struct vkCmdSetDepthBoundsTestEnableEXT_params *params = args;
29402
29403     TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
29404
29405     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
29406     return STATUS_SUCCESS;
29407 }
29408 #endif /* _WIN64 */
29409
29410 static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnableEXT(void *args)
29411 {
29412     struct
29413     {
29414         PTR32 commandBuffer;
29415         VkBool32 depthBoundsTestEnable;
29416     } *params = args;
29417
29418     TRACE("%#x, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
29419
29420     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);
29421     return STATUS_SUCCESS;
29422 }
29423
29424 #ifdef _WIN64
29425 static NTSTATUS thunk64_vkCmdSetDepthClampEnableEXT(void *args)
29426 {
29427     struct vkCmdSetDepthClampEnableEXT_params *params = args;
29428
29429     TRACE("%p, %u\n", params->commandBuffer, params->depthClampEnable);
29430
29431     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClampEnable);
29432     return STATUS_SUCCESS;
29433 }
29434 #endif /* _WIN64 */
29435
29436 static NTSTATUS thunk32_vkCmdSetDepthClampEnableEXT(void *args)
29437 {
29438     struct
29439     {
29440         PTR32 commandBuffer;
29441         VkBool32 depthClampEnable;
29442     } *params = args;
29443
29444     TRACE("%#x, %u\n", params->commandBuffer, params->depthClampEnable);
29445
29446     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);
29447     return STATUS_SUCCESS;
29448 }
29449
29450 #ifdef _WIN64
29451 static NTSTATUS thunk64_vkCmdSetDepthClipEnableEXT(void *args)
29452 {
29453     struct vkCmdSetDepthClipEnableEXT_params *params = args;
29454
29455     TRACE("%p, %u\n", params->commandBuffer, params->depthClipEnable);
29456
29457     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClipEnable);
29458     return STATUS_SUCCESS;
29459 }
29460 #endif /* _WIN64 */
29461
29462 static NTSTATUS thunk32_vkCmdSetDepthClipEnableEXT(void *args)
29463 {
29464     struct
29465     {
29466         PTR32 commandBuffer;
29467         VkBool32 depthClipEnable;
29468     } *params = args;
29469
29470     TRACE("%#x, %u\n", params->commandBuffer, params->depthClipEnable);
29471
29472     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);
29473     return STATUS_SUCCESS;
29474 }
29475
29476 #ifdef _WIN64
29477 static NTSTATUS thunk64_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
29478 {
29479     struct vkCmdSetDepthClipNegativeOneToOneEXT_params *params = args;
29480
29481     TRACE("%p, %u\n", params->commandBuffer, params->negativeOneToOne);
29482
29483     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->negativeOneToOne);
29484     return STATUS_SUCCESS;
29485 }
29486 #endif /* _WIN64 */
29487
29488 static NTSTATUS thunk32_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
29489 {
29490     struct
29491     {
29492         PTR32 commandBuffer;
29493         VkBool32 negativeOneToOne;
29494     } *params = args;
29495
29496     TRACE("%#x, %u\n", params->commandBuffer, params->negativeOneToOne);
29497
29498     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);
29499     return STATUS_SUCCESS;
29500 }
29501
29502 #ifdef _WIN64
29503 static NTSTATUS thunk64_vkCmdSetDepthCompareOp(void *args)
29504 {
29505     struct vkCmdSetDepthCompareOp_params *params = args;
29506
29507     TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
29508
29509     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
29510     return STATUS_SUCCESS;
29511 }
29512 #endif /* _WIN64 */
29513
29514 static NTSTATUS thunk32_vkCmdSetDepthCompareOp(void *args)
29515 {
29516     struct
29517     {
29518         PTR32 commandBuffer;
29519         VkCompareOp depthCompareOp;
29520     } *params = args;
29521
29522     TRACE("%#x, %#x\n", params->commandBuffer, params->depthCompareOp);
29523
29524     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);
29525     return STATUS_SUCCESS;
29526 }
29527
29528 #ifdef _WIN64
29529 static NTSTATUS thunk64_vkCmdSetDepthCompareOpEXT(void *args)
29530 {
29531     struct vkCmdSetDepthCompareOpEXT_params *params = args;
29532
29533     TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
29534
29535     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
29536     return STATUS_SUCCESS;
29537 }
29538 #endif /* _WIN64 */
29539
29540 static NTSTATUS thunk32_vkCmdSetDepthCompareOpEXT(void *args)
29541 {
29542     struct
29543     {
29544         PTR32 commandBuffer;
29545         VkCompareOp depthCompareOp;
29546     } *params = args;
29547
29548     TRACE("%#x, %#x\n", params->commandBuffer, params->depthCompareOp);
29549
29550     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);
29551     return STATUS_SUCCESS;
29552 }
29553
29554 #ifdef _WIN64
29555 static NTSTATUS thunk64_vkCmdSetDepthTestEnable(void *args)
29556 {
29557     struct vkCmdSetDepthTestEnable_params *params = args;
29558
29559     TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
29560
29561     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
29562     return STATUS_SUCCESS;
29563 }
29564 #endif /* _WIN64 */
29565
29566 static NTSTATUS thunk32_vkCmdSetDepthTestEnable(void *args)
29567 {
29568     struct
29569     {
29570         PTR32 commandBuffer;
29571         VkBool32 depthTestEnable;
29572     } *params = args;
29573
29574     TRACE("%#x, %u\n", params->commandBuffer, params->depthTestEnable);
29575
29576     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);
29577     return STATUS_SUCCESS;
29578 }
29579
29580 #ifdef _WIN64
29581 static NTSTATUS thunk64_vkCmdSetDepthTestEnableEXT(void *args)
29582 {
29583     struct vkCmdSetDepthTestEnableEXT_params *params = args;
29584
29585     TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
29586
29587     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
29588     return STATUS_SUCCESS;
29589 }
29590 #endif /* _WIN64 */
29591
29592 static NTSTATUS thunk32_vkCmdSetDepthTestEnableEXT(void *args)
29593 {
29594     struct
29595     {
29596         PTR32 commandBuffer;
29597         VkBool32 depthTestEnable;
29598     } *params = args;
29599
29600     TRACE("%#x, %u\n", params->commandBuffer, params->depthTestEnable);
29601
29602     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);
29603     return STATUS_SUCCESS;
29604 }
29605
29606 #ifdef _WIN64
29607 static NTSTATUS thunk64_vkCmdSetDepthWriteEnable(void *args)
29608 {
29609     struct vkCmdSetDepthWriteEnable_params *params = args;
29610
29611     TRACE("%p, %u\n", params->commandBuffer, params->depthWriteEnable);
29612
29613     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
29614     return STATUS_SUCCESS;
29615 }
29616 #endif /* _WIN64 */
29617
29618 static NTSTATUS thunk32_vkCmdSetDepthWriteEnable(void *args)
29619 {
29620     struct
29621     {
29622         PTR32 commandBuffer;
29623         VkBool32 depthWriteEnable;
29624     } *params = args;
29625
29626     TRACE("%#x, %u\n", params->commandBuffer, params->depthWriteEnable);
29627
29628     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);
29629     return STATUS_SUCCESS;
29630 }
29631
29632 #ifdef _WIN64
29633 static NTSTATUS thunk64_vkCmdSetDepthWriteEnableEXT(void *args)
29634 {
29635     struct vkCmdSetDepthWriteEnableEXT_params *params = args;
29636
29637     TRACE("%p, %u\n", params->commandBuffer, params->depthWriteEnable);
29638
29639     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
29640     return STATUS_SUCCESS;
29641 }
29642 #endif /* _WIN64 */
29643
29644 static NTSTATUS thunk32_vkCmdSetDepthWriteEnableEXT(void *args)
29645 {
29646     struct
29647     {
29648         PTR32 commandBuffer;
29649         VkBool32 depthWriteEnable;
29650     } *params = args;
29651
29652     TRACE("%#x, %u\n", params->commandBuffer, params->depthWriteEnable);
29653
29654     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);
29655     return STATUS_SUCCESS;
29656 }
29657
29658 #ifdef _WIN64
29659 static NTSTATUS thunk64_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
29660 {
29661     struct vkCmdSetDescriptorBufferOffsetsEXT_params *params = args;
29662
29663     TRACE("%p, %#x, 0x%s, %u, %u, %p, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->firstSet, params->setCount, params->pBufferIndices, params->pOffsets);
29664
29665     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);
29666     return STATUS_SUCCESS;
29667 }
29668 #endif /* _WIN64 */
29669
29670 static NTSTATUS thunk32_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
29671 {
29672     struct
29673     {
29674         PTR32 commandBuffer;
29675         VkPipelineBindPoint pipelineBindPoint;
29676         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
29677         uint32_t firstSet;
29678         uint32_t setCount;
29679         PTR32 pBufferIndices;
29680         PTR32 pOffsets;
29681     } *params = args;
29682
29683     TRACE("%#x, %#x, 0x%s, %u, %u, %#x, %#x\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->firstSet, params->setCount, params->pBufferIndices, params->pOffsets);
29684
29685     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));
29686     return STATUS_SUCCESS;
29687 }
29688
29689 #ifdef _WIN64
29690 static NTSTATUS thunk64_vkCmdSetDeviceMask(void *args)
29691 {
29692     struct vkCmdSetDeviceMask_params *params = args;
29693
29694     TRACE("%p, %u\n", params->commandBuffer, params->deviceMask);
29695
29696     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
29697     return STATUS_SUCCESS;
29698 }
29699 #endif /* _WIN64 */
29700
29701 static NTSTATUS thunk32_vkCmdSetDeviceMask(void *args)
29702 {
29703     struct
29704     {
29705         PTR32 commandBuffer;
29706         uint32_t deviceMask;
29707     } *params = args;
29708
29709     TRACE("%#x, %u\n", params->commandBuffer, params->deviceMask);
29710
29711     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);
29712     return STATUS_SUCCESS;
29713 }
29714
29715 #ifdef _WIN64
29716 static NTSTATUS thunk64_vkCmdSetDeviceMaskKHR(void *args)
29717 {
29718     struct vkCmdSetDeviceMaskKHR_params *params = args;
29719
29720     TRACE("%p, %u\n", params->commandBuffer, params->deviceMask);
29721
29722     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
29723     return STATUS_SUCCESS;
29724 }
29725 #endif /* _WIN64 */
29726
29727 static NTSTATUS thunk32_vkCmdSetDeviceMaskKHR(void *args)
29728 {
29729     struct
29730     {
29731         PTR32 commandBuffer;
29732         uint32_t deviceMask;
29733     } *params = args;
29734
29735     TRACE("%#x, %u\n", params->commandBuffer, params->deviceMask);
29736
29737     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);
29738     return STATUS_SUCCESS;
29739 }
29740
29741 #ifdef _WIN64
29742 static NTSTATUS thunk64_vkCmdSetDiscardRectangleEXT(void *args)
29743 {
29744     struct vkCmdSetDiscardRectangleEXT_params *params = args;
29745
29746     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);
29747
29748     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);
29749     return STATUS_SUCCESS;
29750 }
29751 #endif /* _WIN64 */
29752
29753 static NTSTATUS thunk32_vkCmdSetDiscardRectangleEXT(void *args)
29754 {
29755     struct
29756     {
29757         PTR32 commandBuffer;
29758         uint32_t firstDiscardRectangle;
29759         uint32_t discardRectangleCount;
29760         PTR32 pDiscardRectangles;
29761     } *params = args;
29762
29763     TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);
29764
29765     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));
29766     return STATUS_SUCCESS;
29767 }
29768
29769 #ifdef _WIN64
29770 static NTSTATUS thunk64_vkCmdSetEvent(void *args)
29771 {
29772     struct vkCmdSetEvent_params *params = args;
29773
29774     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
29775
29776     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
29777     return STATUS_SUCCESS;
29778 }
29779 #endif /* _WIN64 */
29780
29781 static NTSTATUS thunk32_vkCmdSetEvent(void *args)
29782 {
29783     struct
29784     {
29785         PTR32 commandBuffer;
29786         VkEvent DECLSPEC_ALIGN(8) event;
29787         VkPipelineStageFlags stageMask;
29788     } *params = args;
29789
29790     TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
29791
29792     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);
29793     return STATUS_SUCCESS;
29794 }
29795
29796 #ifdef _WIN64
29797 static NTSTATUS thunk64_vkCmdSetEvent2(void *args)
29798 {
29799     struct vkCmdSetEvent2_params *params = args;
29800
29801     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
29802
29803     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
29804     return STATUS_SUCCESS;
29805 }
29806 #endif /* _WIN64 */
29807
29808 static NTSTATUS thunk32_vkCmdSetEvent2(void *args)
29809 {
29810     struct
29811     {
29812         PTR32 commandBuffer;
29813         VkEvent DECLSPEC_ALIGN(8) event;
29814         PTR32 pDependencyInfo;
29815     } *params = args;
29816     VkDependencyInfo pDependencyInfo_host;
29817     struct conversion_context ctx;
29818
29819     TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
29820
29821     init_conversion_context(&ctx);
29822     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
29823     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);
29824     free_conversion_context(&ctx);
29825     return STATUS_SUCCESS;
29826 }
29827
29828 #ifdef _WIN64
29829 static NTSTATUS thunk64_vkCmdSetEvent2KHR(void *args)
29830 {
29831     struct vkCmdSetEvent2KHR_params *params = args;
29832
29833     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
29834
29835     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
29836     return STATUS_SUCCESS;
29837 }
29838 #endif /* _WIN64 */
29839
29840 static NTSTATUS thunk32_vkCmdSetEvent2KHR(void *args)
29841 {
29842     struct
29843     {
29844         PTR32 commandBuffer;
29845         VkEvent DECLSPEC_ALIGN(8) event;
29846         PTR32 pDependencyInfo;
29847     } *params = args;
29848     VkDependencyInfo pDependencyInfo_host;
29849     struct conversion_context ctx;
29850
29851     TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
29852
29853     init_conversion_context(&ctx);
29854     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
29855     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);
29856     free_conversion_context(&ctx);
29857     return STATUS_SUCCESS;
29858 }
29859
29860 #ifdef _WIN64
29861 static NTSTATUS thunk64_vkCmdSetExclusiveScissorNV(void *args)
29862 {
29863     struct vkCmdSetExclusiveScissorNV_params *params = args;
29864
29865     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);
29866
29867     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);
29868     return STATUS_SUCCESS;
29869 }
29870 #endif /* _WIN64 */
29871
29872 static NTSTATUS thunk32_vkCmdSetExclusiveScissorNV(void *args)
29873 {
29874     struct
29875     {
29876         PTR32 commandBuffer;
29877         uint32_t firstExclusiveScissor;
29878         uint32_t exclusiveScissorCount;
29879         PTR32 pExclusiveScissors;
29880     } *params = args;
29881
29882     TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);
29883
29884     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));
29885     return STATUS_SUCCESS;
29886 }
29887
29888 #ifdef _WIN64
29889 static NTSTATUS thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
29890 {
29891     struct vkCmdSetExtraPrimitiveOverestimationSizeEXT_params *params = args;
29892
29893     TRACE("%p, %f\n", params->commandBuffer, params->extraPrimitiveOverestimationSize);
29894
29895     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->extraPrimitiveOverestimationSize);
29896     return STATUS_SUCCESS;
29897 }
29898 #endif /* _WIN64 */
29899
29900 static NTSTATUS thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
29901 {
29902     struct
29903     {
29904         PTR32 commandBuffer;
29905         float extraPrimitiveOverestimationSize;
29906     } *params = args;
29907
29908     TRACE("%#x, %f\n", params->commandBuffer, params->extraPrimitiveOverestimationSize);
29909
29910     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);
29911     return STATUS_SUCCESS;
29912 }
29913
29914 #ifdef _WIN64
29915 static NTSTATUS thunk64_vkCmdSetFragmentShadingRateEnumNV(void *args)
29916 {
29917     struct vkCmdSetFragmentShadingRateEnumNV_params *params = args;
29918
29919     TRACE("%p, %#x, %p\n", params->commandBuffer, params->shadingRate, params->combinerOps);
29920
29921     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRate, params->combinerOps);
29922     return STATUS_SUCCESS;
29923 }
29924 #endif /* _WIN64 */
29925
29926 static NTSTATUS thunk32_vkCmdSetFragmentShadingRateEnumNV(void *args)
29927 {
29928     struct
29929     {
29930         PTR32 commandBuffer;
29931         VkFragmentShadingRateNV shadingRate;
29932         PTR32 combinerOps;
29933     } *params = args;
29934
29935     TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->shadingRate, params->combinerOps);
29936
29937     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));
29938     return STATUS_SUCCESS;
29939 }
29940
29941 #ifdef _WIN64
29942 static NTSTATUS thunk64_vkCmdSetFragmentShadingRateKHR(void *args)
29943 {
29944     struct vkCmdSetFragmentShadingRateKHR_params *params = args;
29945
29946     TRACE("%p, %p, %p\n", params->commandBuffer, params->pFragmentSize, params->combinerOps);
29947
29948     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pFragmentSize, params->combinerOps);
29949     return STATUS_SUCCESS;
29950 }
29951 #endif /* _WIN64 */
29952
29953 static NTSTATUS thunk32_vkCmdSetFragmentShadingRateKHR(void *args)
29954 {
29955     struct
29956     {
29957         PTR32 commandBuffer;
29958         PTR32 pFragmentSize;
29959         PTR32 combinerOps;
29960     } *params = args;
29961
29962     TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pFragmentSize, params->combinerOps);
29963
29964     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));
29965     return STATUS_SUCCESS;
29966 }
29967
29968 #ifdef _WIN64
29969 static NTSTATUS thunk64_vkCmdSetFrontFace(void *args)
29970 {
29971     struct vkCmdSetFrontFace_params *params = args;
29972
29973     TRACE("%p, %#x\n", params->commandBuffer, params->frontFace);
29974
29975     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
29976     return STATUS_SUCCESS;
29977 }
29978 #endif /* _WIN64 */
29979
29980 static NTSTATUS thunk32_vkCmdSetFrontFace(void *args)
29981 {
29982     struct
29983     {
29984         PTR32 commandBuffer;
29985         VkFrontFace frontFace;
29986     } *params = args;
29987
29988     TRACE("%#x, %#x\n", params->commandBuffer, params->frontFace);
29989
29990     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);
29991     return STATUS_SUCCESS;
29992 }
29993
29994 #ifdef _WIN64
29995 static NTSTATUS thunk64_vkCmdSetFrontFaceEXT(void *args)
29996 {
29997     struct vkCmdSetFrontFaceEXT_params *params = args;
29998
29999     TRACE("%p, %#x\n", params->commandBuffer, params->frontFace);
30000
30001     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
30002     return STATUS_SUCCESS;
30003 }
30004 #endif /* _WIN64 */
30005
30006 static NTSTATUS thunk32_vkCmdSetFrontFaceEXT(void *args)
30007 {
30008     struct
30009     {
30010         PTR32 commandBuffer;
30011         VkFrontFace frontFace;
30012     } *params = args;
30013
30014     TRACE("%#x, %#x\n", params->commandBuffer, params->frontFace);
30015
30016     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);
30017     return STATUS_SUCCESS;
30018 }
30019
30020 #ifdef _WIN64
30021 static NTSTATUS thunk64_vkCmdSetLineRasterizationModeEXT(void *args)
30022 {
30023     struct vkCmdSetLineRasterizationModeEXT_params *params = args;
30024
30025     TRACE("%p, %#x\n", params->commandBuffer, params->lineRasterizationMode);
30026
30027     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineRasterizationMode);
30028     return STATUS_SUCCESS;
30029 }
30030 #endif /* _WIN64 */
30031
30032 static NTSTATUS thunk32_vkCmdSetLineRasterizationModeEXT(void *args)
30033 {
30034     struct
30035     {
30036         PTR32 commandBuffer;
30037         VkLineRasterizationModeEXT lineRasterizationMode;
30038     } *params = args;
30039
30040     TRACE("%#x, %#x\n", params->commandBuffer, params->lineRasterizationMode);
30041
30042     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);
30043     return STATUS_SUCCESS;
30044 }
30045
30046 #ifdef _WIN64
30047 static NTSTATUS thunk64_vkCmdSetLineStippleEXT(void *args)
30048 {
30049     struct vkCmdSetLineStippleEXT_params *params = args;
30050
30051     TRACE("%p, %u, %u\n", params->commandBuffer, params->lineStippleFactor, params->lineStipplePattern);
30052
30053     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
30054     return STATUS_SUCCESS;
30055 }
30056 #endif /* _WIN64 */
30057
30058 static NTSTATUS thunk32_vkCmdSetLineStippleEXT(void *args)
30059 {
30060     struct
30061     {
30062         PTR32 commandBuffer;
30063         uint32_t lineStippleFactor;
30064         uint16_t lineStipplePattern;
30065     } *params = args;
30066
30067     TRACE("%#x, %u, %u\n", params->commandBuffer, params->lineStippleFactor, params->lineStipplePattern);
30068
30069     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);
30070     return STATUS_SUCCESS;
30071 }
30072
30073 #ifdef _WIN64
30074 static NTSTATUS thunk64_vkCmdSetLineStippleEnableEXT(void *args)
30075 {
30076     struct vkCmdSetLineStippleEnableEXT_params *params = args;
30077
30078     TRACE("%p, %u\n", params->commandBuffer, params->stippledLineEnable);
30079
30080     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stippledLineEnable);
30081     return STATUS_SUCCESS;
30082 }
30083 #endif /* _WIN64 */
30084
30085 static NTSTATUS thunk32_vkCmdSetLineStippleEnableEXT(void *args)
30086 {
30087     struct
30088     {
30089         PTR32 commandBuffer;
30090         VkBool32 stippledLineEnable;
30091     } *params = args;
30092
30093     TRACE("%#x, %u\n", params->commandBuffer, params->stippledLineEnable);
30094
30095     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);
30096     return STATUS_SUCCESS;
30097 }
30098
30099 #ifdef _WIN64
30100 static NTSTATUS thunk64_vkCmdSetLineWidth(void *args)
30101 {
30102     struct vkCmdSetLineWidth_params *params = args;
30103
30104     TRACE("%p, %f\n", params->commandBuffer, params->lineWidth);
30105
30106     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineWidth);
30107     return STATUS_SUCCESS;
30108 }
30109 #endif /* _WIN64 */
30110
30111 static NTSTATUS thunk32_vkCmdSetLineWidth(void *args)
30112 {
30113     struct
30114     {
30115         PTR32 commandBuffer;
30116         float lineWidth;
30117     } *params = args;
30118
30119     TRACE("%#x, %f\n", params->commandBuffer, params->lineWidth);
30120
30121     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);
30122     return STATUS_SUCCESS;
30123 }
30124
30125 #ifdef _WIN64
30126 static NTSTATUS thunk64_vkCmdSetLogicOpEXT(void *args)
30127 {
30128     struct vkCmdSetLogicOpEXT_params *params = args;
30129
30130     TRACE("%p, %#x\n", params->commandBuffer, params->logicOp);
30131
30132     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOp);
30133     return STATUS_SUCCESS;
30134 }
30135 #endif /* _WIN64 */
30136
30137 static NTSTATUS thunk32_vkCmdSetLogicOpEXT(void *args)
30138 {
30139     struct
30140     {
30141         PTR32 commandBuffer;
30142         VkLogicOp logicOp;
30143     } *params = args;
30144
30145     TRACE("%#x, %#x\n", params->commandBuffer, params->logicOp);
30146
30147     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);
30148     return STATUS_SUCCESS;
30149 }
30150
30151 #ifdef _WIN64
30152 static NTSTATUS thunk64_vkCmdSetLogicOpEnableEXT(void *args)
30153 {
30154     struct vkCmdSetLogicOpEnableEXT_params *params = args;
30155
30156     TRACE("%p, %u\n", params->commandBuffer, params->logicOpEnable);
30157
30158     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOpEnable);
30159     return STATUS_SUCCESS;
30160 }
30161 #endif /* _WIN64 */
30162
30163 static NTSTATUS thunk32_vkCmdSetLogicOpEnableEXT(void *args)
30164 {
30165     struct
30166     {
30167         PTR32 commandBuffer;
30168         VkBool32 logicOpEnable;
30169     } *params = args;
30170
30171     TRACE("%#x, %u\n", params->commandBuffer, params->logicOpEnable);
30172
30173     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);
30174     return STATUS_SUCCESS;
30175 }
30176
30177 #ifdef _WIN64
30178 static NTSTATUS thunk64_vkCmdSetPatchControlPointsEXT(void *args)
30179 {
30180     struct vkCmdSetPatchControlPointsEXT_params *params = args;
30181
30182     TRACE("%p, %u\n", params->commandBuffer, params->patchControlPoints);
30183
30184     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->patchControlPoints);
30185     return STATUS_SUCCESS;
30186 }
30187 #endif /* _WIN64 */
30188
30189 static NTSTATUS thunk32_vkCmdSetPatchControlPointsEXT(void *args)
30190 {
30191     struct
30192     {
30193         PTR32 commandBuffer;
30194         uint32_t patchControlPoints;
30195     } *params = args;
30196
30197     TRACE("%#x, %u\n", params->commandBuffer, params->patchControlPoints);
30198
30199     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);
30200     return STATUS_SUCCESS;
30201 }
30202
30203 #ifdef _WIN64
30204 static NTSTATUS thunk64_vkCmdSetPerformanceMarkerINTEL(void *args)
30205 {
30206     struct vkCmdSetPerformanceMarkerINTEL_params *params = args;
30207
30208     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
30209
30210     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
30211     return STATUS_SUCCESS;
30212 }
30213 #endif /* _WIN64 */
30214
30215 static NTSTATUS thunk32_vkCmdSetPerformanceMarkerINTEL(void *args)
30216 {
30217     struct
30218     {
30219         PTR32 commandBuffer;
30220         PTR32 pMarkerInfo;
30221         VkResult result;
30222     } *params = args;
30223     VkPerformanceMarkerInfoINTEL pMarkerInfo_host;
30224
30225     TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);
30226
30227     convert_VkPerformanceMarkerInfoINTEL_win32_to_host((const VkPerformanceMarkerInfoINTEL32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
30228     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);
30229     return STATUS_SUCCESS;
30230 }
30231
30232 #ifdef _WIN64
30233 static NTSTATUS thunk64_vkCmdSetPerformanceOverrideINTEL(void *args)
30234 {
30235     struct vkCmdSetPerformanceOverrideINTEL_params *params = args;
30236
30237     TRACE("%p, %p\n", params->commandBuffer, params->pOverrideInfo);
30238
30239     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pOverrideInfo);
30240     return STATUS_SUCCESS;
30241 }
30242 #endif /* _WIN64 */
30243
30244 static NTSTATUS thunk32_vkCmdSetPerformanceOverrideINTEL(void *args)
30245 {
30246     struct
30247     {
30248         PTR32 commandBuffer;
30249         PTR32 pOverrideInfo;
30250         VkResult result;
30251     } *params = args;
30252     VkPerformanceOverrideInfoINTEL pOverrideInfo_host;
30253
30254     TRACE("%#x, %#x\n", params->commandBuffer, params->pOverrideInfo);
30255
30256     convert_VkPerformanceOverrideInfoINTEL_win32_to_host((const VkPerformanceOverrideInfoINTEL32 *)UlongToPtr(params->pOverrideInfo), &pOverrideInfo_host);
30257     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);
30258     return STATUS_SUCCESS;
30259 }
30260
30261 #ifdef _WIN64
30262 static NTSTATUS thunk64_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
30263 {
30264     struct vkCmdSetPerformanceStreamMarkerINTEL_params *params = args;
30265
30266     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
30267
30268     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
30269     return STATUS_SUCCESS;
30270 }
30271 #endif /* _WIN64 */
30272
30273 static NTSTATUS thunk32_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
30274 {
30275     struct
30276     {
30277         PTR32 commandBuffer;
30278         PTR32 pMarkerInfo;
30279         VkResult result;
30280     } *params = args;
30281     VkPerformanceStreamMarkerInfoINTEL pMarkerInfo_host;
30282
30283     TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);
30284
30285     convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host((const VkPerformanceStreamMarkerInfoINTEL32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
30286     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);
30287     return STATUS_SUCCESS;
30288 }
30289
30290 #ifdef _WIN64
30291 static NTSTATUS thunk64_vkCmdSetPolygonModeEXT(void *args)
30292 {
30293     struct vkCmdSetPolygonModeEXT_params *params = args;
30294
30295     TRACE("%p, %#x\n", params->commandBuffer, params->polygonMode);
30296
30297     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->polygonMode);
30298     return STATUS_SUCCESS;
30299 }
30300 #endif /* _WIN64 */
30301
30302 static NTSTATUS thunk32_vkCmdSetPolygonModeEXT(void *args)
30303 {
30304     struct
30305     {
30306         PTR32 commandBuffer;
30307         VkPolygonMode polygonMode;
30308     } *params = args;
30309
30310     TRACE("%#x, %#x\n", params->commandBuffer, params->polygonMode);
30311
30312     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);
30313     return STATUS_SUCCESS;
30314 }
30315
30316 #ifdef _WIN64
30317 static NTSTATUS thunk64_vkCmdSetPrimitiveRestartEnable(void *args)
30318 {
30319     struct vkCmdSetPrimitiveRestartEnable_params *params = args;
30320
30321     TRACE("%p, %u\n", params->commandBuffer, params->primitiveRestartEnable);
30322
30323     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
30324     return STATUS_SUCCESS;
30325 }
30326 #endif /* _WIN64 */
30327
30328 static NTSTATUS thunk32_vkCmdSetPrimitiveRestartEnable(void *args)
30329 {
30330     struct
30331     {
30332         PTR32 commandBuffer;
30333         VkBool32 primitiveRestartEnable;
30334     } *params = args;
30335
30336     TRACE("%#x, %u\n", params->commandBuffer, params->primitiveRestartEnable);
30337
30338     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);
30339     return STATUS_SUCCESS;
30340 }
30341
30342 #ifdef _WIN64
30343 static NTSTATUS thunk64_vkCmdSetPrimitiveRestartEnableEXT(void *args)
30344 {
30345     struct vkCmdSetPrimitiveRestartEnableEXT_params *params = args;
30346
30347     TRACE("%p, %u\n", params->commandBuffer, params->primitiveRestartEnable);
30348
30349     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
30350     return STATUS_SUCCESS;
30351 }
30352 #endif /* _WIN64 */
30353
30354 static NTSTATUS thunk32_vkCmdSetPrimitiveRestartEnableEXT(void *args)
30355 {
30356     struct
30357     {
30358         PTR32 commandBuffer;
30359         VkBool32 primitiveRestartEnable;
30360     } *params = args;
30361
30362     TRACE("%#x, %u\n", params->commandBuffer, params->primitiveRestartEnable);
30363
30364     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);
30365     return STATUS_SUCCESS;
30366 }
30367
30368 #ifdef _WIN64
30369 static NTSTATUS thunk64_vkCmdSetPrimitiveTopology(void *args)
30370 {
30371     struct vkCmdSetPrimitiveTopology_params *params = args;
30372
30373     TRACE("%p, %#x\n", params->commandBuffer, params->primitiveTopology);
30374
30375     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
30376     return STATUS_SUCCESS;
30377 }
30378 #endif /* _WIN64 */
30379
30380 static NTSTATUS thunk32_vkCmdSetPrimitiveTopology(void *args)
30381 {
30382     struct
30383     {
30384         PTR32 commandBuffer;
30385         VkPrimitiveTopology primitiveTopology;
30386     } *params = args;
30387
30388     TRACE("%#x, %#x\n", params->commandBuffer, params->primitiveTopology);
30389
30390     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);
30391     return STATUS_SUCCESS;
30392 }
30393
30394 #ifdef _WIN64
30395 static NTSTATUS thunk64_vkCmdSetPrimitiveTopologyEXT(void *args)
30396 {
30397     struct vkCmdSetPrimitiveTopologyEXT_params *params = args;
30398
30399     TRACE("%p, %#x\n", params->commandBuffer, params->primitiveTopology);
30400
30401     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
30402     return STATUS_SUCCESS;
30403 }
30404 #endif /* _WIN64 */
30405
30406 static NTSTATUS thunk32_vkCmdSetPrimitiveTopologyEXT(void *args)
30407 {
30408     struct
30409     {
30410         PTR32 commandBuffer;
30411         VkPrimitiveTopology primitiveTopology;
30412     } *params = args;
30413
30414     TRACE("%#x, %#x\n", params->commandBuffer, params->primitiveTopology);
30415
30416     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);
30417     return STATUS_SUCCESS;
30418 }
30419
30420 #ifdef _WIN64
30421 static NTSTATUS thunk64_vkCmdSetProvokingVertexModeEXT(void *args)
30422 {
30423     struct vkCmdSetProvokingVertexModeEXT_params *params = args;
30424
30425     TRACE("%p, %#x\n", params->commandBuffer, params->provokingVertexMode);
30426
30427     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->provokingVertexMode);
30428     return STATUS_SUCCESS;
30429 }
30430 #endif /* _WIN64 */
30431
30432 static NTSTATUS thunk32_vkCmdSetProvokingVertexModeEXT(void *args)
30433 {
30434     struct
30435     {
30436         PTR32 commandBuffer;
30437         VkProvokingVertexModeEXT provokingVertexMode;
30438     } *params = args;
30439
30440     TRACE("%#x, %#x\n", params->commandBuffer, params->provokingVertexMode);
30441
30442     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);
30443     return STATUS_SUCCESS;
30444 }
30445
30446 #ifdef _WIN64
30447 static NTSTATUS thunk64_vkCmdSetRasterizationSamplesEXT(void *args)
30448 {
30449     struct vkCmdSetRasterizationSamplesEXT_params *params = args;
30450
30451     TRACE("%p, %#x\n", params->commandBuffer, params->rasterizationSamples);
30452
30453     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationSamples);
30454     return STATUS_SUCCESS;
30455 }
30456 #endif /* _WIN64 */
30457
30458 static NTSTATUS thunk32_vkCmdSetRasterizationSamplesEXT(void *args)
30459 {
30460     struct
30461     {
30462         PTR32 commandBuffer;
30463         VkSampleCountFlagBits rasterizationSamples;
30464     } *params = args;
30465
30466     TRACE("%#x, %#x\n", params->commandBuffer, params->rasterizationSamples);
30467
30468     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);
30469     return STATUS_SUCCESS;
30470 }
30471
30472 #ifdef _WIN64
30473 static NTSTATUS thunk64_vkCmdSetRasterizationStreamEXT(void *args)
30474 {
30475     struct vkCmdSetRasterizationStreamEXT_params *params = args;
30476
30477     TRACE("%p, %u\n", params->commandBuffer, params->rasterizationStream);
30478
30479     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationStream);
30480     return STATUS_SUCCESS;
30481 }
30482 #endif /* _WIN64 */
30483
30484 static NTSTATUS thunk32_vkCmdSetRasterizationStreamEXT(void *args)
30485 {
30486     struct
30487     {
30488         PTR32 commandBuffer;
30489         uint32_t rasterizationStream;
30490     } *params = args;
30491
30492     TRACE("%#x, %u\n", params->commandBuffer, params->rasterizationStream);
30493
30494     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);
30495     return STATUS_SUCCESS;
30496 }
30497
30498 #ifdef _WIN64
30499 static NTSTATUS thunk64_vkCmdSetRasterizerDiscardEnable(void *args)
30500 {
30501     struct vkCmdSetRasterizerDiscardEnable_params *params = args;
30502
30503     TRACE("%p, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
30504
30505     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
30506     return STATUS_SUCCESS;
30507 }
30508 #endif /* _WIN64 */
30509
30510 static NTSTATUS thunk32_vkCmdSetRasterizerDiscardEnable(void *args)
30511 {
30512     struct
30513     {
30514         PTR32 commandBuffer;
30515         VkBool32 rasterizerDiscardEnable;
30516     } *params = args;
30517
30518     TRACE("%#x, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
30519
30520     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);
30521     return STATUS_SUCCESS;
30522 }
30523
30524 #ifdef _WIN64
30525 static NTSTATUS thunk64_vkCmdSetRasterizerDiscardEnableEXT(void *args)
30526 {
30527     struct vkCmdSetRasterizerDiscardEnableEXT_params *params = args;
30528
30529     TRACE("%p, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
30530
30531     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
30532     return STATUS_SUCCESS;
30533 }
30534 #endif /* _WIN64 */
30535
30536 static NTSTATUS thunk32_vkCmdSetRasterizerDiscardEnableEXT(void *args)
30537 {
30538     struct
30539     {
30540         PTR32 commandBuffer;
30541         VkBool32 rasterizerDiscardEnable;
30542     } *params = args;
30543
30544     TRACE("%#x, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
30545
30546     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);
30547     return STATUS_SUCCESS;
30548 }
30549
30550 #ifdef _WIN64
30551 static NTSTATUS thunk64_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
30552 {
30553     struct vkCmdSetRayTracingPipelineStackSizeKHR_params *params = args;
30554
30555     TRACE("%p, %u\n", params->commandBuffer, params->pipelineStackSize);
30556
30557     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStackSize);
30558     return STATUS_SUCCESS;
30559 }
30560 #endif /* _WIN64 */
30561
30562 static NTSTATUS thunk32_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
30563 {
30564     struct
30565     {
30566         PTR32 commandBuffer;
30567         uint32_t pipelineStackSize;
30568     } *params = args;
30569
30570     TRACE("%#x, %u\n", params->commandBuffer, params->pipelineStackSize);
30571
30572     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);
30573     return STATUS_SUCCESS;
30574 }
30575
30576 #ifdef _WIN64
30577 static NTSTATUS thunk64_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
30578 {
30579     struct vkCmdSetRepresentativeFragmentTestEnableNV_params *params = args;
30580
30581     TRACE("%p, %u\n", params->commandBuffer, params->representativeFragmentTestEnable);
30582
30583     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->representativeFragmentTestEnable);
30584     return STATUS_SUCCESS;
30585 }
30586 #endif /* _WIN64 */
30587
30588 static NTSTATUS thunk32_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
30589 {
30590     struct
30591     {
30592         PTR32 commandBuffer;
30593         VkBool32 representativeFragmentTestEnable;
30594     } *params = args;
30595
30596     TRACE("%#x, %u\n", params->commandBuffer, params->representativeFragmentTestEnable);
30597
30598     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);
30599     return STATUS_SUCCESS;
30600 }
30601
30602 #ifdef _WIN64
30603 static NTSTATUS thunk64_vkCmdSetSampleLocationsEXT(void *args)
30604 {
30605     struct vkCmdSetSampleLocationsEXT_params *params = args;
30606
30607     TRACE("%p, %p\n", params->commandBuffer, params->pSampleLocationsInfo);
30608
30609     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSampleLocationsInfo);
30610     return STATUS_SUCCESS;
30611 }
30612 #endif /* _WIN64 */
30613
30614 static NTSTATUS thunk32_vkCmdSetSampleLocationsEXT(void *args)
30615 {
30616     struct
30617     {
30618         PTR32 commandBuffer;
30619         PTR32 pSampleLocationsInfo;
30620     } *params = args;
30621     VkSampleLocationsInfoEXT pSampleLocationsInfo_host;
30622
30623     TRACE("%#x, %#x\n", params->commandBuffer, params->pSampleLocationsInfo);
30624
30625     convert_VkSampleLocationsInfoEXT_win32_to_host((const VkSampleLocationsInfoEXT32 *)UlongToPtr(params->pSampleLocationsInfo), &pSampleLocationsInfo_host);
30626     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);
30627     return STATUS_SUCCESS;
30628 }
30629
30630 #ifdef _WIN64
30631 static NTSTATUS thunk64_vkCmdSetSampleLocationsEnableEXT(void *args)
30632 {
30633     struct vkCmdSetSampleLocationsEnableEXT_params *params = args;
30634
30635     TRACE("%p, %u\n", params->commandBuffer, params->sampleLocationsEnable);
30636
30637     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleLocationsEnable);
30638     return STATUS_SUCCESS;
30639 }
30640 #endif /* _WIN64 */
30641
30642 static NTSTATUS thunk32_vkCmdSetSampleLocationsEnableEXT(void *args)
30643 {
30644     struct
30645     {
30646         PTR32 commandBuffer;
30647         VkBool32 sampleLocationsEnable;
30648     } *params = args;
30649
30650     TRACE("%#x, %u\n", params->commandBuffer, params->sampleLocationsEnable);
30651
30652     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);
30653     return STATUS_SUCCESS;
30654 }
30655
30656 #ifdef _WIN64
30657 static NTSTATUS thunk64_vkCmdSetSampleMaskEXT(void *args)
30658 {
30659     struct vkCmdSetSampleMaskEXT_params *params = args;
30660
30661     TRACE("%p, %#x, %p\n", params->commandBuffer, params->samples, params->pSampleMask);
30662
30663     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->samples, params->pSampleMask);
30664     return STATUS_SUCCESS;
30665 }
30666 #endif /* _WIN64 */
30667
30668 static NTSTATUS thunk32_vkCmdSetSampleMaskEXT(void *args)
30669 {
30670     struct
30671     {
30672         PTR32 commandBuffer;
30673         VkSampleCountFlagBits samples;
30674         PTR32 pSampleMask;
30675     } *params = args;
30676
30677     TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->samples, params->pSampleMask);
30678
30679     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));
30680     return STATUS_SUCCESS;
30681 }
30682
30683 #ifdef _WIN64
30684 static NTSTATUS thunk64_vkCmdSetScissor(void *args)
30685 {
30686     struct vkCmdSetScissor_params *params = args;
30687
30688     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstScissor, params->scissorCount, params->pScissors);
30689
30690     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);
30691     return STATUS_SUCCESS;
30692 }
30693 #endif /* _WIN64 */
30694
30695 static NTSTATUS thunk32_vkCmdSetScissor(void *args)
30696 {
30697     struct
30698     {
30699         PTR32 commandBuffer;
30700         uint32_t firstScissor;
30701         uint32_t scissorCount;
30702         PTR32 pScissors;
30703     } *params = args;
30704
30705     TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstScissor, params->scissorCount, params->pScissors);
30706
30707     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));
30708     return STATUS_SUCCESS;
30709 }
30710
30711 #ifdef _WIN64
30712 static NTSTATUS thunk64_vkCmdSetScissorWithCount(void *args)
30713 {
30714     struct vkCmdSetScissorWithCount_params *params = args;
30715
30716     TRACE("%p, %u, %p\n", params->commandBuffer, params->scissorCount, params->pScissors);
30717
30718     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
30719     return STATUS_SUCCESS;
30720 }
30721 #endif /* _WIN64 */
30722
30723 static NTSTATUS thunk32_vkCmdSetScissorWithCount(void *args)
30724 {
30725     struct
30726     {
30727         PTR32 commandBuffer;
30728         uint32_t scissorCount;
30729         PTR32 pScissors;
30730     } *params = args;
30731
30732     TRACE("%#x, %u, %#x\n", params->commandBuffer, params->scissorCount, params->pScissors);
30733
30734     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));
30735     return STATUS_SUCCESS;
30736 }
30737
30738 #ifdef _WIN64
30739 static NTSTATUS thunk64_vkCmdSetScissorWithCountEXT(void *args)
30740 {
30741     struct vkCmdSetScissorWithCountEXT_params *params = args;
30742
30743     TRACE("%p, %u, %p\n", params->commandBuffer, params->scissorCount, params->pScissors);
30744
30745     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
30746     return STATUS_SUCCESS;
30747 }
30748 #endif /* _WIN64 */
30749
30750 static NTSTATUS thunk32_vkCmdSetScissorWithCountEXT(void *args)
30751 {
30752     struct
30753     {
30754         PTR32 commandBuffer;
30755         uint32_t scissorCount;
30756         PTR32 pScissors;
30757     } *params = args;
30758
30759     TRACE("%#x, %u, %#x\n", params->commandBuffer, params->scissorCount, params->pScissors);
30760
30761     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));
30762     return STATUS_SUCCESS;
30763 }
30764
30765 #ifdef _WIN64
30766 static NTSTATUS thunk64_vkCmdSetShadingRateImageEnableNV(void *args)
30767 {
30768     struct vkCmdSetShadingRateImageEnableNV_params *params = args;
30769
30770     TRACE("%p, %u\n", params->commandBuffer, params->shadingRateImageEnable);
30771
30772     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRateImageEnable);
30773     return STATUS_SUCCESS;
30774 }
30775 #endif /* _WIN64 */
30776
30777 static NTSTATUS thunk32_vkCmdSetShadingRateImageEnableNV(void *args)
30778 {
30779     struct
30780     {
30781         PTR32 commandBuffer;
30782         VkBool32 shadingRateImageEnable;
30783     } *params = args;
30784
30785     TRACE("%#x, %u\n", params->commandBuffer, params->shadingRateImageEnable);
30786
30787     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);
30788     return STATUS_SUCCESS;
30789 }
30790
30791 #ifdef _WIN64
30792 static NTSTATUS thunk64_vkCmdSetStencilCompareMask(void *args)
30793 {
30794     struct vkCmdSetStencilCompareMask_params *params = args;
30795
30796     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->compareMask);
30797
30798     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->compareMask);
30799     return STATUS_SUCCESS;
30800 }
30801 #endif /* _WIN64 */
30802
30803 static NTSTATUS thunk32_vkCmdSetStencilCompareMask(void *args)
30804 {
30805     struct
30806     {
30807         PTR32 commandBuffer;
30808         VkStencilFaceFlags faceMask;
30809         uint32_t compareMask;
30810     } *params = args;
30811
30812     TRACE("%#x, %#x, %u\n", params->commandBuffer, params->faceMask, params->compareMask);
30813
30814     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);
30815     return STATUS_SUCCESS;
30816 }
30817
30818 #ifdef _WIN64
30819 static NTSTATUS thunk64_vkCmdSetStencilOp(void *args)
30820 {
30821     struct vkCmdSetStencilOp_params *params = args;
30822
30823     TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
30824
30825     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);
30826     return STATUS_SUCCESS;
30827 }
30828 #endif /* _WIN64 */
30829
30830 static NTSTATUS thunk32_vkCmdSetStencilOp(void *args)
30831 {
30832     struct
30833     {
30834         PTR32 commandBuffer;
30835         VkStencilFaceFlags faceMask;
30836         VkStencilOp failOp;
30837         VkStencilOp passOp;
30838         VkStencilOp depthFailOp;
30839         VkCompareOp compareOp;
30840     } *params = args;
30841
30842     TRACE("%#x, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
30843
30844     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);
30845     return STATUS_SUCCESS;
30846 }
30847
30848 #ifdef _WIN64
30849 static NTSTATUS thunk64_vkCmdSetStencilOpEXT(void *args)
30850 {
30851     struct vkCmdSetStencilOpEXT_params *params = args;
30852
30853     TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
30854
30855     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);
30856     return STATUS_SUCCESS;
30857 }
30858 #endif /* _WIN64 */
30859
30860 static NTSTATUS thunk32_vkCmdSetStencilOpEXT(void *args)
30861 {
30862     struct
30863     {
30864         PTR32 commandBuffer;
30865         VkStencilFaceFlags faceMask;
30866         VkStencilOp failOp;
30867         VkStencilOp passOp;
30868         VkStencilOp depthFailOp;
30869         VkCompareOp compareOp;
30870     } *params = args;
30871
30872     TRACE("%#x, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
30873
30874     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);
30875     return STATUS_SUCCESS;
30876 }
30877
30878 #ifdef _WIN64
30879 static NTSTATUS thunk64_vkCmdSetStencilReference(void *args)
30880 {
30881     struct vkCmdSetStencilReference_params *params = args;
30882
30883     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->reference);
30884
30885     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->reference);
30886     return STATUS_SUCCESS;
30887 }
30888 #endif /* _WIN64 */
30889
30890 static NTSTATUS thunk32_vkCmdSetStencilReference(void *args)
30891 {
30892     struct
30893     {
30894         PTR32 commandBuffer;
30895         VkStencilFaceFlags faceMask;
30896         uint32_t reference;
30897     } *params = args;
30898
30899     TRACE("%#x, %#x, %u\n", params->commandBuffer, params->faceMask, params->reference);
30900
30901     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);
30902     return STATUS_SUCCESS;
30903 }
30904
30905 #ifdef _WIN64
30906 static NTSTATUS thunk64_vkCmdSetStencilTestEnable(void *args)
30907 {
30908     struct vkCmdSetStencilTestEnable_params *params = args;
30909
30910     TRACE("%p, %u\n", params->commandBuffer, params->stencilTestEnable);
30911
30912     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
30913     return STATUS_SUCCESS;
30914 }
30915 #endif /* _WIN64 */
30916
30917 static NTSTATUS thunk32_vkCmdSetStencilTestEnable(void *args)
30918 {
30919     struct
30920     {
30921         PTR32 commandBuffer;
30922         VkBool32 stencilTestEnable;
30923     } *params = args;
30924
30925     TRACE("%#x, %u\n", params->commandBuffer, params->stencilTestEnable);
30926
30927     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);
30928     return STATUS_SUCCESS;
30929 }
30930
30931 #ifdef _WIN64
30932 static NTSTATUS thunk64_vkCmdSetStencilTestEnableEXT(void *args)
30933 {
30934     struct vkCmdSetStencilTestEnableEXT_params *params = args;
30935
30936     TRACE("%p, %u\n", params->commandBuffer, params->stencilTestEnable);
30937
30938     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
30939     return STATUS_SUCCESS;
30940 }
30941 #endif /* _WIN64 */
30942
30943 static NTSTATUS thunk32_vkCmdSetStencilTestEnableEXT(void *args)
30944 {
30945     struct
30946     {
30947         PTR32 commandBuffer;
30948         VkBool32 stencilTestEnable;
30949     } *params = args;
30950
30951     TRACE("%#x, %u\n", params->commandBuffer, params->stencilTestEnable);
30952
30953     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);
30954     return STATUS_SUCCESS;
30955 }
30956
30957 #ifdef _WIN64
30958 static NTSTATUS thunk64_vkCmdSetStencilWriteMask(void *args)
30959 {
30960     struct vkCmdSetStencilWriteMask_params *params = args;
30961
30962     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->writeMask);
30963
30964     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
30965     return STATUS_SUCCESS;
30966 }
30967 #endif /* _WIN64 */
30968
30969 static NTSTATUS thunk32_vkCmdSetStencilWriteMask(void *args)
30970 {
30971     struct
30972     {
30973         PTR32 commandBuffer;
30974         VkStencilFaceFlags faceMask;
30975         uint32_t writeMask;
30976     } *params = args;
30977
30978     TRACE("%#x, %#x, %u\n", params->commandBuffer, params->faceMask, params->writeMask);
30979
30980     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);
30981     return STATUS_SUCCESS;
30982 }
30983
30984 #ifdef _WIN64
30985 static NTSTATUS thunk64_vkCmdSetTessellationDomainOriginEXT(void *args)
30986 {
30987     struct vkCmdSetTessellationDomainOriginEXT_params *params = args;
30988
30989     TRACE("%p, %#x\n", params->commandBuffer, params->domainOrigin);
30990
30991     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->domainOrigin);
30992     return STATUS_SUCCESS;
30993 }
30994 #endif /* _WIN64 */
30995
30996 static NTSTATUS thunk32_vkCmdSetTessellationDomainOriginEXT(void *args)
30997 {
30998     struct
30999     {
31000         PTR32 commandBuffer;
31001         VkTessellationDomainOrigin domainOrigin;
31002     } *params = args;
31003
31004     TRACE("%#x, %#x\n", params->commandBuffer, params->domainOrigin);
31005
31006     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);
31007     return STATUS_SUCCESS;
31008 }
31009
31010 #ifdef _WIN64
31011 static NTSTATUS thunk64_vkCmdSetVertexInputEXT(void *args)
31012 {
31013     struct vkCmdSetVertexInputEXT_params *params = args;
31014
31015     TRACE("%p, %u, %p, %u, %p\n", params->commandBuffer, params->vertexBindingDescriptionCount, params->pVertexBindingDescriptions, params->vertexAttributeDescriptionCount, params->pVertexAttributeDescriptions);
31016
31017     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);
31018     return STATUS_SUCCESS;
31019 }
31020 #endif /* _WIN64 */
31021
31022 static NTSTATUS thunk32_vkCmdSetVertexInputEXT(void *args)
31023 {
31024     struct
31025     {
31026         PTR32 commandBuffer;
31027         uint32_t vertexBindingDescriptionCount;
31028         PTR32 pVertexBindingDescriptions;
31029         uint32_t vertexAttributeDescriptionCount;
31030         PTR32 pVertexAttributeDescriptions;
31031     } *params = args;
31032     const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions_host;
31033     const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions_host;
31034     struct conversion_context ctx;
31035
31036     TRACE("%#x, %u, %#x, %u, %#x\n", params->commandBuffer, params->vertexBindingDescriptionCount, params->pVertexBindingDescriptions, params->vertexAttributeDescriptionCount, params->pVertexAttributeDescriptions);
31037
31038     init_conversion_context(&ctx);
31039     pVertexBindingDescriptions_host = convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(&ctx, (const VkVertexInputBindingDescription2EXT32 *)UlongToPtr(params->pVertexBindingDescriptions), params->vertexBindingDescriptionCount);
31040     pVertexAttributeDescriptions_host = convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(&ctx, (const VkVertexInputAttributeDescription2EXT32 *)UlongToPtr(params->pVertexAttributeDescriptions), params->vertexAttributeDescriptionCount);
31041     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);
31042     free_conversion_context(&ctx);
31043     return STATUS_SUCCESS;
31044 }
31045
31046 #ifdef _WIN64
31047 static NTSTATUS thunk64_vkCmdSetViewport(void *args)
31048 {
31049     struct vkCmdSetViewport_params *params = args;
31050
31051     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewports);
31052
31053     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);
31054     return STATUS_SUCCESS;
31055 }
31056 #endif /* _WIN64 */
31057
31058 static NTSTATUS thunk32_vkCmdSetViewport(void *args)
31059 {
31060     struct
31061     {
31062         PTR32 commandBuffer;
31063         uint32_t firstViewport;
31064         uint32_t viewportCount;
31065         PTR32 pViewports;
31066     } *params = args;
31067
31068     TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewports);
31069
31070     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));
31071     return STATUS_SUCCESS;
31072 }
31073
31074 #ifdef _WIN64
31075 static NTSTATUS thunk64_vkCmdSetViewportShadingRatePaletteNV(void *args)
31076 {
31077     struct vkCmdSetViewportShadingRatePaletteNV_params *params = args;
31078
31079     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pShadingRatePalettes);
31080
31081     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);
31082     return STATUS_SUCCESS;
31083 }
31084 #endif /* _WIN64 */
31085
31086 static NTSTATUS thunk32_vkCmdSetViewportShadingRatePaletteNV(void *args)
31087 {
31088     struct
31089     {
31090         PTR32 commandBuffer;
31091         uint32_t firstViewport;
31092         uint32_t viewportCount;
31093         PTR32 pShadingRatePalettes;
31094     } *params = args;
31095     const VkShadingRatePaletteNV *pShadingRatePalettes_host;
31096     struct conversion_context ctx;
31097
31098     TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pShadingRatePalettes);
31099
31100     init_conversion_context(&ctx);
31101     pShadingRatePalettes_host = convert_VkShadingRatePaletteNV_array_win32_to_host(&ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(params->pShadingRatePalettes), params->viewportCount);
31102     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);
31103     free_conversion_context(&ctx);
31104     return STATUS_SUCCESS;
31105 }
31106
31107 #ifdef _WIN64
31108 static NTSTATUS thunk64_vkCmdSetViewportSwizzleNV(void *args)
31109 {
31110     struct vkCmdSetViewportSwizzleNV_params *params = args;
31111
31112     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
31113
31114     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);
31115     return STATUS_SUCCESS;
31116 }
31117 #endif /* _WIN64 */
31118
31119 static NTSTATUS thunk32_vkCmdSetViewportSwizzleNV(void *args)
31120 {
31121     struct
31122     {
31123         PTR32 commandBuffer;
31124         uint32_t firstViewport;
31125         uint32_t viewportCount;
31126         PTR32 pViewportSwizzles;
31127     } *params = args;
31128
31129     TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
31130
31131     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));
31132     return STATUS_SUCCESS;
31133 }
31134
31135 #ifdef _WIN64
31136 static NTSTATUS thunk64_vkCmdSetViewportWScalingEnableNV(void *args)
31137 {
31138     struct vkCmdSetViewportWScalingEnableNV_params *params = args;
31139
31140     TRACE("%p, %u\n", params->commandBuffer, params->viewportWScalingEnable);
31141
31142     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportWScalingEnable);
31143     return STATUS_SUCCESS;
31144 }
31145 #endif /* _WIN64 */
31146
31147 static NTSTATUS thunk32_vkCmdSetViewportWScalingEnableNV(void *args)
31148 {
31149     struct
31150     {
31151         PTR32 commandBuffer;
31152         VkBool32 viewportWScalingEnable;
31153     } *params = args;
31154
31155     TRACE("%#x, %u\n", params->commandBuffer, params->viewportWScalingEnable);
31156
31157     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);
31158     return STATUS_SUCCESS;
31159 }
31160
31161 #ifdef _WIN64
31162 static NTSTATUS thunk64_vkCmdSetViewportWScalingNV(void *args)
31163 {
31164     struct vkCmdSetViewportWScalingNV_params *params = args;
31165
31166     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);
31167
31168     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);
31169     return STATUS_SUCCESS;
31170 }
31171 #endif /* _WIN64 */
31172
31173 static NTSTATUS thunk32_vkCmdSetViewportWScalingNV(void *args)
31174 {
31175     struct
31176     {
31177         PTR32 commandBuffer;
31178         uint32_t firstViewport;
31179         uint32_t viewportCount;
31180         PTR32 pViewportWScalings;
31181     } *params = args;
31182
31183     TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);
31184
31185     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));
31186     return STATUS_SUCCESS;
31187 }
31188
31189 #ifdef _WIN64
31190 static NTSTATUS thunk64_vkCmdSetViewportWithCount(void *args)
31191 {
31192     struct vkCmdSetViewportWithCount_params *params = args;
31193
31194     TRACE("%p, %u, %p\n", params->commandBuffer, params->viewportCount, params->pViewports);
31195
31196     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
31197     return STATUS_SUCCESS;
31198 }
31199 #endif /* _WIN64 */
31200
31201 static NTSTATUS thunk32_vkCmdSetViewportWithCount(void *args)
31202 {
31203     struct
31204     {
31205         PTR32 commandBuffer;
31206         uint32_t viewportCount;
31207         PTR32 pViewports;
31208     } *params = args;
31209
31210     TRACE("%#x, %u, %#x\n", params->commandBuffer, params->viewportCount, params->pViewports);
31211
31212     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));
31213     return STATUS_SUCCESS;
31214 }
31215
31216 #ifdef _WIN64
31217 static NTSTATUS thunk64_vkCmdSetViewportWithCountEXT(void *args)
31218 {
31219     struct vkCmdSetViewportWithCountEXT_params *params = args;
31220
31221     TRACE("%p, %u, %p\n", params->commandBuffer, params->viewportCount, params->pViewports);
31222
31223     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
31224     return STATUS_SUCCESS;
31225 }
31226 #endif /* _WIN64 */
31227
31228 static NTSTATUS thunk32_vkCmdSetViewportWithCountEXT(void *args)
31229 {
31230     struct
31231     {
31232         PTR32 commandBuffer;
31233         uint32_t viewportCount;
31234         PTR32 pViewports;
31235     } *params = args;
31236
31237     TRACE("%#x, %u, %#x\n", params->commandBuffer, params->viewportCount, params->pViewports);
31238
31239     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));
31240     return STATUS_SUCCESS;
31241 }
31242
31243 #ifdef _WIN64
31244 static NTSTATUS thunk64_vkCmdSubpassShadingHUAWEI(void *args)
31245 {
31246     struct vkCmdSubpassShadingHUAWEI_params *params = args;
31247
31248     TRACE("%p\n", params->commandBuffer);
31249
31250     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
31251     return STATUS_SUCCESS;
31252 }
31253 #endif /* _WIN64 */
31254
31255 static NTSTATUS thunk32_vkCmdSubpassShadingHUAWEI(void *args)
31256 {
31257     struct
31258     {
31259         PTR32 commandBuffer;
31260     } *params = args;
31261
31262     TRACE("%#x\n", params->commandBuffer);
31263
31264     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
31265     return STATUS_SUCCESS;
31266 }
31267
31268 #ifdef _WIN64
31269 static NTSTATUS thunk64_vkCmdTraceRaysIndirect2KHR(void *args)
31270 {
31271     struct vkCmdTraceRaysIndirect2KHR_params *params = args;
31272
31273     TRACE("%p, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectDeviceAddress));
31274
31275     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectDeviceAddress);
31276     return STATUS_SUCCESS;
31277 }
31278 #endif /* _WIN64 */
31279
31280 static NTSTATUS thunk32_vkCmdTraceRaysIndirect2KHR(void *args)
31281 {
31282     struct
31283     {
31284         PTR32 commandBuffer;
31285         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
31286     } *params = args;
31287
31288     TRACE("%#x, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectDeviceAddress));
31289
31290     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);
31291     return STATUS_SUCCESS;
31292 }
31293
31294 #ifdef _WIN64
31295 static NTSTATUS thunk64_vkCmdTraceRaysIndirectKHR(void *args)
31296 {
31297     struct vkCmdTraceRaysIndirectKHR_params *params = args;
31298
31299     TRACE("%p, %p, %p, %p, %p, 0x%s\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, wine_dbgstr_longlong(params->indirectDeviceAddress));
31300
31301     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);
31302     return STATUS_SUCCESS;
31303 }
31304 #endif /* _WIN64 */
31305
31306 static NTSTATUS thunk32_vkCmdTraceRaysIndirectKHR(void *args)
31307 {
31308     struct
31309     {
31310         PTR32 commandBuffer;
31311         PTR32 pRaygenShaderBindingTable;
31312         PTR32 pMissShaderBindingTable;
31313         PTR32 pHitShaderBindingTable;
31314         PTR32 pCallableShaderBindingTable;
31315         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
31316     } *params = args;
31317     VkStridedDeviceAddressRegionKHR pRaygenShaderBindingTable_host;
31318     VkStridedDeviceAddressRegionKHR pMissShaderBindingTable_host;
31319     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
31320     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;
31321
31322     TRACE("%#x, %#x, %#x, %#x, %#x, 0x%s\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, wine_dbgstr_longlong(params->indirectDeviceAddress));
31323
31324     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pRaygenShaderBindingTable), &pRaygenShaderBindingTable_host);
31325     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pMissShaderBindingTable), &pMissShaderBindingTable_host);
31326     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pHitShaderBindingTable), &pHitShaderBindingTable_host);
31327     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pCallableShaderBindingTable), &pCallableShaderBindingTable_host);
31328     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);
31329     return STATUS_SUCCESS;
31330 }
31331
31332 #ifdef _WIN64
31333 static NTSTATUS thunk64_vkCmdTraceRaysKHR(void *args)
31334 {
31335     struct vkCmdTraceRaysKHR_params *params = args;
31336
31337     TRACE("%p, %p, %p, %p, %p, %u, %u, %u\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, params->width, params->height, params->depth);
31338
31339     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);
31340     return STATUS_SUCCESS;
31341 }
31342 #endif /* _WIN64 */
31343
31344 static NTSTATUS thunk32_vkCmdTraceRaysKHR(void *args)
31345 {
31346     struct
31347     {
31348         PTR32 commandBuffer;
31349         PTR32 pRaygenShaderBindingTable;
31350         PTR32 pMissShaderBindingTable;
31351         PTR32 pHitShaderBindingTable;
31352         PTR32 pCallableShaderBindingTable;
31353         uint32_t width;
31354         uint32_t height;
31355         uint32_t depth;
31356     } *params = args;
31357     VkStridedDeviceAddressRegionKHR pRaygenShaderBindingTable_host;
31358     VkStridedDeviceAddressRegionKHR pMissShaderBindingTable_host;
31359     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
31360     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;
31361
31362     TRACE("%#x, %#x, %#x, %#x, %#x, %u, %u, %u\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, params->width, params->height, params->depth);
31363
31364     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pRaygenShaderBindingTable), &pRaygenShaderBindingTable_host);
31365     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pMissShaderBindingTable), &pMissShaderBindingTable_host);
31366     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pHitShaderBindingTable), &pHitShaderBindingTable_host);
31367     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pCallableShaderBindingTable), &pCallableShaderBindingTable_host);
31368     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);
31369     return STATUS_SUCCESS;
31370 }
31371
31372 #ifdef _WIN64
31373 static NTSTATUS thunk64_vkCmdTraceRaysNV(void *args)
31374 {
31375     struct vkCmdTraceRaysNV_params *params = args;
31376
31377     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->raygenShaderBindingTableBuffer), wine_dbgstr_longlong(params->raygenShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingTableBuffer), wine_dbgstr_longlong(params->missShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingStride), wine_dbgstr_longlong(params->hitShaderBindingTableBuffer), wine_dbgstr_longlong(params->hitShaderBindingOffset), wine_dbgstr_longlong(params->hitShaderBindingStride), wine_dbgstr_longlong(params->callableShaderBindingTableBuffer), wine_dbgstr_longlong(params->callableShaderBindingOffset), wine_dbgstr_longlong(params->callableShaderBindingStride), params->width, params->height, params->depth);
31378
31379     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);
31380     return STATUS_SUCCESS;
31381 }
31382 #endif /* _WIN64 */
31383
31384 static NTSTATUS thunk32_vkCmdTraceRaysNV(void *args)
31385 {
31386     struct
31387     {
31388         PTR32 commandBuffer;
31389         VkBuffer DECLSPEC_ALIGN(8) raygenShaderBindingTableBuffer;
31390         VkDeviceSize DECLSPEC_ALIGN(8) raygenShaderBindingOffset;
31391         VkBuffer DECLSPEC_ALIGN(8) missShaderBindingTableBuffer;
31392         VkDeviceSize DECLSPEC_ALIGN(8) missShaderBindingOffset;
31393         VkDeviceSize DECLSPEC_ALIGN(8) missShaderBindingStride;
31394         VkBuffer DECLSPEC_ALIGN(8) hitShaderBindingTableBuffer;
31395         VkDeviceSize DECLSPEC_ALIGN(8) hitShaderBindingOffset;
31396         VkDeviceSize DECLSPEC_ALIGN(8) hitShaderBindingStride;
31397         VkBuffer DECLSPEC_ALIGN(8) callableShaderBindingTableBuffer;
31398         VkDeviceSize DECLSPEC_ALIGN(8) callableShaderBindingOffset;
31399         VkDeviceSize DECLSPEC_ALIGN(8) callableShaderBindingStride;
31400         uint32_t width;
31401         uint32_t height;
31402         uint32_t depth;
31403     } *params = args;
31404
31405     TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->raygenShaderBindingTableBuffer), wine_dbgstr_longlong(params->raygenShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingTableBuffer), wine_dbgstr_longlong(params->missShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingStride), wine_dbgstr_longlong(params->hitShaderBindingTableBuffer), wine_dbgstr_longlong(params->hitShaderBindingOffset), wine_dbgstr_longlong(params->hitShaderBindingStride), wine_dbgstr_longlong(params->callableShaderBindingTableBuffer), wine_dbgstr_longlong(params->callableShaderBindingOffset), wine_dbgstr_longlong(params->callableShaderBindingStride), params->width, params->height, params->depth);
31406
31407     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);
31408     return STATUS_SUCCESS;
31409 }
31410
31411 #ifdef _WIN64
31412 static NTSTATUS thunk64_vkCmdUpdateBuffer(void *args)
31413 {
31414     struct vkCmdUpdateBuffer_params *params = args;
31415
31416     TRACE("%p, 0x%s, 0x%s, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->dataSize), params->pData);
31417
31418     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);
31419     return STATUS_SUCCESS;
31420 }
31421 #endif /* _WIN64 */
31422
31423 static NTSTATUS thunk32_vkCmdUpdateBuffer(void *args)
31424 {
31425     struct
31426     {
31427         PTR32 commandBuffer;
31428         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
31429         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
31430         VkDeviceSize DECLSPEC_ALIGN(8) dataSize;
31431         PTR32 pData;
31432     } *params = args;
31433
31434     TRACE("%#x, 0x%s, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->dataSize), params->pData);
31435
31436     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));
31437     return STATUS_SUCCESS;
31438 }
31439
31440 #ifdef _WIN64
31441 static NTSTATUS thunk64_vkCmdWaitEvents(void *args)
31442 {
31443     struct vkCmdWaitEvents_params *params = args;
31444
31445     TRACE("%p, %u, %p, %#x, %#x, %u, %p, %u, %p, %u, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
31446
31447     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);
31448     return STATUS_SUCCESS;
31449 }
31450 #endif /* _WIN64 */
31451
31452 static NTSTATUS thunk32_vkCmdWaitEvents(void *args)
31453 {
31454     struct
31455     {
31456         PTR32 commandBuffer;
31457         uint32_t eventCount;
31458         PTR32 pEvents;
31459         VkPipelineStageFlags srcStageMask;
31460         VkPipelineStageFlags dstStageMask;
31461         uint32_t memoryBarrierCount;
31462         PTR32 pMemoryBarriers;
31463         uint32_t bufferMemoryBarrierCount;
31464         PTR32 pBufferMemoryBarriers;
31465         uint32_t imageMemoryBarrierCount;
31466         PTR32 pImageMemoryBarriers;
31467     } *params = args;
31468     const VkMemoryBarrier *pMemoryBarriers_host;
31469     const VkBufferMemoryBarrier *pBufferMemoryBarriers_host;
31470     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
31471     struct conversion_context ctx;
31472
31473     TRACE("%#x, %u, %#x, %#x, %#x, %u, %#x, %u, %#x, %u, %#x\n", params->commandBuffer, params->eventCount, params->pEvents, params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
31474
31475     init_conversion_context(&ctx);
31476     pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(&ctx, (const VkMemoryBarrier32 *)UlongToPtr(params->pMemoryBarriers), params->memoryBarrierCount);
31477     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(&ctx, (const VkBufferMemoryBarrier32 *)UlongToPtr(params->pBufferMemoryBarriers), params->bufferMemoryBarrierCount);
31478     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(&ctx, (const VkImageMemoryBarrier32 *)UlongToPtr(params->pImageMemoryBarriers), params->imageMemoryBarrierCount);
31479     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);
31480     free_conversion_context(&ctx);
31481     return STATUS_SUCCESS;
31482 }
31483
31484 #ifdef _WIN64
31485 static NTSTATUS thunk64_vkCmdWaitEvents2(void *args)
31486 {
31487     struct vkCmdWaitEvents2_params *params = args;
31488
31489     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
31490
31491     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);
31492     return STATUS_SUCCESS;
31493 }
31494 #endif /* _WIN64 */
31495
31496 static NTSTATUS thunk32_vkCmdWaitEvents2(void *args)
31497 {
31498     struct
31499     {
31500         PTR32 commandBuffer;
31501         uint32_t eventCount;
31502         PTR32 pEvents;
31503         PTR32 pDependencyInfos;
31504     } *params = args;
31505     const VkDependencyInfo *pDependencyInfos_host;
31506     struct conversion_context ctx;
31507
31508     TRACE("%#x, %u, %#x, %#x\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
31509
31510     init_conversion_context(&ctx);
31511     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfos), params->eventCount);
31512     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);
31513     free_conversion_context(&ctx);
31514     return STATUS_SUCCESS;
31515 }
31516
31517 #ifdef _WIN64
31518 static NTSTATUS thunk64_vkCmdWaitEvents2KHR(void *args)
31519 {
31520     struct vkCmdWaitEvents2KHR_params *params = args;
31521
31522     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
31523
31524     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);
31525     return STATUS_SUCCESS;
31526 }
31527 #endif /* _WIN64 */
31528
31529 static NTSTATUS thunk32_vkCmdWaitEvents2KHR(void *args)
31530 {
31531     struct
31532     {
31533         PTR32 commandBuffer;
31534         uint32_t eventCount;
31535         PTR32 pEvents;
31536         PTR32 pDependencyInfos;
31537     } *params = args;
31538     const VkDependencyInfo *pDependencyInfos_host;
31539     struct conversion_context ctx;
31540
31541     TRACE("%#x, %u, %#x, %#x\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
31542
31543     init_conversion_context(&ctx);
31544     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfos), params->eventCount);
31545     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);
31546     free_conversion_context(&ctx);
31547     return STATUS_SUCCESS;
31548 }
31549
31550 #ifdef _WIN64
31551 static NTSTATUS thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
31552 {
31553     struct vkCmdWriteAccelerationStructuresPropertiesKHR_params *params = args;
31554
31555     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
31556
31557     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);
31558     return STATUS_SUCCESS;
31559 }
31560 #endif /* _WIN64 */
31561
31562 static NTSTATUS thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
31563 {
31564     struct
31565     {
31566         PTR32 commandBuffer;
31567         uint32_t accelerationStructureCount;
31568         PTR32 pAccelerationStructures;
31569         VkQueryType queryType;
31570         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
31571         uint32_t firstQuery;
31572     } *params = args;
31573
31574     TRACE("%#x, %u, %#x, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
31575
31576     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);
31577     return STATUS_SUCCESS;
31578 }
31579
31580 #ifdef _WIN64
31581 static NTSTATUS thunk64_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
31582 {
31583     struct vkCmdWriteAccelerationStructuresPropertiesNV_params *params = args;
31584
31585     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
31586
31587     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);
31588     return STATUS_SUCCESS;
31589 }
31590 #endif /* _WIN64 */
31591
31592 static NTSTATUS thunk32_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
31593 {
31594     struct
31595     {
31596         PTR32 commandBuffer;
31597         uint32_t accelerationStructureCount;
31598         PTR32 pAccelerationStructures;
31599         VkQueryType queryType;
31600         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
31601         uint32_t firstQuery;
31602     } *params = args;
31603
31604     TRACE("%#x, %u, %#x, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
31605
31606     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);
31607     return STATUS_SUCCESS;
31608 }
31609
31610 #ifdef _WIN64
31611 static NTSTATUS thunk64_vkCmdWriteBufferMarker2AMD(void *args)
31612 {
31613     struct vkCmdWriteBufferMarker2AMD_params *params = args;
31614
31615     TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);
31616
31617     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);
31618     return STATUS_SUCCESS;
31619 }
31620 #endif /* _WIN64 */
31621
31622 static NTSTATUS thunk32_vkCmdWriteBufferMarker2AMD(void *args)
31623 {
31624     struct
31625     {
31626         PTR32 commandBuffer;
31627         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
31628         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
31629         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
31630         uint32_t marker;
31631     } *params = args;
31632
31633     TRACE("%#x, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);
31634
31635     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);
31636     return STATUS_SUCCESS;
31637 }
31638
31639 #ifdef _WIN64
31640 static NTSTATUS thunk64_vkCmdWriteBufferMarkerAMD(void *args)
31641 {
31642     struct vkCmdWriteBufferMarkerAMD_params *params = args;
31643
31644     TRACE("%p, %#x, 0x%s, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);
31645
31646     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);
31647     return STATUS_SUCCESS;
31648 }
31649 #endif /* _WIN64 */
31650
31651 static NTSTATUS thunk32_vkCmdWriteBufferMarkerAMD(void *args)
31652 {
31653     struct
31654     {
31655         PTR32 commandBuffer;
31656         VkPipelineStageFlagBits pipelineStage;
31657         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
31658         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
31659         uint32_t marker;
31660     } *params = args;
31661
31662     TRACE("%#x, %#x, 0x%s, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);
31663
31664     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);
31665     return STATUS_SUCCESS;
31666 }
31667
31668 #ifdef _WIN64
31669 static NTSTATUS thunk64_vkCmdWriteMicromapsPropertiesEXT(void *args)
31670 {
31671     struct vkCmdWriteMicromapsPropertiesEXT_params *params = args;
31672
31673     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
31674
31675     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);
31676     return STATUS_SUCCESS;
31677 }
31678 #endif /* _WIN64 */
31679
31680 static NTSTATUS thunk32_vkCmdWriteMicromapsPropertiesEXT(void *args)
31681 {
31682     struct
31683     {
31684         PTR32 commandBuffer;
31685         uint32_t micromapCount;
31686         PTR32 pMicromaps;
31687         VkQueryType queryType;
31688         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
31689         uint32_t firstQuery;
31690     } *params = args;
31691
31692     TRACE("%#x, %u, %#x, %#x, 0x%s, %u\n", params->commandBuffer, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
31693
31694     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);
31695     return STATUS_SUCCESS;
31696 }
31697
31698 #ifdef _WIN64
31699 static NTSTATUS thunk64_vkCmdWriteTimestamp(void *args)
31700 {
31701     struct vkCmdWriteTimestamp_params *params = args;
31702
31703     TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->queryPool), params->query);
31704
31705     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);
31706     return STATUS_SUCCESS;
31707 }
31708 #endif /* _WIN64 */
31709
31710 static NTSTATUS thunk32_vkCmdWriteTimestamp(void *args)
31711 {
31712     struct
31713     {
31714         PTR32 commandBuffer;
31715         VkPipelineStageFlagBits pipelineStage;
31716         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
31717         uint32_t query;
31718     } *params = args;
31719
31720     TRACE("%#x, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->queryPool), params->query);
31721
31722     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);
31723     return STATUS_SUCCESS;
31724 }
31725
31726 #ifdef _WIN64
31727 static NTSTATUS thunk64_vkCmdWriteTimestamp2(void *args)
31728 {
31729     struct vkCmdWriteTimestamp2_params *params = args;
31730
31731     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
31732
31733     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);
31734     return STATUS_SUCCESS;
31735 }
31736 #endif /* _WIN64 */
31737
31738 static NTSTATUS thunk32_vkCmdWriteTimestamp2(void *args)
31739 {
31740     struct
31741     {
31742         PTR32 commandBuffer;
31743         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
31744         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
31745         uint32_t query;
31746     } *params = args;
31747
31748     TRACE("%#x, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
31749
31750     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);
31751     return STATUS_SUCCESS;
31752 }
31753
31754 #ifdef _WIN64
31755 static NTSTATUS thunk64_vkCmdWriteTimestamp2KHR(void *args)
31756 {
31757     struct vkCmdWriteTimestamp2KHR_params *params = args;
31758
31759     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
31760
31761     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);
31762     return STATUS_SUCCESS;
31763 }
31764 #endif /* _WIN64 */
31765
31766 static NTSTATUS thunk32_vkCmdWriteTimestamp2KHR(void *args)
31767 {
31768     struct
31769     {
31770         PTR32 commandBuffer;
31771         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
31772         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
31773         uint32_t query;
31774     } *params = args;
31775
31776     TRACE("%#x, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
31777
31778     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);
31779     return STATUS_SUCCESS;
31780 }
31781
31782 #ifdef _WIN64
31783 static NTSTATUS thunk64_vkCompileDeferredNV(void *args)
31784 {
31785     struct vkCompileDeferredNV_params *params = args;
31786
31787     TRACE("%p, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);
31788
31789     params->result = wine_device_from_handle(params->device)->funcs.p_vkCompileDeferredNV(wine_device_from_handle(params->device)->device, params->pipeline, params->shader);
31790     return STATUS_SUCCESS;
31791 }
31792 #endif /* _WIN64 */
31793
31794 static NTSTATUS thunk32_vkCompileDeferredNV(void *args)
31795 {
31796     struct
31797     {
31798         PTR32 device;
31799         VkPipeline DECLSPEC_ALIGN(8) pipeline;
31800         uint32_t shader;
31801         VkResult result;
31802     } *params = args;
31803
31804     TRACE("%#x, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);
31805
31806     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);
31807     return STATUS_SUCCESS;
31808 }
31809
31810 #ifdef _WIN64
31811 static NTSTATUS thunk64_vkCopyAccelerationStructureKHR(void *args)
31812 {
31813     struct vkCopyAccelerationStructureKHR_params *params = args;
31814
31815     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
31816
31817     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
31818     return STATUS_SUCCESS;
31819 }
31820 #endif /* _WIN64 */
31821
31822 static NTSTATUS thunk32_vkCopyAccelerationStructureKHR(void *args)
31823 {
31824     struct
31825     {
31826         PTR32 device;
31827         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
31828         PTR32 pInfo;
31829         VkResult result;
31830     } *params = args;
31831     VkCopyAccelerationStructureInfoKHR pInfo_host;
31832
31833     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
31834
31835     convert_VkCopyAccelerationStructureInfoKHR_win32_to_host((const VkCopyAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
31836     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
31837     return STATUS_SUCCESS;
31838 }
31839
31840 #ifdef _WIN64
31841 static NTSTATUS thunk64_vkCopyAccelerationStructureToMemoryKHR(void *args)
31842 {
31843     struct vkCopyAccelerationStructureToMemoryKHR_params *params = args;
31844
31845     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
31846
31847     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
31848     return STATUS_SUCCESS;
31849 }
31850 #endif /* _WIN64 */
31851
31852 static NTSTATUS thunk32_vkCopyAccelerationStructureToMemoryKHR(void *args)
31853 {
31854     struct
31855     {
31856         PTR32 device;
31857         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
31858         PTR32 pInfo;
31859         VkResult result;
31860     } *params = args;
31861     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;
31862
31863     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
31864
31865     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host((const VkCopyAccelerationStructureToMemoryInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
31866     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
31867     return STATUS_SUCCESS;
31868 }
31869
31870 #ifdef _WIN64
31871 static NTSTATUS thunk64_vkCopyMemoryToAccelerationStructureKHR(void *args)
31872 {
31873     struct vkCopyMemoryToAccelerationStructureKHR_params *params = args;
31874
31875     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
31876
31877     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
31878     return STATUS_SUCCESS;
31879 }
31880 #endif /* _WIN64 */
31881
31882 static NTSTATUS thunk32_vkCopyMemoryToAccelerationStructureKHR(void *args)
31883 {
31884     struct
31885     {
31886         PTR32 device;
31887         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
31888         PTR32 pInfo;
31889         VkResult result;
31890     } *params = args;
31891     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;
31892
31893     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
31894
31895     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host((const VkCopyMemoryToAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
31896     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
31897     return STATUS_SUCCESS;
31898 }
31899
31900 #ifdef _WIN64
31901 static NTSTATUS thunk64_vkCopyMemoryToMicromapEXT(void *args)
31902 {
31903     struct vkCopyMemoryToMicromapEXT_params *params = args;
31904
31905     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
31906
31907     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
31908     return STATUS_SUCCESS;
31909 }
31910 #endif /* _WIN64 */
31911
31912 static NTSTATUS thunk32_vkCopyMemoryToMicromapEXT(void *args)
31913 {
31914     struct
31915     {
31916         PTR32 device;
31917         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
31918         PTR32 pInfo;
31919         VkResult result;
31920     } *params = args;
31921     VkCopyMemoryToMicromapInfoEXT pInfo_host;
31922
31923     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
31924
31925     convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host((const VkCopyMemoryToMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
31926     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMemoryToMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
31927     return STATUS_SUCCESS;
31928 }
31929
31930 #ifdef _WIN64
31931 static NTSTATUS thunk64_vkCopyMicromapEXT(void *args)
31932 {
31933     struct vkCopyMicromapEXT_params *params = args;
31934
31935     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
31936
31937     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
31938     return STATUS_SUCCESS;
31939 }
31940 #endif /* _WIN64 */
31941
31942 static NTSTATUS thunk32_vkCopyMicromapEXT(void *args)
31943 {
31944     struct
31945     {
31946         PTR32 device;
31947         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
31948         PTR32 pInfo;
31949         VkResult result;
31950     } *params = args;
31951     VkCopyMicromapInfoEXT pInfo_host;
31952
31953     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
31954
31955     convert_VkCopyMicromapInfoEXT_win32_to_host((const VkCopyMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
31956     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
31957     return STATUS_SUCCESS;
31958 }
31959
31960 #ifdef _WIN64
31961 static NTSTATUS thunk64_vkCopyMicromapToMemoryEXT(void *args)
31962 {
31963     struct vkCopyMicromapToMemoryEXT_params *params = args;
31964
31965     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
31966
31967     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapToMemoryEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
31968     return STATUS_SUCCESS;
31969 }
31970 #endif /* _WIN64 */
31971
31972 static NTSTATUS thunk32_vkCopyMicromapToMemoryEXT(void *args)
31973 {
31974     struct
31975     {
31976         PTR32 device;
31977         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
31978         PTR32 pInfo;
31979         VkResult result;
31980     } *params = args;
31981     VkCopyMicromapToMemoryInfoEXT pInfo_host;
31982
31983     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
31984
31985     convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host((const VkCopyMicromapToMemoryInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
31986     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMicromapToMemoryEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
31987     return STATUS_SUCCESS;
31988 }
31989
31990 #ifdef _WIN64
31991 static NTSTATUS thunk64_vkCreateAccelerationStructureKHR(void *args)
31992 {
31993     struct vkCreateAccelerationStructureKHR_params *params = args;
31994
31995     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
31996
31997     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
31998     return STATUS_SUCCESS;
31999 }
32000 #endif /* _WIN64 */
32001
32002 static NTSTATUS thunk32_vkCreateAccelerationStructureKHR(void *args)
32003 {
32004     struct
32005     {
32006         PTR32 device;
32007         PTR32 pCreateInfo;
32008         PTR32 pAllocator;
32009         PTR32 pAccelerationStructure;
32010         VkResult result;
32011     } *params = args;
32012     VkAccelerationStructureCreateInfoKHR pCreateInfo_host;
32013     struct conversion_context ctx;
32014
32015     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32016
32017     init_conversion_context(&ctx);
32018     convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(&ctx, (const VkAccelerationStructureCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32019     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));
32020     free_conversion_context(&ctx);
32021     return STATUS_SUCCESS;
32022 }
32023
32024 #ifdef _WIN64
32025 static NTSTATUS thunk64_vkCreateAccelerationStructureNV(void *args)
32026 {
32027     struct vkCreateAccelerationStructureNV_params *params = args;
32028
32029     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32030
32031     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
32032     return STATUS_SUCCESS;
32033 }
32034 #endif /* _WIN64 */
32035
32036 static NTSTATUS thunk32_vkCreateAccelerationStructureNV(void *args)
32037 {
32038     struct
32039     {
32040         PTR32 device;
32041         PTR32 pCreateInfo;
32042         PTR32 pAllocator;
32043         PTR32 pAccelerationStructure;
32044         VkResult result;
32045     } *params = args;
32046     VkAccelerationStructureCreateInfoNV pCreateInfo_host;
32047     struct conversion_context ctx;
32048
32049     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
32050
32051     init_conversion_context(&ctx);
32052     convert_VkAccelerationStructureCreateInfoNV_win32_to_host(&ctx, (const VkAccelerationStructureCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32053     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));
32054     free_conversion_context(&ctx);
32055     return STATUS_SUCCESS;
32056 }
32057
32058 #ifdef _WIN64
32059 static NTSTATUS thunk64_vkCreateBuffer(void *args)
32060 {
32061     struct vkCreateBuffer_params *params = args;
32062
32063     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
32064
32065     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBuffer(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pBuffer);
32066     return STATUS_SUCCESS;
32067 }
32068 #endif /* _WIN64 */
32069
32070 static NTSTATUS thunk32_vkCreateBuffer(void *args)
32071 {
32072     struct
32073     {
32074         PTR32 device;
32075         PTR32 pCreateInfo;
32076         PTR32 pAllocator;
32077         PTR32 pBuffer;
32078         VkResult result;
32079     } *params = args;
32080     VkBufferCreateInfo pCreateInfo_host;
32081     struct conversion_context ctx;
32082
32083     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
32084
32085     init_conversion_context(&ctx);
32086     convert_VkBufferCreateInfo_win32_to_host(&ctx, (const VkBufferCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32087     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateBuffer(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkBuffer *)UlongToPtr(params->pBuffer));
32088     free_conversion_context(&ctx);
32089     return STATUS_SUCCESS;
32090 }
32091
32092 #ifdef _WIN64
32093 static NTSTATUS thunk64_vkCreateBufferView(void *args)
32094 {
32095     struct vkCreateBufferView_params *params = args;
32096
32097     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
32098
32099     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBufferView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
32100     return STATUS_SUCCESS;
32101 }
32102 #endif /* _WIN64 */
32103
32104 static NTSTATUS thunk32_vkCreateBufferView(void *args)
32105 {
32106     struct
32107     {
32108         PTR32 device;
32109         PTR32 pCreateInfo;
32110         PTR32 pAllocator;
32111         PTR32 pView;
32112         VkResult result;
32113     } *params = args;
32114     VkBufferViewCreateInfo pCreateInfo_host;
32115
32116     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
32117
32118     convert_VkBufferViewCreateInfo_win32_to_host((const VkBufferViewCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32119     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));
32120     return STATUS_SUCCESS;
32121 }
32122
32123 #ifdef _WIN64
32124 static NTSTATUS thunk64_vkCreateCommandPool(void *args)
32125 {
32126     struct vkCreateCommandPool_params *params = args;
32127
32128     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);
32129
32130     params->result = wine_vkCreateCommandPool(params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool, params->client_ptr);
32131     return STATUS_SUCCESS;
32132 }
32133 #endif /* _WIN64 */
32134
32135 static NTSTATUS thunk32_vkCreateCommandPool(void *args)
32136 {
32137     struct
32138     {
32139         PTR32 device;
32140         PTR32 pCreateInfo;
32141         PTR32 pAllocator;
32142         PTR32 pCommandPool;
32143         PTR32 client_ptr;
32144         VkResult result;
32145     } *params = args;
32146     VkCommandPoolCreateInfo pCreateInfo_host;
32147
32148     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);
32149
32150     convert_VkCommandPoolCreateInfo_win32_to_host((const VkCommandPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32151     params->result = wine_vkCreateCommandPool((VkDevice)UlongToPtr(params->device), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkCommandPool *)UlongToPtr(params->pCommandPool), UlongToPtr(params->client_ptr));
32152     return STATUS_SUCCESS;
32153 }
32154
32155 #ifdef _WIN64
32156 static NTSTATUS thunk64_vkCreateComputePipelines(void *args)
32157 {
32158     struct vkCreateComputePipelines_params *params = args;
32159     const VkComputePipelineCreateInfo *pCreateInfos_host;
32160     struct conversion_context ctx;
32161
32162     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
32163
32164     init_conversion_context(&ctx);
32165     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
32166     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);
32167     free_conversion_context(&ctx);
32168     return STATUS_SUCCESS;
32169 }
32170 #endif /* _WIN64 */
32171
32172 static NTSTATUS thunk32_vkCreateComputePipelines(void *args)
32173 {
32174     struct
32175     {
32176         PTR32 device;
32177         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
32178         uint32_t createInfoCount;
32179         PTR32 pCreateInfos;
32180         PTR32 pAllocator;
32181         PTR32 pPipelines;
32182         VkResult result;
32183     } *params = args;
32184     const VkComputePipelineCreateInfo *pCreateInfos_host;
32185     struct conversion_context ctx;
32186
32187     TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
32188
32189     init_conversion_context(&ctx);
32190     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win32_to_host(&ctx, (const VkComputePipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
32191     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));
32192     convert_VkComputePipelineCreateInfo_array_host_to_win32(pCreateInfos_host, (const VkComputePipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
32193     free_conversion_context(&ctx);
32194     return STATUS_SUCCESS;
32195 }
32196
32197 #ifdef _WIN64
32198 static NTSTATUS thunk64_vkCreateCuFunctionNVX(void *args)
32199 {
32200     struct vkCreateCuFunctionNVX_params *params = args;
32201
32202     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);
32203
32204     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFunction);
32205     return STATUS_SUCCESS;
32206 }
32207 #endif /* _WIN64 */
32208
32209 static NTSTATUS thunk32_vkCreateCuFunctionNVX(void *args)
32210 {
32211     struct
32212     {
32213         PTR32 device;
32214         PTR32 pCreateInfo;
32215         PTR32 pAllocator;
32216         PTR32 pFunction;
32217         VkResult result;
32218     } *params = args;
32219     VkCuFunctionCreateInfoNVX pCreateInfo_host;
32220
32221     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);
32222
32223     convert_VkCuFunctionCreateInfoNVX_win32_to_host((const VkCuFunctionCreateInfoNVX32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32224     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));
32225     return STATUS_SUCCESS;
32226 }
32227
32228 #ifdef _WIN64
32229 static NTSTATUS thunk64_vkCreateCuModuleNVX(void *args)
32230 {
32231     struct vkCreateCuModuleNVX_params *params = args;
32232
32233     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);
32234
32235     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pModule);
32236     return STATUS_SUCCESS;
32237 }
32238 #endif /* _WIN64 */
32239
32240 static NTSTATUS thunk32_vkCreateCuModuleNVX(void *args)
32241 {
32242     struct
32243     {
32244         PTR32 device;
32245         PTR32 pCreateInfo;
32246         PTR32 pAllocator;
32247         PTR32 pModule;
32248         VkResult result;
32249     } *params = args;
32250     VkCuModuleCreateInfoNVX pCreateInfo_host;
32251
32252     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);
32253
32254     convert_VkCuModuleCreateInfoNVX_win32_to_host((const VkCuModuleCreateInfoNVX32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32255     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));
32256     return STATUS_SUCCESS;
32257 }
32258
32259 #ifdef _WIN64
32260 static NTSTATUS thunk64_vkCreateDebugReportCallbackEXT(void *args)
32261 {
32262     struct vkCreateDebugReportCallbackEXT_params *params = args;
32263
32264     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
32265
32266     params->result = wine_vkCreateDebugReportCallbackEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
32267     return STATUS_SUCCESS;
32268 }
32269 #endif /* _WIN64 */
32270
32271 static NTSTATUS thunk32_vkCreateDebugReportCallbackEXT(void *args)
32272 {
32273     struct
32274     {
32275         PTR32 instance;
32276         PTR32 pCreateInfo;
32277         PTR32 pAllocator;
32278         PTR32 pCallback;
32279         VkResult result;
32280     } *params = args;
32281     VkDebugReportCallbackCreateInfoEXT pCreateInfo_host;
32282
32283     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
32284
32285     convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host((const VkDebugReportCallbackCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32286     params->result = wine_vkCreateDebugReportCallbackEXT((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDebugReportCallbackEXT *)UlongToPtr(params->pCallback));
32287     return STATUS_SUCCESS;
32288 }
32289
32290 #ifdef _WIN64
32291 static NTSTATUS thunk64_vkCreateDebugUtilsMessengerEXT(void *args)
32292 {
32293     struct vkCreateDebugUtilsMessengerEXT_params *params = args;
32294
32295     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
32296
32297     params->result = wine_vkCreateDebugUtilsMessengerEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
32298     return STATUS_SUCCESS;
32299 }
32300 #endif /* _WIN64 */
32301
32302 static NTSTATUS thunk32_vkCreateDebugUtilsMessengerEXT(void *args)
32303 {
32304     struct
32305     {
32306         PTR32 instance;
32307         PTR32 pCreateInfo;
32308         PTR32 pAllocator;
32309         PTR32 pMessenger;
32310         VkResult result;
32311     } *params = args;
32312     VkDebugUtilsMessengerCreateInfoEXT pCreateInfo_host;
32313
32314     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
32315
32316     convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host((const VkDebugUtilsMessengerCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32317     params->result = wine_vkCreateDebugUtilsMessengerEXT((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDebugUtilsMessengerEXT *)UlongToPtr(params->pMessenger));
32318     return STATUS_SUCCESS;
32319 }
32320
32321 #ifdef _WIN64
32322 static NTSTATUS thunk64_vkCreateDeferredOperationKHR(void *args)
32323 {
32324     struct vkCreateDeferredOperationKHR_params *params = args;
32325
32326     TRACE("%p, %p, %p\n", params->device, params->pAllocator, params->pDeferredOperation);
32327
32328     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDeferredOperationKHR(wine_device_from_handle(params->device)->device, NULL, params->pDeferredOperation);
32329     return STATUS_SUCCESS;
32330 }
32331 #endif /* _WIN64 */
32332
32333 static NTSTATUS thunk32_vkCreateDeferredOperationKHR(void *args)
32334 {
32335     struct
32336     {
32337         PTR32 device;
32338         PTR32 pAllocator;
32339         PTR32 pDeferredOperation;
32340         VkResult result;
32341     } *params = args;
32342
32343     TRACE("%#x, %#x, %#x\n", params->device, params->pAllocator, params->pDeferredOperation);
32344
32345     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateDeferredOperationKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, NULL, (VkDeferredOperationKHR *)UlongToPtr(params->pDeferredOperation));
32346     return STATUS_SUCCESS;
32347 }
32348
32349 #ifdef _WIN64
32350 static NTSTATUS thunk64_vkCreateDescriptorPool(void *args)
32351 {
32352     struct vkCreateDescriptorPool_params *params = args;
32353
32354     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);
32355
32356     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorPool);
32357     return STATUS_SUCCESS;
32358 }
32359 #endif /* _WIN64 */
32360
32361 static NTSTATUS thunk32_vkCreateDescriptorPool(void *args)
32362 {
32363     struct
32364     {
32365         PTR32 device;
32366         PTR32 pCreateInfo;
32367         PTR32 pAllocator;
32368         PTR32 pDescriptorPool;
32369         VkResult result;
32370     } *params = args;
32371     VkDescriptorPoolCreateInfo pCreateInfo_host;
32372     struct conversion_context ctx;
32373
32374     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);
32375
32376     init_conversion_context(&ctx);
32377     convert_VkDescriptorPoolCreateInfo_win32_to_host(&ctx, (const VkDescriptorPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32378     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));
32379     free_conversion_context(&ctx);
32380     return STATUS_SUCCESS;
32381 }
32382
32383 #ifdef _WIN64
32384 static NTSTATUS thunk64_vkCreateDescriptorSetLayout(void *args)
32385 {
32386     struct vkCreateDescriptorSetLayout_params *params = args;
32387
32388     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);
32389
32390     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSetLayout);
32391     return STATUS_SUCCESS;
32392 }
32393 #endif /* _WIN64 */
32394
32395 static NTSTATUS thunk32_vkCreateDescriptorSetLayout(void *args)
32396 {
32397     struct
32398     {
32399         PTR32 device;
32400         PTR32 pCreateInfo;
32401         PTR32 pAllocator;
32402         PTR32 pSetLayout;
32403         VkResult result;
32404     } *params = args;
32405     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
32406     struct conversion_context ctx;
32407
32408     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);
32409
32410     init_conversion_context(&ctx);
32411     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32412     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));
32413     free_conversion_context(&ctx);
32414     return STATUS_SUCCESS;
32415 }
32416
32417 #ifdef _WIN64
32418 static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplate(void *args)
32419 {
32420     struct vkCreateDescriptorUpdateTemplate_params *params = args;
32421
32422     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
32423
32424     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
32425     return STATUS_SUCCESS;
32426 }
32427 #endif /* _WIN64 */
32428
32429 static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplate(void *args)
32430 {
32431     struct
32432     {
32433         PTR32 device;
32434         PTR32 pCreateInfo;
32435         PTR32 pAllocator;
32436         PTR32 pDescriptorUpdateTemplate;
32437         VkResult result;
32438     } *params = args;
32439     VkDescriptorUpdateTemplateCreateInfo pCreateInfo_host;
32440     struct conversion_context ctx;
32441
32442     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
32443
32444     init_conversion_context(&ctx);
32445     convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(&ctx, (const VkDescriptorUpdateTemplateCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32446     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));
32447     free_conversion_context(&ctx);
32448     return STATUS_SUCCESS;
32449 }
32450
32451 #ifdef _WIN64
32452 static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplateKHR(void *args)
32453 {
32454     struct vkCreateDescriptorUpdateTemplateKHR_params *params = args;
32455
32456     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
32457
32458     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
32459     return STATUS_SUCCESS;
32460 }
32461 #endif /* _WIN64 */
32462
32463 static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplateKHR(void *args)
32464 {
32465     struct
32466     {
32467         PTR32 device;
32468         PTR32 pCreateInfo;
32469         PTR32 pAllocator;
32470         PTR32 pDescriptorUpdateTemplate;
32471         VkResult result;
32472     } *params = args;
32473     VkDescriptorUpdateTemplateCreateInfo pCreateInfo_host;
32474     struct conversion_context ctx;
32475
32476     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
32477
32478     init_conversion_context(&ctx);
32479     convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(&ctx, (const VkDescriptorUpdateTemplateCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32480     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));
32481     free_conversion_context(&ctx);
32482     return STATUS_SUCCESS;
32483 }
32484
32485 #ifdef _WIN64
32486 static NTSTATUS thunk64_vkCreateDevice(void *args)
32487 {
32488     struct vkCreateDevice_params *params = args;
32489     VkDeviceCreateInfo pCreateInfo_host;
32490     struct conversion_context ctx;
32491
32492     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);
32493
32494     init_conversion_context(&ctx);
32495     convert_VkDeviceCreateInfo_win64_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
32496     params->result = wine_vkCreateDevice(params->physicalDevice, &pCreateInfo_host, params->pAllocator, params->pDevice, params->client_ptr);
32497     free_conversion_context(&ctx);
32498     return STATUS_SUCCESS;
32499 }
32500 #endif /* _WIN64 */
32501
32502 static NTSTATUS thunk32_vkCreateDevice(void *args)
32503 {
32504     struct
32505     {
32506         PTR32 physicalDevice;
32507         PTR32 pCreateInfo;
32508         PTR32 pAllocator;
32509         PTR32 pDevice;
32510         PTR32 client_ptr;
32511         VkResult result;
32512     } *params = args;
32513     VkDeviceCreateInfo pCreateInfo_host;
32514     VkDevice pDevice_host;
32515     struct conversion_context ctx;
32516
32517     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);
32518
32519     init_conversion_context(&ctx);
32520     convert_VkDeviceCreateInfo_win32_to_host(&ctx, (const VkDeviceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32521     pDevice_host = *(VkDevice *)UlongToPtr(params->pDevice);
32522     params->result = wine_vkCreateDevice((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), &pDevice_host, UlongToPtr(params->client_ptr));
32523     *(VkDevice *)UlongToPtr(params->pDevice) = pDevice_host;
32524     free_conversion_context(&ctx);
32525     return STATUS_SUCCESS;
32526 }
32527
32528 #ifdef _WIN64
32529 static NTSTATUS thunk64_vkCreateEvent(void *args)
32530 {
32531     struct vkCreateEvent_params *params = args;
32532
32533     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);
32534
32535     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateEvent(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pEvent);
32536     return STATUS_SUCCESS;
32537 }
32538 #endif /* _WIN64 */
32539
32540 static NTSTATUS thunk32_vkCreateEvent(void *args)
32541 {
32542     struct
32543     {
32544         PTR32 device;
32545         PTR32 pCreateInfo;
32546         PTR32 pAllocator;
32547         PTR32 pEvent;
32548         VkResult result;
32549     } *params = args;
32550     VkEventCreateInfo pCreateInfo_host;
32551
32552     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);
32553
32554     convert_VkEventCreateInfo_win32_to_host((const VkEventCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32555     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));
32556     return STATUS_SUCCESS;
32557 }
32558
32559 #ifdef _WIN64
32560 static NTSTATUS thunk64_vkCreateFence(void *args)
32561 {
32562     struct vkCreateFence_params *params = args;
32563
32564     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);
32565
32566     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFence(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFence);
32567     return STATUS_SUCCESS;
32568 }
32569 #endif /* _WIN64 */
32570
32571 static NTSTATUS thunk32_vkCreateFence(void *args)
32572 {
32573     struct
32574     {
32575         PTR32 device;
32576         PTR32 pCreateInfo;
32577         PTR32 pAllocator;
32578         PTR32 pFence;
32579         VkResult result;
32580     } *params = args;
32581     VkFenceCreateInfo pCreateInfo_host;
32582     struct conversion_context ctx;
32583
32584     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);
32585
32586     init_conversion_context(&ctx);
32587     convert_VkFenceCreateInfo_win32_to_host(&ctx, (const VkFenceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32588     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));
32589     free_conversion_context(&ctx);
32590     return STATUS_SUCCESS;
32591 }
32592
32593 #ifdef _WIN64
32594 static NTSTATUS thunk64_vkCreateFramebuffer(void *args)
32595 {
32596     struct vkCreateFramebuffer_params *params = args;
32597
32598     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);
32599
32600     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFramebuffer(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFramebuffer);
32601     return STATUS_SUCCESS;
32602 }
32603 #endif /* _WIN64 */
32604
32605 static NTSTATUS thunk32_vkCreateFramebuffer(void *args)
32606 {
32607     struct
32608     {
32609         PTR32 device;
32610         PTR32 pCreateInfo;
32611         PTR32 pAllocator;
32612         PTR32 pFramebuffer;
32613         VkResult result;
32614     } *params = args;
32615     VkFramebufferCreateInfo pCreateInfo_host;
32616     struct conversion_context ctx;
32617
32618     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);
32619
32620     init_conversion_context(&ctx);
32621     convert_VkFramebufferCreateInfo_win32_to_host(&ctx, (const VkFramebufferCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32622     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));
32623     free_conversion_context(&ctx);
32624     return STATUS_SUCCESS;
32625 }
32626
32627 #ifdef _WIN64
32628 static NTSTATUS thunk64_vkCreateGraphicsPipelines(void *args)
32629 {
32630     struct vkCreateGraphicsPipelines_params *params = args;
32631     const VkGraphicsPipelineCreateInfo *pCreateInfos_host;
32632     struct conversion_context ctx;
32633
32634     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
32635
32636     init_conversion_context(&ctx);
32637     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
32638     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);
32639     free_conversion_context(&ctx);
32640     return STATUS_SUCCESS;
32641 }
32642 #endif /* _WIN64 */
32643
32644 static NTSTATUS thunk32_vkCreateGraphicsPipelines(void *args)
32645 {
32646     struct
32647     {
32648         PTR32 device;
32649         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
32650         uint32_t createInfoCount;
32651         PTR32 pCreateInfos;
32652         PTR32 pAllocator;
32653         PTR32 pPipelines;
32654         VkResult result;
32655     } *params = args;
32656     const VkGraphicsPipelineCreateInfo *pCreateInfos_host;
32657     struct conversion_context ctx;
32658
32659     TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
32660
32661     init_conversion_context(&ctx);
32662     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(&ctx, (const VkGraphicsPipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
32663     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));
32664     convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(pCreateInfos_host, (const VkGraphicsPipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
32665     free_conversion_context(&ctx);
32666     return STATUS_SUCCESS;
32667 }
32668
32669 #ifdef _WIN64
32670 static NTSTATUS thunk64_vkCreateImage(void *args)
32671 {
32672     struct vkCreateImage_params *params = args;
32673
32674     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);
32675
32676     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImage(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pImage);
32677     return STATUS_SUCCESS;
32678 }
32679 #endif /* _WIN64 */
32680
32681 static NTSTATUS thunk32_vkCreateImage(void *args)
32682 {
32683     struct
32684     {
32685         PTR32 device;
32686         PTR32 pCreateInfo;
32687         PTR32 pAllocator;
32688         PTR32 pImage;
32689         VkResult result;
32690     } *params = args;
32691     VkImageCreateInfo pCreateInfo_host;
32692     struct conversion_context ctx;
32693
32694     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);
32695
32696     init_conversion_context(&ctx);
32697     convert_VkImageCreateInfo_win32_to_host(&ctx, (const VkImageCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32698     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateImage(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkImage *)UlongToPtr(params->pImage));
32699     free_conversion_context(&ctx);
32700     return STATUS_SUCCESS;
32701 }
32702
32703 #ifdef _WIN64
32704 static NTSTATUS thunk64_vkCreateImageView(void *args)
32705 {
32706     struct vkCreateImageView_params *params = args;
32707
32708     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
32709
32710     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImageView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
32711     return STATUS_SUCCESS;
32712 }
32713 #endif /* _WIN64 */
32714
32715 static NTSTATUS thunk32_vkCreateImageView(void *args)
32716 {
32717     struct
32718     {
32719         PTR32 device;
32720         PTR32 pCreateInfo;
32721         PTR32 pAllocator;
32722         PTR32 pView;
32723         VkResult result;
32724     } *params = args;
32725     VkImageViewCreateInfo pCreateInfo_host;
32726     struct conversion_context ctx;
32727
32728     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
32729
32730     init_conversion_context(&ctx);
32731     convert_VkImageViewCreateInfo_win32_to_host(&ctx, (const VkImageViewCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32732     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));
32733     free_conversion_context(&ctx);
32734     return STATUS_SUCCESS;
32735 }
32736
32737 #ifdef _WIN64
32738 static NTSTATUS thunk64_vkCreateIndirectCommandsLayoutNV(void *args)
32739 {
32740     struct vkCreateIndirectCommandsLayoutNV_params *params = args;
32741
32742     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
32743
32744     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pIndirectCommandsLayout);
32745     return STATUS_SUCCESS;
32746 }
32747 #endif /* _WIN64 */
32748
32749 static NTSTATUS thunk32_vkCreateIndirectCommandsLayoutNV(void *args)
32750 {
32751     struct
32752     {
32753         PTR32 device;
32754         PTR32 pCreateInfo;
32755         PTR32 pAllocator;
32756         PTR32 pIndirectCommandsLayout;
32757         VkResult result;
32758     } *params = args;
32759     VkIndirectCommandsLayoutCreateInfoNV pCreateInfo_host;
32760     struct conversion_context ctx;
32761
32762     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
32763
32764     init_conversion_context(&ctx);
32765     convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(&ctx, (const VkIndirectCommandsLayoutCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32766     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));
32767     free_conversion_context(&ctx);
32768     return STATUS_SUCCESS;
32769 }
32770
32771 #ifdef _WIN64
32772 static NTSTATUS thunk64_vkCreateInstance(void *args)
32773 {
32774     struct vkCreateInstance_params *params = args;
32775     VkInstanceCreateInfo pCreateInfo_host;
32776     struct conversion_context ctx;
32777
32778     TRACE("%p, %p, %p\n", params->pCreateInfo, params->pAllocator, params->pInstance);
32779
32780     init_conversion_context(&ctx);
32781     convert_VkInstanceCreateInfo_win64_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
32782     params->result = wine_vkCreateInstance(&pCreateInfo_host, params->pAllocator, params->pInstance, params->client_ptr);
32783     free_conversion_context(&ctx);
32784     return STATUS_SUCCESS;
32785 }
32786 #endif /* _WIN64 */
32787
32788 static NTSTATUS thunk32_vkCreateInstance(void *args)
32789 {
32790     struct
32791     {
32792         PTR32 pCreateInfo;
32793         PTR32 pAllocator;
32794         PTR32 pInstance;
32795         PTR32 client_ptr;
32796         VkResult result;
32797     } *params = args;
32798     VkInstanceCreateInfo pCreateInfo_host;
32799     VkInstance pInstance_host;
32800     struct conversion_context ctx;
32801
32802     TRACE("%#x, %#x, %#x\n", params->pCreateInfo, params->pAllocator, params->pInstance);
32803
32804     init_conversion_context(&ctx);
32805     convert_VkInstanceCreateInfo_win32_to_host(&ctx, (const VkInstanceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32806     pInstance_host = *(VkInstance *)UlongToPtr(params->pInstance);
32807     params->result = wine_vkCreateInstance(&pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), &pInstance_host, UlongToPtr(params->client_ptr));
32808     *(VkInstance *)UlongToPtr(params->pInstance) = pInstance_host;
32809     free_conversion_context(&ctx);
32810     return STATUS_SUCCESS;
32811 }
32812
32813 #ifdef _WIN64
32814 static NTSTATUS thunk64_vkCreateMicromapEXT(void *args)
32815 {
32816     struct vkCreateMicromapEXT_params *params = args;
32817
32818     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
32819
32820     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateMicromapEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pMicromap);
32821     return STATUS_SUCCESS;
32822 }
32823 #endif /* _WIN64 */
32824
32825 static NTSTATUS thunk32_vkCreateMicromapEXT(void *args)
32826 {
32827     struct
32828     {
32829         PTR32 device;
32830         PTR32 pCreateInfo;
32831         PTR32 pAllocator;
32832         PTR32 pMicromap;
32833         VkResult result;
32834     } *params = args;
32835     VkMicromapCreateInfoEXT pCreateInfo_host;
32836
32837     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
32838
32839     convert_VkMicromapCreateInfoEXT_win32_to_host((const VkMicromapCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32840     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));
32841     return STATUS_SUCCESS;
32842 }
32843
32844 #ifdef _WIN64
32845 static NTSTATUS thunk64_vkCreateOpticalFlowSessionNV(void *args)
32846 {
32847     struct vkCreateOpticalFlowSessionNV_params *params = args;
32848
32849     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
32850
32851     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSession);
32852     return STATUS_SUCCESS;
32853 }
32854 #endif /* _WIN64 */
32855
32856 static NTSTATUS thunk32_vkCreateOpticalFlowSessionNV(void *args)
32857 {
32858     struct
32859     {
32860         PTR32 device;
32861         PTR32 pCreateInfo;
32862         PTR32 pAllocator;
32863         PTR32 pSession;
32864         VkResult result;
32865     } *params = args;
32866     VkOpticalFlowSessionCreateInfoNV pCreateInfo_host;
32867     struct conversion_context ctx;
32868
32869     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
32870
32871     init_conversion_context(&ctx);
32872     convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(&ctx, (const VkOpticalFlowSessionCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32873     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));
32874     free_conversion_context(&ctx);
32875     return STATUS_SUCCESS;
32876 }
32877
32878 #ifdef _WIN64
32879 static NTSTATUS thunk64_vkCreatePipelineCache(void *args)
32880 {
32881     struct vkCreatePipelineCache_params *params = args;
32882
32883     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);
32884
32885     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineCache(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineCache);
32886     return STATUS_SUCCESS;
32887 }
32888 #endif /* _WIN64 */
32889
32890 static NTSTATUS thunk32_vkCreatePipelineCache(void *args)
32891 {
32892     struct
32893     {
32894         PTR32 device;
32895         PTR32 pCreateInfo;
32896         PTR32 pAllocator;
32897         PTR32 pPipelineCache;
32898         VkResult result;
32899     } *params = args;
32900     VkPipelineCacheCreateInfo pCreateInfo_host;
32901
32902     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);
32903
32904     convert_VkPipelineCacheCreateInfo_win32_to_host((const VkPipelineCacheCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32905     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));
32906     return STATUS_SUCCESS;
32907 }
32908
32909 #ifdef _WIN64
32910 static NTSTATUS thunk64_vkCreatePipelineLayout(void *args)
32911 {
32912     struct vkCreatePipelineLayout_params *params = args;
32913
32914     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);
32915
32916     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineLayout);
32917     return STATUS_SUCCESS;
32918 }
32919 #endif /* _WIN64 */
32920
32921 static NTSTATUS thunk32_vkCreatePipelineLayout(void *args)
32922 {
32923     struct
32924     {
32925         PTR32 device;
32926         PTR32 pCreateInfo;
32927         PTR32 pAllocator;
32928         PTR32 pPipelineLayout;
32929         VkResult result;
32930     } *params = args;
32931     VkPipelineLayoutCreateInfo pCreateInfo_host;
32932
32933     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);
32934
32935     convert_VkPipelineLayoutCreateInfo_win32_to_host((const VkPipelineLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32936     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));
32937     return STATUS_SUCCESS;
32938 }
32939
32940 #ifdef _WIN64
32941 static NTSTATUS thunk64_vkCreatePrivateDataSlot(void *args)
32942 {
32943     struct vkCreatePrivateDataSlot_params *params = args;
32944
32945     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
32946
32947     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
32948     return STATUS_SUCCESS;
32949 }
32950 #endif /* _WIN64 */
32951
32952 static NTSTATUS thunk32_vkCreatePrivateDataSlot(void *args)
32953 {
32954     struct
32955     {
32956         PTR32 device;
32957         PTR32 pCreateInfo;
32958         PTR32 pAllocator;
32959         PTR32 pPrivateDataSlot;
32960         VkResult result;
32961     } *params = args;
32962     VkPrivateDataSlotCreateInfo pCreateInfo_host;
32963
32964     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
32965
32966     convert_VkPrivateDataSlotCreateInfo_win32_to_host((const VkPrivateDataSlotCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32967     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));
32968     return STATUS_SUCCESS;
32969 }
32970
32971 #ifdef _WIN64
32972 static NTSTATUS thunk64_vkCreatePrivateDataSlotEXT(void *args)
32973 {
32974     struct vkCreatePrivateDataSlotEXT_params *params = args;
32975
32976     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
32977
32978     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
32979     return STATUS_SUCCESS;
32980 }
32981 #endif /* _WIN64 */
32982
32983 static NTSTATUS thunk32_vkCreatePrivateDataSlotEXT(void *args)
32984 {
32985     struct
32986     {
32987         PTR32 device;
32988         PTR32 pCreateInfo;
32989         PTR32 pAllocator;
32990         PTR32 pPrivateDataSlot;
32991         VkResult result;
32992     } *params = args;
32993     VkPrivateDataSlotCreateInfo pCreateInfo_host;
32994
32995     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
32996
32997     convert_VkPrivateDataSlotCreateInfo_win32_to_host((const VkPrivateDataSlotCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
32998     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));
32999     return STATUS_SUCCESS;
33000 }
33001
33002 #ifdef _WIN64
33003 static NTSTATUS thunk64_vkCreateQueryPool(void *args)
33004 {
33005     struct vkCreateQueryPool_params *params = args;
33006
33007     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);
33008
33009     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateQueryPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pQueryPool);
33010     return STATUS_SUCCESS;
33011 }
33012 #endif /* _WIN64 */
33013
33014 static NTSTATUS thunk32_vkCreateQueryPool(void *args)
33015 {
33016     struct
33017     {
33018         PTR32 device;
33019         PTR32 pCreateInfo;
33020         PTR32 pAllocator;
33021         PTR32 pQueryPool;
33022         VkResult result;
33023     } *params = args;
33024     VkQueryPoolCreateInfo pCreateInfo_host;
33025     struct conversion_context ctx;
33026
33027     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);
33028
33029     init_conversion_context(&ctx);
33030     convert_VkQueryPoolCreateInfo_win32_to_host(&ctx, (const VkQueryPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33031     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));
33032     free_conversion_context(&ctx);
33033     return STATUS_SUCCESS;
33034 }
33035
33036 #ifdef _WIN64
33037 static NTSTATUS thunk64_vkCreateRayTracingPipelinesKHR(void *args)
33038 {
33039     struct vkCreateRayTracingPipelinesKHR_params *params = args;
33040     const VkRayTracingPipelineCreateInfoKHR *pCreateInfos_host;
33041     struct conversion_context ctx;
33042
33043     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);
33044
33045     init_conversion_context(&ctx);
33046     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
33047     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRayTracingPipelinesKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, params->pPipelines);
33048     free_conversion_context(&ctx);
33049     return STATUS_SUCCESS;
33050 }
33051 #endif /* _WIN64 */
33052
33053 static NTSTATUS thunk32_vkCreateRayTracingPipelinesKHR(void *args)
33054 {
33055     struct
33056     {
33057         PTR32 device;
33058         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
33059         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
33060         uint32_t createInfoCount;
33061         PTR32 pCreateInfos;
33062         PTR32 pAllocator;
33063         PTR32 pPipelines;
33064         VkResult result;
33065     } *params = args;
33066     const VkRayTracingPipelineCreateInfoKHR *pCreateInfos_host;
33067     struct conversion_context ctx;
33068
33069     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);
33070
33071     init_conversion_context(&ctx);
33072     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(&ctx, (const VkRayTracingPipelineCreateInfoKHR32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33073     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateRayTracingPipelinesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, (VkPipeline *)UlongToPtr(params->pPipelines));
33074     convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(pCreateInfos_host, (const VkRayTracingPipelineCreateInfoKHR32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33075     free_conversion_context(&ctx);
33076     return STATUS_SUCCESS;
33077 }
33078
33079 #ifdef _WIN64
33080 static NTSTATUS thunk64_vkCreateRayTracingPipelinesNV(void *args)
33081 {
33082     struct vkCreateRayTracingPipelinesNV_params *params = args;
33083     const VkRayTracingPipelineCreateInfoNV *pCreateInfos_host;
33084     struct conversion_context ctx;
33085
33086     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33087
33088     init_conversion_context(&ctx);
33089     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
33090     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);
33091     free_conversion_context(&ctx);
33092     return STATUS_SUCCESS;
33093 }
33094 #endif /* _WIN64 */
33095
33096 static NTSTATUS thunk32_vkCreateRayTracingPipelinesNV(void *args)
33097 {
33098     struct
33099     {
33100         PTR32 device;
33101         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
33102         uint32_t createInfoCount;
33103         PTR32 pCreateInfos;
33104         PTR32 pAllocator;
33105         PTR32 pPipelines;
33106         VkResult result;
33107     } *params = args;
33108     const VkRayTracingPipelineCreateInfoNV *pCreateInfos_host;
33109     struct conversion_context ctx;
33110
33111     TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
33112
33113     init_conversion_context(&ctx);
33114     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(&ctx, (const VkRayTracingPipelineCreateInfoNV32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33115     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));
33116     convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(pCreateInfos_host, (const VkRayTracingPipelineCreateInfoNV32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
33117     free_conversion_context(&ctx);
33118     return STATUS_SUCCESS;
33119 }
33120
33121 #ifdef _WIN64
33122 static NTSTATUS thunk64_vkCreateRenderPass(void *args)
33123 {
33124     struct vkCreateRenderPass_params *params = args;
33125
33126     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33127
33128     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
33129     return STATUS_SUCCESS;
33130 }
33131 #endif /* _WIN64 */
33132
33133 static NTSTATUS thunk32_vkCreateRenderPass(void *args)
33134 {
33135     struct
33136     {
33137         PTR32 device;
33138         PTR32 pCreateInfo;
33139         PTR32 pAllocator;
33140         PTR32 pRenderPass;
33141         VkResult result;
33142     } *params = args;
33143     VkRenderPassCreateInfo pCreateInfo_host;
33144     struct conversion_context ctx;
33145
33146     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33147
33148     init_conversion_context(&ctx);
33149     convert_VkRenderPassCreateInfo_win32_to_host(&ctx, (const VkRenderPassCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33150     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));
33151     free_conversion_context(&ctx);
33152     return STATUS_SUCCESS;
33153 }
33154
33155 #ifdef _WIN64
33156 static NTSTATUS thunk64_vkCreateRenderPass2(void *args)
33157 {
33158     struct vkCreateRenderPass2_params *params = args;
33159
33160     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33161
33162     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
33163     return STATUS_SUCCESS;
33164 }
33165 #endif /* _WIN64 */
33166
33167 static NTSTATUS thunk32_vkCreateRenderPass2(void *args)
33168 {
33169     struct
33170     {
33171         PTR32 device;
33172         PTR32 pCreateInfo;
33173         PTR32 pAllocator;
33174         PTR32 pRenderPass;
33175         VkResult result;
33176     } *params = args;
33177     VkRenderPassCreateInfo2 pCreateInfo_host;
33178     struct conversion_context ctx;
33179
33180     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33181
33182     init_conversion_context(&ctx);
33183     convert_VkRenderPassCreateInfo2_win32_to_host(&ctx, (const VkRenderPassCreateInfo232 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33184     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));
33185     free_conversion_context(&ctx);
33186     return STATUS_SUCCESS;
33187 }
33188
33189 #ifdef _WIN64
33190 static NTSTATUS thunk64_vkCreateRenderPass2KHR(void *args)
33191 {
33192     struct vkCreateRenderPass2KHR_params *params = args;
33193
33194     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33195
33196     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
33197     return STATUS_SUCCESS;
33198 }
33199 #endif /* _WIN64 */
33200
33201 static NTSTATUS thunk32_vkCreateRenderPass2KHR(void *args)
33202 {
33203     struct
33204     {
33205         PTR32 device;
33206         PTR32 pCreateInfo;
33207         PTR32 pAllocator;
33208         PTR32 pRenderPass;
33209         VkResult result;
33210     } *params = args;
33211     VkRenderPassCreateInfo2 pCreateInfo_host;
33212     struct conversion_context ctx;
33213
33214     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
33215
33216     init_conversion_context(&ctx);
33217     convert_VkRenderPassCreateInfo2_win32_to_host(&ctx, (const VkRenderPassCreateInfo232 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33218     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));
33219     free_conversion_context(&ctx);
33220     return STATUS_SUCCESS;
33221 }
33222
33223 #ifdef _WIN64
33224 static NTSTATUS thunk64_vkCreateSampler(void *args)
33225 {
33226     struct vkCreateSampler_params *params = args;
33227
33228     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);
33229
33230     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSampler(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSampler);
33231     return STATUS_SUCCESS;
33232 }
33233 #endif /* _WIN64 */
33234
33235 static NTSTATUS thunk32_vkCreateSampler(void *args)
33236 {
33237     struct
33238     {
33239         PTR32 device;
33240         PTR32 pCreateInfo;
33241         PTR32 pAllocator;
33242         PTR32 pSampler;
33243         VkResult result;
33244     } *params = args;
33245     VkSamplerCreateInfo pCreateInfo_host;
33246     struct conversion_context ctx;
33247
33248     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);
33249
33250     init_conversion_context(&ctx);
33251     convert_VkSamplerCreateInfo_win32_to_host(&ctx, (const VkSamplerCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33252     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));
33253     free_conversion_context(&ctx);
33254     return STATUS_SUCCESS;
33255 }
33256
33257 #ifdef _WIN64
33258 static NTSTATUS thunk64_vkCreateSamplerYcbcrConversion(void *args)
33259 {
33260     struct vkCreateSamplerYcbcrConversion_params *params = args;
33261
33262     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33263
33264     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
33265     return STATUS_SUCCESS;
33266 }
33267 #endif /* _WIN64 */
33268
33269 static NTSTATUS thunk32_vkCreateSamplerYcbcrConversion(void *args)
33270 {
33271     struct
33272     {
33273         PTR32 device;
33274         PTR32 pCreateInfo;
33275         PTR32 pAllocator;
33276         PTR32 pYcbcrConversion;
33277         VkResult result;
33278     } *params = args;
33279     VkSamplerYcbcrConversionCreateInfo pCreateInfo_host;
33280
33281     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33282
33283     convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host((const VkSamplerYcbcrConversionCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33284     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));
33285     return STATUS_SUCCESS;
33286 }
33287
33288 #ifdef _WIN64
33289 static NTSTATUS thunk64_vkCreateSamplerYcbcrConversionKHR(void *args)
33290 {
33291     struct vkCreateSamplerYcbcrConversionKHR_params *params = args;
33292
33293     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33294
33295     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
33296     return STATUS_SUCCESS;
33297 }
33298 #endif /* _WIN64 */
33299
33300 static NTSTATUS thunk32_vkCreateSamplerYcbcrConversionKHR(void *args)
33301 {
33302     struct
33303     {
33304         PTR32 device;
33305         PTR32 pCreateInfo;
33306         PTR32 pAllocator;
33307         PTR32 pYcbcrConversion;
33308         VkResult result;
33309     } *params = args;
33310     VkSamplerYcbcrConversionCreateInfo pCreateInfo_host;
33311
33312     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
33313
33314     convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host((const VkSamplerYcbcrConversionCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33315     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));
33316     return STATUS_SUCCESS;
33317 }
33318
33319 #ifdef _WIN64
33320 static NTSTATUS thunk64_vkCreateSemaphore(void *args)
33321 {
33322     struct vkCreateSemaphore_params *params = args;
33323
33324     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);
33325
33326     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSemaphore(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSemaphore);
33327     return STATUS_SUCCESS;
33328 }
33329 #endif /* _WIN64 */
33330
33331 static NTSTATUS thunk32_vkCreateSemaphore(void *args)
33332 {
33333     struct
33334     {
33335         PTR32 device;
33336         PTR32 pCreateInfo;
33337         PTR32 pAllocator;
33338         PTR32 pSemaphore;
33339         VkResult result;
33340     } *params = args;
33341     VkSemaphoreCreateInfo pCreateInfo_host;
33342     struct conversion_context ctx;
33343
33344     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);
33345
33346     init_conversion_context(&ctx);
33347     convert_VkSemaphoreCreateInfo_win32_to_host(&ctx, (const VkSemaphoreCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33348     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));
33349     free_conversion_context(&ctx);
33350     return STATUS_SUCCESS;
33351 }
33352
33353 #ifdef _WIN64
33354 static NTSTATUS thunk64_vkCreateShaderModule(void *args)
33355 {
33356     struct vkCreateShaderModule_params *params = args;
33357
33358     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);
33359
33360     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateShaderModule(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pShaderModule);
33361     return STATUS_SUCCESS;
33362 }
33363 #endif /* _WIN64 */
33364
33365 static NTSTATUS thunk32_vkCreateShaderModule(void *args)
33366 {
33367     struct
33368     {
33369         PTR32 device;
33370         PTR32 pCreateInfo;
33371         PTR32 pAllocator;
33372         PTR32 pShaderModule;
33373         VkResult result;
33374     } *params = args;
33375     VkShaderModuleCreateInfo pCreateInfo_host;
33376     struct conversion_context ctx;
33377
33378     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);
33379
33380     init_conversion_context(&ctx);
33381     convert_VkShaderModuleCreateInfo_win32_to_host(&ctx, (const VkShaderModuleCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33382     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));
33383     free_conversion_context(&ctx);
33384     return STATUS_SUCCESS;
33385 }
33386
33387 #ifdef _WIN64
33388 static NTSTATUS thunk64_vkCreateSwapchainKHR(void *args)
33389 {
33390     struct vkCreateSwapchainKHR_params *params = args;
33391     VkSwapchainCreateInfoKHR pCreateInfo_host;
33392
33393     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);
33394
33395     convert_VkSwapchainCreateInfoKHR_win64_to_host(params->pCreateInfo, &pCreateInfo_host);
33396     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSwapchain);
33397     return STATUS_SUCCESS;
33398 }
33399 #endif /* _WIN64 */
33400
33401 static NTSTATUS thunk32_vkCreateSwapchainKHR(void *args)
33402 {
33403     struct
33404     {
33405         PTR32 device;
33406         PTR32 pCreateInfo;
33407         PTR32 pAllocator;
33408         PTR32 pSwapchain;
33409         VkResult result;
33410     } *params = args;
33411     VkSwapchainCreateInfoKHR pCreateInfo_host;
33412     struct conversion_context ctx;
33413
33414     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);
33415
33416     init_conversion_context(&ctx);
33417     convert_VkSwapchainCreateInfoKHR_win32_to_host(&ctx, (const VkSwapchainCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33418     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));
33419     free_conversion_context(&ctx);
33420     return STATUS_SUCCESS;
33421 }
33422
33423 #ifdef _WIN64
33424 static NTSTATUS thunk64_vkCreateValidationCacheEXT(void *args)
33425 {
33426     struct vkCreateValidationCacheEXT_params *params = args;
33427
33428     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);
33429
33430     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pValidationCache);
33431     return STATUS_SUCCESS;
33432 }
33433 #endif /* _WIN64 */
33434
33435 static NTSTATUS thunk32_vkCreateValidationCacheEXT(void *args)
33436 {
33437     struct
33438     {
33439         PTR32 device;
33440         PTR32 pCreateInfo;
33441         PTR32 pAllocator;
33442         PTR32 pValidationCache;
33443         VkResult result;
33444     } *params = args;
33445     VkValidationCacheCreateInfoEXT pCreateInfo_host;
33446
33447     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);
33448
33449     convert_VkValidationCacheCreateInfoEXT_win32_to_host((const VkValidationCacheCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33450     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));
33451     return STATUS_SUCCESS;
33452 }
33453
33454 #ifdef _WIN64
33455 static NTSTATUS thunk64_vkCreateWin32SurfaceKHR(void *args)
33456 {
33457     struct vkCreateWin32SurfaceKHR_params *params = args;
33458
33459     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
33460
33461     params->result = wine_vkCreateWin32SurfaceKHR(params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
33462     return STATUS_SUCCESS;
33463 }
33464 #endif /* _WIN64 */
33465
33466 static NTSTATUS thunk32_vkCreateWin32SurfaceKHR(void *args)
33467 {
33468     struct
33469     {
33470         PTR32 instance;
33471         PTR32 pCreateInfo;
33472         PTR32 pAllocator;
33473         PTR32 pSurface;
33474         VkResult result;
33475     } *params = args;
33476     VkWin32SurfaceCreateInfoKHR pCreateInfo_host;
33477
33478     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
33479
33480     convert_VkWin32SurfaceCreateInfoKHR_win32_to_host((const VkWin32SurfaceCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
33481     params->result = wine_vkCreateWin32SurfaceKHR((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkSurfaceKHR *)UlongToPtr(params->pSurface));
33482     return STATUS_SUCCESS;
33483 }
33484
33485 #ifdef _WIN64
33486 static NTSTATUS thunk64_vkDebugMarkerSetObjectNameEXT(void *args)
33487 {
33488     struct vkDebugMarkerSetObjectNameEXT_params *params = args;
33489     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;
33490
33491     TRACE("%p, %p\n", params->device, params->pNameInfo);
33492
33493     convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(params->pNameInfo, &pNameInfo_host);
33494     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
33495     return STATUS_SUCCESS;
33496 }
33497 #endif /* _WIN64 */
33498
33499 static NTSTATUS thunk32_vkDebugMarkerSetObjectNameEXT(void *args)
33500 {
33501     struct
33502     {
33503         PTR32 device;
33504         PTR32 pNameInfo;
33505         VkResult result;
33506     } *params = args;
33507     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;
33508
33509     TRACE("%#x, %#x\n", params->device, params->pNameInfo);
33510
33511     convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host((const VkDebugMarkerObjectNameInfoEXT32 *)UlongToPtr(params->pNameInfo), &pNameInfo_host);
33512     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pNameInfo_host);
33513     return STATUS_SUCCESS;
33514 }
33515
33516 #ifdef _WIN64
33517 static NTSTATUS thunk64_vkDebugMarkerSetObjectTagEXT(void *args)
33518 {
33519     struct vkDebugMarkerSetObjectTagEXT_params *params = args;
33520     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;
33521
33522     TRACE("%p, %p\n", params->device, params->pTagInfo);
33523
33524     convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(params->pTagInfo, &pTagInfo_host);
33525     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
33526     return STATUS_SUCCESS;
33527 }
33528 #endif /* _WIN64 */
33529
33530 static NTSTATUS thunk32_vkDebugMarkerSetObjectTagEXT(void *args)
33531 {
33532     struct
33533     {
33534         PTR32 device;
33535         PTR32 pTagInfo;
33536         VkResult result;
33537     } *params = args;
33538     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;
33539
33540     TRACE("%#x, %#x\n", params->device, params->pTagInfo);
33541
33542     convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host((const VkDebugMarkerObjectTagInfoEXT32 *)UlongToPtr(params->pTagInfo), &pTagInfo_host);
33543     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pTagInfo_host);
33544     return STATUS_SUCCESS;
33545 }
33546
33547 #ifdef _WIN64
33548 static NTSTATUS thunk64_vkDebugReportMessageEXT(void *args)
33549 {
33550     struct vkDebugReportMessageEXT_params *params = args;
33551
33552     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);
33553
33554     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);
33555     return STATUS_SUCCESS;
33556 }
33557 #endif /* _WIN64 */
33558
33559 static NTSTATUS thunk32_vkDebugReportMessageEXT(void *args)
33560 {
33561     struct
33562     {
33563         PTR32 instance;
33564         VkDebugReportFlagsEXT flags;
33565         VkDebugReportObjectTypeEXT objectType;
33566         uint64_t DECLSPEC_ALIGN(8) object;
33567         PTR32 location;
33568         int32_t messageCode;
33569         PTR32 pLayerPrefix;
33570         PTR32 pMessage;
33571     } *params = args;
33572
33573     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);
33574
33575     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));
33576     return STATUS_SUCCESS;
33577 }
33578
33579 #ifdef _WIN64
33580 static NTSTATUS thunk64_vkDeferredOperationJoinKHR(void *args)
33581 {
33582     struct vkDeferredOperationJoinKHR_params *params = args;
33583
33584     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
33585
33586     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle(params->device)->device, params->operation);
33587     return STATUS_SUCCESS;
33588 }
33589 #endif /* _WIN64 */
33590
33591 static NTSTATUS thunk32_vkDeferredOperationJoinKHR(void *args)
33592 {
33593     struct
33594     {
33595         PTR32 device;
33596         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
33597         VkResult result;
33598     } *params = args;
33599
33600     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
33601
33602     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->operation);
33603     return STATUS_SUCCESS;
33604 }
33605
33606 #ifdef _WIN64
33607 static NTSTATUS thunk64_vkDestroyAccelerationStructureKHR(void *args)
33608 {
33609     struct vkDestroyAccelerationStructureKHR_params *params = args;
33610
33611     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
33612
33613     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
33614     return STATUS_SUCCESS;
33615 }
33616 #endif /* _WIN64 */
33617
33618 static NTSTATUS thunk32_vkDestroyAccelerationStructureKHR(void *args)
33619 {
33620     struct
33621     {
33622         PTR32 device;
33623         VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
33624         PTR32 pAllocator;
33625     } *params = args;
33626
33627     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
33628
33629     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->accelerationStructure, NULL);
33630     return STATUS_SUCCESS;
33631 }
33632
33633 #ifdef _WIN64
33634 static NTSTATUS thunk64_vkDestroyAccelerationStructureNV(void *args)
33635 {
33636     struct vkDestroyAccelerationStructureNV_params *params = args;
33637
33638     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
33639
33640     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
33641     return STATUS_SUCCESS;
33642 }
33643 #endif /* _WIN64 */
33644
33645 static NTSTATUS thunk32_vkDestroyAccelerationStructureNV(void *args)
33646 {
33647     struct
33648     {
33649         PTR32 device;
33650         VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
33651         PTR32 pAllocator;
33652     } *params = args;
33653
33654     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
33655
33656     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyAccelerationStructureNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->accelerationStructure, NULL);
33657     return STATUS_SUCCESS;
33658 }
33659
33660 #ifdef _WIN64
33661 static NTSTATUS thunk64_vkDestroyBuffer(void *args)
33662 {
33663     struct vkDestroyBuffer_params *params = args;
33664
33665     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pAllocator);
33666
33667     wine_device_from_handle(params->device)->funcs.p_vkDestroyBuffer(wine_device_from_handle(params->device)->device, params->buffer, NULL);
33668     return STATUS_SUCCESS;
33669 }
33670 #endif /* _WIN64 */
33671
33672 static NTSTATUS thunk32_vkDestroyBuffer(void *args)
33673 {
33674     struct
33675     {
33676         PTR32 device;
33677         VkBuffer DECLSPEC_ALIGN(8) buffer;
33678         PTR32 pAllocator;
33679     } *params = args;
33680
33681     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->buffer), params->pAllocator);
33682
33683     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyBuffer(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buffer, NULL);
33684     return STATUS_SUCCESS;
33685 }
33686
33687 #ifdef _WIN64
33688 static NTSTATUS thunk64_vkDestroyBufferView(void *args)
33689 {
33690     struct vkDestroyBufferView_params *params = args;
33691
33692     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->bufferView), params->pAllocator);
33693
33694     wine_device_from_handle(params->device)->funcs.p_vkDestroyBufferView(wine_device_from_handle(params->device)->device, params->bufferView, NULL);
33695     return STATUS_SUCCESS;
33696 }
33697 #endif /* _WIN64 */
33698
33699 static NTSTATUS thunk32_vkDestroyBufferView(void *args)
33700 {
33701     struct
33702     {
33703         PTR32 device;
33704         VkBufferView DECLSPEC_ALIGN(8) bufferView;
33705         PTR32 pAllocator;
33706     } *params = args;
33707
33708     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->bufferView), params->pAllocator);
33709
33710     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyBufferView(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bufferView, NULL);
33711     return STATUS_SUCCESS;
33712 }
33713
33714 #ifdef _WIN64
33715 static NTSTATUS thunk64_vkDestroyCommandPool(void *args)
33716 {
33717     struct vkDestroyCommandPool_params *params = args;
33718
33719     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->pAllocator);
33720
33721     wine_vkDestroyCommandPool(params->device, params->commandPool, params->pAllocator);
33722     return STATUS_SUCCESS;
33723 }
33724 #endif /* _WIN64 */
33725
33726 static NTSTATUS thunk32_vkDestroyCommandPool(void *args)
33727 {
33728     struct
33729     {
33730         PTR32 device;
33731         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
33732         PTR32 pAllocator;
33733     } *params = args;
33734
33735     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->pAllocator);
33736
33737     wine_vkDestroyCommandPool((VkDevice)UlongToPtr(params->device), params->commandPool, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
33738     return STATUS_SUCCESS;
33739 }
33740
33741 #ifdef _WIN64
33742 static NTSTATUS thunk64_vkDestroyCuFunctionNVX(void *args)
33743 {
33744     struct vkDestroyCuFunctionNVX_params *params = args;
33745
33746     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator);
33747
33748     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuFunctionNVX(wine_device_from_handle(params->device)->device, params->function, NULL);
33749     return STATUS_SUCCESS;
33750 }
33751 #endif /* _WIN64 */
33752
33753 static NTSTATUS thunk32_vkDestroyCuFunctionNVX(void *args)
33754 {
33755     struct
33756     {
33757         PTR32 device;
33758         VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
33759         PTR32 pAllocator;
33760     } *params = args;
33761
33762     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator);
33763
33764     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyCuFunctionNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->function, NULL);
33765     return STATUS_SUCCESS;
33766 }
33767
33768 #ifdef _WIN64
33769 static NTSTATUS thunk64_vkDestroyCuModuleNVX(void *args)
33770 {
33771     struct vkDestroyCuModuleNVX_params *params = args;
33772
33773     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator);
33774
33775     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuModuleNVX(wine_device_from_handle(params->device)->device, params->module, NULL);
33776     return STATUS_SUCCESS;
33777 }
33778 #endif /* _WIN64 */
33779
33780 static NTSTATUS thunk32_vkDestroyCuModuleNVX(void *args)
33781 {
33782     struct
33783     {
33784         PTR32 device;
33785         VkCuModuleNVX DECLSPEC_ALIGN(8) module;
33786         PTR32 pAllocator;
33787     } *params = args;
33788
33789     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator);
33790
33791     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyCuModuleNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->module, NULL);
33792     return STATUS_SUCCESS;
33793 }
33794
33795 #ifdef _WIN64
33796 static NTSTATUS thunk64_vkDestroyDebugReportCallbackEXT(void *args)
33797 {
33798     struct vkDestroyDebugReportCallbackEXT_params *params = args;
33799
33800     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->callback), params->pAllocator);
33801
33802     wine_vkDestroyDebugReportCallbackEXT(params->instance, params->callback, params->pAllocator);
33803     return STATUS_SUCCESS;
33804 }
33805 #endif /* _WIN64 */
33806
33807 static NTSTATUS thunk32_vkDestroyDebugReportCallbackEXT(void *args)
33808 {
33809     struct
33810     {
33811         PTR32 instance;
33812         VkDebugReportCallbackEXT DECLSPEC_ALIGN(8) callback;
33813         PTR32 pAllocator;
33814     } *params = args;
33815
33816     TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->callback), params->pAllocator);
33817
33818     wine_vkDestroyDebugReportCallbackEXT((VkInstance)UlongToPtr(params->instance), params->callback, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
33819     return STATUS_SUCCESS;
33820 }
33821
33822 #ifdef _WIN64
33823 static NTSTATUS thunk64_vkDestroyDebugUtilsMessengerEXT(void *args)
33824 {
33825     struct vkDestroyDebugUtilsMessengerEXT_params *params = args;
33826
33827     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->messenger), params->pAllocator);
33828
33829     wine_vkDestroyDebugUtilsMessengerEXT(params->instance, params->messenger, params->pAllocator);
33830     return STATUS_SUCCESS;
33831 }
33832 #endif /* _WIN64 */
33833
33834 static NTSTATUS thunk32_vkDestroyDebugUtilsMessengerEXT(void *args)
33835 {
33836     struct
33837     {
33838         PTR32 instance;
33839         VkDebugUtilsMessengerEXT DECLSPEC_ALIGN(8) messenger;
33840         PTR32 pAllocator;
33841     } *params = args;
33842
33843     TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->messenger), params->pAllocator);
33844
33845     wine_vkDestroyDebugUtilsMessengerEXT((VkInstance)UlongToPtr(params->instance), params->messenger, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
33846     return STATUS_SUCCESS;
33847 }
33848
33849 #ifdef _WIN64
33850 static NTSTATUS thunk64_vkDestroyDeferredOperationKHR(void *args)
33851 {
33852     struct vkDestroyDeferredOperationKHR_params *params = args;
33853
33854     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->operation), params->pAllocator);
33855
33856     wine_device_from_handle(params->device)->funcs.p_vkDestroyDeferredOperationKHR(wine_device_from_handle(params->device)->device, params->operation, NULL);
33857     return STATUS_SUCCESS;
33858 }
33859 #endif /* _WIN64 */
33860
33861 static NTSTATUS thunk32_vkDestroyDeferredOperationKHR(void *args)
33862 {
33863     struct
33864     {
33865         PTR32 device;
33866         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
33867         PTR32 pAllocator;
33868     } *params = args;
33869
33870     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->operation), params->pAllocator);
33871
33872     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDeferredOperationKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->operation, NULL);
33873     return STATUS_SUCCESS;
33874 }
33875
33876 #ifdef _WIN64
33877 static NTSTATUS thunk64_vkDestroyDescriptorPool(void *args)
33878 {
33879     struct vkDestroyDescriptorPool_params *params = args;
33880
33881     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->pAllocator);
33882
33883     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, NULL);
33884     return STATUS_SUCCESS;
33885 }
33886 #endif /* _WIN64 */
33887
33888 static NTSTATUS thunk32_vkDestroyDescriptorPool(void *args)
33889 {
33890     struct
33891     {
33892         PTR32 device;
33893         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
33894         PTR32 pAllocator;
33895     } *params = args;
33896
33897     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->pAllocator);
33898
33899     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorPool, NULL);
33900     return STATUS_SUCCESS;
33901 }
33902
33903 #ifdef _WIN64
33904 static NTSTATUS thunk64_vkDestroyDescriptorSetLayout(void *args)
33905 {
33906     struct vkDestroyDescriptorSetLayout_params *params = args;
33907
33908     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSetLayout), params->pAllocator);
33909
33910     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->descriptorSetLayout, NULL);
33911     return STATUS_SUCCESS;
33912 }
33913 #endif /* _WIN64 */
33914
33915 static NTSTATUS thunk32_vkDestroyDescriptorSetLayout(void *args)
33916 {
33917     struct
33918     {
33919         PTR32 device;
33920         VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
33921         PTR32 pAllocator;
33922     } *params = args;
33923
33924     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSetLayout), params->pAllocator);
33925
33926     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorSetLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorSetLayout, NULL);
33927     return STATUS_SUCCESS;
33928 }
33929
33930 #ifdef _WIN64
33931 static NTSTATUS thunk64_vkDestroyDescriptorUpdateTemplate(void *args)
33932 {
33933     struct vkDestroyDescriptorUpdateTemplate_params *params = args;
33934
33935     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
33936
33937     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
33938     return STATUS_SUCCESS;
33939 }
33940 #endif /* _WIN64 */
33941
33942 static NTSTATUS thunk32_vkDestroyDescriptorUpdateTemplate(void *args)
33943 {
33944     struct
33945     {
33946         PTR32 device;
33947         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
33948         PTR32 pAllocator;
33949     } *params = args;
33950
33951     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
33952
33953     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorUpdateTemplate(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorUpdateTemplate, NULL);
33954     return STATUS_SUCCESS;
33955 }
33956
33957 #ifdef _WIN64
33958 static NTSTATUS thunk64_vkDestroyDescriptorUpdateTemplateKHR(void *args)
33959 {
33960     struct vkDestroyDescriptorUpdateTemplateKHR_params *params = args;
33961
33962     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
33963
33964     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
33965     return STATUS_SUCCESS;
33966 }
33967 #endif /* _WIN64 */
33968
33969 static NTSTATUS thunk32_vkDestroyDescriptorUpdateTemplateKHR(void *args)
33970 {
33971     struct
33972     {
33973         PTR32 device;
33974         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
33975         PTR32 pAllocator;
33976     } *params = args;
33977
33978     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
33979
33980     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorUpdateTemplate, NULL);
33981     return STATUS_SUCCESS;
33982 }
33983
33984 #ifdef _WIN64
33985 static NTSTATUS thunk64_vkDestroyDevice(void *args)
33986 {
33987     struct vkDestroyDevice_params *params = args;
33988
33989     TRACE("%p, %p\n", params->device, params->pAllocator);
33990
33991     if (!params->device)
33992         return STATUS_SUCCESS;
33993
33994     wine_vkDestroyDevice(params->device, params->pAllocator);
33995     return STATUS_SUCCESS;
33996 }
33997 #endif /* _WIN64 */
33998
33999 static NTSTATUS thunk32_vkDestroyDevice(void *args)
34000 {
34001     struct
34002     {
34003         PTR32 device;
34004         PTR32 pAllocator;
34005     } *params = args;
34006
34007     TRACE("%#x, %#x\n", params->device, params->pAllocator);
34008
34009     if (!params->device)
34010         return STATUS_SUCCESS;
34011
34012     wine_vkDestroyDevice((VkDevice)UlongToPtr(params->device), (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34013     return STATUS_SUCCESS;
34014 }
34015
34016 #ifdef _WIN64
34017 static NTSTATUS thunk64_vkDestroyEvent(void *args)
34018 {
34019     struct vkDestroyEvent_params *params = args;
34020
34021     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->event), params->pAllocator);
34022
34023     wine_device_from_handle(params->device)->funcs.p_vkDestroyEvent(wine_device_from_handle(params->device)->device, params->event, NULL);
34024     return STATUS_SUCCESS;
34025 }
34026 #endif /* _WIN64 */
34027
34028 static NTSTATUS thunk32_vkDestroyEvent(void *args)
34029 {
34030     struct
34031     {
34032         PTR32 device;
34033         VkEvent DECLSPEC_ALIGN(8) event;
34034         PTR32 pAllocator;
34035     } *params = args;
34036
34037     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->event), params->pAllocator);
34038
34039     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event, NULL);
34040     return STATUS_SUCCESS;
34041 }
34042
34043 #ifdef _WIN64
34044 static NTSTATUS thunk64_vkDestroyFence(void *args)
34045 {
34046     struct vkDestroyFence_params *params = args;
34047
34048     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
34049
34050     wine_device_from_handle(params->device)->funcs.p_vkDestroyFence(wine_device_from_handle(params->device)->device, params->fence, NULL);
34051     return STATUS_SUCCESS;
34052 }
34053 #endif /* _WIN64 */
34054
34055 static NTSTATUS thunk32_vkDestroyFence(void *args)
34056 {
34057     struct
34058     {
34059         PTR32 device;
34060         VkFence DECLSPEC_ALIGN(8) fence;
34061         PTR32 pAllocator;
34062     } *params = args;
34063
34064     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
34065
34066     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyFence(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->fence, NULL);
34067     return STATUS_SUCCESS;
34068 }
34069
34070 #ifdef _WIN64
34071 static NTSTATUS thunk64_vkDestroyFramebuffer(void *args)
34072 {
34073     struct vkDestroyFramebuffer_params *params = args;
34074
34075     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pAllocator);
34076
34077     wine_device_from_handle(params->device)->funcs.p_vkDestroyFramebuffer(wine_device_from_handle(params->device)->device, params->framebuffer, NULL);
34078     return STATUS_SUCCESS;
34079 }
34080 #endif /* _WIN64 */
34081
34082 static NTSTATUS thunk32_vkDestroyFramebuffer(void *args)
34083 {
34084     struct
34085     {
34086         PTR32 device;
34087         VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
34088         PTR32 pAllocator;
34089     } *params = args;
34090
34091     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pAllocator);
34092
34093     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyFramebuffer(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->framebuffer, NULL);
34094     return STATUS_SUCCESS;
34095 }
34096
34097 #ifdef _WIN64
34098 static NTSTATUS thunk64_vkDestroyImage(void *args)
34099 {
34100     struct vkDestroyImage_params *params = args;
34101
34102     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pAllocator);
34103
34104     wine_device_from_handle(params->device)->funcs.p_vkDestroyImage(wine_device_from_handle(params->device)->device, params->image, NULL);
34105     return STATUS_SUCCESS;
34106 }
34107 #endif /* _WIN64 */
34108
34109 static NTSTATUS thunk32_vkDestroyImage(void *args)
34110 {
34111     struct
34112     {
34113         PTR32 device;
34114         VkImage DECLSPEC_ALIGN(8) image;
34115         PTR32 pAllocator;
34116     } *params = args;
34117
34118     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pAllocator);
34119
34120     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyImage(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, NULL);
34121     return STATUS_SUCCESS;
34122 }
34123
34124 #ifdef _WIN64
34125 static NTSTATUS thunk64_vkDestroyImageView(void *args)
34126 {
34127     struct vkDestroyImageView_params *params = args;
34128
34129     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pAllocator);
34130
34131     wine_device_from_handle(params->device)->funcs.p_vkDestroyImageView(wine_device_from_handle(params->device)->device, params->imageView, NULL);
34132     return STATUS_SUCCESS;
34133 }
34134 #endif /* _WIN64 */
34135
34136 static NTSTATUS thunk32_vkDestroyImageView(void *args)
34137 {
34138     struct
34139     {
34140         PTR32 device;
34141         VkImageView DECLSPEC_ALIGN(8) imageView;
34142         PTR32 pAllocator;
34143     } *params = args;
34144
34145     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->imageView), params->pAllocator);
34146
34147     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyImageView(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->imageView, NULL);
34148     return STATUS_SUCCESS;
34149 }
34150
34151 #ifdef _WIN64
34152 static NTSTATUS thunk64_vkDestroyIndirectCommandsLayoutNV(void *args)
34153 {
34154     struct vkDestroyIndirectCommandsLayoutNV_params *params = args;
34155
34156     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
34157
34158     wine_device_from_handle(params->device)->funcs.p_vkDestroyIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->indirectCommandsLayout, NULL);
34159     return STATUS_SUCCESS;
34160 }
34161 #endif /* _WIN64 */
34162
34163 static NTSTATUS thunk32_vkDestroyIndirectCommandsLayoutNV(void *args)
34164 {
34165     struct
34166     {
34167         PTR32 device;
34168         VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
34169         PTR32 pAllocator;
34170     } *params = args;
34171
34172     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
34173
34174     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyIndirectCommandsLayoutNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->indirectCommandsLayout, NULL);
34175     return STATUS_SUCCESS;
34176 }
34177
34178 #ifdef _WIN64
34179 static NTSTATUS thunk64_vkDestroyInstance(void *args)
34180 {
34181     struct vkDestroyInstance_params *params = args;
34182
34183     TRACE("%p, %p\n", params->instance, params->pAllocator);
34184
34185     if (!params->instance)
34186         return STATUS_SUCCESS;
34187
34188     wine_vkDestroyInstance(params->instance, params->pAllocator);
34189     return STATUS_SUCCESS;
34190 }
34191 #endif /* _WIN64 */
34192
34193 static NTSTATUS thunk32_vkDestroyInstance(void *args)
34194 {
34195     struct
34196     {
34197         PTR32 instance;
34198         PTR32 pAllocator;
34199     } *params = args;
34200
34201     TRACE("%#x, %#x\n", params->instance, params->pAllocator);
34202
34203     if (!params->instance)
34204         return STATUS_SUCCESS;
34205
34206     wine_vkDestroyInstance((VkInstance)UlongToPtr(params->instance), (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34207     return STATUS_SUCCESS;
34208 }
34209
34210 #ifdef _WIN64
34211 static NTSTATUS thunk64_vkDestroyMicromapEXT(void *args)
34212 {
34213     struct vkDestroyMicromapEXT_params *params = args;
34214
34215     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
34216
34217     wine_device_from_handle(params->device)->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle(params->device)->device, params->micromap, NULL);
34218     return STATUS_SUCCESS;
34219 }
34220 #endif /* _WIN64 */
34221
34222 static NTSTATUS thunk32_vkDestroyMicromapEXT(void *args)
34223 {
34224     struct
34225     {
34226         PTR32 device;
34227         VkMicromapEXT DECLSPEC_ALIGN(8) micromap;
34228         PTR32 pAllocator;
34229     } *params = args;
34230
34231     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
34232
34233     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->micromap, NULL);
34234     return STATUS_SUCCESS;
34235 }
34236
34237 #ifdef _WIN64
34238 static NTSTATUS thunk64_vkDestroyOpticalFlowSessionNV(void *args)
34239 {
34240     struct vkDestroyOpticalFlowSessionNV_params *params = args;
34241
34242     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
34243
34244     wine_device_from_handle(params->device)->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->session, NULL);
34245     return STATUS_SUCCESS;
34246 }
34247 #endif /* _WIN64 */
34248
34249 static NTSTATUS thunk32_vkDestroyOpticalFlowSessionNV(void *args)
34250 {
34251     struct
34252     {
34253         PTR32 device;
34254         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
34255         PTR32 pAllocator;
34256     } *params = args;
34257
34258     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
34259
34260     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->session, NULL);
34261     return STATUS_SUCCESS;
34262 }
34263
34264 #ifdef _WIN64
34265 static NTSTATUS thunk64_vkDestroyPipeline(void *args)
34266 {
34267     struct vkDestroyPipeline_params *params = args;
34268
34269     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->pAllocator);
34270
34271     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipeline(wine_device_from_handle(params->device)->device, params->pipeline, NULL);
34272     return STATUS_SUCCESS;
34273 }
34274 #endif /* _WIN64 */
34275
34276 static NTSTATUS thunk32_vkDestroyPipeline(void *args)
34277 {
34278     struct
34279     {
34280         PTR32 device;
34281         VkPipeline DECLSPEC_ALIGN(8) pipeline;
34282         PTR32 pAllocator;
34283     } *params = args;
34284
34285     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->pAllocator);
34286
34287     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipeline(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, NULL);
34288     return STATUS_SUCCESS;
34289 }
34290
34291 #ifdef _WIN64
34292 static NTSTATUS thunk64_vkDestroyPipelineCache(void *args)
34293 {
34294     struct vkDestroyPipelineCache_params *params = args;
34295
34296     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pAllocator);
34297
34298     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineCache(wine_device_from_handle(params->device)->device, params->pipelineCache, NULL);
34299     return STATUS_SUCCESS;
34300 }
34301 #endif /* _WIN64 */
34302
34303 static NTSTATUS thunk32_vkDestroyPipelineCache(void *args)
34304 {
34305     struct
34306     {
34307         PTR32 device;
34308         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
34309         PTR32 pAllocator;
34310     } *params = args;
34311
34312     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pAllocator);
34313
34314     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipelineCache(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineCache, NULL);
34315     return STATUS_SUCCESS;
34316 }
34317
34318 #ifdef _WIN64
34319 static NTSTATUS thunk64_vkDestroyPipelineLayout(void *args)
34320 {
34321     struct vkDestroyPipelineLayout_params *params = args;
34322
34323     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineLayout), params->pAllocator);
34324
34325     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineLayout(wine_device_from_handle(params->device)->device, params->pipelineLayout, NULL);
34326     return STATUS_SUCCESS;
34327 }
34328 #endif /* _WIN64 */
34329
34330 static NTSTATUS thunk32_vkDestroyPipelineLayout(void *args)
34331 {
34332     struct
34333     {
34334         PTR32 device;
34335         VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
34336         PTR32 pAllocator;
34337     } *params = args;
34338
34339     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineLayout), params->pAllocator);
34340
34341     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipelineLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineLayout, NULL);
34342     return STATUS_SUCCESS;
34343 }
34344
34345 #ifdef _WIN64
34346 static NTSTATUS thunk64_vkDestroyPrivateDataSlot(void *args)
34347 {
34348     struct vkDestroyPrivateDataSlot_params *params = args;
34349
34350     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
34351
34352     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlot(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
34353     return STATUS_SUCCESS;
34354 }
34355 #endif /* _WIN64 */
34356
34357 static NTSTATUS thunk32_vkDestroyPrivateDataSlot(void *args)
34358 {
34359     struct
34360     {
34361         PTR32 device;
34362         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
34363         PTR32 pAllocator;
34364     } *params = args;
34365
34366     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
34367
34368     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPrivateDataSlot(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->privateDataSlot, NULL);
34369     return STATUS_SUCCESS;
34370 }
34371
34372 #ifdef _WIN64
34373 static NTSTATUS thunk64_vkDestroyPrivateDataSlotEXT(void *args)
34374 {
34375     struct vkDestroyPrivateDataSlotEXT_params *params = args;
34376
34377     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
34378
34379     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
34380     return STATUS_SUCCESS;
34381 }
34382 #endif /* _WIN64 */
34383
34384 static NTSTATUS thunk32_vkDestroyPrivateDataSlotEXT(void *args)
34385 {
34386     struct
34387     {
34388         PTR32 device;
34389         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
34390         PTR32 pAllocator;
34391     } *params = args;
34392
34393     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
34394
34395     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPrivateDataSlotEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->privateDataSlot, NULL);
34396     return STATUS_SUCCESS;
34397 }
34398
34399 #ifdef _WIN64
34400 static NTSTATUS thunk64_vkDestroyQueryPool(void *args)
34401 {
34402     struct vkDestroyQueryPool_params *params = args;
34403
34404     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->queryPool), params->pAllocator);
34405
34406     wine_device_from_handle(params->device)->funcs.p_vkDestroyQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, NULL);
34407     return STATUS_SUCCESS;
34408 }
34409 #endif /* _WIN64 */
34410
34411 static NTSTATUS thunk32_vkDestroyQueryPool(void *args)
34412 {
34413     struct
34414     {
34415         PTR32 device;
34416         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
34417         PTR32 pAllocator;
34418     } *params = args;
34419
34420     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->queryPool), params->pAllocator);
34421
34422     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyQueryPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->queryPool, NULL);
34423     return STATUS_SUCCESS;
34424 }
34425
34426 #ifdef _WIN64
34427 static NTSTATUS thunk64_vkDestroyRenderPass(void *args)
34428 {
34429     struct vkDestroyRenderPass_params *params = args;
34430
34431     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pAllocator);
34432
34433     wine_device_from_handle(params->device)->funcs.p_vkDestroyRenderPass(wine_device_from_handle(params->device)->device, params->renderPass, NULL);
34434     return STATUS_SUCCESS;
34435 }
34436 #endif /* _WIN64 */
34437
34438 static NTSTATUS thunk32_vkDestroyRenderPass(void *args)
34439 {
34440     struct
34441     {
34442         PTR32 device;
34443         VkRenderPass DECLSPEC_ALIGN(8) renderPass;
34444         PTR32 pAllocator;
34445     } *params = args;
34446
34447     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pAllocator);
34448
34449     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyRenderPass(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->renderPass, NULL);
34450     return STATUS_SUCCESS;
34451 }
34452
34453 #ifdef _WIN64
34454 static NTSTATUS thunk64_vkDestroySampler(void *args)
34455 {
34456     struct vkDestroySampler_params *params = args;
34457
34458     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->sampler), params->pAllocator);
34459
34460     wine_device_from_handle(params->device)->funcs.p_vkDestroySampler(wine_device_from_handle(params->device)->device, params->sampler, NULL);
34461     return STATUS_SUCCESS;
34462 }
34463 #endif /* _WIN64 */
34464
34465 static NTSTATUS thunk32_vkDestroySampler(void *args)
34466 {
34467     struct
34468     {
34469         PTR32 device;
34470         VkSampler DECLSPEC_ALIGN(8) sampler;
34471         PTR32 pAllocator;
34472     } *params = args;
34473
34474     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->sampler), params->pAllocator);
34475
34476     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySampler(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->sampler, NULL);
34477     return STATUS_SUCCESS;
34478 }
34479
34480 #ifdef _WIN64
34481 static NTSTATUS thunk64_vkDestroySamplerYcbcrConversion(void *args)
34482 {
34483     struct vkDestroySamplerYcbcrConversion_params *params = args;
34484
34485     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
34486
34487     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
34488     return STATUS_SUCCESS;
34489 }
34490 #endif /* _WIN64 */
34491
34492 static NTSTATUS thunk32_vkDestroySamplerYcbcrConversion(void *args)
34493 {
34494     struct
34495     {
34496         PTR32 device;
34497         VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) ycbcrConversion;
34498         PTR32 pAllocator;
34499     } *params = args;
34500
34501     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
34502
34503     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySamplerYcbcrConversion(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->ycbcrConversion, NULL);
34504     return STATUS_SUCCESS;
34505 }
34506
34507 #ifdef _WIN64
34508 static NTSTATUS thunk64_vkDestroySamplerYcbcrConversionKHR(void *args)
34509 {
34510     struct vkDestroySamplerYcbcrConversionKHR_params *params = args;
34511
34512     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
34513
34514     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
34515     return STATUS_SUCCESS;
34516 }
34517 #endif /* _WIN64 */
34518
34519 static NTSTATUS thunk32_vkDestroySamplerYcbcrConversionKHR(void *args)
34520 {
34521     struct
34522     {
34523         PTR32 device;
34524         VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) ycbcrConversion;
34525         PTR32 pAllocator;
34526     } *params = args;
34527
34528     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
34529
34530     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySamplerYcbcrConversionKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->ycbcrConversion, NULL);
34531     return STATUS_SUCCESS;
34532 }
34533
34534 #ifdef _WIN64
34535 static NTSTATUS thunk64_vkDestroySemaphore(void *args)
34536 {
34537     struct vkDestroySemaphore_params *params = args;
34538
34539     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pAllocator);
34540
34541     wine_device_from_handle(params->device)->funcs.p_vkDestroySemaphore(wine_device_from_handle(params->device)->device, params->semaphore, NULL);
34542     return STATUS_SUCCESS;
34543 }
34544 #endif /* _WIN64 */
34545
34546 static NTSTATUS thunk32_vkDestroySemaphore(void *args)
34547 {
34548     struct
34549     {
34550         PTR32 device;
34551         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
34552         PTR32 pAllocator;
34553     } *params = args;
34554
34555     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pAllocator);
34556
34557     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySemaphore(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->semaphore, NULL);
34558     return STATUS_SUCCESS;
34559 }
34560
34561 #ifdef _WIN64
34562 static NTSTATUS thunk64_vkDestroyShaderModule(void *args)
34563 {
34564     struct vkDestroyShaderModule_params *params = args;
34565
34566     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pAllocator);
34567
34568     wine_device_from_handle(params->device)->funcs.p_vkDestroyShaderModule(wine_device_from_handle(params->device)->device, params->shaderModule, NULL);
34569     return STATUS_SUCCESS;
34570 }
34571 #endif /* _WIN64 */
34572
34573 static NTSTATUS thunk32_vkDestroyShaderModule(void *args)
34574 {
34575     struct
34576     {
34577         PTR32 device;
34578         VkShaderModule DECLSPEC_ALIGN(8) shaderModule;
34579         PTR32 pAllocator;
34580     } *params = args;
34581
34582     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pAllocator);
34583
34584     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyShaderModule(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->shaderModule, NULL);
34585     return STATUS_SUCCESS;
34586 }
34587
34588 #ifdef _WIN64
34589 static NTSTATUS thunk64_vkDestroySurfaceKHR(void *args)
34590 {
34591     struct vkDestroySurfaceKHR_params *params = args;
34592
34593     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->surface), params->pAllocator);
34594
34595     wine_vkDestroySurfaceKHR(params->instance, params->surface, params->pAllocator);
34596     return STATUS_SUCCESS;
34597 }
34598 #endif /* _WIN64 */
34599
34600 static NTSTATUS thunk32_vkDestroySurfaceKHR(void *args)
34601 {
34602     struct
34603     {
34604         PTR32 instance;
34605         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
34606         PTR32 pAllocator;
34607     } *params = args;
34608
34609     TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->surface), params->pAllocator);
34610
34611     wine_vkDestroySurfaceKHR((VkInstance)UlongToPtr(params->instance), params->surface, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
34612     return STATUS_SUCCESS;
34613 }
34614
34615 #ifdef _WIN64
34616 static NTSTATUS thunk64_vkDestroySwapchainKHR(void *args)
34617 {
34618     struct vkDestroySwapchainKHR_params *params = args;
34619
34620     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pAllocator);
34621
34622     wine_device_from_handle(params->device)->funcs.p_vkDestroySwapchainKHR(wine_device_from_handle(params->device)->device, params->swapchain, NULL);
34623     return STATUS_SUCCESS;
34624 }
34625 #endif /* _WIN64 */
34626
34627 static NTSTATUS thunk32_vkDestroySwapchainKHR(void *args)
34628 {
34629     struct
34630     {
34631         PTR32 device;
34632         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
34633         PTR32 pAllocator;
34634     } *params = args;
34635
34636     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pAllocator);
34637
34638     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySwapchainKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->swapchain, NULL);
34639     return STATUS_SUCCESS;
34640 }
34641
34642 #ifdef _WIN64
34643 static NTSTATUS thunk64_vkDestroyValidationCacheEXT(void *args)
34644 {
34645     struct vkDestroyValidationCacheEXT_params *params = args;
34646
34647     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pAllocator);
34648
34649     wine_device_from_handle(params->device)->funcs.p_vkDestroyValidationCacheEXT(wine_device_from_handle(params->device)->device, params->validationCache, NULL);
34650     return STATUS_SUCCESS;
34651 }
34652 #endif /* _WIN64 */
34653
34654 static NTSTATUS thunk32_vkDestroyValidationCacheEXT(void *args)
34655 {
34656     struct
34657     {
34658         PTR32 device;
34659         VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
34660         PTR32 pAllocator;
34661     } *params = args;
34662
34663     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pAllocator);
34664
34665     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyValidationCacheEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->validationCache, NULL);
34666     return STATUS_SUCCESS;
34667 }
34668
34669 #ifdef _WIN64
34670 static NTSTATUS thunk64_vkDeviceWaitIdle(void *args)
34671 {
34672     struct vkDeviceWaitIdle_params *params = args;
34673
34674     TRACE("%p\n", params->device);
34675
34676     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeviceWaitIdle(wine_device_from_handle(params->device)->device);
34677     return STATUS_SUCCESS;
34678 }
34679 #endif /* _WIN64 */
34680
34681 static NTSTATUS thunk32_vkDeviceWaitIdle(void *args)
34682 {
34683     struct
34684     {
34685         PTR32 device;
34686         VkResult result;
34687     } *params = args;
34688
34689     TRACE("%#x\n", params->device);
34690
34691     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDeviceWaitIdle(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
34692     return STATUS_SUCCESS;
34693 }
34694
34695 #ifdef _WIN64
34696 static NTSTATUS thunk64_vkEndCommandBuffer(void *args)
34697 {
34698     struct vkEndCommandBuffer_params *params = args;
34699
34700     TRACE("%p\n", params->commandBuffer);
34701
34702     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
34703     return STATUS_SUCCESS;
34704 }
34705 #endif /* _WIN64 */
34706
34707 static NTSTATUS thunk32_vkEndCommandBuffer(void *args)
34708 {
34709     struct
34710     {
34711         PTR32 commandBuffer;
34712         VkResult result;
34713     } *params = args;
34714
34715     TRACE("%#x\n", params->commandBuffer);
34716
34717     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);
34718     return STATUS_SUCCESS;
34719 }
34720
34721 #ifdef _WIN64
34722 static NTSTATUS thunk64_vkEnumerateDeviceExtensionProperties(void *args)
34723 {
34724     struct vkEnumerateDeviceExtensionProperties_params *params = args;
34725
34726     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
34727
34728     params->result = wine_vkEnumerateDeviceExtensionProperties(params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
34729     return STATUS_SUCCESS;
34730 }
34731 #endif /* _WIN64 */
34732
34733 static NTSTATUS thunk32_vkEnumerateDeviceExtensionProperties(void *args)
34734 {
34735     struct
34736     {
34737         PTR32 physicalDevice;
34738         PTR32 pLayerName;
34739         PTR32 pPropertyCount;
34740         PTR32 pProperties;
34741         VkResult result;
34742     } *params = args;
34743
34744     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
34745
34746     params->result = wine_vkEnumerateDeviceExtensionProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (const char *)UlongToPtr(params->pLayerName), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkExtensionProperties *)UlongToPtr(params->pProperties));
34747     return STATUS_SUCCESS;
34748 }
34749
34750 #ifdef _WIN64
34751 static NTSTATUS thunk64_vkEnumerateDeviceLayerProperties(void *args)
34752 {
34753     struct vkEnumerateDeviceLayerProperties_params *params = args;
34754
34755     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
34756
34757     params->result = wine_vkEnumerateDeviceLayerProperties(params->physicalDevice, params->pPropertyCount, params->pProperties);
34758     return STATUS_SUCCESS;
34759 }
34760 #endif /* _WIN64 */
34761
34762 static NTSTATUS thunk32_vkEnumerateDeviceLayerProperties(void *args)
34763 {
34764     struct
34765     {
34766         PTR32 physicalDevice;
34767         PTR32 pPropertyCount;
34768         PTR32 pProperties;
34769         VkResult result;
34770     } *params = args;
34771
34772     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
34773
34774     params->result = wine_vkEnumerateDeviceLayerProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkLayerProperties *)UlongToPtr(params->pProperties));
34775     return STATUS_SUCCESS;
34776 }
34777
34778 #ifdef _WIN64
34779 static NTSTATUS thunk64_vkEnumerateInstanceExtensionProperties(void *args)
34780 {
34781     struct vkEnumerateInstanceExtensionProperties_params *params = args;
34782
34783     TRACE("%p, %p, %p\n", params->pLayerName, params->pPropertyCount, params->pProperties);
34784
34785     params->result = wine_vkEnumerateInstanceExtensionProperties(params->pLayerName, params->pPropertyCount, params->pProperties);
34786     return STATUS_SUCCESS;
34787 }
34788 #endif /* _WIN64 */
34789
34790 static NTSTATUS thunk32_vkEnumerateInstanceExtensionProperties(void *args)
34791 {
34792     struct
34793     {
34794         PTR32 pLayerName;
34795         PTR32 pPropertyCount;
34796         PTR32 pProperties;
34797         VkResult result;
34798     } *params = args;
34799
34800     TRACE("%#x, %#x, %#x\n", params->pLayerName, params->pPropertyCount, params->pProperties);
34801
34802     params->result = wine_vkEnumerateInstanceExtensionProperties((const char *)UlongToPtr(params->pLayerName), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkExtensionProperties *)UlongToPtr(params->pProperties));
34803     return STATUS_SUCCESS;
34804 }
34805
34806 #ifdef _WIN64
34807 static NTSTATUS thunk64_vkEnumerateInstanceVersion(void *args)
34808 {
34809     struct vkEnumerateInstanceVersion_params *params = args;
34810
34811     TRACE("%p\n", params->pApiVersion);
34812
34813     params->result = wine_vkEnumerateInstanceVersion(params->pApiVersion);
34814     return STATUS_SUCCESS;
34815 }
34816 #endif /* _WIN64 */
34817
34818 static NTSTATUS thunk32_vkEnumerateInstanceVersion(void *args)
34819 {
34820     struct
34821     {
34822         PTR32 pApiVersion;
34823         VkResult result;
34824     } *params = args;
34825
34826     TRACE("%#x\n", params->pApiVersion);
34827
34828     params->result = wine_vkEnumerateInstanceVersion((uint32_t *)UlongToPtr(params->pApiVersion));
34829     return STATUS_SUCCESS;
34830 }
34831
34832 #ifdef _WIN64
34833 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroups(void *args)
34834 {
34835     struct vkEnumeratePhysicalDeviceGroups_params *params = args;
34836
34837     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
34838
34839     params->result = wine_vkEnumeratePhysicalDeviceGroups(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
34840     return STATUS_SUCCESS;
34841 }
34842 #endif /* _WIN64 */
34843
34844 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroups(void *args)
34845 {
34846     struct
34847     {
34848         PTR32 instance;
34849         PTR32 pPhysicalDeviceGroupCount;
34850         PTR32 pPhysicalDeviceGroupProperties;
34851         VkResult result;
34852     } *params = args;
34853     VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties_host;
34854     struct conversion_context ctx;
34855
34856     TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
34857
34858     init_conversion_context(&ctx);
34859     pPhysicalDeviceGroupProperties_host = convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(&ctx, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
34860     params->result = wine_vkEnumeratePhysicalDeviceGroups((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount), pPhysicalDeviceGroupProperties_host);
34861     convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(pPhysicalDeviceGroupProperties_host, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
34862     free_conversion_context(&ctx);
34863     return STATUS_SUCCESS;
34864 }
34865
34866 #ifdef _WIN64
34867 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
34868 {
34869     struct vkEnumeratePhysicalDeviceGroupsKHR_params *params = args;
34870
34871     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
34872
34873     params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
34874     return STATUS_SUCCESS;
34875 }
34876 #endif /* _WIN64 */
34877
34878 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
34879 {
34880     struct
34881     {
34882         PTR32 instance;
34883         PTR32 pPhysicalDeviceGroupCount;
34884         PTR32 pPhysicalDeviceGroupProperties;
34885         VkResult result;
34886     } *params = args;
34887     VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties_host;
34888     struct conversion_context ctx;
34889
34890     TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
34891
34892     init_conversion_context(&ctx);
34893     pPhysicalDeviceGroupProperties_host = convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(&ctx, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
34894     params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount), pPhysicalDeviceGroupProperties_host);
34895     convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(pPhysicalDeviceGroupProperties_host, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
34896     free_conversion_context(&ctx);
34897     return STATUS_SUCCESS;
34898 }
34899
34900 #ifdef _WIN64
34901 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(void *args)
34902 {
34903     struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_params *params = args;
34904
34905     TRACE("%p, %u, %p, %p, %p\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
34906
34907     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);
34908     return STATUS_SUCCESS;
34909 }
34910 #endif /* _WIN64 */
34911
34912 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(void *args)
34913 {
34914     struct
34915     {
34916         PTR32 physicalDevice;
34917         uint32_t queueFamilyIndex;
34918         PTR32 pCounterCount;
34919         PTR32 pCounters;
34920         PTR32 pCounterDescriptions;
34921         VkResult result;
34922     } *params = args;
34923     VkPerformanceCounterKHR *pCounters_host;
34924     VkPerformanceCounterDescriptionKHR *pCounterDescriptions_host;
34925     struct conversion_context ctx;
34926
34927     TRACE("%#x, %u, %#x, %#x, %#x\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
34928
34929     init_conversion_context(&ctx);
34930     pCounters_host = convert_VkPerformanceCounterKHR_array_win32_to_host(&ctx, (VkPerformanceCounterKHR32 *)UlongToPtr(params->pCounters), *(uint32_t *)UlongToPtr(params->pCounterCount));
34931     pCounterDescriptions_host = convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(&ctx, (VkPerformanceCounterDescriptionKHR32 *)UlongToPtr(params->pCounterDescriptions), *(uint32_t *)UlongToPtr(params->pCounterCount));
34932     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);
34933     convert_VkPerformanceCounterKHR_array_host_to_win32(pCounters_host, (VkPerformanceCounterKHR32 *)UlongToPtr(params->pCounters), *(uint32_t *)UlongToPtr(params->pCounterCount));
34934     convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(pCounterDescriptions_host, (VkPerformanceCounterDescriptionKHR32 *)UlongToPtr(params->pCounterDescriptions), *(uint32_t *)UlongToPtr(params->pCounterCount));
34935     free_conversion_context(&ctx);
34936     return STATUS_SUCCESS;
34937 }
34938
34939 #ifdef _WIN64
34940 static NTSTATUS thunk64_vkEnumeratePhysicalDevices(void *args)
34941 {
34942     struct vkEnumeratePhysicalDevices_params *params = args;
34943
34944     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
34945
34946     params->result = wine_vkEnumeratePhysicalDevices(params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
34947     return STATUS_SUCCESS;
34948 }
34949 #endif /* _WIN64 */
34950
34951 static NTSTATUS thunk32_vkEnumeratePhysicalDevices(void *args)
34952 {
34953     struct
34954     {
34955         PTR32 instance;
34956         PTR32 pPhysicalDeviceCount;
34957         PTR32 pPhysicalDevices;
34958         VkResult result;
34959     } *params = args;
34960     VkPhysicalDevice *pPhysicalDevices_host;
34961     struct conversion_context ctx;
34962
34963     TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
34964
34965     init_conversion_context(&ctx);
34966     pPhysicalDevices_host = (params->pPhysicalDevices && *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount)) ? conversion_context_alloc(&ctx, sizeof(*pPhysicalDevices_host) * *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount)) : NULL;
34967     params->result = wine_vkEnumeratePhysicalDevices((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceCount), pPhysicalDevices_host);
34968     convert_VkPhysicalDevice_array_unwrapped_host_to_win32(pPhysicalDevices_host, (PTR32 *)UlongToPtr(params->pPhysicalDevices), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount));
34969     free_conversion_context(&ctx);
34970     return STATUS_SUCCESS;
34971 }
34972
34973 #ifdef _WIN64
34974 static NTSTATUS thunk64_vkFlushMappedMemoryRanges(void *args)
34975 {
34976     struct vkFlushMappedMemoryRanges_params *params = args;
34977
34978     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
34979
34980     params->result = wine_device_from_handle(params->device)->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, params->pMemoryRanges);
34981     return STATUS_SUCCESS;
34982 }
34983 #endif /* _WIN64 */
34984
34985 static NTSTATUS thunk32_vkFlushMappedMemoryRanges(void *args)
34986 {
34987     struct
34988     {
34989         PTR32 device;
34990         uint32_t memoryRangeCount;
34991         PTR32 pMemoryRanges;
34992         VkResult result;
34993     } *params = args;
34994     const VkMappedMemoryRange *pMemoryRanges_host;
34995     struct conversion_context ctx;
34996
34997     TRACE("%#x, %u, %#x\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
34998
34999     init_conversion_context(&ctx);
35000     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(&ctx, (const VkMappedMemoryRange32 *)UlongToPtr(params->pMemoryRanges), params->memoryRangeCount);
35001     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);
35002     free_conversion_context(&ctx);
35003     return STATUS_SUCCESS;
35004 }
35005
35006 #ifdef _WIN64
35007 static NTSTATUS thunk64_vkFreeCommandBuffers(void *args)
35008 {
35009     struct vkFreeCommandBuffers_params *params = args;
35010
35011     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->commandBufferCount, params->pCommandBuffers);
35012
35013     wine_vkFreeCommandBuffers(params->device, params->commandPool, params->commandBufferCount, params->pCommandBuffers);
35014     return STATUS_SUCCESS;
35015 }
35016 #endif /* _WIN64 */
35017
35018 static NTSTATUS thunk32_vkFreeCommandBuffers(void *args)
35019 {
35020     struct
35021     {
35022         PTR32 device;
35023         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
35024         uint32_t commandBufferCount;
35025         PTR32 pCommandBuffers;
35026     } *params = args;
35027     const VkCommandBuffer *pCommandBuffers_host;
35028     struct conversion_context ctx;
35029
35030     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->commandBufferCount, params->pCommandBuffers);
35031
35032     init_conversion_context(&ctx);
35033     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_unwrapped_host(&ctx, (const PTR32 *)UlongToPtr(params->pCommandBuffers), params->commandBufferCount);
35034     wine_vkFreeCommandBuffers((VkDevice)UlongToPtr(params->device), params->commandPool, params->commandBufferCount, pCommandBuffers_host);
35035     free_conversion_context(&ctx);
35036     return STATUS_SUCCESS;
35037 }
35038
35039 #ifdef _WIN64
35040 static NTSTATUS thunk64_vkFreeDescriptorSets(void *args)
35041 {
35042     struct vkFreeDescriptorSets_params *params = args;
35043
35044     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);
35045
35046     params->result = wine_device_from_handle(params->device)->funcs.p_vkFreeDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorPool, params->descriptorSetCount, params->pDescriptorSets);
35047     return STATUS_SUCCESS;
35048 }
35049 #endif /* _WIN64 */
35050
35051 static NTSTATUS thunk32_vkFreeDescriptorSets(void *args)
35052 {
35053     struct
35054     {
35055         PTR32 device;
35056         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
35057         uint32_t descriptorSetCount;
35058         PTR32 pDescriptorSets;
35059         VkResult result;
35060     } *params = args;
35061
35062     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);
35063
35064     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));
35065     return STATUS_SUCCESS;
35066 }
35067
35068 #ifdef _WIN64
35069 static NTSTATUS thunk64_vkFreeMemory(void *args)
35070 {
35071     struct vkFreeMemory_params *params = args;
35072
35073     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pAllocator);
35074
35075     wine_device_from_handle(params->device)->funcs.p_vkFreeMemory(wine_device_from_handle(params->device)->device, params->memory, NULL);
35076     return STATUS_SUCCESS;
35077 }
35078 #endif /* _WIN64 */
35079
35080 static NTSTATUS thunk32_vkFreeMemory(void *args)
35081 {
35082     struct
35083     {
35084         PTR32 device;
35085         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
35086         PTR32 pAllocator;
35087     } *params = args;
35088
35089     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->memory), params->pAllocator);
35090
35091     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkFreeMemory(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->memory, NULL);
35092     return STATUS_SUCCESS;
35093 }
35094
35095 #ifdef _WIN64
35096 static NTSTATUS thunk64_vkGetAccelerationStructureBuildSizesKHR(void *args)
35097 {
35098     struct vkGetAccelerationStructureBuildSizesKHR_params *params = args;
35099
35100     TRACE("%p, %#x, %p, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
35101
35102     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureBuildSizesKHR(wine_device_from_handle(params->device)->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
35103     return STATUS_SUCCESS;
35104 }
35105 #endif /* _WIN64 */
35106
35107 static NTSTATUS thunk32_vkGetAccelerationStructureBuildSizesKHR(void *args)
35108 {
35109     struct
35110     {
35111         PTR32 device;
35112         VkAccelerationStructureBuildTypeKHR buildType;
35113         PTR32 pBuildInfo;
35114         PTR32 pMaxPrimitiveCounts;
35115         PTR32 pSizeInfo;
35116     } *params = args;
35117     VkAccelerationStructureBuildGeometryInfoKHR pBuildInfo_host;
35118     VkAccelerationStructureBuildSizesInfoKHR pSizeInfo_host;
35119     struct conversion_context ctx;
35120
35121     TRACE("%#x, %#x, %#x, %#x, %#x\n", params->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
35122
35123     init_conversion_context(&ctx);
35124     convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pBuildInfo), &pBuildInfo_host);
35125     convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host((VkAccelerationStructureBuildSizesInfoKHR32 *)UlongToPtr(params->pSizeInfo), &pSizeInfo_host);
35126     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);
35127     convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(&pSizeInfo_host, (VkAccelerationStructureBuildSizesInfoKHR32 *)UlongToPtr(params->pSizeInfo));
35128     free_conversion_context(&ctx);
35129     return STATUS_SUCCESS;
35130 }
35131
35132 #ifdef _WIN64
35133 static NTSTATUS thunk64_vkGetAccelerationStructureDeviceAddressKHR(void *args)
35134 {
35135     struct vkGetAccelerationStructureDeviceAddressKHR_params *params = args;
35136
35137     TRACE("%p, %p\n", params->device, params->pInfo);
35138
35139     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
35140     return STATUS_SUCCESS;
35141 }
35142 #endif /* _WIN64 */
35143
35144 static NTSTATUS thunk32_vkGetAccelerationStructureDeviceAddressKHR(void *args)
35145 {
35146     struct
35147     {
35148         PTR32 device;
35149         PTR32 pInfo;
35150         VkDeviceAddress result;
35151     } *params = args;
35152     VkAccelerationStructureDeviceAddressInfoKHR pInfo_host;
35153
35154     TRACE("%#x, %#x\n", params->device, params->pInfo);
35155
35156     convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host((const VkAccelerationStructureDeviceAddressInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
35157     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
35158     return STATUS_SUCCESS;
35159 }
35160
35161 #ifdef _WIN64
35162 static NTSTATUS thunk64_vkGetAccelerationStructureHandleNV(void *args)
35163 {
35164     struct vkGetAccelerationStructureHandleNV_params *params = args;
35165
35166     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);
35167
35168     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, params->dataSize, params->pData);
35169     return STATUS_SUCCESS;
35170 }
35171 #endif /* _WIN64 */
35172
35173 static NTSTATUS thunk32_vkGetAccelerationStructureHandleNV(void *args)
35174 {
35175     struct
35176     {
35177         PTR32 device;
35178         VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
35179         PTR32 dataSize;
35180         PTR32 pData;
35181         VkResult result;
35182     } *params = args;
35183
35184     TRACE("%#x, 0x%s, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);
35185
35186     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));
35187     return STATUS_SUCCESS;
35188 }
35189
35190 #ifdef _WIN64
35191 static NTSTATUS thunk64_vkGetAccelerationStructureMemoryRequirementsNV(void *args)
35192 {
35193     struct vkGetAccelerationStructureMemoryRequirementsNV_params *params = args;
35194
35195     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
35196
35197     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
35198     return STATUS_SUCCESS;
35199 }
35200 #endif /* _WIN64 */
35201
35202 static NTSTATUS thunk32_vkGetAccelerationStructureMemoryRequirementsNV(void *args)
35203 {
35204     struct
35205     {
35206         PTR32 device;
35207         PTR32 pInfo;
35208         PTR32 pMemoryRequirements;
35209     } *params = args;
35210     VkAccelerationStructureMemoryRequirementsInfoNV pInfo_host;
35211     VkMemoryRequirements2KHR pMemoryRequirements_host;
35212
35213     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
35214
35215     convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host((const VkAccelerationStructureMemoryRequirementsInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
35216     convert_VkMemoryRequirements2KHR_win32_to_host((VkMemoryRequirements2KHR32 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
35217     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
35218     convert_VkMemoryRequirements2KHR_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements2KHR32 *)UlongToPtr(params->pMemoryRequirements));
35219     return STATUS_SUCCESS;
35220 }
35221
35222 #ifdef _WIN64
35223 static NTSTATUS thunk64_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(void *args)
35224 {
35225     struct vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_params *params = args;
35226
35227     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
35228
35229     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
35230     return STATUS_SUCCESS;
35231 }
35232 #endif /* _WIN64 */
35233
35234 static NTSTATUS thunk32_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(void *args)
35235 {
35236     struct
35237     {
35238         PTR32 device;
35239         PTR32 pInfo;
35240         PTR32 pData;
35241         VkResult result;
35242     } *params = args;
35243     VkAccelerationStructureCaptureDescriptorDataInfoEXT pInfo_host;
35244
35245     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
35246
35247     convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_win32_to_host((const VkAccelerationStructureCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
35248     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));
35249     return STATUS_SUCCESS;
35250 }
35251
35252 #ifdef _WIN64
35253 static NTSTATUS thunk64_vkGetBufferDeviceAddress(void *args)
35254 {
35255     struct vkGetBufferDeviceAddress_params *params = args;
35256
35257     TRACE("%p, %p\n", params->device, params->pInfo);
35258
35259     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddress(wine_device_from_handle(params->device)->device, params->pInfo);
35260     return STATUS_SUCCESS;
35261 }
35262 #endif /* _WIN64 */
35263
35264 static NTSTATUS thunk32_vkGetBufferDeviceAddress(void *args)
35265 {
35266     struct
35267     {
35268         PTR32 device;
35269         PTR32 pInfo;
35270         VkDeviceAddress result;
35271     } *params = args;
35272     VkBufferDeviceAddressInfo pInfo_host;
35273
35274     TRACE("%#x, %#x\n", params->device, params->pInfo);
35275
35276     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
35277     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
35278     return STATUS_SUCCESS;
35279 }
35280
35281 #ifdef _WIN64
35282 static NTSTATUS thunk64_vkGetBufferDeviceAddressEXT(void *args)
35283 {
35284     struct vkGetBufferDeviceAddressEXT_params *params = args;
35285
35286     TRACE("%p, %p\n", params->device, params->pInfo);
35287
35288     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressEXT(wine_device_from_handle(params->device)->device, params->pInfo);
35289     return STATUS_SUCCESS;
35290 }
35291 #endif /* _WIN64 */
35292
35293 static NTSTATUS thunk32_vkGetBufferDeviceAddressEXT(void *args)
35294 {
35295     struct
35296     {
35297         PTR32 device;
35298         PTR32 pInfo;
35299         VkDeviceAddress result;
35300     } *params = args;
35301     VkBufferDeviceAddressInfo pInfo_host;
35302
35303     TRACE("%#x, %#x\n", params->device, params->pInfo);
35304
35305     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
35306     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddressEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
35307     return STATUS_SUCCESS;
35308 }
35309
35310 #ifdef _WIN64
35311 static NTSTATUS thunk64_vkGetBufferDeviceAddressKHR(void *args)
35312 {
35313     struct vkGetBufferDeviceAddressKHR_params *params = args;
35314
35315     TRACE("%p, %p\n", params->device, params->pInfo);
35316
35317     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
35318     return STATUS_SUCCESS;
35319 }
35320 #endif /* _WIN64 */
35321
35322 static NTSTATUS thunk32_vkGetBufferDeviceAddressKHR(void *args)
35323 {
35324     struct
35325     {
35326         PTR32 device;
35327         PTR32 pInfo;
35328         VkDeviceAddress result;
35329     } *params = args;
35330     VkBufferDeviceAddressInfo pInfo_host;
35331
35332     TRACE("%#x, %#x\n", params->device, params->pInfo);
35333
35334     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
35335     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
35336     return STATUS_SUCCESS;
35337 }
35338
35339 #ifdef _WIN64
35340 static NTSTATUS thunk64_vkGetBufferMemoryRequirements(void *args)
35341 {
35342     struct vkGetBufferMemoryRequirements_params *params = args;
35343
35344     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pMemoryRequirements);
35345
35346     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->buffer, params->pMemoryRequirements);
35347     return STATUS_SUCCESS;
35348 }
35349 #endif /* _WIN64 */
35350
35351 static NTSTATUS thunk32_vkGetBufferMemoryRequirements(void *args)
35352 {
35353     struct
35354     {
35355         PTR32 device;
35356         VkBuffer DECLSPEC_ALIGN(8) buffer;
35357         PTR32 pMemoryRequirements;
35358     } *params = args;
35359     VkMemoryRequirements pMemoryRequirements_host;
35360
35361     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->buffer), params->pMemoryRequirements);
35362
35363     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buffer, &pMemoryRequirements_host);
35364     convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements32 *)UlongToPtr(params->pMemoryRequirements));
35365     return STATUS_SUCCESS;
35366 }
35367
35368 #ifdef _WIN64
35369 static NTSTATUS thunk64_vkGetBufferMemoryRequirements2(void *args)
35370 {
35371     struct vkGetBufferMemoryRequirements2_params *params = args;
35372
35373     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
35374
35375     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
35376     return STATUS_SUCCESS;
35377 }
35378 #endif /* _WIN64 */
35379
35380 static NTSTATUS thunk32_vkGetBufferMemoryRequirements2(void *args)
35381 {
35382     struct
35383     {
35384         PTR32 device;
35385         PTR32 pInfo;
35386         PTR32 pMemoryRequirements;
35387     } *params = args;
35388     VkBufferMemoryRequirementsInfo2 pInfo_host;
35389     VkMemoryRequirements2 pMemoryRequirements_host;
35390     struct conversion_context ctx;
35391
35392     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
35393
35394     init_conversion_context(&ctx);
35395     convert_VkBufferMemoryRequirementsInfo2_win32_to_host((const VkBufferMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
35396     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
35397     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
35398     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
35399     free_conversion_context(&ctx);
35400     return STATUS_SUCCESS;
35401 }
35402
35403 #ifdef _WIN64
35404 static NTSTATUS thunk64_vkGetBufferMemoryRequirements2KHR(void *args)
35405 {
35406     struct vkGetBufferMemoryRequirements2KHR_params *params = args;
35407
35408     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
35409
35410     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
35411     return STATUS_SUCCESS;
35412 }
35413 #endif /* _WIN64 */
35414
35415 static NTSTATUS thunk32_vkGetBufferMemoryRequirements2KHR(void *args)
35416 {
35417     struct
35418     {
35419         PTR32 device;
35420         PTR32 pInfo;
35421         PTR32 pMemoryRequirements;
35422     } *params = args;
35423     VkBufferMemoryRequirementsInfo2 pInfo_host;
35424     VkMemoryRequirements2 pMemoryRequirements_host;
35425     struct conversion_context ctx;
35426
35427     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
35428
35429     init_conversion_context(&ctx);
35430     convert_VkBufferMemoryRequirementsInfo2_win32_to_host((const VkBufferMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
35431     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
35432     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
35433     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
35434     free_conversion_context(&ctx);
35435     return STATUS_SUCCESS;
35436 }
35437
35438 #ifdef _WIN64
35439 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureAddress(void *args)
35440 {
35441     struct vkGetBufferOpaqueCaptureAddress_params *params = args;
35442
35443     TRACE("%p, %p\n", params->device, params->pInfo);
35444
35445     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, params->pInfo);
35446     return STATUS_SUCCESS;
35447 }
35448 #endif /* _WIN64 */
35449
35450 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddress(void *args)
35451 {
35452     struct
35453     {
35454         PTR32 device;
35455         PTR32 pInfo;
35456         uint64_t result;
35457     } *params = args;
35458     VkBufferDeviceAddressInfo pInfo_host;
35459
35460     TRACE("%#x, %#x\n", params->device, params->pInfo);
35461
35462     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
35463     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferOpaqueCaptureAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
35464     return STATUS_SUCCESS;
35465 }
35466
35467 #ifdef _WIN64
35468 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureAddressKHR(void *args)
35469 {
35470     struct vkGetBufferOpaqueCaptureAddressKHR_params *params = args;
35471
35472     TRACE("%p, %p\n", params->device, params->pInfo);
35473
35474     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
35475     return STATUS_SUCCESS;
35476 }
35477 #endif /* _WIN64 */
35478
35479 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddressKHR(void *args)
35480 {
35481     struct
35482     {
35483         PTR32 device;
35484         PTR32 pInfo;
35485         uint64_t result;
35486     } *params = args;
35487     VkBufferDeviceAddressInfo pInfo_host;
35488
35489     TRACE("%#x, %#x\n", params->device, params->pInfo);
35490
35491     convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
35492     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
35493     return STATUS_SUCCESS;
35494 }
35495
35496 #ifdef _WIN64
35497 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureDescriptorDataEXT(void *args)
35498 {
35499     struct vkGetBufferOpaqueCaptureDescriptorDataEXT_params *params = args;
35500
35501     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
35502
35503     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
35504     return STATUS_SUCCESS;
35505 }
35506 #endif /* _WIN64 */
35507
35508 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureDescriptorDataEXT(void *args)
35509 {
35510     struct
35511     {
35512         PTR32 device;
35513         PTR32 pInfo;
35514         PTR32 pData;
35515         VkResult result;
35516     } *params = args;
35517     VkBufferCaptureDescriptorDataInfoEXT pInfo_host;
35518
35519     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
35520
35521     convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host((const VkBufferCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
35522     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));
35523     return STATUS_SUCCESS;
35524 }
35525
35526 #ifdef _WIN64
35527 static NTSTATUS thunk64_vkGetCalibratedTimestampsEXT(void *args)
35528 {
35529     struct vkGetCalibratedTimestampsEXT_params *params = args;
35530
35531     TRACE("%p, %u, %p, %p, %p\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
35532
35533     params->result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
35534     return STATUS_SUCCESS;
35535 }
35536 #endif /* _WIN64 */
35537
35538 static NTSTATUS thunk32_vkGetCalibratedTimestampsEXT(void *args)
35539 {
35540     struct
35541     {
35542         PTR32 device;
35543         uint32_t timestampCount;
35544         PTR32 pTimestampInfos;
35545         PTR32 pTimestamps;
35546         PTR32 pMaxDeviation;
35547         VkResult result;
35548     } *params = args;
35549     const VkCalibratedTimestampInfoEXT *pTimestampInfos_host;
35550     struct conversion_context ctx;
35551
35552     TRACE("%#x, %u, %#x, %#x, %#x\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
35553
35554     init_conversion_context(&ctx);
35555     pTimestampInfos_host = convert_VkCalibratedTimestampInfoEXT_array_win32_to_host(&ctx, (const VkCalibratedTimestampInfoEXT32 *)UlongToPtr(params->pTimestampInfos), params->timestampCount);
35556     params->result = wine_vkGetCalibratedTimestampsEXT((VkDevice)UlongToPtr(params->device), params->timestampCount, pTimestampInfos_host, (uint64_t *)UlongToPtr(params->pTimestamps), (uint64_t *)UlongToPtr(params->pMaxDeviation));
35557     free_conversion_context(&ctx);
35558     return STATUS_SUCCESS;
35559 }
35560
35561 #ifdef _WIN64
35562 static NTSTATUS thunk64_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
35563 {
35564     struct vkGetDeferredOperationMaxConcurrencyKHR_params *params = args;
35565
35566     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
35567
35568     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle(params->device)->device, params->operation);
35569     return STATUS_SUCCESS;
35570 }
35571 #endif /* _WIN64 */
35572
35573 static NTSTATUS thunk32_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
35574 {
35575     struct
35576     {
35577         PTR32 device;
35578         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
35579         uint32_t result;
35580     } *params = args;
35581
35582     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
35583
35584     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->operation);
35585     return STATUS_SUCCESS;
35586 }
35587
35588 #ifdef _WIN64
35589 static NTSTATUS thunk64_vkGetDeferredOperationResultKHR(void *args)
35590 {
35591     struct vkGetDeferredOperationResultKHR_params *params = args;
35592
35593     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
35594
35595     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle(params->device)->device, params->operation);
35596     return STATUS_SUCCESS;
35597 }
35598 #endif /* _WIN64 */
35599
35600 static NTSTATUS thunk32_vkGetDeferredOperationResultKHR(void *args)
35601 {
35602     struct
35603     {
35604         PTR32 device;
35605         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
35606         VkResult result;
35607     } *params = args;
35608
35609     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
35610
35611     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->operation);
35612     return STATUS_SUCCESS;
35613 }
35614
35615 #ifdef _WIN64
35616 static NTSTATUS thunk64_vkGetDescriptorEXT(void *args)
35617 {
35618     struct vkGetDescriptorEXT_params *params = args;
35619
35620     TRACE("%p, %p, 0x%s, %p\n", params->device, params->pDescriptorInfo, wine_dbgstr_longlong(params->dataSize), params->pDescriptor);
35621
35622     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorEXT(wine_device_from_handle(params->device)->device, params->pDescriptorInfo, params->dataSize, params->pDescriptor);
35623     return STATUS_SUCCESS;
35624 }
35625 #endif /* _WIN64 */
35626
35627 static NTSTATUS thunk32_vkGetDescriptorEXT(void *args)
35628 {
35629     struct
35630     {
35631         PTR32 device;
35632         PTR32 pDescriptorInfo;
35633         PTR32 dataSize;
35634         PTR32 pDescriptor;
35635     } *params = args;
35636     VkDescriptorGetInfoEXT pDescriptorInfo_host;
35637     struct conversion_context ctx;
35638
35639     TRACE("%#x, %#x, 0x%s, %#x\n", params->device, params->pDescriptorInfo, wine_dbgstr_longlong(params->dataSize), params->pDescriptor);
35640
35641     init_conversion_context(&ctx);
35642     convert_VkDescriptorGetInfoEXT_win32_to_host(&ctx, (const VkDescriptorGetInfoEXT32 *)UlongToPtr(params->pDescriptorInfo), &pDescriptorInfo_host);
35643     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));
35644     free_conversion_context(&ctx);
35645     return STATUS_SUCCESS;
35646 }
35647
35648 #ifdef _WIN64
35649 static NTSTATUS thunk64_vkGetDescriptorSetHostMappingVALVE(void *args)
35650 {
35651     struct vkGetDescriptorSetHostMappingVALVE_params *params = args;
35652
35653     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), params->ppData);
35654
35655     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetHostMappingVALVE(wine_device_from_handle(params->device)->device, params->descriptorSet, params->ppData);
35656     return STATUS_SUCCESS;
35657 }
35658 #endif /* _WIN64 */
35659
35660 static NTSTATUS thunk32_vkGetDescriptorSetHostMappingVALVE(void *args)
35661 {
35662     struct
35663     {
35664         PTR32 device;
35665         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
35666         PTR32 ppData;
35667     } *params = args;
35668
35669     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSet), params->ppData);
35670
35671     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));
35672     return STATUS_SUCCESS;
35673 }
35674
35675 #ifdef _WIN64
35676 static NTSTATUS thunk64_vkGetDescriptorSetLayoutBindingOffsetEXT(void *args)
35677 {
35678     struct vkGetDescriptorSetLayoutBindingOffsetEXT_params *params = args;
35679
35680     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->layout), params->binding, params->pOffset);
35681
35682     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutBindingOffsetEXT(wine_device_from_handle(params->device)->device, params->layout, params->binding, params->pOffset);
35683     return STATUS_SUCCESS;
35684 }
35685 #endif /* _WIN64 */
35686
35687 static NTSTATUS thunk32_vkGetDescriptorSetLayoutBindingOffsetEXT(void *args)
35688 {
35689     struct
35690     {
35691         PTR32 device;
35692         VkDescriptorSetLayout DECLSPEC_ALIGN(8) layout;
35693         uint32_t binding;
35694         PTR32 pOffset;
35695     } *params = args;
35696
35697     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->layout), params->binding, params->pOffset);
35698
35699     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));
35700     return STATUS_SUCCESS;
35701 }
35702
35703 #ifdef _WIN64
35704 static NTSTATUS thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args)
35705 {
35706     struct vkGetDescriptorSetLayoutHostMappingInfoVALVE_params *params = args;
35707
35708     TRACE("%p, %p, %p\n", params->device, params->pBindingReference, params->pHostMapping);
35709
35710     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutHostMappingInfoVALVE(wine_device_from_handle(params->device)->device, params->pBindingReference, params->pHostMapping);
35711     return STATUS_SUCCESS;
35712 }
35713 #endif /* _WIN64 */
35714
35715 static NTSTATUS thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args)
35716 {
35717     struct
35718     {
35719         PTR32 device;
35720         PTR32 pBindingReference;
35721         PTR32 pHostMapping;
35722     } *params = args;
35723     VkDescriptorSetBindingReferenceVALVE pBindingReference_host;
35724     VkDescriptorSetLayoutHostMappingInfoVALVE pHostMapping_host;
35725
35726     TRACE("%#x, %#x, %#x\n", params->device, params->pBindingReference, params->pHostMapping);
35727
35728     convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host((const VkDescriptorSetBindingReferenceVALVE32 *)UlongToPtr(params->pBindingReference), &pBindingReference_host);
35729     convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host((VkDescriptorSetLayoutHostMappingInfoVALVE32 *)UlongToPtr(params->pHostMapping), &pHostMapping_host);
35730     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutHostMappingInfoVALVE(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pBindingReference_host, &pHostMapping_host);
35731     convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(&pHostMapping_host, (VkDescriptorSetLayoutHostMappingInfoVALVE32 *)UlongToPtr(params->pHostMapping));
35732     return STATUS_SUCCESS;
35733 }
35734
35735 #ifdef _WIN64
35736 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSizeEXT(void *args)
35737 {
35738     struct vkGetDescriptorSetLayoutSizeEXT_params *params = args;
35739
35740     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->layout), params->pLayoutSizeInBytes);
35741
35742     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSizeEXT(wine_device_from_handle(params->device)->device, params->layout, params->pLayoutSizeInBytes);
35743     return STATUS_SUCCESS;
35744 }
35745 #endif /* _WIN64 */
35746
35747 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSizeEXT(void *args)
35748 {
35749     struct
35750     {
35751         PTR32 device;
35752         VkDescriptorSetLayout DECLSPEC_ALIGN(8) layout;
35753         PTR32 pLayoutSizeInBytes;
35754     } *params = args;
35755
35756     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->layout), params->pLayoutSizeInBytes);
35757
35758     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));
35759     return STATUS_SUCCESS;
35760 }
35761
35762 #ifdef _WIN64
35763 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSupport(void *args)
35764 {
35765     struct vkGetDescriptorSetLayoutSupport_params *params = args;
35766
35767     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
35768
35769     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupport(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pSupport);
35770     return STATUS_SUCCESS;
35771 }
35772 #endif /* _WIN64 */
35773
35774 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSupport(void *args)
35775 {
35776     struct
35777     {
35778         PTR32 device;
35779         PTR32 pCreateInfo;
35780         PTR32 pSupport;
35781     } *params = args;
35782     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
35783     VkDescriptorSetLayoutSupport pSupport_host;
35784     struct conversion_context ctx;
35785
35786     TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pSupport);
35787
35788     init_conversion_context(&ctx);
35789     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
35790     convert_VkDescriptorSetLayoutSupport_win32_to_host(&ctx, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport), &pSupport_host);
35791     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutSupport(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pSupport_host);
35792     convert_VkDescriptorSetLayoutSupport_host_to_win32(&pSupport_host, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport));
35793     free_conversion_context(&ctx);
35794     return STATUS_SUCCESS;
35795 }
35796
35797 #ifdef _WIN64
35798 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSupportKHR(void *args)
35799 {
35800     struct vkGetDescriptorSetLayoutSupportKHR_params *params = args;
35801
35802     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
35803
35804     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupportKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pSupport);
35805     return STATUS_SUCCESS;
35806 }
35807 #endif /* _WIN64 */
35808
35809 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSupportKHR(void *args)
35810 {
35811     struct
35812     {
35813         PTR32 device;
35814         PTR32 pCreateInfo;
35815         PTR32 pSupport;
35816     } *params = args;
35817     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
35818     VkDescriptorSetLayoutSupport pSupport_host;
35819     struct conversion_context ctx;
35820
35821     TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pSupport);
35822
35823     init_conversion_context(&ctx);
35824     convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
35825     convert_VkDescriptorSetLayoutSupport_win32_to_host(&ctx, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport), &pSupport_host);
35826     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutSupportKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pSupport_host);
35827     convert_VkDescriptorSetLayoutSupport_host_to_win32(&pSupport_host, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport));
35828     free_conversion_context(&ctx);
35829     return STATUS_SUCCESS;
35830 }
35831
35832 #ifdef _WIN64
35833 static NTSTATUS thunk64_vkGetDeviceAccelerationStructureCompatibilityKHR(void *args)
35834 {
35835     struct vkGetDeviceAccelerationStructureCompatibilityKHR_params *params = args;
35836
35837     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
35838
35839     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceAccelerationStructureCompatibilityKHR(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
35840     return STATUS_SUCCESS;
35841 }
35842 #endif /* _WIN64 */
35843
35844 static NTSTATUS thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR(void *args)
35845 {
35846     struct
35847     {
35848         PTR32 device;
35849         PTR32 pVersionInfo;
35850         PTR32 pCompatibility;
35851     } *params = args;
35852     VkAccelerationStructureVersionInfoKHR pVersionInfo_host;
35853
35854     TRACE("%#x, %#x, %#x\n", params->device, params->pVersionInfo, params->pCompatibility);
35855
35856     convert_VkAccelerationStructureVersionInfoKHR_win32_to_host((const VkAccelerationStructureVersionInfoKHR32 *)UlongToPtr(params->pVersionInfo), &pVersionInfo_host);
35857     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));
35858     return STATUS_SUCCESS;
35859 }
35860
35861 #ifdef _WIN64
35862 static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirements(void *args)
35863 {
35864     struct vkGetDeviceBufferMemoryRequirements_params *params = args;
35865
35866     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
35867
35868     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
35869     return STATUS_SUCCESS;
35870 }
35871 #endif /* _WIN64 */
35872
35873 static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirements(void *args)
35874 {
35875     struct
35876     {
35877         PTR32 device;
35878         PTR32 pInfo;
35879         PTR32 pMemoryRequirements;
35880     } *params = args;
35881     VkDeviceBufferMemoryRequirements pInfo_host;
35882     VkMemoryRequirements2 pMemoryRequirements_host;
35883     struct conversion_context ctx;
35884
35885     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
35886
35887     init_conversion_context(&ctx);
35888     convert_VkDeviceBufferMemoryRequirements_win32_to_host(&ctx, (const VkDeviceBufferMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
35889     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
35890     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceBufferMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
35891     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
35892     free_conversion_context(&ctx);
35893     return STATUS_SUCCESS;
35894 }
35895
35896 #ifdef _WIN64
35897 static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirementsKHR(void *args)
35898 {
35899     struct vkGetDeviceBufferMemoryRequirementsKHR_params *params = args;
35900
35901     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
35902
35903     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
35904     return STATUS_SUCCESS;
35905 }
35906 #endif /* _WIN64 */
35907
35908 static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirementsKHR(void *args)
35909 {
35910     struct
35911     {
35912         PTR32 device;
35913         PTR32 pInfo;
35914         PTR32 pMemoryRequirements;
35915     } *params = args;
35916     VkDeviceBufferMemoryRequirements pInfo_host;
35917     VkMemoryRequirements2 pMemoryRequirements_host;
35918     struct conversion_context ctx;
35919
35920     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
35921
35922     init_conversion_context(&ctx);
35923     convert_VkDeviceBufferMemoryRequirements_win32_to_host(&ctx, (const VkDeviceBufferMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
35924     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
35925     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceBufferMemoryRequirementsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
35926     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
35927     free_conversion_context(&ctx);
35928     return STATUS_SUCCESS;
35929 }
35930
35931 #ifdef _WIN64
35932 static NTSTATUS thunk64_vkGetDeviceFaultInfoEXT(void *args)
35933 {
35934     struct vkGetDeviceFaultInfoEXT_params *params = args;
35935
35936     TRACE("%p, %p, %p\n", params->device, params->pFaultCounts, params->pFaultInfo);
35937
35938     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceFaultInfoEXT(wine_device_from_handle(params->device)->device, params->pFaultCounts, params->pFaultInfo);
35939     return STATUS_SUCCESS;
35940 }
35941 #endif /* _WIN64 */
35942
35943 static NTSTATUS thunk32_vkGetDeviceFaultInfoEXT(void *args)
35944 {
35945     struct
35946     {
35947         PTR32 device;
35948         PTR32 pFaultCounts;
35949         PTR32 pFaultInfo;
35950         VkResult result;
35951     } *params = args;
35952     VkDeviceFaultCountsEXT pFaultCounts_host;
35953     VkDeviceFaultInfoEXT *pFaultInfo_host = NULL;
35954     struct conversion_context ctx;
35955
35956     TRACE("%#x, %#x, %#x\n", params->device, params->pFaultCounts, params->pFaultInfo);
35957
35958     init_conversion_context(&ctx);
35959     convert_VkDeviceFaultCountsEXT_win32_to_host((VkDeviceFaultCountsEXT32 *)UlongToPtr(params->pFaultCounts), &pFaultCounts_host);
35960     if (params->pFaultInfo)
35961     {
35962         pFaultInfo_host = conversion_context_alloc(&ctx, sizeof(*pFaultInfo_host));
35963         convert_VkDeviceFaultInfoEXT_win32_to_host(&ctx, (VkDeviceFaultInfoEXT32 *)UlongToPtr(params->pFaultInfo), pFaultInfo_host);
35964     }
35965     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);
35966     convert_VkDeviceFaultCountsEXT_host_to_win32(&pFaultCounts_host, (VkDeviceFaultCountsEXT32 *)UlongToPtr(params->pFaultCounts));
35967     convert_VkDeviceFaultInfoEXT_host_to_win32(pFaultInfo_host, (VkDeviceFaultInfoEXT32 *)UlongToPtr(params->pFaultInfo));
35968     free_conversion_context(&ctx);
35969     return STATUS_SUCCESS;
35970 }
35971
35972 #ifdef _WIN64
35973 static NTSTATUS thunk64_vkGetDeviceGroupPeerMemoryFeatures(void *args)
35974 {
35975     struct vkGetDeviceGroupPeerMemoryFeatures_params *params = args;
35976
35977     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
35978
35979     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
35980     return STATUS_SUCCESS;
35981 }
35982 #endif /* _WIN64 */
35983
35984 static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeatures(void *args)
35985 {
35986     struct
35987     {
35988         PTR32 device;
35989         uint32_t heapIndex;
35990         uint32_t localDeviceIndex;
35991         uint32_t remoteDeviceIndex;
35992         PTR32 pPeerMemoryFeatures;
35993     } *params = args;
35994
35995     TRACE("%#x, %u, %u, %u, %#x\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
35996
35997     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));
35998     return STATUS_SUCCESS;
35999 }
36000
36001 #ifdef _WIN64
36002 static NTSTATUS thunk64_vkGetDeviceGroupPeerMemoryFeaturesKHR(void *args)
36003 {
36004     struct vkGetDeviceGroupPeerMemoryFeaturesKHR_params *params = args;
36005
36006     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36007
36008     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36009     return STATUS_SUCCESS;
36010 }
36011 #endif /* _WIN64 */
36012
36013 static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR(void *args)
36014 {
36015     struct
36016     {
36017         PTR32 device;
36018         uint32_t heapIndex;
36019         uint32_t localDeviceIndex;
36020         uint32_t remoteDeviceIndex;
36021         PTR32 pPeerMemoryFeatures;
36022     } *params = args;
36023
36024     TRACE("%#x, %u, %u, %u, %#x\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
36025
36026     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));
36027     return STATUS_SUCCESS;
36028 }
36029
36030 #ifdef _WIN64
36031 static NTSTATUS thunk64_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
36032 {
36033     struct vkGetDeviceGroupPresentCapabilitiesKHR_params *params = args;
36034
36035     TRACE("%p, %p\n", params->device, params->pDeviceGroupPresentCapabilities);
36036
36037     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle(params->device)->device, params->pDeviceGroupPresentCapabilities);
36038     return STATUS_SUCCESS;
36039 }
36040 #endif /* _WIN64 */
36041
36042 static NTSTATUS thunk32_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
36043 {
36044     struct
36045     {
36046         PTR32 device;
36047         PTR32 pDeviceGroupPresentCapabilities;
36048         VkResult result;
36049     } *params = args;
36050     VkDeviceGroupPresentCapabilitiesKHR pDeviceGroupPresentCapabilities_host;
36051
36052     TRACE("%#x, %#x\n", params->device, params->pDeviceGroupPresentCapabilities);
36053
36054     convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host((VkDeviceGroupPresentCapabilitiesKHR32 *)UlongToPtr(params->pDeviceGroupPresentCapabilities), &pDeviceGroupPresentCapabilities_host);
36055     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pDeviceGroupPresentCapabilities_host);
36056     convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(&pDeviceGroupPresentCapabilities_host, (VkDeviceGroupPresentCapabilitiesKHR32 *)UlongToPtr(params->pDeviceGroupPresentCapabilities));
36057     return STATUS_SUCCESS;
36058 }
36059
36060 #ifdef _WIN64
36061 static NTSTATUS thunk64_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
36062 {
36063     struct vkGetDeviceGroupSurfacePresentModesKHR_params *params = args;
36064
36065     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);
36066
36067     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);
36068     return STATUS_SUCCESS;
36069 }
36070 #endif /* _WIN64 */
36071
36072 static NTSTATUS thunk32_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
36073 {
36074     struct
36075     {
36076         PTR32 device;
36077         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
36078         PTR32 pModes;
36079         VkResult result;
36080     } *params = args;
36081
36082     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);
36083
36084     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));
36085     return STATUS_SUCCESS;
36086 }
36087
36088 #ifdef _WIN64
36089 static NTSTATUS thunk64_vkGetDeviceImageMemoryRequirements(void *args)
36090 {
36091     struct vkGetDeviceImageMemoryRequirements_params *params = args;
36092
36093     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36094
36095     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36096     return STATUS_SUCCESS;
36097 }
36098 #endif /* _WIN64 */
36099
36100 static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirements(void *args)
36101 {
36102     struct
36103     {
36104         PTR32 device;
36105         PTR32 pInfo;
36106         PTR32 pMemoryRequirements;
36107     } *params = args;
36108     VkDeviceImageMemoryRequirements pInfo_host;
36109     VkMemoryRequirements2 pMemoryRequirements_host;
36110     struct conversion_context ctx;
36111
36112     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36113
36114     init_conversion_context(&ctx);
36115     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36116     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36117     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36118     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36119     free_conversion_context(&ctx);
36120     return STATUS_SUCCESS;
36121 }
36122
36123 #ifdef _WIN64
36124 static NTSTATUS thunk64_vkGetDeviceImageMemoryRequirementsKHR(void *args)
36125 {
36126     struct vkGetDeviceImageMemoryRequirementsKHR_params *params = args;
36127
36128     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36129
36130     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36131     return STATUS_SUCCESS;
36132 }
36133 #endif /* _WIN64 */
36134
36135 static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirementsKHR(void *args)
36136 {
36137     struct
36138     {
36139         PTR32 device;
36140         PTR32 pInfo;
36141         PTR32 pMemoryRequirements;
36142     } *params = args;
36143     VkDeviceImageMemoryRequirements pInfo_host;
36144     VkMemoryRequirements2 pMemoryRequirements_host;
36145     struct conversion_context ctx;
36146
36147     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36148
36149     init_conversion_context(&ctx);
36150     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36151     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36152     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageMemoryRequirementsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36153     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36154     free_conversion_context(&ctx);
36155     return STATUS_SUCCESS;
36156 }
36157
36158 #ifdef _WIN64
36159 static NTSTATUS thunk64_vkGetDeviceImageSparseMemoryRequirements(void *args)
36160 {
36161     struct vkGetDeviceImageSparseMemoryRequirements_params *params = args;
36162
36163     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36164
36165     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36166     return STATUS_SUCCESS;
36167 }
36168 #endif /* _WIN64 */
36169
36170 static NTSTATUS thunk32_vkGetDeviceImageSparseMemoryRequirements(void *args)
36171 {
36172     struct
36173     {
36174         PTR32 device;
36175         PTR32 pInfo;
36176         PTR32 pSparseMemoryRequirementCount;
36177         PTR32 pSparseMemoryRequirements;
36178     } *params = args;
36179     VkDeviceImageMemoryRequirements pInfo_host;
36180     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
36181     struct conversion_context ctx;
36182
36183     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36184
36185     init_conversion_context(&ctx);
36186     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36187     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36188     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);
36189     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36190     free_conversion_context(&ctx);
36191     return STATUS_SUCCESS;
36192 }
36193
36194 #ifdef _WIN64
36195 static NTSTATUS thunk64_vkGetDeviceImageSparseMemoryRequirementsKHR(void *args)
36196 {
36197     struct vkGetDeviceImageSparseMemoryRequirementsKHR_params *params = args;
36198
36199     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36200
36201     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36202     return STATUS_SUCCESS;
36203 }
36204 #endif /* _WIN64 */
36205
36206 static NTSTATUS thunk32_vkGetDeviceImageSparseMemoryRequirementsKHR(void *args)
36207 {
36208     struct
36209     {
36210         PTR32 device;
36211         PTR32 pInfo;
36212         PTR32 pSparseMemoryRequirementCount;
36213         PTR32 pSparseMemoryRequirements;
36214     } *params = args;
36215     VkDeviceImageMemoryRequirements pInfo_host;
36216     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
36217     struct conversion_context ctx;
36218
36219     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36220
36221     init_conversion_context(&ctx);
36222     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
36223     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36224     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);
36225     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36226     free_conversion_context(&ctx);
36227     return STATUS_SUCCESS;
36228 }
36229
36230 #ifdef _WIN64
36231 static NTSTATUS thunk64_vkGetDeviceMemoryCommitment(void *args)
36232 {
36233     struct vkGetDeviceMemoryCommitment_params *params = args;
36234
36235     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pCommittedMemoryInBytes);
36236
36237     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryCommitment(wine_device_from_handle(params->device)->device, params->memory, params->pCommittedMemoryInBytes);
36238     return STATUS_SUCCESS;
36239 }
36240 #endif /* _WIN64 */
36241
36242 static NTSTATUS thunk32_vkGetDeviceMemoryCommitment(void *args)
36243 {
36244     struct
36245     {
36246         PTR32 device;
36247         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
36248         PTR32 pCommittedMemoryInBytes;
36249     } *params = args;
36250
36251     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->memory), params->pCommittedMemoryInBytes);
36252
36253     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMemoryCommitment(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->memory, (VkDeviceSize *)UlongToPtr(params->pCommittedMemoryInBytes));
36254     return STATUS_SUCCESS;
36255 }
36256
36257 #ifdef _WIN64
36258 static NTSTATUS thunk64_vkGetDeviceMemoryOpaqueCaptureAddress(void *args)
36259 {
36260     struct vkGetDeviceMemoryOpaqueCaptureAddress_params *params = args;
36261
36262     TRACE("%p, %p\n", params->device, params->pInfo);
36263
36264     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, params->pInfo);
36265     return STATUS_SUCCESS;
36266 }
36267 #endif /* _WIN64 */
36268
36269 static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddress(void *args)
36270 {
36271     struct
36272     {
36273         PTR32 device;
36274         PTR32 pInfo;
36275         uint64_t result;
36276     } *params = args;
36277     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
36278
36279     TRACE("%#x, %#x\n", params->device, params->pInfo);
36280
36281     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host((const VkDeviceMemoryOpaqueCaptureAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
36282     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
36283     return STATUS_SUCCESS;
36284 }
36285
36286 #ifdef _WIN64
36287 static NTSTATUS thunk64_vkGetDeviceMemoryOpaqueCaptureAddressKHR(void *args)
36288 {
36289     struct vkGetDeviceMemoryOpaqueCaptureAddressKHR_params *params = args;
36290
36291     TRACE("%p, %p\n", params->device, params->pInfo);
36292
36293     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
36294     return STATUS_SUCCESS;
36295 }
36296 #endif /* _WIN64 */
36297
36298 static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR(void *args)
36299 {
36300     struct
36301     {
36302         PTR32 device;
36303         PTR32 pInfo;
36304         uint64_t result;
36305     } *params = args;
36306     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
36307
36308     TRACE("%#x, %#x\n", params->device, params->pInfo);
36309
36310     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host((const VkDeviceMemoryOpaqueCaptureAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
36311     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
36312     return STATUS_SUCCESS;
36313 }
36314
36315 #ifdef _WIN64
36316 static NTSTATUS thunk64_vkGetDeviceMicromapCompatibilityEXT(void *args)
36317 {
36318     struct vkGetDeviceMicromapCompatibilityEXT_params *params = args;
36319
36320     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
36321
36322     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMicromapCompatibilityEXT(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
36323     return STATUS_SUCCESS;
36324 }
36325 #endif /* _WIN64 */
36326
36327 static NTSTATUS thunk32_vkGetDeviceMicromapCompatibilityEXT(void *args)
36328 {
36329     struct
36330     {
36331         PTR32 device;
36332         PTR32 pVersionInfo;
36333         PTR32 pCompatibility;
36334     } *params = args;
36335     VkMicromapVersionInfoEXT pVersionInfo_host;
36336
36337     TRACE("%#x, %#x, %#x\n", params->device, params->pVersionInfo, params->pCompatibility);
36338
36339     convert_VkMicromapVersionInfoEXT_win32_to_host((const VkMicromapVersionInfoEXT32 *)UlongToPtr(params->pVersionInfo), &pVersionInfo_host);
36340     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));
36341     return STATUS_SUCCESS;
36342 }
36343
36344 #ifdef _WIN64
36345 static NTSTATUS thunk64_vkGetDeviceQueue(void *args)
36346 {
36347     struct vkGetDeviceQueue_params *params = args;
36348
36349     TRACE("%p, %u, %u, %p\n", params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
36350
36351     wine_vkGetDeviceQueue(params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
36352     return STATUS_SUCCESS;
36353 }
36354 #endif /* _WIN64 */
36355
36356 static NTSTATUS thunk32_vkGetDeviceQueue(void *args)
36357 {
36358     struct
36359     {
36360         PTR32 device;
36361         uint32_t queueFamilyIndex;
36362         uint32_t queueIndex;
36363         PTR32 pQueue;
36364     } *params = args;
36365     VkQueue pQueue_host;
36366
36367     TRACE("%#x, %u, %u, %#x\n", params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
36368
36369     pQueue_host = *(VkQueue *)UlongToPtr(params->pQueue);
36370     wine_vkGetDeviceQueue((VkDevice)UlongToPtr(params->device), params->queueFamilyIndex, params->queueIndex, &pQueue_host);
36371     *(VkQueue *)UlongToPtr(params->pQueue) = pQueue_host;
36372     return STATUS_SUCCESS;
36373 }
36374
36375 #ifdef _WIN64
36376 static NTSTATUS thunk64_vkGetDeviceQueue2(void *args)
36377 {
36378     struct vkGetDeviceQueue2_params *params = args;
36379
36380     TRACE("%p, %p, %p\n", params->device, params->pQueueInfo, params->pQueue);
36381
36382     wine_vkGetDeviceQueue2(params->device, params->pQueueInfo, params->pQueue);
36383     return STATUS_SUCCESS;
36384 }
36385 #endif /* _WIN64 */
36386
36387 static NTSTATUS thunk32_vkGetDeviceQueue2(void *args)
36388 {
36389     struct
36390     {
36391         PTR32 device;
36392         PTR32 pQueueInfo;
36393         PTR32 pQueue;
36394     } *params = args;
36395     VkDeviceQueueInfo2 pQueueInfo_host;
36396     VkQueue pQueue_host;
36397
36398     TRACE("%#x, %#x, %#x\n", params->device, params->pQueueInfo, params->pQueue);
36399
36400     convert_VkDeviceQueueInfo2_win32_to_host((const VkDeviceQueueInfo232 *)UlongToPtr(params->pQueueInfo), &pQueueInfo_host);
36401     pQueue_host = *(VkQueue *)UlongToPtr(params->pQueue);
36402     wine_vkGetDeviceQueue2((VkDevice)UlongToPtr(params->device), &pQueueInfo_host, &pQueue_host);
36403     *(VkQueue *)UlongToPtr(params->pQueue) = pQueue_host;
36404     return STATUS_SUCCESS;
36405 }
36406
36407 #ifdef _WIN64
36408 static NTSTATUS thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *args)
36409 {
36410     struct vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_params *params = args;
36411
36412     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);
36413
36414     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle(params->device)->device, params->renderpass, params->pMaxWorkgroupSize);
36415     return STATUS_SUCCESS;
36416 }
36417 #endif /* _WIN64 */
36418
36419 static NTSTATUS thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *args)
36420 {
36421     struct
36422     {
36423         PTR32 device;
36424         VkRenderPass DECLSPEC_ALIGN(8) renderpass;
36425         PTR32 pMaxWorkgroupSize;
36426         VkResult result;
36427     } *params = args;
36428
36429     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);
36430
36431     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));
36432     return STATUS_SUCCESS;
36433 }
36434
36435 #ifdef _WIN64
36436 static NTSTATUS thunk64_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
36437 {
36438     struct vkGetDynamicRenderingTilePropertiesQCOM_params *params = args;
36439
36440     TRACE("%p, %p, %p\n", params->device, params->pRenderingInfo, params->pProperties);
36441
36442     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->pRenderingInfo, params->pProperties);
36443     return STATUS_SUCCESS;
36444 }
36445 #endif /* _WIN64 */
36446
36447 static NTSTATUS thunk32_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
36448 {
36449     struct
36450     {
36451         PTR32 device;
36452         PTR32 pRenderingInfo;
36453         PTR32 pProperties;
36454         VkResult result;
36455     } *params = args;
36456     VkRenderingInfo pRenderingInfo_host;
36457     VkTilePropertiesQCOM pProperties_host;
36458     struct conversion_context ctx;
36459
36460     TRACE("%#x, %#x, %#x\n", params->device, params->pRenderingInfo, params->pProperties);
36461
36462     init_conversion_context(&ctx);
36463     convert_VkRenderingInfo_win32_to_host(&ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
36464     convert_VkTilePropertiesQCOM_win32_to_host((VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), &pProperties_host);
36465     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);
36466     convert_VkTilePropertiesQCOM_host_to_win32(&pProperties_host, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties));
36467     free_conversion_context(&ctx);
36468     return STATUS_SUCCESS;
36469 }
36470
36471 #ifdef _WIN64
36472 static NTSTATUS thunk64_vkGetEventStatus(void *args)
36473 {
36474     struct vkGetEventStatus_params *params = args;
36475
36476     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
36477
36478     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetEventStatus(wine_device_from_handle(params->device)->device, params->event);
36479     return STATUS_SUCCESS;
36480 }
36481 #endif /* _WIN64 */
36482
36483 static NTSTATUS thunk32_vkGetEventStatus(void *args)
36484 {
36485     struct
36486     {
36487         PTR32 device;
36488         VkEvent DECLSPEC_ALIGN(8) event;
36489         VkResult result;
36490     } *params = args;
36491
36492     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
36493
36494     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetEventStatus(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
36495     return STATUS_SUCCESS;
36496 }
36497
36498 #ifdef _WIN64
36499 static NTSTATUS thunk64_vkGetFenceStatus(void *args)
36500 {
36501     struct vkGetFenceStatus_params *params = args;
36502
36503     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));
36504
36505     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFenceStatus(wine_device_from_handle(params->device)->device, params->fence);
36506     return STATUS_SUCCESS;
36507 }
36508 #endif /* _WIN64 */
36509
36510 static NTSTATUS thunk32_vkGetFenceStatus(void *args)
36511 {
36512     struct
36513     {
36514         PTR32 device;
36515         VkFence DECLSPEC_ALIGN(8) fence;
36516         VkResult result;
36517     } *params = args;
36518
36519     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));
36520
36521     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetFenceStatus(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->fence);
36522     return STATUS_SUCCESS;
36523 }
36524
36525 #ifdef _WIN64
36526 static NTSTATUS thunk64_vkGetFramebufferTilePropertiesQCOM(void *args)
36527 {
36528     struct vkGetFramebufferTilePropertiesQCOM_params *params = args;
36529
36530     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);
36531
36532     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->framebuffer, params->pPropertiesCount, params->pProperties);
36533     return STATUS_SUCCESS;
36534 }
36535 #endif /* _WIN64 */
36536
36537 static NTSTATUS thunk32_vkGetFramebufferTilePropertiesQCOM(void *args)
36538 {
36539     struct
36540     {
36541         PTR32 device;
36542         VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
36543         PTR32 pPropertiesCount;
36544         PTR32 pProperties;
36545         VkResult result;
36546     } *params = args;
36547     VkTilePropertiesQCOM *pProperties_host;
36548     struct conversion_context ctx;
36549
36550     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);
36551
36552     init_conversion_context(&ctx);
36553     pProperties_host = convert_VkTilePropertiesQCOM_array_win32_to_host(&ctx, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertiesCount));
36554     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);
36555     convert_VkTilePropertiesQCOM_array_host_to_win32(pProperties_host, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertiesCount));
36556     free_conversion_context(&ctx);
36557     return STATUS_SUCCESS;
36558 }
36559
36560 #ifdef _WIN64
36561 static NTSTATUS thunk64_vkGetGeneratedCommandsMemoryRequirementsNV(void *args)
36562 {
36563     struct vkGetGeneratedCommandsMemoryRequirementsNV_params *params = args;
36564
36565     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36566
36567     wine_device_from_handle(params->device)->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36568     return STATUS_SUCCESS;
36569 }
36570 #endif /* _WIN64 */
36571
36572 static NTSTATUS thunk32_vkGetGeneratedCommandsMemoryRequirementsNV(void *args)
36573 {
36574     struct
36575     {
36576         PTR32 device;
36577         PTR32 pInfo;
36578         PTR32 pMemoryRequirements;
36579     } *params = args;
36580     VkGeneratedCommandsMemoryRequirementsInfoNV pInfo_host;
36581     VkMemoryRequirements2 pMemoryRequirements_host;
36582     struct conversion_context ctx;
36583
36584     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36585
36586     init_conversion_context(&ctx);
36587     convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host((const VkGeneratedCommandsMemoryRequirementsInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
36588     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36589     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36590     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36591     free_conversion_context(&ctx);
36592     return STATUS_SUCCESS;
36593 }
36594
36595 #ifdef _WIN64
36596 static NTSTATUS thunk64_vkGetImageMemoryRequirements(void *args)
36597 {
36598     struct vkGetImageMemoryRequirements_params *params = args;
36599
36600     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pMemoryRequirements);
36601
36602     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pMemoryRequirements);
36603     return STATUS_SUCCESS;
36604 }
36605 #endif /* _WIN64 */
36606
36607 static NTSTATUS thunk32_vkGetImageMemoryRequirements(void *args)
36608 {
36609     struct
36610     {
36611         PTR32 device;
36612         VkImage DECLSPEC_ALIGN(8) image;
36613         PTR32 pMemoryRequirements;
36614     } *params = args;
36615     VkMemoryRequirements pMemoryRequirements_host;
36616
36617     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pMemoryRequirements);
36618
36619     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, &pMemoryRequirements_host);
36620     convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements32 *)UlongToPtr(params->pMemoryRequirements));
36621     return STATUS_SUCCESS;
36622 }
36623
36624 #ifdef _WIN64
36625 static NTSTATUS thunk64_vkGetImageMemoryRequirements2(void *args)
36626 {
36627     struct vkGetImageMemoryRequirements2_params *params = args;
36628
36629     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36630
36631     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36632     return STATUS_SUCCESS;
36633 }
36634 #endif /* _WIN64 */
36635
36636 static NTSTATUS thunk32_vkGetImageMemoryRequirements2(void *args)
36637 {
36638     struct
36639     {
36640         PTR32 device;
36641         PTR32 pInfo;
36642         PTR32 pMemoryRequirements;
36643     } *params = args;
36644     VkImageMemoryRequirementsInfo2 pInfo_host;
36645     VkMemoryRequirements2 pMemoryRequirements_host;
36646     struct conversion_context ctx;
36647
36648     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36649
36650     init_conversion_context(&ctx);
36651     convert_VkImageMemoryRequirementsInfo2_win32_to_host(&ctx, (const VkImageMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
36652     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36653     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36654     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36655     free_conversion_context(&ctx);
36656     return STATUS_SUCCESS;
36657 }
36658
36659 #ifdef _WIN64
36660 static NTSTATUS thunk64_vkGetImageMemoryRequirements2KHR(void *args)
36661 {
36662     struct vkGetImageMemoryRequirements2KHR_params *params = args;
36663
36664     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
36665
36666     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
36667     return STATUS_SUCCESS;
36668 }
36669 #endif /* _WIN64 */
36670
36671 static NTSTATUS thunk32_vkGetImageMemoryRequirements2KHR(void *args)
36672 {
36673     struct
36674     {
36675         PTR32 device;
36676         PTR32 pInfo;
36677         PTR32 pMemoryRequirements;
36678     } *params = args;
36679     VkImageMemoryRequirementsInfo2 pInfo_host;
36680     VkMemoryRequirements2 pMemoryRequirements_host;
36681     struct conversion_context ctx;
36682
36683     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
36684
36685     init_conversion_context(&ctx);
36686     convert_VkImageMemoryRequirementsInfo2_win32_to_host(&ctx, (const VkImageMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
36687     convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
36688     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
36689     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
36690     free_conversion_context(&ctx);
36691     return STATUS_SUCCESS;
36692 }
36693
36694 #ifdef _WIN64
36695 static NTSTATUS thunk64_vkGetImageOpaqueCaptureDescriptorDataEXT(void *args)
36696 {
36697     struct vkGetImageOpaqueCaptureDescriptorDataEXT_params *params = args;
36698
36699     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
36700
36701     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
36702     return STATUS_SUCCESS;
36703 }
36704 #endif /* _WIN64 */
36705
36706 static NTSTATUS thunk32_vkGetImageOpaqueCaptureDescriptorDataEXT(void *args)
36707 {
36708     struct
36709     {
36710         PTR32 device;
36711         PTR32 pInfo;
36712         PTR32 pData;
36713         VkResult result;
36714     } *params = args;
36715     VkImageCaptureDescriptorDataInfoEXT pInfo_host;
36716
36717     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
36718
36719     convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host((const VkImageCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
36720     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));
36721     return STATUS_SUCCESS;
36722 }
36723
36724 #ifdef _WIN64
36725 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements(void *args)
36726 {
36727     struct vkGetImageSparseMemoryRequirements_params *params = args;
36728
36729     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36730
36731     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36732     return STATUS_SUCCESS;
36733 }
36734 #endif /* _WIN64 */
36735
36736 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements(void *args)
36737 {
36738     struct
36739     {
36740         PTR32 device;
36741         VkImage DECLSPEC_ALIGN(8) image;
36742         PTR32 pSparseMemoryRequirementCount;
36743         PTR32 pSparseMemoryRequirements;
36744     } *params = args;
36745     VkSparseImageMemoryRequirements *pSparseMemoryRequirements_host;
36746     struct conversion_context ctx;
36747
36748     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36749
36750     init_conversion_context(&ctx);
36751     pSparseMemoryRequirements_host = (params->pSparseMemoryRequirements && *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount)) ? conversion_context_alloc(&ctx, sizeof(*pSparseMemoryRequirements_host) * *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount)) : NULL;
36752     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);
36753     convert_VkSparseImageMemoryRequirements_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements32 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36754     free_conversion_context(&ctx);
36755     return STATUS_SUCCESS;
36756 }
36757
36758 #ifdef _WIN64
36759 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements2(void *args)
36760 {
36761     struct vkGetImageSparseMemoryRequirements2_params *params = args;
36762
36763     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36764
36765     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36766     return STATUS_SUCCESS;
36767 }
36768 #endif /* _WIN64 */
36769
36770 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements2(void *args)
36771 {
36772     struct
36773     {
36774         PTR32 device;
36775         PTR32 pInfo;
36776         PTR32 pSparseMemoryRequirementCount;
36777         PTR32 pSparseMemoryRequirements;
36778     } *params = args;
36779     VkImageSparseMemoryRequirementsInfo2 pInfo_host;
36780     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
36781     struct conversion_context ctx;
36782
36783     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36784
36785     init_conversion_context(&ctx);
36786     convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host((const VkImageSparseMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
36787     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36788     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);
36789     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36790     free_conversion_context(&ctx);
36791     return STATUS_SUCCESS;
36792 }
36793
36794 #ifdef _WIN64
36795 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements2KHR(void *args)
36796 {
36797     struct vkGetImageSparseMemoryRequirements2KHR_params *params = args;
36798
36799     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36800
36801     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36802     return STATUS_SUCCESS;
36803 }
36804 #endif /* _WIN64 */
36805
36806 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements2KHR(void *args)
36807 {
36808     struct
36809     {
36810         PTR32 device;
36811         PTR32 pInfo;
36812         PTR32 pSparseMemoryRequirementCount;
36813         PTR32 pSparseMemoryRequirements;
36814     } *params = args;
36815     VkImageSparseMemoryRequirementsInfo2 pInfo_host;
36816     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
36817     struct conversion_context ctx;
36818
36819     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
36820
36821     init_conversion_context(&ctx);
36822     convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host((const VkImageSparseMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
36823     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36824     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);
36825     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
36826     free_conversion_context(&ctx);
36827     return STATUS_SUCCESS;
36828 }
36829
36830 #ifdef _WIN64
36831 static NTSTATUS thunk64_vkGetImageSubresourceLayout(void *args)
36832 {
36833     struct vkGetImageSubresourceLayout_params *params = args;
36834
36835     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
36836
36837     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, params->pLayout);
36838     return STATUS_SUCCESS;
36839 }
36840 #endif /* _WIN64 */
36841
36842 static NTSTATUS thunk32_vkGetImageSubresourceLayout(void *args)
36843 {
36844     struct
36845     {
36846         PTR32 device;
36847         VkImage DECLSPEC_ALIGN(8) image;
36848         PTR32 pSubresource;
36849         PTR32 pLayout;
36850     } *params = args;
36851     VkSubresourceLayout pLayout_host;
36852
36853     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
36854
36855     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);
36856     convert_VkSubresourceLayout_host_to_win32(&pLayout_host, (VkSubresourceLayout32 *)UlongToPtr(params->pLayout));
36857     return STATUS_SUCCESS;
36858 }
36859
36860 #ifdef _WIN64
36861 static NTSTATUS thunk64_vkGetImageSubresourceLayout2EXT(void *args)
36862 {
36863     struct vkGetImageSubresourceLayout2EXT_params *params = args;
36864
36865     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
36866
36867     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout2EXT(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, params->pLayout);
36868     return STATUS_SUCCESS;
36869 }
36870 #endif /* _WIN64 */
36871
36872 static NTSTATUS thunk32_vkGetImageSubresourceLayout2EXT(void *args)
36873 {
36874     struct
36875     {
36876         PTR32 device;
36877         VkImage DECLSPEC_ALIGN(8) image;
36878         PTR32 pSubresource;
36879         PTR32 pLayout;
36880     } *params = args;
36881     VkImageSubresource2EXT pSubresource_host;
36882     VkSubresourceLayout2EXT pLayout_host;
36883     struct conversion_context ctx;
36884
36885     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
36886
36887     init_conversion_context(&ctx);
36888     convert_VkImageSubresource2EXT_win32_to_host((const VkImageSubresource2EXT32 *)UlongToPtr(params->pSubresource), &pSubresource_host);
36889     convert_VkSubresourceLayout2EXT_win32_to_host(&ctx, (VkSubresourceLayout2EXT32 *)UlongToPtr(params->pLayout), &pLayout_host);
36890     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);
36891     convert_VkSubresourceLayout2EXT_host_to_win32(&pLayout_host, (VkSubresourceLayout2EXT32 *)UlongToPtr(params->pLayout));
36892     free_conversion_context(&ctx);
36893     return STATUS_SUCCESS;
36894 }
36895
36896 #ifdef _WIN64
36897 static NTSTATUS thunk64_vkGetImageViewAddressNVX(void *args)
36898 {
36899     struct vkGetImageViewAddressNVX_params *params = args;
36900
36901     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);
36902
36903     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle(params->device)->device, params->imageView, params->pProperties);
36904     return STATUS_SUCCESS;
36905 }
36906 #endif /* _WIN64 */
36907
36908 static NTSTATUS thunk32_vkGetImageViewAddressNVX(void *args)
36909 {
36910     struct
36911     {
36912         PTR32 device;
36913         VkImageView DECLSPEC_ALIGN(8) imageView;
36914         PTR32 pProperties;
36915         VkResult result;
36916     } *params = args;
36917     VkImageViewAddressPropertiesNVX pProperties_host;
36918
36919     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);
36920
36921     convert_VkImageViewAddressPropertiesNVX_win32_to_host((VkImageViewAddressPropertiesNVX32 *)UlongToPtr(params->pProperties), &pProperties_host);
36922     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);
36923     convert_VkImageViewAddressPropertiesNVX_host_to_win32(&pProperties_host, (VkImageViewAddressPropertiesNVX32 *)UlongToPtr(params->pProperties));
36924     return STATUS_SUCCESS;
36925 }
36926
36927 #ifdef _WIN64
36928 static NTSTATUS thunk64_vkGetImageViewHandleNVX(void *args)
36929 {
36930     struct vkGetImageViewHandleNVX_params *params = args;
36931
36932     TRACE("%p, %p\n", params->device, params->pInfo);
36933
36934     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle(params->device)->device, params->pInfo);
36935     return STATUS_SUCCESS;
36936 }
36937 #endif /* _WIN64 */
36938
36939 static NTSTATUS thunk32_vkGetImageViewHandleNVX(void *args)
36940 {
36941     struct
36942     {
36943         PTR32 device;
36944         PTR32 pInfo;
36945         uint32_t result;
36946     } *params = args;
36947     VkImageViewHandleInfoNVX pInfo_host;
36948
36949     TRACE("%#x, %#x\n", params->device, params->pInfo);
36950
36951     convert_VkImageViewHandleInfoNVX_win32_to_host((const VkImageViewHandleInfoNVX32 *)UlongToPtr(params->pInfo), &pInfo_host);
36952     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
36953     return STATUS_SUCCESS;
36954 }
36955
36956 #ifdef _WIN64
36957 static NTSTATUS thunk64_vkGetImageViewOpaqueCaptureDescriptorDataEXT(void *args)
36958 {
36959     struct vkGetImageViewOpaqueCaptureDescriptorDataEXT_params *params = args;
36960
36961     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
36962
36963     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
36964     return STATUS_SUCCESS;
36965 }
36966 #endif /* _WIN64 */
36967
36968 static NTSTATUS thunk32_vkGetImageViewOpaqueCaptureDescriptorDataEXT(void *args)
36969 {
36970     struct
36971     {
36972         PTR32 device;
36973         PTR32 pInfo;
36974         PTR32 pData;
36975         VkResult result;
36976     } *params = args;
36977     VkImageViewCaptureDescriptorDataInfoEXT pInfo_host;
36978
36979     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
36980
36981     convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host((const VkImageViewCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
36982     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));
36983     return STATUS_SUCCESS;
36984 }
36985
36986 #ifdef _WIN64
36987 static NTSTATUS thunk64_vkGetMemoryHostPointerPropertiesEXT(void *args)
36988 {
36989     struct vkGetMemoryHostPointerPropertiesEXT_params *params = args;
36990
36991     TRACE("%p, %#x, %p, %p\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
36992
36993     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle(params->device)->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
36994     return STATUS_SUCCESS;
36995 }
36996 #endif /* _WIN64 */
36997
36998 static NTSTATUS thunk32_vkGetMemoryHostPointerPropertiesEXT(void *args)
36999 {
37000     struct
37001     {
37002         PTR32 device;
37003         VkExternalMemoryHandleTypeFlagBits handleType;
37004         PTR32 pHostPointer;
37005         PTR32 pMemoryHostPointerProperties;
37006         VkResult result;
37007     } *params = args;
37008     VkMemoryHostPointerPropertiesEXT pMemoryHostPointerProperties_host;
37009
37010     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
37011
37012     convert_VkMemoryHostPointerPropertiesEXT_win32_to_host((VkMemoryHostPointerPropertiesEXT32 *)UlongToPtr(params->pMemoryHostPointerProperties), &pMemoryHostPointerProperties_host);
37013     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);
37014     convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(&pMemoryHostPointerProperties_host, (VkMemoryHostPointerPropertiesEXT32 *)UlongToPtr(params->pMemoryHostPointerProperties));
37015     return STATUS_SUCCESS;
37016 }
37017
37018 #ifdef _WIN64
37019 static NTSTATUS thunk64_vkGetMicromapBuildSizesEXT(void *args)
37020 {
37021     struct vkGetMicromapBuildSizesEXT_params *params = args;
37022
37023     TRACE("%p, %#x, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
37024
37025     wine_device_from_handle(params->device)->funcs.p_vkGetMicromapBuildSizesEXT(wine_device_from_handle(params->device)->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
37026     return STATUS_SUCCESS;
37027 }
37028 #endif /* _WIN64 */
37029
37030 static NTSTATUS thunk32_vkGetMicromapBuildSizesEXT(void *args)
37031 {
37032     struct
37033     {
37034         PTR32 device;
37035         VkAccelerationStructureBuildTypeKHR buildType;
37036         PTR32 pBuildInfo;
37037         PTR32 pSizeInfo;
37038     } *params = args;
37039     VkMicromapBuildInfoEXT pBuildInfo_host;
37040     VkMicromapBuildSizesInfoEXT pSizeInfo_host;
37041     struct conversion_context ctx;
37042
37043     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
37044
37045     init_conversion_context(&ctx);
37046     convert_VkMicromapBuildInfoEXT_win32_to_host(&ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pBuildInfo), &pBuildInfo_host);
37047     convert_VkMicromapBuildSizesInfoEXT_win32_to_host((VkMicromapBuildSizesInfoEXT32 *)UlongToPtr(params->pSizeInfo), &pSizeInfo_host);
37048     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);
37049     convert_VkMicromapBuildSizesInfoEXT_host_to_win32(&pSizeInfo_host, (VkMicromapBuildSizesInfoEXT32 *)UlongToPtr(params->pSizeInfo));
37050     free_conversion_context(&ctx);
37051     return STATUS_SUCCESS;
37052 }
37053
37054 #ifdef _WIN64
37055 static NTSTATUS thunk64_vkGetPerformanceParameterINTEL(void *args)
37056 {
37057     struct vkGetPerformanceParameterINTEL_params *params = args;
37058
37059     TRACE("%p, %#x, %p\n", params->device, params->parameter, params->pValue);
37060
37061     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle(params->device)->device, params->parameter, params->pValue);
37062     return STATUS_SUCCESS;
37063 }
37064 #endif /* _WIN64 */
37065
37066 static NTSTATUS thunk32_vkGetPerformanceParameterINTEL(void *args)
37067 {
37068     struct
37069     {
37070         PTR32 device;
37071         VkPerformanceParameterTypeINTEL parameter;
37072         PTR32 pValue;
37073         VkResult result;
37074     } *params = args;
37075     VkPerformanceValueINTEL pValue_host;
37076
37077     TRACE("%#x, %#x, %#x\n", params->device, params->parameter, params->pValue);
37078
37079     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);
37080     convert_VkPerformanceValueINTEL_host_to_win32(&pValue_host, (VkPerformanceValueINTEL32 *)UlongToPtr(params->pValue));
37081     return STATUS_SUCCESS;
37082 }
37083
37084 #ifdef _WIN64
37085 static NTSTATUS thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
37086 {
37087     struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params *params = args;
37088
37089     TRACE("%p, %p, %p\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
37090
37091     params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
37092     return STATUS_SUCCESS;
37093 }
37094 #endif /* _WIN64 */
37095
37096 static NTSTATUS thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
37097 {
37098     struct
37099     {
37100         PTR32 physicalDevice;
37101         PTR32 pTimeDomainCount;
37102         PTR32 pTimeDomains;
37103         VkResult result;
37104     } *params = args;
37105
37106     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
37107
37108     params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (uint32_t *)UlongToPtr(params->pTimeDomainCount), (VkTimeDomainEXT *)UlongToPtr(params->pTimeDomains));
37109     return STATUS_SUCCESS;
37110 }
37111
37112 #ifdef _WIN64
37113 static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
37114 {
37115     struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params *params = args;
37116
37117     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
37118
37119     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);
37120     return STATUS_SUCCESS;
37121 }
37122 #endif /* _WIN64 */
37123
37124 static NTSTATUS thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
37125 {
37126     struct
37127     {
37128         PTR32 physicalDevice;
37129         PTR32 pPropertyCount;
37130         PTR32 pProperties;
37131         VkResult result;
37132     } *params = args;
37133     VkCooperativeMatrixPropertiesNV *pProperties_host;
37134     struct conversion_context ctx;
37135
37136     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
37137
37138     init_conversion_context(&ctx);
37139     pProperties_host = convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(&ctx, (VkCooperativeMatrixPropertiesNV32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
37140     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);
37141     convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(pProperties_host, (VkCooperativeMatrixPropertiesNV32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
37142     free_conversion_context(&ctx);
37143     return STATUS_SUCCESS;
37144 }
37145
37146 #ifdef _WIN64
37147 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalBufferProperties(void *args)
37148 {
37149     struct vkGetPhysicalDeviceExternalBufferProperties_params *params = args;
37150
37151     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37152
37153     wine_vkGetPhysicalDeviceExternalBufferProperties(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37154     return STATUS_SUCCESS;
37155 }
37156 #endif /* _WIN64 */
37157
37158 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferProperties(void *args)
37159 {
37160     struct
37161     {
37162         PTR32 physicalDevice;
37163         PTR32 pExternalBufferInfo;
37164         PTR32 pExternalBufferProperties;
37165     } *params = args;
37166     VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo_host;
37167     VkExternalBufferProperties pExternalBufferProperties_host;
37168
37169     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37170
37171     convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host((const VkPhysicalDeviceExternalBufferInfo32 *)UlongToPtr(params->pExternalBufferInfo), &pExternalBufferInfo_host);
37172     convert_VkExternalBufferProperties_win32_to_host((VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties), &pExternalBufferProperties_host);
37173     wine_vkGetPhysicalDeviceExternalBufferProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalBufferInfo_host, &pExternalBufferProperties_host);
37174     convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, (VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties));
37175     return STATUS_SUCCESS;
37176 }
37177
37178 #ifdef _WIN64
37179 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args)
37180 {
37181     struct vkGetPhysicalDeviceExternalBufferPropertiesKHR_params *params = args;
37182
37183     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37184
37185     wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37186     return STATUS_SUCCESS;
37187 }
37188 #endif /* _WIN64 */
37189
37190 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args)
37191 {
37192     struct
37193     {
37194         PTR32 physicalDevice;
37195         PTR32 pExternalBufferInfo;
37196         PTR32 pExternalBufferProperties;
37197     } *params = args;
37198     VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo_host;
37199     VkExternalBufferProperties pExternalBufferProperties_host;
37200
37201     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
37202
37203     convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host((const VkPhysicalDeviceExternalBufferInfo32 *)UlongToPtr(params->pExternalBufferInfo), &pExternalBufferInfo_host);
37204     convert_VkExternalBufferProperties_win32_to_host((VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties), &pExternalBufferProperties_host);
37205     wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalBufferInfo_host, &pExternalBufferProperties_host);
37206     convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, (VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties));
37207     return STATUS_SUCCESS;
37208 }
37209
37210 #ifdef _WIN64
37211 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalFenceProperties(void *args)
37212 {
37213     struct vkGetPhysicalDeviceExternalFenceProperties_params *params = args;
37214
37215     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37216
37217     wine_vkGetPhysicalDeviceExternalFenceProperties(params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37218     return STATUS_SUCCESS;
37219 }
37220 #endif /* _WIN64 */
37221
37222 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalFenceProperties(void *args)
37223 {
37224     struct
37225     {
37226         PTR32 physicalDevice;
37227         PTR32 pExternalFenceInfo;
37228         PTR32 pExternalFenceProperties;
37229     } *params = args;
37230     VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo_host;
37231     VkExternalFenceProperties pExternalFenceProperties_host;
37232
37233     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37234
37235     convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host((const VkPhysicalDeviceExternalFenceInfo32 *)UlongToPtr(params->pExternalFenceInfo), &pExternalFenceInfo_host);
37236     convert_VkExternalFenceProperties_win32_to_host((VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties), &pExternalFenceProperties_host);
37237     wine_vkGetPhysicalDeviceExternalFenceProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalFenceInfo_host, &pExternalFenceProperties_host);
37238     convert_VkExternalFenceProperties_host_to_win32(&pExternalFenceProperties_host, (VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties));
37239     return STATUS_SUCCESS;
37240 }
37241
37242 #ifdef _WIN64
37243 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args)
37244 {
37245     struct vkGetPhysicalDeviceExternalFencePropertiesKHR_params *params = args;
37246
37247     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37248
37249     wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37250     return STATUS_SUCCESS;
37251 }
37252 #endif /* _WIN64 */
37253
37254 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args)
37255 {
37256     struct
37257     {
37258         PTR32 physicalDevice;
37259         PTR32 pExternalFenceInfo;
37260         PTR32 pExternalFenceProperties;
37261     } *params = args;
37262     VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo_host;
37263     VkExternalFenceProperties pExternalFenceProperties_host;
37264
37265     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
37266
37267     convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host((const VkPhysicalDeviceExternalFenceInfo32 *)UlongToPtr(params->pExternalFenceInfo), &pExternalFenceInfo_host);
37268     convert_VkExternalFenceProperties_win32_to_host((VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties), &pExternalFenceProperties_host);
37269     wine_vkGetPhysicalDeviceExternalFencePropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalFenceInfo_host, &pExternalFenceProperties_host);
37270     convert_VkExternalFenceProperties_host_to_win32(&pExternalFenceProperties_host, (VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties));
37271     return STATUS_SUCCESS;
37272 }
37273
37274 #ifdef _WIN64
37275 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalSemaphoreProperties(void *args)
37276 {
37277     struct vkGetPhysicalDeviceExternalSemaphoreProperties_params *params = args;
37278
37279     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
37280
37281     wine_vkGetPhysicalDeviceExternalSemaphoreProperties(params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
37282     return STATUS_SUCCESS;
37283 }
37284 #endif /* _WIN64 */
37285
37286 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphoreProperties(void *args)
37287 {
37288     struct
37289     {
37290         PTR32 physicalDevice;
37291         PTR32 pExternalSemaphoreInfo;
37292         PTR32 pExternalSemaphoreProperties;
37293     } *params = args;
37294     VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo_host;
37295     VkExternalSemaphoreProperties pExternalSemaphoreProperties_host;
37296     struct conversion_context ctx;
37297
37298     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
37299
37300     init_conversion_context(&ctx);
37301     convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(&ctx, (const VkPhysicalDeviceExternalSemaphoreInfo32 *)UlongToPtr(params->pExternalSemaphoreInfo), &pExternalSemaphoreInfo_host);
37302     convert_VkExternalSemaphoreProperties_win32_to_host((VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties), &pExternalSemaphoreProperties_host);
37303     wine_vkGetPhysicalDeviceExternalSemaphoreProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalSemaphoreInfo_host, &pExternalSemaphoreProperties_host);
37304     convert_VkExternalSemaphoreProperties_host_to_win32(&pExternalSemaphoreProperties_host, (VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties));
37305     free_conversion_context(&ctx);
37306     return STATUS_SUCCESS;
37307 }
37308
37309 #ifdef _WIN64
37310 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *args)
37311 {
37312     struct vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_params *params = args;
37313
37314     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
37315
37316     wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
37317     return STATUS_SUCCESS;
37318 }
37319 #endif /* _WIN64 */
37320
37321 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *args)
37322 {
37323     struct
37324     {
37325         PTR32 physicalDevice;
37326         PTR32 pExternalSemaphoreInfo;
37327         PTR32 pExternalSemaphoreProperties;
37328     } *params = args;
37329     VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo_host;
37330     VkExternalSemaphoreProperties pExternalSemaphoreProperties_host;
37331     struct conversion_context ctx;
37332
37333     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
37334
37335     init_conversion_context(&ctx);
37336     convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(&ctx, (const VkPhysicalDeviceExternalSemaphoreInfo32 *)UlongToPtr(params->pExternalSemaphoreInfo), &pExternalSemaphoreInfo_host);
37337     convert_VkExternalSemaphoreProperties_win32_to_host((VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties), &pExternalSemaphoreProperties_host);
37338     wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalSemaphoreInfo_host, &pExternalSemaphoreProperties_host);
37339     convert_VkExternalSemaphoreProperties_host_to_win32(&pExternalSemaphoreProperties_host, (VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties));
37340     free_conversion_context(&ctx);
37341     return STATUS_SUCCESS;
37342 }
37343
37344 #ifdef _WIN64
37345 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures(void *args)
37346 {
37347     struct vkGetPhysicalDeviceFeatures_params *params = args;
37348
37349     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
37350
37351     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
37352     return STATUS_SUCCESS;
37353 }
37354 #endif /* _WIN64 */
37355
37356 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures(void *args)
37357 {
37358     struct
37359     {
37360         PTR32 physicalDevice;
37361         PTR32 pFeatures;
37362     } *params = args;
37363
37364     TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);
37365
37366     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));
37367     return STATUS_SUCCESS;
37368 }
37369
37370 #ifdef _WIN64
37371 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures2(void *args)
37372 {
37373     struct vkGetPhysicalDeviceFeatures2_params *params = args;
37374
37375     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
37376
37377     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
37378     return STATUS_SUCCESS;
37379 }
37380 #endif /* _WIN64 */
37381
37382 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures2(void *args)
37383 {
37384     struct
37385     {
37386         PTR32 physicalDevice;
37387         PTR32 pFeatures;
37388     } *params = args;
37389     VkPhysicalDeviceFeatures2 pFeatures_host;
37390     struct conversion_context ctx;
37391
37392     TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);
37393
37394     init_conversion_context(&ctx);
37395     convert_VkPhysicalDeviceFeatures2_win32_to_host(&ctx, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures), &pFeatures_host);
37396     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);
37397     convert_VkPhysicalDeviceFeatures2_host_to_win32(&pFeatures_host, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures));
37398     free_conversion_context(&ctx);
37399     return STATUS_SUCCESS;
37400 }
37401
37402 #ifdef _WIN64
37403 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures2KHR(void *args)
37404 {
37405     struct vkGetPhysicalDeviceFeatures2KHR_params *params = args;
37406
37407     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
37408
37409     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
37410     return STATUS_SUCCESS;
37411 }
37412 #endif /* _WIN64 */
37413
37414 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures2KHR(void *args)
37415 {
37416     struct
37417     {
37418         PTR32 physicalDevice;
37419         PTR32 pFeatures;
37420     } *params = args;
37421     VkPhysicalDeviceFeatures2 pFeatures_host;
37422     struct conversion_context ctx;
37423
37424     TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);
37425
37426     init_conversion_context(&ctx);
37427     convert_VkPhysicalDeviceFeatures2_win32_to_host(&ctx, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures), &pFeatures_host);
37428     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);
37429     convert_VkPhysicalDeviceFeatures2_host_to_win32(&pFeatures_host, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures));
37430     free_conversion_context(&ctx);
37431     return STATUS_SUCCESS;
37432 }
37433
37434 #ifdef _WIN64
37435 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties(void *args)
37436 {
37437     struct vkGetPhysicalDeviceFormatProperties_params *params = args;
37438
37439     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
37440
37441     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
37442     return STATUS_SUCCESS;
37443 }
37444 #endif /* _WIN64 */
37445
37446 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties(void *args)
37447 {
37448     struct
37449     {
37450         PTR32 physicalDevice;
37451         VkFormat format;
37452         PTR32 pFormatProperties;
37453     } *params = args;
37454
37455     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);
37456
37457     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));
37458     return STATUS_SUCCESS;
37459 }
37460
37461 #ifdef _WIN64
37462 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties2(void *args)
37463 {
37464     struct vkGetPhysicalDeviceFormatProperties2_params *params = args;
37465
37466     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
37467
37468     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
37469     return STATUS_SUCCESS;
37470 }
37471 #endif /* _WIN64 */
37472
37473 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2(void *args)
37474 {
37475     struct
37476     {
37477         PTR32 physicalDevice;
37478         VkFormat format;
37479         PTR32 pFormatProperties;
37480     } *params = args;
37481     VkFormatProperties2 pFormatProperties_host;
37482     struct conversion_context ctx;
37483
37484     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);
37485
37486     init_conversion_context(&ctx);
37487     convert_VkFormatProperties2_win32_to_host(&ctx, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties), &pFormatProperties_host);
37488     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);
37489     convert_VkFormatProperties2_host_to_win32(&pFormatProperties_host, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties));
37490     free_conversion_context(&ctx);
37491     return STATUS_SUCCESS;
37492 }
37493
37494 #ifdef _WIN64
37495 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties2KHR(void *args)
37496 {
37497     struct vkGetPhysicalDeviceFormatProperties2KHR_params *params = args;
37498
37499     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
37500
37501     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
37502     return STATUS_SUCCESS;
37503 }
37504 #endif /* _WIN64 */
37505
37506 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2KHR(void *args)
37507 {
37508     struct
37509     {
37510         PTR32 physicalDevice;
37511         VkFormat format;
37512         PTR32 pFormatProperties;
37513     } *params = args;
37514     VkFormatProperties2 pFormatProperties_host;
37515     struct conversion_context ctx;
37516
37517     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);
37518
37519     init_conversion_context(&ctx);
37520     convert_VkFormatProperties2_win32_to_host(&ctx, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties), &pFormatProperties_host);
37521     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);
37522     convert_VkFormatProperties2_host_to_win32(&pFormatProperties_host, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties));
37523     free_conversion_context(&ctx);
37524     return STATUS_SUCCESS;
37525 }
37526
37527 #ifdef _WIN64
37528 static NTSTATUS thunk64_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
37529 {
37530     struct vkGetPhysicalDeviceFragmentShadingRatesKHR_params *params = args;
37531
37532     TRACE("%p, %p, %p\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
37533
37534     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);
37535     return STATUS_SUCCESS;
37536 }
37537 #endif /* _WIN64 */
37538
37539 static NTSTATUS thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
37540 {
37541     struct
37542     {
37543         PTR32 physicalDevice;
37544         PTR32 pFragmentShadingRateCount;
37545         PTR32 pFragmentShadingRates;
37546         VkResult result;
37547     } *params = args;
37548     VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates_host;
37549     struct conversion_context ctx;
37550
37551     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
37552
37553     init_conversion_context(&ctx);
37554     pFragmentShadingRates_host = convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(&ctx, (VkPhysicalDeviceFragmentShadingRateKHR32 *)UlongToPtr(params->pFragmentShadingRates), *(uint32_t *)UlongToPtr(params->pFragmentShadingRateCount));
37555     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);
37556     convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(pFragmentShadingRates_host, (VkPhysicalDeviceFragmentShadingRateKHR32 *)UlongToPtr(params->pFragmentShadingRates), *(uint32_t *)UlongToPtr(params->pFragmentShadingRateCount));
37557     free_conversion_context(&ctx);
37558     return STATUS_SUCCESS;
37559 }
37560
37561 #ifdef _WIN64
37562 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties(void *args)
37563 {
37564     struct vkGetPhysicalDeviceImageFormatProperties_params *params = args;
37565
37566     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
37567
37568     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);
37569     return STATUS_SUCCESS;
37570 }
37571 #endif /* _WIN64 */
37572
37573 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties(void *args)
37574 {
37575     struct
37576     {
37577         PTR32 physicalDevice;
37578         VkFormat format;
37579         VkImageType type;
37580         VkImageTiling tiling;
37581         VkImageUsageFlags usage;
37582         VkImageCreateFlags flags;
37583         PTR32 pImageFormatProperties;
37584         VkResult result;
37585     } *params = args;
37586     VkImageFormatProperties pImageFormatProperties_host;
37587
37588     TRACE("%#x, %#x, %#x, %#x, %#x, %#x, %#x\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
37589
37590     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);
37591     convert_VkImageFormatProperties_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties32 *)UlongToPtr(params->pImageFormatProperties));
37592     return STATUS_SUCCESS;
37593 }
37594
37595 #ifdef _WIN64
37596 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2(void *args)
37597 {
37598     struct vkGetPhysicalDeviceImageFormatProperties2_params *params = args;
37599
37600     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
37601
37602     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
37603     return STATUS_SUCCESS;
37604 }
37605 #endif /* _WIN64 */
37606
37607 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2(void *args)
37608 {
37609     struct
37610     {
37611         PTR32 physicalDevice;
37612         PTR32 pImageFormatInfo;
37613         PTR32 pImageFormatProperties;
37614         VkResult result;
37615     } *params = args;
37616     VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo_host;
37617     VkImageFormatProperties2 pImageFormatProperties_host;
37618     struct conversion_context ctx;
37619
37620     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
37621
37622     init_conversion_context(&ctx);
37623     convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(&ctx, (const VkPhysicalDeviceImageFormatInfo232 *)UlongToPtr(params->pImageFormatInfo), &pImageFormatInfo_host);
37624     convert_VkImageFormatProperties2_win32_to_host(&ctx, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties), &pImageFormatProperties_host);
37625     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pImageFormatInfo_host, &pImageFormatProperties_host);
37626     convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties));
37627     free_conversion_context(&ctx);
37628     return STATUS_SUCCESS;
37629 }
37630
37631 #ifdef _WIN64
37632 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
37633 {
37634     struct vkGetPhysicalDeviceImageFormatProperties2KHR_params *params = args;
37635
37636     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
37637
37638     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
37639     return STATUS_SUCCESS;
37640 }
37641 #endif /* _WIN64 */
37642
37643 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
37644 {
37645     struct
37646     {
37647         PTR32 physicalDevice;
37648         PTR32 pImageFormatInfo;
37649         PTR32 pImageFormatProperties;
37650         VkResult result;
37651     } *params = args;
37652     VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo_host;
37653     VkImageFormatProperties2 pImageFormatProperties_host;
37654     struct conversion_context ctx;
37655
37656     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
37657
37658     init_conversion_context(&ctx);
37659     convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(&ctx, (const VkPhysicalDeviceImageFormatInfo232 *)UlongToPtr(params->pImageFormatInfo), &pImageFormatInfo_host);
37660     convert_VkImageFormatProperties2_win32_to_host(&ctx, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties), &pImageFormatProperties_host);
37661     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pImageFormatInfo_host, &pImageFormatProperties_host);
37662     convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties));
37663     free_conversion_context(&ctx);
37664     return STATUS_SUCCESS;
37665 }
37666
37667 #ifdef _WIN64
37668 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties(void *args)
37669 {
37670     struct vkGetPhysicalDeviceMemoryProperties_params *params = args;
37671
37672     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
37673
37674     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
37675     return STATUS_SUCCESS;
37676 }
37677 #endif /* _WIN64 */
37678
37679 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties(void *args)
37680 {
37681     struct
37682     {
37683         PTR32 physicalDevice;
37684         PTR32 pMemoryProperties;
37685     } *params = args;
37686     VkPhysicalDeviceMemoryProperties pMemoryProperties_host;
37687
37688     TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);
37689
37690     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);
37691     convert_VkPhysicalDeviceMemoryProperties_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties32 *)UlongToPtr(params->pMemoryProperties));
37692     return STATUS_SUCCESS;
37693 }
37694
37695 #ifdef _WIN64
37696 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties2(void *args)
37697 {
37698     struct vkGetPhysicalDeviceMemoryProperties2_params *params = args;
37699
37700     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
37701
37702     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
37703     return STATUS_SUCCESS;
37704 }
37705 #endif /* _WIN64 */
37706
37707 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties2(void *args)
37708 {
37709     struct
37710     {
37711         PTR32 physicalDevice;
37712         PTR32 pMemoryProperties;
37713     } *params = args;
37714     VkPhysicalDeviceMemoryProperties2 pMemoryProperties_host;
37715     struct conversion_context ctx;
37716
37717     TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);
37718
37719     init_conversion_context(&ctx);
37720     convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(&ctx, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties), &pMemoryProperties_host);
37721     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);
37722     convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties));
37723     free_conversion_context(&ctx);
37724     return STATUS_SUCCESS;
37725 }
37726
37727 #ifdef _WIN64
37728 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties2KHR(void *args)
37729 {
37730     struct vkGetPhysicalDeviceMemoryProperties2KHR_params *params = args;
37731
37732     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
37733
37734     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
37735     return STATUS_SUCCESS;
37736 }
37737 #endif /* _WIN64 */
37738
37739 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties2KHR(void *args)
37740 {
37741     struct
37742     {
37743         PTR32 physicalDevice;
37744         PTR32 pMemoryProperties;
37745     } *params = args;
37746     VkPhysicalDeviceMemoryProperties2 pMemoryProperties_host;
37747     struct conversion_context ctx;
37748
37749     TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);
37750
37751     init_conversion_context(&ctx);
37752     convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(&ctx, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties), &pMemoryProperties_host);
37753     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);
37754     convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties));
37755     free_conversion_context(&ctx);
37756     return STATUS_SUCCESS;
37757 }
37758
37759 #ifdef _WIN64
37760 static NTSTATUS thunk64_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)
37761 {
37762     struct vkGetPhysicalDeviceMultisamplePropertiesEXT_params *params = args;
37763
37764     TRACE("%p, %#x, %p\n", params->physicalDevice, params->samples, params->pMultisampleProperties);
37765
37766     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->samples, params->pMultisampleProperties);
37767     return STATUS_SUCCESS;
37768 }
37769 #endif /* _WIN64 */
37770
37771 static NTSTATUS thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)
37772 {
37773     struct
37774     {
37775         PTR32 physicalDevice;
37776         VkSampleCountFlagBits samples;
37777         PTR32 pMultisampleProperties;
37778     } *params = args;
37779     VkMultisamplePropertiesEXT pMultisampleProperties_host;
37780
37781     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->samples, params->pMultisampleProperties);
37782
37783     convert_VkMultisamplePropertiesEXT_win32_to_host((VkMultisamplePropertiesEXT32 *)UlongToPtr(params->pMultisampleProperties), &pMultisampleProperties_host);
37784     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);
37785     convert_VkMultisamplePropertiesEXT_host_to_win32(&pMultisampleProperties_host, (VkMultisamplePropertiesEXT32 *)UlongToPtr(params->pMultisampleProperties));
37786     return STATUS_SUCCESS;
37787 }
37788
37789 #ifdef _WIN64
37790 static NTSTATUS thunk64_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
37791 {
37792     struct vkGetPhysicalDeviceOpticalFlowImageFormatsNV_params *params = args;
37793
37794     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
37795
37796     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);
37797     return STATUS_SUCCESS;
37798 }
37799 #endif /* _WIN64 */
37800
37801 static NTSTATUS thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
37802 {
37803     struct
37804     {
37805         PTR32 physicalDevice;
37806         PTR32 pOpticalFlowImageFormatInfo;
37807         PTR32 pFormatCount;
37808         PTR32 pImageFormatProperties;
37809         VkResult result;
37810     } *params = args;
37811     VkOpticalFlowImageFormatInfoNV pOpticalFlowImageFormatInfo_host;
37812     VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties_host;
37813     struct conversion_context ctx;
37814
37815     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
37816
37817     init_conversion_context(&ctx);
37818     convert_VkOpticalFlowImageFormatInfoNV_win32_to_host((const VkOpticalFlowImageFormatInfoNV32 *)UlongToPtr(params->pOpticalFlowImageFormatInfo), &pOpticalFlowImageFormatInfo_host);
37819     pImageFormatProperties_host = convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(&ctx, (VkOpticalFlowImageFormatPropertiesNV32 *)UlongToPtr(params->pImageFormatProperties), *(uint32_t *)UlongToPtr(params->pFormatCount));
37820     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);
37821     convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(pImageFormatProperties_host, (VkOpticalFlowImageFormatPropertiesNV32 *)UlongToPtr(params->pImageFormatProperties), *(uint32_t *)UlongToPtr(params->pFormatCount));
37822     free_conversion_context(&ctx);
37823     return STATUS_SUCCESS;
37824 }
37825
37826 #ifdef _WIN64
37827 static NTSTATUS thunk64_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
37828 {
37829     struct vkGetPhysicalDevicePresentRectanglesKHR_params *params = args;
37830
37831     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);
37832
37833     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);
37834     return STATUS_SUCCESS;
37835 }
37836 #endif /* _WIN64 */
37837
37838 static NTSTATUS thunk32_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
37839 {
37840     struct
37841     {
37842         PTR32 physicalDevice;
37843         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
37844         PTR32 pRectCount;
37845         PTR32 pRects;
37846         VkResult result;
37847     } *params = args;
37848
37849     TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);
37850
37851     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));
37852     return STATUS_SUCCESS;
37853 }
37854
37855 #ifdef _WIN64
37856 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties(void *args)
37857 {
37858     struct vkGetPhysicalDeviceProperties_params *params = args;
37859
37860     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
37861
37862     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
37863     return STATUS_SUCCESS;
37864 }
37865 #endif /* _WIN64 */
37866
37867 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties(void *args)
37868 {
37869     struct
37870     {
37871         PTR32 physicalDevice;
37872         PTR32 pProperties;
37873     } *params = args;
37874     VkPhysicalDeviceProperties pProperties_host;
37875
37876     TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);
37877
37878     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);
37879     convert_VkPhysicalDeviceProperties_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties32 *)UlongToPtr(params->pProperties));
37880     return STATUS_SUCCESS;
37881 }
37882
37883 #ifdef _WIN64
37884 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties2(void *args)
37885 {
37886     struct vkGetPhysicalDeviceProperties2_params *params = args;
37887
37888     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
37889
37890     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
37891     return STATUS_SUCCESS;
37892 }
37893 #endif /* _WIN64 */
37894
37895 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2(void *args)
37896 {
37897     struct
37898     {
37899         PTR32 physicalDevice;
37900         PTR32 pProperties;
37901     } *params = args;
37902     VkPhysicalDeviceProperties2 pProperties_host;
37903     struct conversion_context ctx;
37904
37905     TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);
37906
37907     init_conversion_context(&ctx);
37908     convert_VkPhysicalDeviceProperties2_win32_to_host(&ctx, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties), &pProperties_host);
37909     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);
37910     convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties));
37911     free_conversion_context(&ctx);
37912     return STATUS_SUCCESS;
37913 }
37914
37915 #ifdef _WIN64
37916 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties2KHR(void *args)
37917 {
37918     struct vkGetPhysicalDeviceProperties2KHR_params *params = args;
37919
37920     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
37921
37922     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
37923     return STATUS_SUCCESS;
37924 }
37925 #endif /* _WIN64 */
37926
37927 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2KHR(void *args)
37928 {
37929     struct
37930     {
37931         PTR32 physicalDevice;
37932         PTR32 pProperties;
37933     } *params = args;
37934     VkPhysicalDeviceProperties2 pProperties_host;
37935     struct conversion_context ctx;
37936
37937     TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);
37938
37939     init_conversion_context(&ctx);
37940     convert_VkPhysicalDeviceProperties2_win32_to_host(&ctx, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties), &pProperties_host);
37941     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);
37942     convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties));
37943     free_conversion_context(&ctx);
37944     return STATUS_SUCCESS;
37945 }
37946
37947 #ifdef _WIN64
37948 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(void *args)
37949 {
37950     struct vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_params *params = args;
37951
37952     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPerformanceQueryCreateInfo, params->pNumPasses);
37953
37954     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPerformanceQueryCreateInfo, params->pNumPasses);
37955     return STATUS_SUCCESS;
37956 }
37957 #endif /* _WIN64 */
37958
37959 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(void *args)
37960 {
37961     struct
37962     {
37963         PTR32 physicalDevice;
37964         PTR32 pPerformanceQueryCreateInfo;
37965         PTR32 pNumPasses;
37966     } *params = args;
37967     VkQueryPoolPerformanceCreateInfoKHR pPerformanceQueryCreateInfo_host;
37968
37969     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPerformanceQueryCreateInfo, params->pNumPasses);
37970
37971     convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host((const VkQueryPoolPerformanceCreateInfoKHR32 *)UlongToPtr(params->pPerformanceQueryCreateInfo), &pPerformanceQueryCreateInfo_host);
37972     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));
37973     return STATUS_SUCCESS;
37974 }
37975
37976 #ifdef _WIN64
37977 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties(void *args)
37978 {
37979     struct vkGetPhysicalDeviceQueueFamilyProperties_params *params = args;
37980
37981     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
37982
37983     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
37984     return STATUS_SUCCESS;
37985 }
37986 #endif /* _WIN64 */
37987
37988 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties(void *args)
37989 {
37990     struct
37991     {
37992         PTR32 physicalDevice;
37993         PTR32 pQueueFamilyPropertyCount;
37994         PTR32 pQueueFamilyProperties;
37995     } *params = args;
37996
37997     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
37998
37999     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));
38000     return STATUS_SUCCESS;
38001 }
38002
38003 #ifdef _WIN64
38004 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties2(void *args)
38005 {
38006     struct vkGetPhysicalDeviceQueueFamilyProperties2_params *params = args;
38007
38008     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38009
38010     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38011     return STATUS_SUCCESS;
38012 }
38013 #endif /* _WIN64 */
38014
38015 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties2(void *args)
38016 {
38017     struct
38018     {
38019         PTR32 physicalDevice;
38020         PTR32 pQueueFamilyPropertyCount;
38021         PTR32 pQueueFamilyProperties;
38022     } *params = args;
38023     VkQueueFamilyProperties2 *pQueueFamilyProperties_host;
38024     struct conversion_context ctx;
38025
38026     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38027
38028     init_conversion_context(&ctx);
38029     pQueueFamilyProperties_host = convert_VkQueueFamilyProperties2_array_win32_to_host(&ctx, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
38030     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);
38031     convert_VkQueueFamilyProperties2_array_host_to_win32(pQueueFamilyProperties_host, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
38032     free_conversion_context(&ctx);
38033     return STATUS_SUCCESS;
38034 }
38035
38036 #ifdef _WIN64
38037 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties2KHR(void *args)
38038 {
38039     struct vkGetPhysicalDeviceQueueFamilyProperties2KHR_params *params = args;
38040
38041     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38042
38043     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38044     return STATUS_SUCCESS;
38045 }
38046 #endif /* _WIN64 */
38047
38048 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties2KHR(void *args)
38049 {
38050     struct
38051     {
38052         PTR32 physicalDevice;
38053         PTR32 pQueueFamilyPropertyCount;
38054         PTR32 pQueueFamilyProperties;
38055     } *params = args;
38056     VkQueueFamilyProperties2 *pQueueFamilyProperties_host;
38057     struct conversion_context ctx;
38058
38059     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
38060
38061     init_conversion_context(&ctx);
38062     pQueueFamilyProperties_host = convert_VkQueueFamilyProperties2_array_win32_to_host(&ctx, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
38063     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);
38064     convert_VkQueueFamilyProperties2_array_host_to_win32(pQueueFamilyProperties_host, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
38065     free_conversion_context(&ctx);
38066     return STATUS_SUCCESS;
38067 }
38068
38069 #ifdef _WIN64
38070 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties(void *args)
38071 {
38072     struct vkGetPhysicalDeviceSparseImageFormatProperties_params *params = args;
38073
38074     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);
38075
38076     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);
38077     return STATUS_SUCCESS;
38078 }
38079 #endif /* _WIN64 */
38080
38081 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties(void *args)
38082 {
38083     struct
38084     {
38085         PTR32 physicalDevice;
38086         VkFormat format;
38087         VkImageType type;
38088         VkSampleCountFlagBits samples;
38089         VkImageUsageFlags usage;
38090         VkImageTiling tiling;
38091         PTR32 pPropertyCount;
38092         PTR32 pProperties;
38093     } *params = args;
38094
38095     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);
38096
38097     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));
38098     return STATUS_SUCCESS;
38099 }
38100
38101 #ifdef _WIN64
38102 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2(void *args)
38103 {
38104     struct vkGetPhysicalDeviceSparseImageFormatProperties2_params *params = args;
38105
38106     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38107
38108     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);
38109     return STATUS_SUCCESS;
38110 }
38111 #endif /* _WIN64 */
38112
38113 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2(void *args)
38114 {
38115     struct
38116     {
38117         PTR32 physicalDevice;
38118         PTR32 pFormatInfo;
38119         PTR32 pPropertyCount;
38120         PTR32 pProperties;
38121     } *params = args;
38122     VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo_host;
38123     VkSparseImageFormatProperties2 *pProperties_host;
38124     struct conversion_context ctx;
38125
38126     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38127
38128     init_conversion_context(&ctx);
38129     convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host((const VkPhysicalDeviceSparseImageFormatInfo232 *)UlongToPtr(params->pFormatInfo), &pFormatInfo_host);
38130     pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(&ctx, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
38131     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);
38132     convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
38133     free_conversion_context(&ctx);
38134     return STATUS_SUCCESS;
38135 }
38136
38137 #ifdef _WIN64
38138 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void *args)
38139 {
38140     struct vkGetPhysicalDeviceSparseImageFormatProperties2KHR_params *params = args;
38141
38142     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38143
38144     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);
38145     return STATUS_SUCCESS;
38146 }
38147 #endif /* _WIN64 */
38148
38149 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void *args)
38150 {
38151     struct
38152     {
38153         PTR32 physicalDevice;
38154         PTR32 pFormatInfo;
38155         PTR32 pPropertyCount;
38156         PTR32 pProperties;
38157     } *params = args;
38158     VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo_host;
38159     VkSparseImageFormatProperties2 *pProperties_host;
38160     struct conversion_context ctx;
38161
38162     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
38163
38164     init_conversion_context(&ctx);
38165     convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host((const VkPhysicalDeviceSparseImageFormatInfo232 *)UlongToPtr(params->pFormatInfo), &pFormatInfo_host);
38166     pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(&ctx, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
38167     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);
38168     convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
38169     free_conversion_context(&ctx);
38170     return STATUS_SUCCESS;
38171 }
38172
38173 #ifdef _WIN64
38174 static NTSTATUS thunk64_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(void *args)
38175 {
38176     struct vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_params *params = args;
38177
38178     TRACE("%p, %p, %p\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);
38179
38180     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);
38181     return STATUS_SUCCESS;
38182 }
38183 #endif /* _WIN64 */
38184
38185 static NTSTATUS thunk32_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(void *args)
38186 {
38187     struct
38188     {
38189         PTR32 physicalDevice;
38190         PTR32 pCombinationCount;
38191         PTR32 pCombinations;
38192         VkResult result;
38193     } *params = args;
38194     VkFramebufferMixedSamplesCombinationNV *pCombinations_host;
38195     struct conversion_context ctx;
38196
38197     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);
38198
38199     init_conversion_context(&ctx);
38200     pCombinations_host = convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(&ctx, (VkFramebufferMixedSamplesCombinationNV32 *)UlongToPtr(params->pCombinations), *(uint32_t *)UlongToPtr(params->pCombinationCount));
38201     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);
38202     convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(pCombinations_host, (VkFramebufferMixedSamplesCombinationNV32 *)UlongToPtr(params->pCombinations), *(uint32_t *)UlongToPtr(params->pCombinationCount));
38203     free_conversion_context(&ctx);
38204     return STATUS_SUCCESS;
38205 }
38206
38207 #ifdef _WIN64
38208 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
38209 {
38210     struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params *params = args;
38211
38212     TRACE("%p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
38213
38214     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
38215     return STATUS_SUCCESS;
38216 }
38217 #endif /* _WIN64 */
38218
38219 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
38220 {
38221     struct
38222     {
38223         PTR32 physicalDevice;
38224         PTR32 pSurfaceInfo;
38225         PTR32 pSurfaceCapabilities;
38226         VkResult result;
38227     } *params = args;
38228     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
38229     VkSurfaceCapabilities2KHR pSurfaceCapabilities_host;
38230     struct conversion_context ctx;
38231
38232     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
38233
38234     init_conversion_context(&ctx);
38235     convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host((const VkPhysicalDeviceSurfaceInfo2KHR32 *)UlongToPtr(params->pSurfaceInfo), &pSurfaceInfo_host);
38236     convert_VkSurfaceCapabilities2KHR_win32_to_host(&ctx, (VkSurfaceCapabilities2KHR32 *)UlongToPtr(params->pSurfaceCapabilities), &pSurfaceCapabilities_host);
38237     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pSurfaceInfo_host, &pSurfaceCapabilities_host);
38238     convert_VkSurfaceCapabilities2KHR_host_to_win32(&pSurfaceCapabilities_host, (VkSurfaceCapabilities2KHR32 *)UlongToPtr(params->pSurfaceCapabilities));
38239     free_conversion_context(&ctx);
38240     return STATUS_SUCCESS;
38241 }
38242
38243 #ifdef _WIN64
38244 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
38245 {
38246     struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params *params = args;
38247
38248     TRACE("%p, 0x%s, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);
38249
38250     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(params->physicalDevice, params->surface, params->pSurfaceCapabilities);
38251     return STATUS_SUCCESS;
38252 }
38253 #endif /* _WIN64 */
38254
38255 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
38256 {
38257     struct
38258     {
38259         PTR32 physicalDevice;
38260         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
38261         PTR32 pSurfaceCapabilities;
38262         VkResult result;
38263     } *params = args;
38264
38265     TRACE("%#x, 0x%s, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);
38266
38267     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), params->surface, (VkSurfaceCapabilitiesKHR *)UlongToPtr(params->pSurfaceCapabilities));
38268     return STATUS_SUCCESS;
38269 }
38270
38271 #ifdef _WIN64
38272 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
38273 {
38274     struct vkGetPhysicalDeviceSurfaceFormats2KHR_params *params = args;
38275     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
38276
38277     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);
38278
38279     convert_VkPhysicalDeviceSurfaceInfo2KHR_win64_to_host(params->pSurfaceInfo, &pSurfaceInfo_host);
38280     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);
38281     return STATUS_SUCCESS;
38282 }
38283 #endif /* _WIN64 */
38284
38285 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
38286 {
38287     struct
38288     {
38289         PTR32 physicalDevice;
38290         PTR32 pSurfaceInfo;
38291         PTR32 pSurfaceFormatCount;
38292         PTR32 pSurfaceFormats;
38293         VkResult result;
38294     } *params = args;
38295     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
38296     VkSurfaceFormat2KHR *pSurfaceFormats_host;
38297     struct conversion_context ctx;
38298
38299     TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);
38300
38301     init_conversion_context(&ctx);
38302     convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host((const VkPhysicalDeviceSurfaceInfo2KHR32 *)UlongToPtr(params->pSurfaceInfo), &pSurfaceInfo_host);
38303     pSurfaceFormats_host = convert_VkSurfaceFormat2KHR_array_win32_to_host(&ctx, (VkSurfaceFormat2KHR32 *)UlongToPtr(params->pSurfaceFormats), *(uint32_t *)UlongToPtr(params->pSurfaceFormatCount));
38304     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);
38305     convert_VkSurfaceFormat2KHR_array_host_to_win32(pSurfaceFormats_host, (VkSurfaceFormat2KHR32 *)UlongToPtr(params->pSurfaceFormats), *(uint32_t *)UlongToPtr(params->pSurfaceFormatCount));
38306     free_conversion_context(&ctx);
38307     return STATUS_SUCCESS;
38308 }
38309
38310 #ifdef _WIN64
38311 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
38312 {
38313     struct vkGetPhysicalDeviceSurfaceFormatsKHR_params *params = args;
38314
38315     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);
38316
38317     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pSurfaceFormatCount, params->pSurfaceFormats);
38318     return STATUS_SUCCESS;
38319 }
38320 #endif /* _WIN64 */
38321
38322 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
38323 {
38324     struct
38325     {
38326         PTR32 physicalDevice;
38327         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
38328         PTR32 pSurfaceFormatCount;
38329         PTR32 pSurfaceFormats;
38330         VkResult result;
38331     } *params = args;
38332
38333     TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);
38334
38335     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, wine_surface_from_handle(params->surface)->driver_surface, (uint32_t *)UlongToPtr(params->pSurfaceFormatCount), (VkSurfaceFormatKHR *)UlongToPtr(params->pSurfaceFormats));
38336     return STATUS_SUCCESS;
38337 }
38338
38339 #ifdef _WIN64
38340 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
38341 {
38342     struct vkGetPhysicalDeviceSurfacePresentModesKHR_params *params = args;
38343
38344     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);
38345
38346     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pPresentModeCount, params->pPresentModes);
38347     return STATUS_SUCCESS;
38348 }
38349 #endif /* _WIN64 */
38350
38351 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
38352 {
38353     struct
38354     {
38355         PTR32 physicalDevice;
38356         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
38357         PTR32 pPresentModeCount;
38358         PTR32 pPresentModes;
38359         VkResult result;
38360     } *params = args;
38361
38362     TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);
38363
38364     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, wine_surface_from_handle(params->surface)->driver_surface, (uint32_t *)UlongToPtr(params->pPresentModeCount), (VkPresentModeKHR *)UlongToPtr(params->pPresentModes));
38365     return STATUS_SUCCESS;
38366 }
38367
38368 #ifdef _WIN64
38369 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
38370 {
38371     struct vkGetPhysicalDeviceSurfaceSupportKHR_params *params = args;
38372
38373     TRACE("%p, %u, 0x%s, %p\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);
38374
38375     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);
38376     return STATUS_SUCCESS;
38377 }
38378 #endif /* _WIN64 */
38379
38380 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
38381 {
38382     struct
38383     {
38384         PTR32 physicalDevice;
38385         uint32_t queueFamilyIndex;
38386         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
38387         PTR32 pSupported;
38388         VkResult result;
38389     } *params = args;
38390
38391     TRACE("%#x, %u, 0x%s, %#x\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);
38392
38393     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));
38394     return STATUS_SUCCESS;
38395 }
38396
38397 #ifdef _WIN64
38398 static NTSTATUS thunk64_vkGetPhysicalDeviceToolProperties(void *args)
38399 {
38400     struct vkGetPhysicalDeviceToolProperties_params *params = args;
38401
38402     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
38403
38404     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);
38405     return STATUS_SUCCESS;
38406 }
38407 #endif /* _WIN64 */
38408
38409 static NTSTATUS thunk32_vkGetPhysicalDeviceToolProperties(void *args)
38410 {
38411     struct
38412     {
38413         PTR32 physicalDevice;
38414         PTR32 pToolCount;
38415         PTR32 pToolProperties;
38416         VkResult result;
38417     } *params = args;
38418     VkPhysicalDeviceToolProperties *pToolProperties_host;
38419     struct conversion_context ctx;
38420
38421     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
38422
38423     init_conversion_context(&ctx);
38424     pToolProperties_host = convert_VkPhysicalDeviceToolProperties_array_win32_to_host(&ctx, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
38425     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);
38426     convert_VkPhysicalDeviceToolProperties_array_host_to_win32(pToolProperties_host, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
38427     free_conversion_context(&ctx);
38428     return STATUS_SUCCESS;
38429 }
38430
38431 #ifdef _WIN64
38432 static NTSTATUS thunk64_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
38433 {
38434     struct vkGetPhysicalDeviceToolPropertiesEXT_params *params = args;
38435
38436     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
38437
38438     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);
38439     return STATUS_SUCCESS;
38440 }
38441 #endif /* _WIN64 */
38442
38443 static NTSTATUS thunk32_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
38444 {
38445     struct
38446     {
38447         PTR32 physicalDevice;
38448         PTR32 pToolCount;
38449         PTR32 pToolProperties;
38450         VkResult result;
38451     } *params = args;
38452     VkPhysicalDeviceToolProperties *pToolProperties_host;
38453     struct conversion_context ctx;
38454
38455     TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
38456
38457     init_conversion_context(&ctx);
38458     pToolProperties_host = convert_VkPhysicalDeviceToolProperties_array_win32_to_host(&ctx, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
38459     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);
38460     convert_VkPhysicalDeviceToolProperties_array_host_to_win32(pToolProperties_host, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
38461     free_conversion_context(&ctx);
38462     return STATUS_SUCCESS;
38463 }
38464
38465 #ifdef _WIN64
38466 static NTSTATUS thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *args)
38467 {
38468     struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params *params = args;
38469
38470     TRACE("%p, %u\n", params->physicalDevice, params->queueFamilyIndex);
38471
38472     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex);
38473     return STATUS_SUCCESS;
38474 }
38475 #endif /* _WIN64 */
38476
38477 static NTSTATUS thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *args)
38478 {
38479     struct
38480     {
38481         PTR32 physicalDevice;
38482         uint32_t queueFamilyIndex;
38483         VkBool32 result;
38484     } *params = args;
38485
38486     TRACE("%#x, %u\n", params->physicalDevice, params->queueFamilyIndex);
38487
38488     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);
38489     return STATUS_SUCCESS;
38490 }
38491
38492 #ifdef _WIN64
38493 static NTSTATUS thunk64_vkGetPipelineCacheData(void *args)
38494 {
38495     struct vkGetPipelineCacheData_params *params = args;
38496
38497     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);
38498
38499     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineCacheData(wine_device_from_handle(params->device)->device, params->pipelineCache, params->pDataSize, params->pData);
38500     return STATUS_SUCCESS;
38501 }
38502 #endif /* _WIN64 */
38503
38504 static NTSTATUS thunk32_vkGetPipelineCacheData(void *args)
38505 {
38506     struct
38507     {
38508         PTR32 device;
38509         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
38510         PTR32 pDataSize;
38511         PTR32 pData;
38512         VkResult result;
38513     } *params = args;
38514     size_t pDataSize_host;
38515
38516     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);
38517
38518     pDataSize_host = *(size_t *)UlongToPtr(params->pDataSize);
38519     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));
38520     *(size_t *)UlongToPtr(params->pDataSize) = pDataSize_host;
38521     return STATUS_SUCCESS;
38522 }
38523
38524 #ifdef _WIN64
38525 static NTSTATUS thunk64_vkGetPipelineExecutableInternalRepresentationsKHR(void *args)
38526 {
38527     struct vkGetPipelineExecutableInternalRepresentationsKHR_params *params = args;
38528
38529     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
38530
38531     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
38532     return STATUS_SUCCESS;
38533 }
38534 #endif /* _WIN64 */
38535
38536 static NTSTATUS thunk32_vkGetPipelineExecutableInternalRepresentationsKHR(void *args)
38537 {
38538     struct
38539     {
38540         PTR32 device;
38541         PTR32 pExecutableInfo;
38542         PTR32 pInternalRepresentationCount;
38543         PTR32 pInternalRepresentations;
38544         VkResult result;
38545     } *params = args;
38546     VkPipelineExecutableInfoKHR pExecutableInfo_host;
38547     VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations_host;
38548     struct conversion_context ctx;
38549
38550     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
38551
38552     init_conversion_context(&ctx);
38553     convert_VkPipelineExecutableInfoKHR_win32_to_host((const VkPipelineExecutableInfoKHR32 *)UlongToPtr(params->pExecutableInfo), &pExecutableInfo_host);
38554     pInternalRepresentations_host = convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(&ctx, (VkPipelineExecutableInternalRepresentationKHR32 *)UlongToPtr(params->pInternalRepresentations), *(uint32_t *)UlongToPtr(params->pInternalRepresentationCount));
38555     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);
38556     convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(pInternalRepresentations_host, (VkPipelineExecutableInternalRepresentationKHR32 *)UlongToPtr(params->pInternalRepresentations), *(uint32_t *)UlongToPtr(params->pInternalRepresentationCount));
38557     free_conversion_context(&ctx);
38558     return STATUS_SUCCESS;
38559 }
38560
38561 #ifdef _WIN64
38562 static NTSTATUS thunk64_vkGetPipelineExecutablePropertiesKHR(void *args)
38563 {
38564     struct vkGetPipelineExecutablePropertiesKHR_params *params = args;
38565
38566     TRACE("%p, %p, %p, %p\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
38567
38568     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
38569     return STATUS_SUCCESS;
38570 }
38571 #endif /* _WIN64 */
38572
38573 static NTSTATUS thunk32_vkGetPipelineExecutablePropertiesKHR(void *args)
38574 {
38575     struct
38576     {
38577         PTR32 device;
38578         PTR32 pPipelineInfo;
38579         PTR32 pExecutableCount;
38580         PTR32 pProperties;
38581         VkResult result;
38582     } *params = args;
38583     VkPipelineInfoKHR pPipelineInfo_host;
38584     VkPipelineExecutablePropertiesKHR *pProperties_host;
38585     struct conversion_context ctx;
38586
38587     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
38588
38589     init_conversion_context(&ctx);
38590     convert_VkPipelineInfoKHR_win32_to_host((const VkPipelineInfoKHR32 *)UlongToPtr(params->pPipelineInfo), &pPipelineInfo_host);
38591     pProperties_host = convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(&ctx, (VkPipelineExecutablePropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pExecutableCount));
38592     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);
38593     convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(pProperties_host, (VkPipelineExecutablePropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pExecutableCount));
38594     free_conversion_context(&ctx);
38595     return STATUS_SUCCESS;
38596 }
38597
38598 #ifdef _WIN64
38599 static NTSTATUS thunk64_vkGetPipelineExecutableStatisticsKHR(void *args)
38600 {
38601     struct vkGetPipelineExecutableStatisticsKHR_params *params = args;
38602
38603     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
38604
38605     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
38606     return STATUS_SUCCESS;
38607 }
38608 #endif /* _WIN64 */
38609
38610 static NTSTATUS thunk32_vkGetPipelineExecutableStatisticsKHR(void *args)
38611 {
38612     struct
38613     {
38614         PTR32 device;
38615         PTR32 pExecutableInfo;
38616         PTR32 pStatisticCount;
38617         PTR32 pStatistics;
38618         VkResult result;
38619     } *params = args;
38620     VkPipelineExecutableInfoKHR pExecutableInfo_host;
38621     VkPipelineExecutableStatisticKHR *pStatistics_host;
38622     struct conversion_context ctx;
38623
38624     TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
38625
38626     init_conversion_context(&ctx);
38627     convert_VkPipelineExecutableInfoKHR_win32_to_host((const VkPipelineExecutableInfoKHR32 *)UlongToPtr(params->pExecutableInfo), &pExecutableInfo_host);
38628     pStatistics_host = convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(&ctx, (VkPipelineExecutableStatisticKHR32 *)UlongToPtr(params->pStatistics), *(uint32_t *)UlongToPtr(params->pStatisticCount));
38629     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);
38630     convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(pStatistics_host, (VkPipelineExecutableStatisticKHR32 *)UlongToPtr(params->pStatistics), *(uint32_t *)UlongToPtr(params->pStatisticCount));
38631     free_conversion_context(&ctx);
38632     return STATUS_SUCCESS;
38633 }
38634
38635 #ifdef _WIN64
38636 static NTSTATUS thunk64_vkGetPipelinePropertiesEXT(void *args)
38637 {
38638     struct vkGetPipelinePropertiesEXT_params *params = args;
38639
38640     TRACE("%p, %p, %p\n", params->device, params->pPipelineInfo, params->pPipelineProperties);
38641
38642     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pPipelineProperties);
38643     return STATUS_SUCCESS;
38644 }
38645 #endif /* _WIN64 */
38646
38647 static NTSTATUS thunk32_vkGetPipelinePropertiesEXT(void *args)
38648 {
38649     struct
38650     {
38651         PTR32 device;
38652         PTR32 pPipelineInfo;
38653         PTR32 pPipelineProperties;
38654         VkResult result;
38655     } *params = args;
38656     VkPipelineInfoEXT pPipelineInfo_host;
38657
38658     TRACE("%#x, %#x, %#x\n", params->device, params->pPipelineInfo, params->pPipelineProperties);
38659
38660     convert_VkPipelineInfoEXT_win32_to_host((const VkPipelineInfoEXT32 *)UlongToPtr(params->pPipelineInfo), &pPipelineInfo_host);
38661     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));
38662     return STATUS_SUCCESS;
38663 }
38664
38665 #ifdef _WIN64
38666 static NTSTATUS thunk64_vkGetPrivateData(void *args)
38667 {
38668     struct vkGetPrivateData_params *params = args;
38669
38670     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);
38671
38672     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);
38673     return STATUS_SUCCESS;
38674 }
38675 #endif /* _WIN64 */
38676
38677 static NTSTATUS thunk32_vkGetPrivateData(void *args)
38678 {
38679     struct
38680     {
38681         PTR32 device;
38682         VkObjectType objectType;
38683         uint64_t DECLSPEC_ALIGN(8) objectHandle;
38684         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
38685         PTR32 pData;
38686     } *params = args;
38687
38688     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);
38689
38690     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));
38691     return STATUS_SUCCESS;
38692 }
38693
38694 #ifdef _WIN64
38695 static NTSTATUS thunk64_vkGetPrivateDataEXT(void *args)
38696 {
38697     struct vkGetPrivateDataEXT_params *params = args;
38698
38699     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);
38700
38701     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);
38702     return STATUS_SUCCESS;
38703 }
38704 #endif /* _WIN64 */
38705
38706 static NTSTATUS thunk32_vkGetPrivateDataEXT(void *args)
38707 {
38708     struct
38709     {
38710         PTR32 device;
38711         VkObjectType objectType;
38712         uint64_t DECLSPEC_ALIGN(8) objectHandle;
38713         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
38714         PTR32 pData;
38715     } *params = args;
38716
38717     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);
38718
38719     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));
38720     return STATUS_SUCCESS;
38721 }
38722
38723 #ifdef _WIN64
38724 static NTSTATUS thunk64_vkGetQueryPoolResults(void *args)
38725 {
38726     struct vkGetQueryPoolResults_params *params = args;
38727
38728     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);
38729
38730     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);
38731     return STATUS_SUCCESS;
38732 }
38733 #endif /* _WIN64 */
38734
38735 static NTSTATUS thunk32_vkGetQueryPoolResults(void *args)
38736 {
38737     struct
38738     {
38739         PTR32 device;
38740         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
38741         uint32_t firstQuery;
38742         uint32_t queryCount;
38743         PTR32 dataSize;
38744         PTR32 pData;
38745         VkDeviceSize DECLSPEC_ALIGN(8) stride;
38746         VkQueryResultFlags flags;
38747         VkResult result;
38748     } *params = args;
38749
38750     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);
38751
38752     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);
38753     return STATUS_SUCCESS;
38754 }
38755
38756 #ifdef _WIN64
38757 static NTSTATUS thunk64_vkGetQueueCheckpointData2NV(void *args)
38758 {
38759     struct vkGetQueueCheckpointData2NV_params *params = args;
38760
38761     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
38762
38763     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointData2NV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, params->pCheckpointData);
38764     return STATUS_SUCCESS;
38765 }
38766 #endif /* _WIN64 */
38767
38768 static NTSTATUS thunk32_vkGetQueueCheckpointData2NV(void *args)
38769 {
38770     struct
38771     {
38772         PTR32 queue;
38773         PTR32 pCheckpointDataCount;
38774         PTR32 pCheckpointData;
38775     } *params = args;
38776     VkCheckpointData2NV *pCheckpointData_host;
38777     struct conversion_context ctx;
38778
38779     TRACE("%#x, %#x, %#x\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
38780
38781     init_conversion_context(&ctx);
38782     pCheckpointData_host = convert_VkCheckpointData2NV_array_win32_to_host(&ctx, (VkCheckpointData2NV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
38783     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);
38784     convert_VkCheckpointData2NV_array_host_to_win32(pCheckpointData_host, (VkCheckpointData2NV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
38785     free_conversion_context(&ctx);
38786     return STATUS_SUCCESS;
38787 }
38788
38789 #ifdef _WIN64
38790 static NTSTATUS thunk64_vkGetQueueCheckpointDataNV(void *args)
38791 {
38792     struct vkGetQueueCheckpointDataNV_params *params = args;
38793
38794     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
38795
38796     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointDataNV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, params->pCheckpointData);
38797     return STATUS_SUCCESS;
38798 }
38799 #endif /* _WIN64 */
38800
38801 static NTSTATUS thunk32_vkGetQueueCheckpointDataNV(void *args)
38802 {
38803     struct
38804     {
38805         PTR32 queue;
38806         PTR32 pCheckpointDataCount;
38807         PTR32 pCheckpointData;
38808     } *params = args;
38809     VkCheckpointDataNV *pCheckpointData_host;
38810     struct conversion_context ctx;
38811
38812     TRACE("%#x, %#x, %#x\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
38813
38814     init_conversion_context(&ctx);
38815     pCheckpointData_host = convert_VkCheckpointDataNV_array_win32_to_host(&ctx, (VkCheckpointDataNV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
38816     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);
38817     convert_VkCheckpointDataNV_array_host_to_win32(pCheckpointData_host, (VkCheckpointDataNV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
38818     free_conversion_context(&ctx);
38819     return STATUS_SUCCESS;
38820 }
38821
38822 #ifdef _WIN64
38823 static NTSTATUS thunk64_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *args)
38824 {
38825     struct vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_params *params = args;
38826
38827     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);
38828
38829     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);
38830     return STATUS_SUCCESS;
38831 }
38832 #endif /* _WIN64 */
38833
38834 static NTSTATUS thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *args)
38835 {
38836     struct
38837     {
38838         PTR32 device;
38839         VkPipeline DECLSPEC_ALIGN(8) pipeline;
38840         uint32_t firstGroup;
38841         uint32_t groupCount;
38842         PTR32 dataSize;
38843         PTR32 pData;
38844         VkResult result;
38845     } *params = args;
38846
38847     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);
38848
38849     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));
38850     return STATUS_SUCCESS;
38851 }
38852
38853 #ifdef _WIN64
38854 static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesKHR(void *args)
38855 {
38856     struct vkGetRayTracingShaderGroupHandlesKHR_params *params = args;
38857
38858     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);
38859
38860     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);
38861     return STATUS_SUCCESS;
38862 }
38863 #endif /* _WIN64 */
38864
38865 static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesKHR(void *args)
38866 {
38867     struct
38868     {
38869         PTR32 device;
38870         VkPipeline DECLSPEC_ALIGN(8) pipeline;
38871         uint32_t firstGroup;
38872         uint32_t groupCount;
38873         PTR32 dataSize;
38874         PTR32 pData;
38875         VkResult result;
38876     } *params = args;
38877
38878     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);
38879
38880     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));
38881     return STATUS_SUCCESS;
38882 }
38883
38884 #ifdef _WIN64
38885 static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesNV(void *args)
38886 {
38887     struct vkGetRayTracingShaderGroupHandlesNV_params *params = args;
38888
38889     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);
38890
38891     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);
38892     return STATUS_SUCCESS;
38893 }
38894 #endif /* _WIN64 */
38895
38896 static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesNV(void *args)
38897 {
38898     struct
38899     {
38900         PTR32 device;
38901         VkPipeline DECLSPEC_ALIGN(8) pipeline;
38902         uint32_t firstGroup;
38903         uint32_t groupCount;
38904         PTR32 dataSize;
38905         PTR32 pData;
38906         VkResult result;
38907     } *params = args;
38908
38909     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);
38910
38911     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));
38912     return STATUS_SUCCESS;
38913 }
38914
38915 #ifdef _WIN64
38916 static NTSTATUS thunk64_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
38917 {
38918     struct vkGetRayTracingShaderGroupStackSizeKHR_params *params = args;
38919
38920     TRACE("%p, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);
38921
38922     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->group, params->groupShader);
38923     return STATUS_SUCCESS;
38924 }
38925 #endif /* _WIN64 */
38926
38927 static NTSTATUS thunk32_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
38928 {
38929     struct
38930     {
38931         PTR32 device;
38932         VkPipeline DECLSPEC_ALIGN(8) pipeline;
38933         uint32_t group;
38934         VkShaderGroupShaderKHR groupShader;
38935         VkDeviceSize result;
38936     } *params = args;
38937
38938     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);
38939
38940     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);
38941     return STATUS_SUCCESS;
38942 }
38943
38944 #ifdef _WIN64
38945 static NTSTATUS thunk64_vkGetRenderAreaGranularity(void *args)
38946 {
38947     struct vkGetRenderAreaGranularity_params *params = args;
38948
38949     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pGranularity);
38950
38951     wine_device_from_handle(params->device)->funcs.p_vkGetRenderAreaGranularity(wine_device_from_handle(params->device)->device, params->renderPass, params->pGranularity);
38952     return STATUS_SUCCESS;
38953 }
38954 #endif /* _WIN64 */
38955
38956 static NTSTATUS thunk32_vkGetRenderAreaGranularity(void *args)
38957 {
38958     struct
38959     {
38960         PTR32 device;
38961         VkRenderPass DECLSPEC_ALIGN(8) renderPass;
38962         PTR32 pGranularity;
38963     } *params = args;
38964
38965     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pGranularity);
38966
38967     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));
38968     return STATUS_SUCCESS;
38969 }
38970
38971 #ifdef _WIN64
38972 static NTSTATUS thunk64_vkGetSamplerOpaqueCaptureDescriptorDataEXT(void *args)
38973 {
38974     struct vkGetSamplerOpaqueCaptureDescriptorDataEXT_params *params = args;
38975
38976     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData);
38977
38978     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSamplerOpaqueCaptureDescriptorDataEXT(wine_device_from_handle(params->device)->device, params->pInfo, params->pData);
38979     return STATUS_SUCCESS;
38980 }
38981 #endif /* _WIN64 */
38982
38983 static NTSTATUS thunk32_vkGetSamplerOpaqueCaptureDescriptorDataEXT(void *args)
38984 {
38985     struct
38986     {
38987         PTR32 device;
38988         PTR32 pInfo;
38989         PTR32 pData;
38990         VkResult result;
38991     } *params = args;
38992     VkSamplerCaptureDescriptorDataInfoEXT pInfo_host;
38993
38994     TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData);
38995
38996     convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host((const VkSamplerCaptureDescriptorDataInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
38997     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));
38998     return STATUS_SUCCESS;
38999 }
39000
39001 #ifdef _WIN64
39002 static NTSTATUS thunk64_vkGetSemaphoreCounterValue(void *args)
39003 {
39004     struct vkGetSemaphoreCounterValue_params *params = args;
39005
39006     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39007
39008     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
39009     return STATUS_SUCCESS;
39010 }
39011 #endif /* _WIN64 */
39012
39013 static NTSTATUS thunk32_vkGetSemaphoreCounterValue(void *args)
39014 {
39015     struct
39016     {
39017         PTR32 device;
39018         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
39019         PTR32 pValue;
39020         VkResult result;
39021     } *params = args;
39022
39023     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39024
39025     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));
39026     return STATUS_SUCCESS;
39027 }
39028
39029 #ifdef _WIN64
39030 static NTSTATUS thunk64_vkGetSemaphoreCounterValueKHR(void *args)
39031 {
39032     struct vkGetSemaphoreCounterValueKHR_params *params = args;
39033
39034     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39035
39036     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
39037     return STATUS_SUCCESS;
39038 }
39039 #endif /* _WIN64 */
39040
39041 static NTSTATUS thunk32_vkGetSemaphoreCounterValueKHR(void *args)
39042 {
39043     struct
39044     {
39045         PTR32 device;
39046         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
39047         PTR32 pValue;
39048         VkResult result;
39049     } *params = args;
39050
39051     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
39052
39053     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));
39054     return STATUS_SUCCESS;
39055 }
39056
39057 #ifdef _WIN64
39058 static NTSTATUS thunk64_vkGetShaderInfoAMD(void *args)
39059 {
39060     struct vkGetShaderInfoAMD_params *params = args;
39061
39062     TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
39063
39064     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);
39065     return STATUS_SUCCESS;
39066 }
39067 #endif /* _WIN64 */
39068
39069 static NTSTATUS thunk32_vkGetShaderInfoAMD(void *args)
39070 {
39071     struct
39072     {
39073         PTR32 device;
39074         VkPipeline DECLSPEC_ALIGN(8) pipeline;
39075         VkShaderStageFlagBits shaderStage;
39076         VkShaderInfoTypeAMD infoType;
39077         PTR32 pInfoSize;
39078         PTR32 pInfo;
39079         VkResult result;
39080     } *params = args;
39081     size_t pInfoSize_host;
39082
39083     TRACE("%#x, 0x%s, %#x, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
39084
39085     pInfoSize_host = *(size_t *)UlongToPtr(params->pInfoSize);
39086     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));
39087     *(size_t *)UlongToPtr(params->pInfoSize) = pInfoSize_host;
39088     return STATUS_SUCCESS;
39089 }
39090
39091 #ifdef _WIN64
39092 static NTSTATUS thunk64_vkGetShaderModuleCreateInfoIdentifierEXT(void *args)
39093 {
39094     struct vkGetShaderModuleCreateInfoIdentifierEXT_params *params = args;
39095
39096     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pIdentifier);
39097
39098     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleCreateInfoIdentifierEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pIdentifier);
39099     return STATUS_SUCCESS;
39100 }
39101 #endif /* _WIN64 */
39102
39103 static NTSTATUS thunk32_vkGetShaderModuleCreateInfoIdentifierEXT(void *args)
39104 {
39105     struct
39106     {
39107         PTR32 device;
39108         PTR32 pCreateInfo;
39109         PTR32 pIdentifier;
39110     } *params = args;
39111     VkShaderModuleCreateInfo pCreateInfo_host;
39112     VkShaderModuleIdentifierEXT pIdentifier_host;
39113     struct conversion_context ctx;
39114
39115     TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pIdentifier);
39116
39117     init_conversion_context(&ctx);
39118     convert_VkShaderModuleCreateInfo_win32_to_host(&ctx, (const VkShaderModuleCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
39119     convert_VkShaderModuleIdentifierEXT_win32_to_host((VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier), &pIdentifier_host);
39120     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetShaderModuleCreateInfoIdentifierEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pIdentifier_host);
39121     convert_VkShaderModuleIdentifierEXT_host_to_win32(&pIdentifier_host, (VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier));
39122     free_conversion_context(&ctx);
39123     return STATUS_SUCCESS;
39124 }
39125
39126 #ifdef _WIN64
39127 static NTSTATUS thunk64_vkGetShaderModuleIdentifierEXT(void *args)
39128 {
39129     struct vkGetShaderModuleIdentifierEXT_params *params = args;
39130
39131     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pIdentifier);
39132
39133     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleIdentifierEXT(wine_device_from_handle(params->device)->device, params->shaderModule, params->pIdentifier);
39134     return STATUS_SUCCESS;
39135 }
39136 #endif /* _WIN64 */
39137
39138 static NTSTATUS thunk32_vkGetShaderModuleIdentifierEXT(void *args)
39139 {
39140     struct
39141     {
39142         PTR32 device;
39143         VkShaderModule DECLSPEC_ALIGN(8) shaderModule;
39144         PTR32 pIdentifier;
39145     } *params = args;
39146     VkShaderModuleIdentifierEXT pIdentifier_host;
39147
39148     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pIdentifier);
39149
39150     convert_VkShaderModuleIdentifierEXT_win32_to_host((VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier), &pIdentifier_host);
39151     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetShaderModuleIdentifierEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->shaderModule, &pIdentifier_host);
39152     convert_VkShaderModuleIdentifierEXT_host_to_win32(&pIdentifier_host, (VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier));
39153     return STATUS_SUCCESS;
39154 }
39155
39156 #ifdef _WIN64
39157 static NTSTATUS thunk64_vkGetSwapchainImagesKHR(void *args)
39158 {
39159     struct vkGetSwapchainImagesKHR_params *params = args;
39160
39161     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);
39162
39163     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->pSwapchainImageCount, params->pSwapchainImages);
39164     return STATUS_SUCCESS;
39165 }
39166 #endif /* _WIN64 */
39167
39168 static NTSTATUS thunk32_vkGetSwapchainImagesKHR(void *args)
39169 {
39170     struct
39171     {
39172         PTR32 device;
39173         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
39174         PTR32 pSwapchainImageCount;
39175         PTR32 pSwapchainImages;
39176         VkResult result;
39177     } *params = args;
39178
39179     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);
39180
39181     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));
39182     return STATUS_SUCCESS;
39183 }
39184
39185 #ifdef _WIN64
39186 static NTSTATUS thunk64_vkGetValidationCacheDataEXT(void *args)
39187 {
39188     struct vkGetValidationCacheDataEXT_params *params = args;
39189
39190     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);
39191
39192     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle(params->device)->device, params->validationCache, params->pDataSize, params->pData);
39193     return STATUS_SUCCESS;
39194 }
39195 #endif /* _WIN64 */
39196
39197 static NTSTATUS thunk32_vkGetValidationCacheDataEXT(void *args)
39198 {
39199     struct
39200     {
39201         PTR32 device;
39202         VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
39203         PTR32 pDataSize;
39204         PTR32 pData;
39205         VkResult result;
39206     } *params = args;
39207     size_t pDataSize_host;
39208
39209     TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);
39210
39211     pDataSize_host = *(size_t *)UlongToPtr(params->pDataSize);
39212     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));
39213     *(size_t *)UlongToPtr(params->pDataSize) = pDataSize_host;
39214     return STATUS_SUCCESS;
39215 }
39216
39217 #ifdef _WIN64
39218 static NTSTATUS thunk64_vkInitializePerformanceApiINTEL(void *args)
39219 {
39220     struct vkInitializePerformanceApiINTEL_params *params = args;
39221
39222     TRACE("%p, %p\n", params->device, params->pInitializeInfo);
39223
39224     params->result = wine_device_from_handle(params->device)->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device, params->pInitializeInfo);
39225     return STATUS_SUCCESS;
39226 }
39227 #endif /* _WIN64 */
39228
39229 static NTSTATUS thunk32_vkInitializePerformanceApiINTEL(void *args)
39230 {
39231     struct
39232     {
39233         PTR32 device;
39234         PTR32 pInitializeInfo;
39235         VkResult result;
39236     } *params = args;
39237     VkInitializePerformanceApiInfoINTEL pInitializeInfo_host;
39238
39239     TRACE("%#x, %#x\n", params->device, params->pInitializeInfo);
39240
39241     convert_VkInitializePerformanceApiInfoINTEL_win32_to_host((const VkInitializePerformanceApiInfoINTEL32 *)UlongToPtr(params->pInitializeInfo), &pInitializeInfo_host);
39242     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInitializeInfo_host);
39243     return STATUS_SUCCESS;
39244 }
39245
39246 #ifdef _WIN64
39247 static NTSTATUS thunk64_vkInvalidateMappedMemoryRanges(void *args)
39248 {
39249     struct vkInvalidateMappedMemoryRanges_params *params = args;
39250
39251     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
39252
39253     params->result = wine_device_from_handle(params->device)->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, params->pMemoryRanges);
39254     return STATUS_SUCCESS;
39255 }
39256 #endif /* _WIN64 */
39257
39258 static NTSTATUS thunk32_vkInvalidateMappedMemoryRanges(void *args)
39259 {
39260     struct
39261     {
39262         PTR32 device;
39263         uint32_t memoryRangeCount;
39264         PTR32 pMemoryRanges;
39265         VkResult result;
39266     } *params = args;
39267     const VkMappedMemoryRange *pMemoryRanges_host;
39268     struct conversion_context ctx;
39269
39270     TRACE("%#x, %u, %#x\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
39271
39272     init_conversion_context(&ctx);
39273     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(&ctx, (const VkMappedMemoryRange32 *)UlongToPtr(params->pMemoryRanges), params->memoryRangeCount);
39274     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);
39275     free_conversion_context(&ctx);
39276     return STATUS_SUCCESS;
39277 }
39278
39279 #ifdef _WIN64
39280 static NTSTATUS thunk64_vkMapMemory(void *args)
39281 {
39282     struct vkMapMemory_params *params = args;
39283
39284     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);
39285
39286     params->result = wine_vkMapMemory(params->device, params->memory, params->offset, params->size, params->flags, params->ppData);
39287     return STATUS_SUCCESS;
39288 }
39289 #endif /* _WIN64 */
39290
39291 static NTSTATUS thunk32_vkMapMemory(void *args)
39292 {
39293     struct
39294     {
39295         PTR32 device;
39296         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
39297         VkDeviceSize DECLSPEC_ALIGN(8) offset;
39298         VkDeviceSize DECLSPEC_ALIGN(8) size;
39299         VkMemoryMapFlags flags;
39300         PTR32 ppData;
39301         VkResult result;
39302     } *params = args;
39303
39304     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);
39305
39306     params->result = wine_vkMapMemory((VkDevice)UlongToPtr(params->device), params->memory, params->offset, params->size, params->flags, (void **)UlongToPtr(params->ppData));
39307     return STATUS_SUCCESS;
39308 }
39309
39310 #ifdef _WIN64
39311 static NTSTATUS thunk64_vkMergePipelineCaches(void *args)
39312 {
39313     struct vkMergePipelineCaches_params *params = args;
39314
39315     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
39316
39317     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergePipelineCaches(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
39318     return STATUS_SUCCESS;
39319 }
39320 #endif /* _WIN64 */
39321
39322 static NTSTATUS thunk32_vkMergePipelineCaches(void *args)
39323 {
39324     struct
39325     {
39326         PTR32 device;
39327         VkPipelineCache DECLSPEC_ALIGN(8) dstCache;
39328         uint32_t srcCacheCount;
39329         PTR32 pSrcCaches;
39330         VkResult result;
39331     } *params = args;
39332
39333     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
39334
39335     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));
39336     return STATUS_SUCCESS;
39337 }
39338
39339 #ifdef _WIN64
39340 static NTSTATUS thunk64_vkMergeValidationCachesEXT(void *args)
39341 {
39342     struct vkMergeValidationCachesEXT_params *params = args;
39343
39344     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
39345
39346     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
39347     return STATUS_SUCCESS;
39348 }
39349 #endif /* _WIN64 */
39350
39351 static NTSTATUS thunk32_vkMergeValidationCachesEXT(void *args)
39352 {
39353     struct
39354     {
39355         PTR32 device;
39356         VkValidationCacheEXT DECLSPEC_ALIGN(8) dstCache;
39357         uint32_t srcCacheCount;
39358         PTR32 pSrcCaches;
39359         VkResult result;
39360     } *params = args;
39361
39362     TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
39363
39364     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));
39365     return STATUS_SUCCESS;
39366 }
39367
39368 #ifdef _WIN64
39369 static NTSTATUS thunk64_vkQueueBeginDebugUtilsLabelEXT(void *args)
39370 {
39371     struct vkQueueBeginDebugUtilsLabelEXT_params *params = args;
39372
39373     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
39374
39375     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, params->pLabelInfo);
39376     return STATUS_SUCCESS;
39377 }
39378 #endif /* _WIN64 */
39379
39380 static NTSTATUS thunk32_vkQueueBeginDebugUtilsLabelEXT(void *args)
39381 {
39382     struct
39383     {
39384         PTR32 queue;
39385         PTR32 pLabelInfo;
39386     } *params = args;
39387     VkDebugUtilsLabelEXT pLabelInfo_host;
39388
39389     TRACE("%#x, %#x\n", params->queue, params->pLabelInfo);
39390
39391     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
39392     wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, &pLabelInfo_host);
39393     return STATUS_SUCCESS;
39394 }
39395
39396 #ifdef _WIN64
39397 static NTSTATUS thunk64_vkQueueBindSparse(void *args)
39398 {
39399     struct vkQueueBindSparse_params *params = args;
39400
39401     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));
39402
39403     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBindSparse(wine_queue_from_handle(params->queue)->queue, params->bindInfoCount, params->pBindInfo, params->fence);
39404     return STATUS_SUCCESS;
39405 }
39406 #endif /* _WIN64 */
39407
39408 static NTSTATUS thunk32_vkQueueBindSparse(void *args)
39409 {
39410     struct
39411     {
39412         PTR32 queue;
39413         uint32_t bindInfoCount;
39414         PTR32 pBindInfo;
39415         VkFence DECLSPEC_ALIGN(8) fence;
39416         VkResult result;
39417     } *params = args;
39418     const VkBindSparseInfo *pBindInfo_host;
39419     struct conversion_context ctx;
39420
39421     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));
39422
39423     init_conversion_context(&ctx);
39424     pBindInfo_host = convert_VkBindSparseInfo_array_win32_to_host(&ctx, (const VkBindSparseInfo32 *)UlongToPtr(params->pBindInfo), params->bindInfoCount);
39425     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);
39426     free_conversion_context(&ctx);
39427     return STATUS_SUCCESS;
39428 }
39429
39430 #ifdef _WIN64
39431 static NTSTATUS thunk64_vkQueueEndDebugUtilsLabelEXT(void *args)
39432 {
39433     struct vkQueueEndDebugUtilsLabelEXT_params *params = args;
39434
39435     TRACE("%p\n", params->queue);
39436
39437     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue);
39438     return STATUS_SUCCESS;
39439 }
39440 #endif /* _WIN64 */
39441
39442 static NTSTATUS thunk32_vkQueueEndDebugUtilsLabelEXT(void *args)
39443 {
39444     struct
39445     {
39446         PTR32 queue;
39447     } *params = args;
39448
39449     TRACE("%#x\n", params->queue);
39450
39451     wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue);
39452     return STATUS_SUCCESS;
39453 }
39454
39455 #ifdef _WIN64
39456 static NTSTATUS thunk64_vkQueueInsertDebugUtilsLabelEXT(void *args)
39457 {
39458     struct vkQueueInsertDebugUtilsLabelEXT_params *params = args;
39459
39460     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
39461
39462     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, params->pLabelInfo);
39463     return STATUS_SUCCESS;
39464 }
39465 #endif /* _WIN64 */
39466
39467 static NTSTATUS thunk32_vkQueueInsertDebugUtilsLabelEXT(void *args)
39468 {
39469     struct
39470     {
39471         PTR32 queue;
39472         PTR32 pLabelInfo;
39473     } *params = args;
39474     VkDebugUtilsLabelEXT pLabelInfo_host;
39475
39476     TRACE("%#x, %#x\n", params->queue, params->pLabelInfo);
39477
39478     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
39479     wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, &pLabelInfo_host);
39480     return STATUS_SUCCESS;
39481 }
39482
39483 #ifdef _WIN64
39484 static NTSTATUS thunk64_vkQueuePresentKHR(void *args)
39485 {
39486     struct vkQueuePresentKHR_params *params = args;
39487
39488     TRACE("%p, %p\n", params->queue, params->pPresentInfo);
39489
39490     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle(params->queue)->queue, params->pPresentInfo);
39491     return STATUS_SUCCESS;
39492 }
39493 #endif /* _WIN64 */
39494
39495 static NTSTATUS thunk32_vkQueuePresentKHR(void *args)
39496 {
39497     struct
39498     {
39499         PTR32 queue;
39500         PTR32 pPresentInfo;
39501         VkResult result;
39502     } *params = args;
39503     VkPresentInfoKHR pPresentInfo_host;
39504     struct conversion_context ctx;
39505
39506     TRACE("%#x, %#x\n", params->queue, params->pPresentInfo);
39507
39508     init_conversion_context(&ctx);
39509     convert_VkPresentInfoKHR_win32_to_host(&ctx, (const VkPresentInfoKHR32 *)UlongToPtr(params->pPresentInfo), &pPresentInfo_host);
39510     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);
39511     free_conversion_context(&ctx);
39512     return STATUS_SUCCESS;
39513 }
39514
39515 #ifdef _WIN64
39516 static NTSTATUS thunk64_vkQueueSetPerformanceConfigurationINTEL(void *args)
39517 {
39518     struct vkQueueSetPerformanceConfigurationINTEL_params *params = args;
39519
39520     TRACE("%p, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));
39521
39522     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle(params->queue)->queue, params->configuration);
39523     return STATUS_SUCCESS;
39524 }
39525 #endif /* _WIN64 */
39526
39527 static NTSTATUS thunk32_vkQueueSetPerformanceConfigurationINTEL(void *args)
39528 {
39529     struct
39530     {
39531         PTR32 queue;
39532         VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
39533         VkResult result;
39534     } *params = args;
39535
39536     TRACE("%#x, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));
39537
39538     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);
39539     return STATUS_SUCCESS;
39540 }
39541
39542 #ifdef _WIN64
39543 static NTSTATUS thunk64_vkQueueSubmit(void *args)
39544 {
39545     struct vkQueueSubmit_params *params = args;
39546     const VkSubmitInfo *pSubmits_host;
39547     struct conversion_context ctx;
39548
39549     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
39550
39551     init_conversion_context(&ctx);
39552     pSubmits_host = convert_VkSubmitInfo_array_win64_to_host(&ctx, params->pSubmits, params->submitCount);
39553     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);
39554     free_conversion_context(&ctx);
39555     return STATUS_SUCCESS;
39556 }
39557 #endif /* _WIN64 */
39558
39559 static NTSTATUS thunk32_vkQueueSubmit(void *args)
39560 {
39561     struct
39562     {
39563         PTR32 queue;
39564         uint32_t submitCount;
39565         PTR32 pSubmits;
39566         VkFence DECLSPEC_ALIGN(8) fence;
39567         VkResult result;
39568     } *params = args;
39569     const VkSubmitInfo *pSubmits_host;
39570     struct conversion_context ctx;
39571
39572     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
39573
39574     init_conversion_context(&ctx);
39575     pSubmits_host = convert_VkSubmitInfo_array_win32_to_host(&ctx, (const VkSubmitInfo32 *)UlongToPtr(params->pSubmits), params->submitCount);
39576     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);
39577     free_conversion_context(&ctx);
39578     return STATUS_SUCCESS;
39579 }
39580
39581 #ifdef _WIN64
39582 static NTSTATUS thunk64_vkQueueSubmit2(void *args)
39583 {
39584     struct vkQueueSubmit2_params *params = args;
39585     const VkSubmitInfo2 *pSubmits_host;
39586     struct conversion_context ctx;
39587
39588     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
39589
39590     init_conversion_context(&ctx);
39591     pSubmits_host = convert_VkSubmitInfo2_array_win64_to_host(&ctx, params->pSubmits, params->submitCount);
39592     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);
39593     free_conversion_context(&ctx);
39594     return STATUS_SUCCESS;
39595 }
39596 #endif /* _WIN64 */
39597
39598 static NTSTATUS thunk32_vkQueueSubmit2(void *args)
39599 {
39600     struct
39601     {
39602         PTR32 queue;
39603         uint32_t submitCount;
39604         PTR32 pSubmits;
39605         VkFence DECLSPEC_ALIGN(8) fence;
39606         VkResult result;
39607     } *params = args;
39608     const VkSubmitInfo2 *pSubmits_host;
39609     struct conversion_context ctx;
39610
39611     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
39612
39613     init_conversion_context(&ctx);
39614     pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(&ctx, (const VkSubmitInfo232 *)UlongToPtr(params->pSubmits), params->submitCount);
39615     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);
39616     free_conversion_context(&ctx);
39617     return STATUS_SUCCESS;
39618 }
39619
39620 #ifdef _WIN64
39621 static NTSTATUS thunk64_vkQueueSubmit2KHR(void *args)
39622 {
39623     struct vkQueueSubmit2KHR_params *params = args;
39624     const VkSubmitInfo2 *pSubmits_host;
39625     struct conversion_context ctx;
39626
39627     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
39628
39629     init_conversion_context(&ctx);
39630     pSubmits_host = convert_VkSubmitInfo2_array_win64_to_host(&ctx, params->pSubmits, params->submitCount);
39631     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);
39632     free_conversion_context(&ctx);
39633     return STATUS_SUCCESS;
39634 }
39635 #endif /* _WIN64 */
39636
39637 static NTSTATUS thunk32_vkQueueSubmit2KHR(void *args)
39638 {
39639     struct
39640     {
39641         PTR32 queue;
39642         uint32_t submitCount;
39643         PTR32 pSubmits;
39644         VkFence DECLSPEC_ALIGN(8) fence;
39645         VkResult result;
39646     } *params = args;
39647     const VkSubmitInfo2 *pSubmits_host;
39648     struct conversion_context ctx;
39649
39650     TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
39651
39652     init_conversion_context(&ctx);
39653     pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(&ctx, (const VkSubmitInfo232 *)UlongToPtr(params->pSubmits), params->submitCount);
39654     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);
39655     free_conversion_context(&ctx);
39656     return STATUS_SUCCESS;
39657 }
39658
39659 #ifdef _WIN64
39660 static NTSTATUS thunk64_vkQueueWaitIdle(void *args)
39661 {
39662     struct vkQueueWaitIdle_params *params = args;
39663
39664     TRACE("%p\n", params->queue);
39665
39666     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle(params->queue)->queue);
39667     return STATUS_SUCCESS;
39668 }
39669 #endif /* _WIN64 */
39670
39671 static NTSTATUS thunk32_vkQueueWaitIdle(void *args)
39672 {
39673     struct
39674     {
39675         PTR32 queue;
39676         VkResult result;
39677     } *params = args;
39678
39679     TRACE("%#x\n", params->queue);
39680
39681     params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue);
39682     return STATUS_SUCCESS;
39683 }
39684
39685 #ifdef _WIN64
39686 static NTSTATUS thunk64_vkReleasePerformanceConfigurationINTEL(void *args)
39687 {
39688     struct vkReleasePerformanceConfigurationINTEL_params *params = args;
39689
39690     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));
39691
39692     params->result = wine_device_from_handle(params->device)->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->configuration);
39693     return STATUS_SUCCESS;
39694 }
39695 #endif /* _WIN64 */
39696
39697 static NTSTATUS thunk32_vkReleasePerformanceConfigurationINTEL(void *args)
39698 {
39699     struct
39700     {
39701         PTR32 device;
39702         VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
39703         VkResult result;
39704     } *params = args;
39705
39706     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));
39707
39708     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->configuration);
39709     return STATUS_SUCCESS;
39710 }
39711
39712 #ifdef _WIN64
39713 static NTSTATUS thunk64_vkReleaseProfilingLockKHR(void *args)
39714 {
39715     struct vkReleaseProfilingLockKHR_params *params = args;
39716
39717     TRACE("%p\n", params->device);
39718
39719     wine_device_from_handle(params->device)->funcs.p_vkReleaseProfilingLockKHR(wine_device_from_handle(params->device)->device);
39720     return STATUS_SUCCESS;
39721 }
39722 #endif /* _WIN64 */
39723
39724 static NTSTATUS thunk32_vkReleaseProfilingLockKHR(void *args)
39725 {
39726     struct
39727     {
39728         PTR32 device;
39729     } *params = args;
39730
39731     TRACE("%#x\n", params->device);
39732
39733     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkReleaseProfilingLockKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
39734     return STATUS_SUCCESS;
39735 }
39736
39737 #ifdef _WIN64
39738 static NTSTATUS thunk64_vkResetCommandBuffer(void *args)
39739 {
39740     struct vkResetCommandBuffer_params *params = args;
39741
39742     TRACE("%p, %#x\n", params->commandBuffer, params->flags);
39743
39744     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->flags);
39745     return STATUS_SUCCESS;
39746 }
39747 #endif /* _WIN64 */
39748
39749 static NTSTATUS thunk32_vkResetCommandBuffer(void *args)
39750 {
39751     struct
39752     {
39753         PTR32 commandBuffer;
39754         VkCommandBufferResetFlags flags;
39755         VkResult result;
39756     } *params = args;
39757
39758     TRACE("%#x, %#x\n", params->commandBuffer, params->flags);
39759
39760     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);
39761     return STATUS_SUCCESS;
39762 }
39763
39764 #ifdef _WIN64
39765 static NTSTATUS thunk64_vkResetCommandPool(void *args)
39766 {
39767     struct vkResetCommandPool_params *params = args;
39768
39769     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
39770
39771     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);
39772     return STATUS_SUCCESS;
39773 }
39774 #endif /* _WIN64 */
39775
39776 static NTSTATUS thunk32_vkResetCommandPool(void *args)
39777 {
39778     struct
39779     {
39780         PTR32 device;
39781         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
39782         VkCommandPoolResetFlags flags;
39783         VkResult result;
39784     } *params = args;
39785
39786     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
39787
39788     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);
39789     return STATUS_SUCCESS;
39790 }
39791
39792 #ifdef _WIN64
39793 static NTSTATUS thunk64_vkResetDescriptorPool(void *args)
39794 {
39795     struct vkResetDescriptorPool_params *params = args;
39796
39797     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);
39798
39799     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, params->flags);
39800     return STATUS_SUCCESS;
39801 }
39802 #endif /* _WIN64 */
39803
39804 static NTSTATUS thunk32_vkResetDescriptorPool(void *args)
39805 {
39806     struct
39807     {
39808         PTR32 device;
39809         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
39810         VkDescriptorPoolResetFlags flags;
39811         VkResult result;
39812     } *params = args;
39813
39814     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);
39815
39816     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);
39817     return STATUS_SUCCESS;
39818 }
39819
39820 #ifdef _WIN64
39821 static NTSTATUS thunk64_vkResetEvent(void *args)
39822 {
39823     struct vkResetEvent_params *params = args;
39824
39825     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
39826
39827     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetEvent(wine_device_from_handle(params->device)->device, params->event);
39828     return STATUS_SUCCESS;
39829 }
39830 #endif /* _WIN64 */
39831
39832 static NTSTATUS thunk32_vkResetEvent(void *args)
39833 {
39834     struct
39835     {
39836         PTR32 device;
39837         VkEvent DECLSPEC_ALIGN(8) event;
39838         VkResult result;
39839     } *params = args;
39840
39841     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
39842
39843     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
39844     return STATUS_SUCCESS;
39845 }
39846
39847 #ifdef _WIN64
39848 static NTSTATUS thunk64_vkResetFences(void *args)
39849 {
39850     struct vkResetFences_params *params = args;
39851
39852     TRACE("%p, %u, %p\n", params->device, params->fenceCount, params->pFences);
39853
39854     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences);
39855     return STATUS_SUCCESS;
39856 }
39857 #endif /* _WIN64 */
39858
39859 static NTSTATUS thunk32_vkResetFences(void *args)
39860 {
39861     struct
39862     {
39863         PTR32 device;
39864         uint32_t fenceCount;
39865         PTR32 pFences;
39866         VkResult result;
39867     } *params = args;
39868
39869     TRACE("%#x, %u, %#x\n", params->device, params->fenceCount, params->pFences);
39870
39871     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));
39872     return STATUS_SUCCESS;
39873 }
39874
39875 #ifdef _WIN64
39876 static NTSTATUS thunk64_vkResetQueryPool(void *args)
39877 {
39878     struct vkResetQueryPool_params *params = args;
39879
39880     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
39881
39882     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
39883     return STATUS_SUCCESS;
39884 }
39885 #endif /* _WIN64 */
39886
39887 static NTSTATUS thunk32_vkResetQueryPool(void *args)
39888 {
39889     struct
39890     {
39891         PTR32 device;
39892         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
39893         uint32_t firstQuery;
39894         uint32_t queryCount;
39895     } *params = args;
39896
39897     TRACE("%#x, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
39898
39899     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);
39900     return STATUS_SUCCESS;
39901 }
39902
39903 #ifdef _WIN64
39904 static NTSTATUS thunk64_vkResetQueryPoolEXT(void *args)
39905 {
39906     struct vkResetQueryPoolEXT_params *params = args;
39907
39908     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
39909
39910     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPoolEXT(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
39911     return STATUS_SUCCESS;
39912 }
39913 #endif /* _WIN64 */
39914
39915 static NTSTATUS thunk32_vkResetQueryPoolEXT(void *args)
39916 {
39917     struct
39918     {
39919         PTR32 device;
39920         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
39921         uint32_t firstQuery;
39922         uint32_t queryCount;
39923     } *params = args;
39924
39925     TRACE("%#x, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
39926
39927     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);
39928     return STATUS_SUCCESS;
39929 }
39930
39931 #ifdef _WIN64
39932 static NTSTATUS thunk64_vkSetDebugUtilsObjectNameEXT(void *args)
39933 {
39934     struct vkSetDebugUtilsObjectNameEXT_params *params = args;
39935     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;
39936
39937     TRACE("%p, %p\n", params->device, params->pNameInfo);
39938
39939     convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(params->pNameInfo, &pNameInfo_host);
39940     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
39941     return STATUS_SUCCESS;
39942 }
39943 #endif /* _WIN64 */
39944
39945 static NTSTATUS thunk32_vkSetDebugUtilsObjectNameEXT(void *args)
39946 {
39947     struct
39948     {
39949         PTR32 device;
39950         PTR32 pNameInfo;
39951         VkResult result;
39952     } *params = args;
39953     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;
39954
39955     TRACE("%#x, %#x\n", params->device, params->pNameInfo);
39956
39957     convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host((const VkDebugUtilsObjectNameInfoEXT32 *)UlongToPtr(params->pNameInfo), &pNameInfo_host);
39958     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pNameInfo_host);
39959     return STATUS_SUCCESS;
39960 }
39961
39962 #ifdef _WIN64
39963 static NTSTATUS thunk64_vkSetDebugUtilsObjectTagEXT(void *args)
39964 {
39965     struct vkSetDebugUtilsObjectTagEXT_params *params = args;
39966     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;
39967
39968     TRACE("%p, %p\n", params->device, params->pTagInfo);
39969
39970     convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(params->pTagInfo, &pTagInfo_host);
39971     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
39972     return STATUS_SUCCESS;
39973 }
39974 #endif /* _WIN64 */
39975
39976 static NTSTATUS thunk32_vkSetDebugUtilsObjectTagEXT(void *args)
39977 {
39978     struct
39979     {
39980         PTR32 device;
39981         PTR32 pTagInfo;
39982         VkResult result;
39983     } *params = args;
39984     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;
39985
39986     TRACE("%#x, %#x\n", params->device, params->pTagInfo);
39987
39988     convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host((const VkDebugUtilsObjectTagInfoEXT32 *)UlongToPtr(params->pTagInfo), &pTagInfo_host);
39989     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pTagInfo_host);
39990     return STATUS_SUCCESS;
39991 }
39992
39993 #ifdef _WIN64
39994 static NTSTATUS thunk64_vkSetDeviceMemoryPriorityEXT(void *args)
39995 {
39996     struct vkSetDeviceMemoryPriorityEXT_params *params = args;
39997
39998     TRACE("%p, 0x%s, %f\n", params->device, wine_dbgstr_longlong(params->memory), params->priority);
39999
40000     wine_device_from_handle(params->device)->funcs.p_vkSetDeviceMemoryPriorityEXT(wine_device_from_handle(params->device)->device, params->memory, params->priority);
40001     return STATUS_SUCCESS;
40002 }
40003 #endif /* _WIN64 */
40004
40005 static NTSTATUS thunk32_vkSetDeviceMemoryPriorityEXT(void *args)
40006 {
40007     struct
40008     {
40009         PTR32 device;
40010         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
40011         float priority;
40012     } *params = args;
40013
40014     TRACE("%#x, 0x%s, %f\n", params->device, wine_dbgstr_longlong(params->memory), params->priority);
40015
40016     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetDeviceMemoryPriorityEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->memory, params->priority);
40017     return STATUS_SUCCESS;
40018 }
40019
40020 #ifdef _WIN64
40021 static NTSTATUS thunk64_vkSetEvent(void *args)
40022 {
40023     struct vkSetEvent_params *params = args;
40024
40025     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
40026
40027     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetEvent(wine_device_from_handle(params->device)->device, params->event);
40028     return STATUS_SUCCESS;
40029 }
40030 #endif /* _WIN64 */
40031
40032 static NTSTATUS thunk32_vkSetEvent(void *args)
40033 {
40034     struct
40035     {
40036         PTR32 device;
40037         VkEvent DECLSPEC_ALIGN(8) event;
40038         VkResult result;
40039     } *params = args;
40040
40041     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
40042
40043     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
40044     return STATUS_SUCCESS;
40045 }
40046
40047 #ifdef _WIN64
40048 static NTSTATUS thunk64_vkSetPrivateData(void *args)
40049 {
40050     struct vkSetPrivateData_params *params = args;
40051
40052     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));
40053
40054     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);
40055     return STATUS_SUCCESS;
40056 }
40057 #endif /* _WIN64 */
40058
40059 static NTSTATUS thunk32_vkSetPrivateData(void *args)
40060 {
40061     struct
40062     {
40063         PTR32 device;
40064         VkObjectType objectType;
40065         uint64_t DECLSPEC_ALIGN(8) objectHandle;
40066         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
40067         uint64_t DECLSPEC_ALIGN(8) data;
40068         VkResult result;
40069     } *params = args;
40070
40071     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));
40072
40073     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);
40074     return STATUS_SUCCESS;
40075 }
40076
40077 #ifdef _WIN64
40078 static NTSTATUS thunk64_vkSetPrivateDataEXT(void *args)
40079 {
40080     struct vkSetPrivateDataEXT_params *params = args;
40081
40082     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));
40083
40084     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);
40085     return STATUS_SUCCESS;
40086 }
40087 #endif /* _WIN64 */
40088
40089 static NTSTATUS thunk32_vkSetPrivateDataEXT(void *args)
40090 {
40091     struct
40092     {
40093         PTR32 device;
40094         VkObjectType objectType;
40095         uint64_t DECLSPEC_ALIGN(8) objectHandle;
40096         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
40097         uint64_t DECLSPEC_ALIGN(8) data;
40098         VkResult result;
40099     } *params = args;
40100
40101     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));
40102
40103     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);
40104     return STATUS_SUCCESS;
40105 }
40106
40107 #ifdef _WIN64
40108 static NTSTATUS thunk64_vkSignalSemaphore(void *args)
40109 {
40110     struct vkSignalSemaphore_params *params = args;
40111
40112     TRACE("%p, %p\n", params->device, params->pSignalInfo);
40113
40114     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphore(wine_device_from_handle(params->device)->device, params->pSignalInfo);
40115     return STATUS_SUCCESS;
40116 }
40117 #endif /* _WIN64 */
40118
40119 static NTSTATUS thunk32_vkSignalSemaphore(void *args)
40120 {
40121     struct
40122     {
40123         PTR32 device;
40124         PTR32 pSignalInfo;
40125         VkResult result;
40126     } *params = args;
40127     VkSemaphoreSignalInfo pSignalInfo_host;
40128
40129     TRACE("%#x, %#x\n", params->device, params->pSignalInfo);
40130
40131     convert_VkSemaphoreSignalInfo_win32_to_host((const VkSemaphoreSignalInfo32 *)UlongToPtr(params->pSignalInfo), &pSignalInfo_host);
40132     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSignalSemaphore(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pSignalInfo_host);
40133     return STATUS_SUCCESS;
40134 }
40135
40136 #ifdef _WIN64
40137 static NTSTATUS thunk64_vkSignalSemaphoreKHR(void *args)
40138 {
40139     struct vkSignalSemaphoreKHR_params *params = args;
40140
40141     TRACE("%p, %p\n", params->device, params->pSignalInfo);
40142
40143     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle(params->device)->device, params->pSignalInfo);
40144     return STATUS_SUCCESS;
40145 }
40146 #endif /* _WIN64 */
40147
40148 static NTSTATUS thunk32_vkSignalSemaphoreKHR(void *args)
40149 {
40150     struct
40151     {
40152         PTR32 device;
40153         PTR32 pSignalInfo;
40154         VkResult result;
40155     } *params = args;
40156     VkSemaphoreSignalInfo pSignalInfo_host;
40157
40158     TRACE("%#x, %#x\n", params->device, params->pSignalInfo);
40159
40160     convert_VkSemaphoreSignalInfo_win32_to_host((const VkSemaphoreSignalInfo32 *)UlongToPtr(params->pSignalInfo), &pSignalInfo_host);
40161     params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pSignalInfo_host);
40162     return STATUS_SUCCESS;
40163 }
40164
40165 #ifdef _WIN64
40166 static NTSTATUS thunk64_vkSubmitDebugUtilsMessageEXT(void *args)
40167 {
40168     struct vkSubmitDebugUtilsMessageEXT_params *params = args;
40169     VkDebugUtilsMessengerCallbackDataEXT pCallbackData_host;
40170     struct conversion_context ctx;
40171
40172     TRACE("%p, %#x, %#x, %p\n", params->instance, params->messageSeverity, params->messageTypes, params->pCallbackData);
40173
40174     init_conversion_context(&ctx);
40175     convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(&ctx, params->pCallbackData, &pCallbackData_host);
40176     wine_instance_from_handle(params->instance)->funcs.p_vkSubmitDebugUtilsMessageEXT(wine_instance_from_handle(params->instance)->instance, params->messageSeverity, params->messageTypes, &pCallbackData_host);
40177     free_conversion_context(&ctx);
40178     return STATUS_SUCCESS;
40179 }
40180 #endif /* _WIN64 */
40181
40182 static NTSTATUS thunk32_vkSubmitDebugUtilsMessageEXT(void *args)
40183 {
40184     struct
40185     {
40186         PTR32 instance;
40187         VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity;
40188         VkDebugUtilsMessageTypeFlagsEXT messageTypes;
40189         PTR32 pCallbackData;
40190     } *params = args;
40191     VkDebugUtilsMessengerCallbackDataEXT pCallbackData_host;
40192     struct conversion_context ctx;
40193
40194     TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->messageSeverity, params->messageTypes, params->pCallbackData);
40195
40196     init_conversion_context(&ctx);
40197     convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(&ctx, (const VkDebugUtilsMessengerCallbackDataEXT32 *)UlongToPtr(params->pCallbackData), &pCallbackData_host);
40198     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);
40199     free_conversion_context(&ctx);
40200     return STATUS_SUCCESS;
40201 }
40202
40203 #ifdef _WIN64
40204 static NTSTATUS thunk64_vkTrimCommandPool(void *args)
40205 {
40206     struct vkTrimCommandPool_params *params = args;
40207
40208     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
40209
40210     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);
40211     return STATUS_SUCCESS;
40212 }
40213 #endif /* _WIN64 */
40214
40215 static NTSTATUS thunk32_vkTrimCommandPool(void *args)
40216 {
40217     struct
40218     {
40219         PTR32 device;
40220         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
40221         VkCommandPoolTrimFlags flags;
40222     } *params = args;
40223
40224     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
40225
40226     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);
40227     return STATUS_SUCCESS;
40228 }
40229
40230 #ifdef _WIN64
40231 static NTSTATUS thunk64_vkTrimCommandPoolKHR(void *args)
40232 {
40233     struct vkTrimCommandPoolKHR_params *params = args;
40234
40235     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
40236
40237     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);
40238     return STATUS_SUCCESS;
40239 }
40240 #endif /* _WIN64 */
40241
40242 static NTSTATUS thunk32_vkTrimCommandPoolKHR(void *args)
40243 {
40244     struct
40245     {
40246         PTR32 device;
40247         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
40248         VkCommandPoolTrimFlags flags;
40249     } *params = args;
40250
40251     TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
40252
40253     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);
40254     return STATUS_SUCCESS;
40255 }
40256
40257 #ifdef _WIN64
40258 static NTSTATUS thunk64_vkUninitializePerformanceApiINTEL(void *args)
40259 {
40260     struct vkUninitializePerformanceApiINTEL_params *params = args;
40261
40262     TRACE("%p\n", params->device);
40263
40264     wine_device_from_handle(params->device)->funcs.p_vkUninitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device);
40265     return STATUS_SUCCESS;
40266 }
40267 #endif /* _WIN64 */
40268
40269 static NTSTATUS thunk32_vkUninitializePerformanceApiINTEL(void *args)
40270 {
40271     struct
40272     {
40273         PTR32 device;
40274     } *params = args;
40275
40276     TRACE("%#x\n", params->device);
40277
40278     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUninitializePerformanceApiINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
40279     return STATUS_SUCCESS;
40280 }
40281
40282 #ifdef _WIN64
40283 static NTSTATUS thunk64_vkUnmapMemory(void *args)
40284 {
40285     struct vkUnmapMemory_params *params = args;
40286
40287     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->memory));
40288
40289     wine_device_from_handle(params->device)->funcs.p_vkUnmapMemory(wine_device_from_handle(params->device)->device, params->memory);
40290     return STATUS_SUCCESS;
40291 }
40292 #endif /* _WIN64 */
40293
40294 static NTSTATUS thunk32_vkUnmapMemory(void *args)
40295 {
40296     struct
40297     {
40298         PTR32 device;
40299         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
40300     } *params = args;
40301
40302     TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->memory));
40303
40304     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUnmapMemory(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->memory);
40305     return STATUS_SUCCESS;
40306 }
40307
40308 #ifdef _WIN64
40309 static NTSTATUS thunk64_vkUpdateDescriptorSetWithTemplate(void *args)
40310 {
40311     struct vkUpdateDescriptorSetWithTemplate_params *params = args;
40312
40313     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
40314
40315     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
40316     return STATUS_SUCCESS;
40317 }
40318 #endif /* _WIN64 */
40319
40320 static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplate(void *args)
40321 {
40322     struct
40323     {
40324         PTR32 device;
40325         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
40326         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
40327         PTR32 pData;
40328     } *params = args;
40329
40330     TRACE("%#x, 0x%s, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
40331
40332     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));
40333     return STATUS_SUCCESS;
40334 }
40335
40336 #ifdef _WIN64
40337 static NTSTATUS thunk64_vkUpdateDescriptorSetWithTemplateKHR(void *args)
40338 {
40339     struct vkUpdateDescriptorSetWithTemplateKHR_params *params = args;
40340
40341     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
40342
40343     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
40344     return STATUS_SUCCESS;
40345 }
40346 #endif /* _WIN64 */
40347
40348 static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplateKHR(void *args)
40349 {
40350     struct
40351     {
40352         PTR32 device;
40353         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
40354         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
40355         PTR32 pData;
40356     } *params = args;
40357
40358     TRACE("%#x, 0x%s, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
40359
40360     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));
40361     return STATUS_SUCCESS;
40362 }
40363
40364 #ifdef _WIN64
40365 static NTSTATUS thunk64_vkUpdateDescriptorSets(void *args)
40366 {
40367     struct vkUpdateDescriptorSets_params *params = args;
40368
40369     TRACE("%p, %u, %p, %u, %p\n", params->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
40370
40371     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
40372     return STATUS_SUCCESS;
40373 }
40374 #endif /* _WIN64 */
40375
40376 static NTSTATUS thunk32_vkUpdateDescriptorSets(void *args)
40377 {
40378     struct
40379     {
40380         PTR32 device;
40381         uint32_t descriptorWriteCount;
40382         PTR32 pDescriptorWrites;
40383         uint32_t descriptorCopyCount;
40384         PTR32 pDescriptorCopies;
40385     } *params = args;
40386     const VkWriteDescriptorSet *pDescriptorWrites_host;
40387     const VkCopyDescriptorSet *pDescriptorCopies_host;
40388     struct conversion_context ctx;
40389
40390     TRACE("%#x, %u, %#x, %u, %#x\n", params->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
40391
40392     init_conversion_context(&ctx);
40393     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, (const VkWriteDescriptorSet32 *)UlongToPtr(params->pDescriptorWrites), params->descriptorWriteCount);
40394     pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win32_to_host(&ctx, (const VkCopyDescriptorSet32 *)UlongToPtr(params->pDescriptorCopies), params->descriptorCopyCount);
40395     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);
40396     free_conversion_context(&ctx);
40397     return STATUS_SUCCESS;
40398 }
40399
40400 #ifdef _WIN64
40401 static NTSTATUS thunk64_vkWaitForFences(void *args)
40402 {
40403     struct vkWaitForFences_params *params = args;
40404
40405     TRACE("%p, %u, %p, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));
40406
40407     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);
40408     return STATUS_SUCCESS;
40409 }
40410 #endif /* _WIN64 */
40411
40412 static NTSTATUS thunk32_vkWaitForFences(void *args)
40413 {
40414     struct
40415     {
40416         PTR32 device;
40417         uint32_t fenceCount;
40418         PTR32 pFences;
40419         VkBool32 waitAll;
40420         uint64_t DECLSPEC_ALIGN(8) timeout;
40421         VkResult result;
40422     } *params = args;
40423
40424     TRACE("%#x, %u, %#x, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));
40425
40426     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);
40427     return STATUS_SUCCESS;
40428 }
40429
40430 #ifdef _WIN64
40431 static NTSTATUS thunk64_vkWaitForPresentKHR(void *args)
40432 {
40433     struct vkWaitForPresentKHR_params *params = args;
40434
40435     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));
40436
40437     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForPresentKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->presentId, params->timeout);
40438     return STATUS_SUCCESS;
40439 }
40440 #endif /* _WIN64 */
40441
40442 static NTSTATUS thunk32_vkWaitForPresentKHR(void *args)
40443 {
40444     struct
40445     {
40446         PTR32 device;
40447         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
40448         uint64_t DECLSPEC_ALIGN(8) presentId;
40449         uint64_t DECLSPEC_ALIGN(8) timeout;
40450         VkResult result;
40451     } *params = args;
40452
40453     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));
40454
40455     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);
40456     return STATUS_SUCCESS;
40457 }
40458
40459 #ifdef _WIN64
40460 static NTSTATUS thunk64_vkWaitSemaphores(void *args)
40461 {
40462     struct vkWaitSemaphores_params *params = args;
40463
40464     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
40465
40466     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphores(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
40467     return STATUS_SUCCESS;
40468 }
40469 #endif /* _WIN64 */
40470
40471 static NTSTATUS thunk32_vkWaitSemaphores(void *args)
40472 {
40473     struct
40474     {
40475         PTR32 device;
40476         PTR32 pWaitInfo;
40477         uint64_t DECLSPEC_ALIGN(8) timeout;
40478         VkResult result;
40479     } *params = args;
40480     VkSemaphoreWaitInfo pWaitInfo_host;
40481
40482     TRACE("%#x, %#x, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
40483
40484     convert_VkSemaphoreWaitInfo_win32_to_host((const VkSemaphoreWaitInfo32 *)UlongToPtr(params->pWaitInfo), &pWaitInfo_host);
40485     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);
40486     return STATUS_SUCCESS;
40487 }
40488
40489 #ifdef _WIN64
40490 static NTSTATUS thunk64_vkWaitSemaphoresKHR(void *args)
40491 {
40492     struct vkWaitSemaphoresKHR_params *params = args;
40493
40494     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
40495
40496     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
40497     return STATUS_SUCCESS;
40498 }
40499 #endif /* _WIN64 */
40500
40501 static NTSTATUS thunk32_vkWaitSemaphoresKHR(void *args)
40502 {
40503     struct
40504     {
40505         PTR32 device;
40506         PTR32 pWaitInfo;
40507         uint64_t DECLSPEC_ALIGN(8) timeout;
40508         VkResult result;
40509     } *params = args;
40510     VkSemaphoreWaitInfo pWaitInfo_host;
40511
40512     TRACE("%#x, %#x, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
40513
40514     convert_VkSemaphoreWaitInfo_win32_to_host((const VkSemaphoreWaitInfo32 *)UlongToPtr(params->pWaitInfo), &pWaitInfo_host);
40515     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);
40516     return STATUS_SUCCESS;
40517 }
40518
40519 #ifdef _WIN64
40520 static NTSTATUS thunk64_vkWriteAccelerationStructuresPropertiesKHR(void *args)
40521 {
40522     struct vkWriteAccelerationStructuresPropertiesKHR_params *params = args;
40523
40524     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));
40525
40526     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);
40527     return STATUS_SUCCESS;
40528 }
40529 #endif /* _WIN64 */
40530
40531 static NTSTATUS thunk32_vkWriteAccelerationStructuresPropertiesKHR(void *args)
40532 {
40533     struct
40534     {
40535         PTR32 device;
40536         uint32_t accelerationStructureCount;
40537         PTR32 pAccelerationStructures;
40538         VkQueryType queryType;
40539         PTR32 dataSize;
40540         PTR32 pData;
40541         PTR32 stride;
40542         VkResult result;
40543     } *params = args;
40544
40545     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));
40546
40547     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);
40548     return STATUS_SUCCESS;
40549 }
40550
40551 #ifdef _WIN64
40552 static NTSTATUS thunk64_vkWriteMicromapsPropertiesEXT(void *args)
40553 {
40554     struct vkWriteMicromapsPropertiesEXT_params *params = args;
40555
40556     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));
40557
40558     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);
40559     return STATUS_SUCCESS;
40560 }
40561 #endif /* _WIN64 */
40562
40563 static NTSTATUS thunk32_vkWriteMicromapsPropertiesEXT(void *args)
40564 {
40565     struct
40566     {
40567         PTR32 device;
40568         uint32_t micromapCount;
40569         PTR32 pMicromaps;
40570         VkQueryType queryType;
40571         PTR32 dataSize;
40572         PTR32 pData;
40573         PTR32 stride;
40574         VkResult result;
40575     } *params = args;
40576
40577     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));
40578
40579     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);
40580     return STATUS_SUCCESS;
40581 }
40582
40583 static const char * const vk_device_extensions[] =
40584 {
40585     "VK_AMD_buffer_marker",
40586     "VK_AMD_device_coherent_memory",
40587     "VK_AMD_draw_indirect_count",
40588     "VK_AMD_gcn_shader",
40589     "VK_AMD_gpu_shader_half_float",
40590     "VK_AMD_gpu_shader_int16",
40591     "VK_AMD_memory_overallocation_behavior",
40592     "VK_AMD_mixed_attachment_samples",
40593     "VK_AMD_negative_viewport_height",
40594     "VK_AMD_pipeline_compiler_control",
40595     "VK_AMD_rasterization_order",
40596     "VK_AMD_shader_ballot",
40597     "VK_AMD_shader_core_properties",
40598     "VK_AMD_shader_core_properties2",
40599     "VK_AMD_shader_early_and_late_fragment_tests",
40600     "VK_AMD_shader_explicit_vertex_parameter",
40601     "VK_AMD_shader_fragment_mask",
40602     "VK_AMD_shader_image_load_store_lod",
40603     "VK_AMD_shader_info",
40604     "VK_AMD_shader_trinary_minmax",
40605     "VK_AMD_texture_gather_bias_lod",
40606     "VK_ARM_rasterization_order_attachment_access",
40607     "VK_ARM_shader_core_builtins",
40608     "VK_EXT_4444_formats",
40609     "VK_EXT_astc_decode_mode",
40610     "VK_EXT_attachment_feedback_loop_layout",
40611     "VK_EXT_blend_operation_advanced",
40612     "VK_EXT_border_color_swizzle",
40613     "VK_EXT_buffer_device_address",
40614     "VK_EXT_calibrated_timestamps",
40615     "VK_EXT_color_write_enable",
40616     "VK_EXT_conditional_rendering",
40617     "VK_EXT_conservative_rasterization",
40618     "VK_EXT_custom_border_color",
40619     "VK_EXT_debug_marker",
40620     "VK_EXT_depth_clamp_zero_one",
40621     "VK_EXT_depth_clip_control",
40622     "VK_EXT_depth_clip_enable",
40623     "VK_EXT_depth_range_unrestricted",
40624     "VK_EXT_descriptor_buffer",
40625     "VK_EXT_descriptor_indexing",
40626     "VK_EXT_device_address_binding_report",
40627     "VK_EXT_device_fault",
40628     "VK_EXT_discard_rectangles",
40629     "VK_EXT_extended_dynamic_state",
40630     "VK_EXT_extended_dynamic_state2",
40631     "VK_EXT_extended_dynamic_state3",
40632     "VK_EXT_external_memory_host",
40633     "VK_EXT_filter_cubic",
40634     "VK_EXT_fragment_density_map",
40635     "VK_EXT_fragment_density_map2",
40636     "VK_EXT_fragment_shader_interlock",
40637     "VK_EXT_global_priority",
40638     "VK_EXT_global_priority_query",
40639     "VK_EXT_graphics_pipeline_library",
40640     "VK_EXT_host_query_reset",
40641     "VK_EXT_image_2d_view_of_3d",
40642     "VK_EXT_image_compression_control",
40643     "VK_EXT_image_compression_control_swapchain",
40644     "VK_EXT_image_robustness",
40645     "VK_EXT_image_view_min_lod",
40646     "VK_EXT_index_type_uint8",
40647     "VK_EXT_inline_uniform_block",
40648     "VK_EXT_legacy_dithering",
40649     "VK_EXT_line_rasterization",
40650     "VK_EXT_load_store_op_none",
40651     "VK_EXT_memory_budget",
40652     "VK_EXT_memory_priority",
40653     "VK_EXT_mesh_shader",
40654     "VK_EXT_multi_draw",
40655     "VK_EXT_multisampled_render_to_single_sampled",
40656     "VK_EXT_mutable_descriptor_type",
40657     "VK_EXT_non_seamless_cube_map",
40658     "VK_EXT_opacity_micromap",
40659     "VK_EXT_pageable_device_local_memory",
40660     "VK_EXT_pci_bus_info",
40661     "VK_EXT_pipeline_creation_cache_control",
40662     "VK_EXT_pipeline_creation_feedback",
40663     "VK_EXT_pipeline_properties",
40664     "VK_EXT_pipeline_protected_access",
40665     "VK_EXT_pipeline_robustness",
40666     "VK_EXT_post_depth_coverage",
40667     "VK_EXT_primitive_topology_list_restart",
40668     "VK_EXT_primitives_generated_query",
40669     "VK_EXT_private_data",
40670     "VK_EXT_provoking_vertex",
40671     "VK_EXT_queue_family_foreign",
40672     "VK_EXT_rasterization_order_attachment_access",
40673     "VK_EXT_rgba10x6_formats",
40674     "VK_EXT_robustness2",
40675     "VK_EXT_sample_locations",
40676     "VK_EXT_sampler_filter_minmax",
40677     "VK_EXT_scalar_block_layout",
40678     "VK_EXT_separate_stencil_usage",
40679     "VK_EXT_shader_atomic_float",
40680     "VK_EXT_shader_atomic_float2",
40681     "VK_EXT_shader_demote_to_helper_invocation",
40682     "VK_EXT_shader_image_atomic_int64",
40683     "VK_EXT_shader_module_identifier",
40684     "VK_EXT_shader_stencil_export",
40685     "VK_EXT_shader_subgroup_ballot",
40686     "VK_EXT_shader_subgroup_vote",
40687     "VK_EXT_shader_viewport_index_layer",
40688     "VK_EXT_subgroup_size_control",
40689     "VK_EXT_subpass_merge_feedback",
40690     "VK_EXT_texel_buffer_alignment",
40691     "VK_EXT_texture_compression_astc_hdr",
40692     "VK_EXT_tooling_info",
40693     "VK_EXT_transform_feedback",
40694     "VK_EXT_validation_cache",
40695     "VK_EXT_vertex_attribute_divisor",
40696     "VK_EXT_vertex_input_dynamic_state",
40697     "VK_EXT_ycbcr_2plane_444_formats",
40698     "VK_EXT_ycbcr_image_arrays",
40699     "VK_GOOGLE_decorate_string",
40700     "VK_GOOGLE_hlsl_functionality1",
40701     "VK_GOOGLE_user_type",
40702     "VK_HUAWEI_invocation_mask",
40703     "VK_HUAWEI_subpass_shading",
40704     "VK_IMG_filter_cubic",
40705     "VK_IMG_format_pvrtc",
40706     "VK_INTEL_performance_query",
40707     "VK_INTEL_shader_integer_functions2",
40708     "VK_KHR_16bit_storage",
40709     "VK_KHR_8bit_storage",
40710     "VK_KHR_acceleration_structure",
40711     "VK_KHR_bind_memory2",
40712     "VK_KHR_buffer_device_address",
40713     "VK_KHR_copy_commands2",
40714     "VK_KHR_create_renderpass2",
40715     "VK_KHR_dedicated_allocation",
40716     "VK_KHR_deferred_host_operations",
40717     "VK_KHR_depth_stencil_resolve",
40718     "VK_KHR_descriptor_update_template",
40719     "VK_KHR_device_group",
40720     "VK_KHR_draw_indirect_count",
40721     "VK_KHR_driver_properties",
40722     "VK_KHR_dynamic_rendering",
40723     "VK_KHR_external_fence",
40724     "VK_KHR_external_memory",
40725     "VK_KHR_external_semaphore",
40726     "VK_KHR_format_feature_flags2",
40727     "VK_KHR_fragment_shader_barycentric",
40728     "VK_KHR_fragment_shading_rate",
40729     "VK_KHR_get_memory_requirements2",
40730     "VK_KHR_global_priority",
40731     "VK_KHR_image_format_list",
40732     "VK_KHR_imageless_framebuffer",
40733     "VK_KHR_incremental_present",
40734     "VK_KHR_maintenance1",
40735     "VK_KHR_maintenance2",
40736     "VK_KHR_maintenance3",
40737     "VK_KHR_maintenance4",
40738     "VK_KHR_multiview",
40739     "VK_KHR_performance_query",
40740     "VK_KHR_pipeline_executable_properties",
40741     "VK_KHR_pipeline_library",
40742     "VK_KHR_present_id",
40743     "VK_KHR_present_wait",
40744     "VK_KHR_push_descriptor",
40745     "VK_KHR_ray_query",
40746     "VK_KHR_ray_tracing_maintenance1",
40747     "VK_KHR_ray_tracing_pipeline",
40748     "VK_KHR_relaxed_block_layout",
40749     "VK_KHR_sampler_mirror_clamp_to_edge",
40750     "VK_KHR_sampler_ycbcr_conversion",
40751     "VK_KHR_separate_depth_stencil_layouts",
40752     "VK_KHR_shader_atomic_int64",
40753     "VK_KHR_shader_clock",
40754     "VK_KHR_shader_draw_parameters",
40755     "VK_KHR_shader_float16_int8",
40756     "VK_KHR_shader_float_controls",
40757     "VK_KHR_shader_integer_dot_product",
40758     "VK_KHR_shader_non_semantic_info",
40759     "VK_KHR_shader_subgroup_extended_types",
40760     "VK_KHR_shader_subgroup_uniform_control_flow",
40761     "VK_KHR_shader_terminate_invocation",
40762     "VK_KHR_spirv_1_4",
40763     "VK_KHR_storage_buffer_storage_class",
40764     "VK_KHR_swapchain",
40765     "VK_KHR_swapchain_mutable_format",
40766     "VK_KHR_synchronization2",
40767     "VK_KHR_timeline_semaphore",
40768     "VK_KHR_uniform_buffer_standard_layout",
40769     "VK_KHR_variable_pointers",
40770     "VK_KHR_vulkan_memory_model",
40771     "VK_KHR_workgroup_memory_explicit_layout",
40772     "VK_KHR_zero_initialize_workgroup_memory",
40773     "VK_NVX_binary_import",
40774     "VK_NVX_image_view_handle",
40775     "VK_NV_clip_space_w_scaling",
40776     "VK_NV_compute_shader_derivatives",
40777     "VK_NV_cooperative_matrix",
40778     "VK_NV_copy_memory_indirect",
40779     "VK_NV_corner_sampled_image",
40780     "VK_NV_coverage_reduction_mode",
40781     "VK_NV_dedicated_allocation",
40782     "VK_NV_dedicated_allocation_image_aliasing",
40783     "VK_NV_device_diagnostic_checkpoints",
40784     "VK_NV_device_diagnostics_config",
40785     "VK_NV_device_generated_commands",
40786     "VK_NV_fill_rectangle",
40787     "VK_NV_fragment_coverage_to_color",
40788     "VK_NV_fragment_shader_barycentric",
40789     "VK_NV_fragment_shading_rate_enums",
40790     "VK_NV_framebuffer_mixed_samples",
40791     "VK_NV_geometry_shader_passthrough",
40792     "VK_NV_glsl_shader",
40793     "VK_NV_inherited_viewport_scissor",
40794     "VK_NV_linear_color_attachment",
40795     "VK_NV_memory_decompression",
40796     "VK_NV_mesh_shader",
40797     "VK_NV_optical_flow",
40798     "VK_NV_present_barrier",
40799     "VK_NV_ray_tracing",
40800     "VK_NV_ray_tracing_invocation_reorder",
40801     "VK_NV_ray_tracing_motion_blur",
40802     "VK_NV_representative_fragment_test",
40803     "VK_NV_sample_mask_override_coverage",
40804     "VK_NV_scissor_exclusive",
40805     "VK_NV_shader_image_footprint",
40806     "VK_NV_shader_sm_builtins",
40807     "VK_NV_shader_subgroup_partitioned",
40808     "VK_NV_shading_rate_image",
40809     "VK_NV_viewport_array2",
40810     "VK_NV_viewport_swizzle",
40811     "VK_QCOM_fragment_density_map_offset",
40812     "VK_QCOM_image_processing",
40813     "VK_QCOM_render_pass_shader_resolve",
40814     "VK_QCOM_render_pass_store_ops",
40815     "VK_QCOM_render_pass_transform",
40816     "VK_QCOM_rotated_copy_commands",
40817     "VK_QCOM_tile_properties",
40818     "VK_VALVE_descriptor_set_host_mapping",
40819     "VK_VALVE_mutable_descriptor_type",
40820 };
40821
40822 static const char * const vk_instance_extensions[] =
40823 {
40824     "VK_EXT_debug_report",
40825     "VK_EXT_debug_utils",
40826     "VK_EXT_swapchain_colorspace",
40827     "VK_EXT_validation_features",
40828     "VK_EXT_validation_flags",
40829     "VK_KHR_device_group_creation",
40830     "VK_KHR_external_fence_capabilities",
40831     "VK_KHR_external_memory_capabilities",
40832     "VK_KHR_external_semaphore_capabilities",
40833     "VK_KHR_get_physical_device_properties2",
40834     "VK_KHR_get_surface_capabilities2",
40835     "VK_KHR_portability_enumeration",
40836     "VK_KHR_surface",
40837     "VK_KHR_win32_surface",
40838 };
40839
40840 BOOL wine_vk_device_extension_supported(const char *name)
40841 {
40842     unsigned int i;
40843     for (i = 0; i < ARRAY_SIZE(vk_device_extensions); i++)
40844     {
40845         if (strcmp(vk_device_extensions[i], name) == 0)
40846             return TRUE;
40847     }
40848     return FALSE;
40849 }
40850
40851 BOOL wine_vk_instance_extension_supported(const char *name)
40852 {
40853     unsigned int i;
40854     for (i = 0; i < ARRAY_SIZE(vk_instance_extensions); i++)
40855     {
40856         if (strcmp(vk_instance_extensions[i], name) == 0)
40857             return TRUE;
40858     }
40859     return FALSE;
40860 }
40861
40862 BOOL wine_vk_is_type_wrapped(VkObjectType type)
40863 {
40864     return FALSE ||
40865         type == VK_OBJECT_TYPE_COMMAND_BUFFER ||
40866         type == VK_OBJECT_TYPE_COMMAND_POOL ||
40867         type == VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT ||
40868         type == VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT ||
40869         type == VK_OBJECT_TYPE_DEVICE ||
40870         type == VK_OBJECT_TYPE_INSTANCE ||
40871         type == VK_OBJECT_TYPE_PHYSICAL_DEVICE ||
40872         type == VK_OBJECT_TYPE_QUEUE ||
40873         type == VK_OBJECT_TYPE_SURFACE_KHR;
40874 }
40875
40876 #ifdef _WIN64
40877
40878 const unixlib_entry_t __wine_unix_call_funcs[] =
40879 {
40880     init_vulkan,
40881     vk_is_available_instance_function,
40882     vk_is_available_device_function,
40883     thunk64_vkAcquireNextImage2KHR,
40884     thunk64_vkAcquireNextImageKHR,
40885     thunk64_vkAcquirePerformanceConfigurationINTEL,
40886     thunk64_vkAcquireProfilingLockKHR,
40887     thunk64_vkAllocateCommandBuffers,
40888     thunk64_vkAllocateDescriptorSets,
40889     thunk64_vkAllocateMemory,
40890     thunk64_vkBeginCommandBuffer,
40891     thunk64_vkBindAccelerationStructureMemoryNV,
40892     thunk64_vkBindBufferMemory,
40893     thunk64_vkBindBufferMemory2,
40894     thunk64_vkBindBufferMemory2KHR,
40895     thunk64_vkBindImageMemory,
40896     thunk64_vkBindImageMemory2,
40897     thunk64_vkBindImageMemory2KHR,
40898     thunk64_vkBindOpticalFlowSessionImageNV,
40899     thunk64_vkBuildAccelerationStructuresKHR,
40900     thunk64_vkBuildMicromapsEXT,
40901     thunk64_vkCmdBeginConditionalRenderingEXT,
40902     thunk64_vkCmdBeginDebugUtilsLabelEXT,
40903     thunk64_vkCmdBeginQuery,
40904     thunk64_vkCmdBeginQueryIndexedEXT,
40905     thunk64_vkCmdBeginRenderPass,
40906     thunk64_vkCmdBeginRenderPass2,
40907     thunk64_vkCmdBeginRenderPass2KHR,
40908     thunk64_vkCmdBeginRendering,
40909     thunk64_vkCmdBeginRenderingKHR,
40910     thunk64_vkCmdBeginTransformFeedbackEXT,
40911     thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
40912     thunk64_vkCmdBindDescriptorBuffersEXT,
40913     thunk64_vkCmdBindDescriptorSets,
40914     thunk64_vkCmdBindIndexBuffer,
40915     thunk64_vkCmdBindInvocationMaskHUAWEI,
40916     thunk64_vkCmdBindPipeline,
40917     thunk64_vkCmdBindPipelineShaderGroupNV,
40918     thunk64_vkCmdBindShadingRateImageNV,
40919     thunk64_vkCmdBindTransformFeedbackBuffersEXT,
40920     thunk64_vkCmdBindVertexBuffers,
40921     thunk64_vkCmdBindVertexBuffers2,
40922     thunk64_vkCmdBindVertexBuffers2EXT,
40923     thunk64_vkCmdBlitImage,
40924     thunk64_vkCmdBlitImage2,
40925     thunk64_vkCmdBlitImage2KHR,
40926     thunk64_vkCmdBuildAccelerationStructureNV,
40927     thunk64_vkCmdBuildAccelerationStructuresIndirectKHR,
40928     thunk64_vkCmdBuildAccelerationStructuresKHR,
40929     thunk64_vkCmdBuildMicromapsEXT,
40930     thunk64_vkCmdClearAttachments,
40931     thunk64_vkCmdClearColorImage,
40932     thunk64_vkCmdClearDepthStencilImage,
40933     thunk64_vkCmdCopyAccelerationStructureKHR,
40934     thunk64_vkCmdCopyAccelerationStructureNV,
40935     thunk64_vkCmdCopyAccelerationStructureToMemoryKHR,
40936     thunk64_vkCmdCopyBuffer,
40937     thunk64_vkCmdCopyBuffer2,
40938     thunk64_vkCmdCopyBuffer2KHR,
40939     thunk64_vkCmdCopyBufferToImage,
40940     thunk64_vkCmdCopyBufferToImage2,
40941     thunk64_vkCmdCopyBufferToImage2KHR,
40942     thunk64_vkCmdCopyImage,
40943     thunk64_vkCmdCopyImage2,
40944     thunk64_vkCmdCopyImage2KHR,
40945     thunk64_vkCmdCopyImageToBuffer,
40946     thunk64_vkCmdCopyImageToBuffer2,
40947     thunk64_vkCmdCopyImageToBuffer2KHR,
40948     thunk64_vkCmdCopyMemoryIndirectNV,
40949     thunk64_vkCmdCopyMemoryToAccelerationStructureKHR,
40950     thunk64_vkCmdCopyMemoryToImageIndirectNV,
40951     thunk64_vkCmdCopyMemoryToMicromapEXT,
40952     thunk64_vkCmdCopyMicromapEXT,
40953     thunk64_vkCmdCopyMicromapToMemoryEXT,
40954     thunk64_vkCmdCopyQueryPoolResults,
40955     thunk64_vkCmdCuLaunchKernelNVX,
40956     thunk64_vkCmdDebugMarkerBeginEXT,
40957     thunk64_vkCmdDebugMarkerEndEXT,
40958     thunk64_vkCmdDebugMarkerInsertEXT,
40959     thunk64_vkCmdDecompressMemoryIndirectCountNV,
40960     thunk64_vkCmdDecompressMemoryNV,
40961     thunk64_vkCmdDispatch,
40962     thunk64_vkCmdDispatchBase,
40963     thunk64_vkCmdDispatchBaseKHR,
40964     thunk64_vkCmdDispatchIndirect,
40965     thunk64_vkCmdDraw,
40966     thunk64_vkCmdDrawIndexed,
40967     thunk64_vkCmdDrawIndexedIndirect,
40968     thunk64_vkCmdDrawIndexedIndirectCount,
40969     thunk64_vkCmdDrawIndexedIndirectCountAMD,
40970     thunk64_vkCmdDrawIndexedIndirectCountKHR,
40971     thunk64_vkCmdDrawIndirect,
40972     thunk64_vkCmdDrawIndirectByteCountEXT,
40973     thunk64_vkCmdDrawIndirectCount,
40974     thunk64_vkCmdDrawIndirectCountAMD,
40975     thunk64_vkCmdDrawIndirectCountKHR,
40976     thunk64_vkCmdDrawMeshTasksEXT,
40977     thunk64_vkCmdDrawMeshTasksIndirectCountEXT,
40978     thunk64_vkCmdDrawMeshTasksIndirectCountNV,
40979     thunk64_vkCmdDrawMeshTasksIndirectEXT,
40980     thunk64_vkCmdDrawMeshTasksIndirectNV,
40981     thunk64_vkCmdDrawMeshTasksNV,
40982     thunk64_vkCmdDrawMultiEXT,
40983     thunk64_vkCmdDrawMultiIndexedEXT,
40984     thunk64_vkCmdEndConditionalRenderingEXT,
40985     thunk64_vkCmdEndDebugUtilsLabelEXT,
40986     thunk64_vkCmdEndQuery,
40987     thunk64_vkCmdEndQueryIndexedEXT,
40988     thunk64_vkCmdEndRenderPass,
40989     thunk64_vkCmdEndRenderPass2,
40990     thunk64_vkCmdEndRenderPass2KHR,
40991     thunk64_vkCmdEndRendering,
40992     thunk64_vkCmdEndRenderingKHR,
40993     thunk64_vkCmdEndTransformFeedbackEXT,
40994     thunk64_vkCmdExecuteCommands,
40995     thunk64_vkCmdExecuteGeneratedCommandsNV,
40996     thunk64_vkCmdFillBuffer,
40997     thunk64_vkCmdInsertDebugUtilsLabelEXT,
40998     thunk64_vkCmdNextSubpass,
40999     thunk64_vkCmdNextSubpass2,
41000     thunk64_vkCmdNextSubpass2KHR,
41001     thunk64_vkCmdOpticalFlowExecuteNV,
41002     thunk64_vkCmdPipelineBarrier,
41003     thunk64_vkCmdPipelineBarrier2,
41004     thunk64_vkCmdPipelineBarrier2KHR,
41005     thunk64_vkCmdPreprocessGeneratedCommandsNV,
41006     thunk64_vkCmdPushConstants,
41007     thunk64_vkCmdPushDescriptorSetKHR,
41008     thunk64_vkCmdPushDescriptorSetWithTemplateKHR,
41009     thunk64_vkCmdResetEvent,
41010     thunk64_vkCmdResetEvent2,
41011     thunk64_vkCmdResetEvent2KHR,
41012     thunk64_vkCmdResetQueryPool,
41013     thunk64_vkCmdResolveImage,
41014     thunk64_vkCmdResolveImage2,
41015     thunk64_vkCmdResolveImage2KHR,
41016     thunk64_vkCmdSetAlphaToCoverageEnableEXT,
41017     thunk64_vkCmdSetAlphaToOneEnableEXT,
41018     thunk64_vkCmdSetBlendConstants,
41019     thunk64_vkCmdSetCheckpointNV,
41020     thunk64_vkCmdSetCoarseSampleOrderNV,
41021     thunk64_vkCmdSetColorBlendAdvancedEXT,
41022     thunk64_vkCmdSetColorBlendEnableEXT,
41023     thunk64_vkCmdSetColorBlendEquationEXT,
41024     thunk64_vkCmdSetColorWriteEnableEXT,
41025     thunk64_vkCmdSetColorWriteMaskEXT,
41026     thunk64_vkCmdSetConservativeRasterizationModeEXT,
41027     thunk64_vkCmdSetCoverageModulationModeNV,
41028     thunk64_vkCmdSetCoverageModulationTableEnableNV,
41029     thunk64_vkCmdSetCoverageModulationTableNV,
41030     thunk64_vkCmdSetCoverageReductionModeNV,
41031     thunk64_vkCmdSetCoverageToColorEnableNV,
41032     thunk64_vkCmdSetCoverageToColorLocationNV,
41033     thunk64_vkCmdSetCullMode,
41034     thunk64_vkCmdSetCullModeEXT,
41035     thunk64_vkCmdSetDepthBias,
41036     thunk64_vkCmdSetDepthBiasEnable,
41037     thunk64_vkCmdSetDepthBiasEnableEXT,
41038     thunk64_vkCmdSetDepthBounds,
41039     thunk64_vkCmdSetDepthBoundsTestEnable,
41040     thunk64_vkCmdSetDepthBoundsTestEnableEXT,
41041     thunk64_vkCmdSetDepthClampEnableEXT,
41042     thunk64_vkCmdSetDepthClipEnableEXT,
41043     thunk64_vkCmdSetDepthClipNegativeOneToOneEXT,
41044     thunk64_vkCmdSetDepthCompareOp,
41045     thunk64_vkCmdSetDepthCompareOpEXT,
41046     thunk64_vkCmdSetDepthTestEnable,
41047     thunk64_vkCmdSetDepthTestEnableEXT,
41048     thunk64_vkCmdSetDepthWriteEnable,
41049     thunk64_vkCmdSetDepthWriteEnableEXT,
41050     thunk64_vkCmdSetDescriptorBufferOffsetsEXT,
41051     thunk64_vkCmdSetDeviceMask,
41052     thunk64_vkCmdSetDeviceMaskKHR,
41053     thunk64_vkCmdSetDiscardRectangleEXT,
41054     thunk64_vkCmdSetEvent,
41055     thunk64_vkCmdSetEvent2,
41056     thunk64_vkCmdSetEvent2KHR,
41057     thunk64_vkCmdSetExclusiveScissorNV,
41058     thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
41059     thunk64_vkCmdSetFragmentShadingRateEnumNV,
41060     thunk64_vkCmdSetFragmentShadingRateKHR,
41061     thunk64_vkCmdSetFrontFace,
41062     thunk64_vkCmdSetFrontFaceEXT,
41063     thunk64_vkCmdSetLineRasterizationModeEXT,
41064     thunk64_vkCmdSetLineStippleEXT,
41065     thunk64_vkCmdSetLineStippleEnableEXT,
41066     thunk64_vkCmdSetLineWidth,
41067     thunk64_vkCmdSetLogicOpEXT,
41068     thunk64_vkCmdSetLogicOpEnableEXT,
41069     thunk64_vkCmdSetPatchControlPointsEXT,
41070     thunk64_vkCmdSetPerformanceMarkerINTEL,
41071     thunk64_vkCmdSetPerformanceOverrideINTEL,
41072     thunk64_vkCmdSetPerformanceStreamMarkerINTEL,
41073     thunk64_vkCmdSetPolygonModeEXT,
41074     thunk64_vkCmdSetPrimitiveRestartEnable,
41075     thunk64_vkCmdSetPrimitiveRestartEnableEXT,
41076     thunk64_vkCmdSetPrimitiveTopology,
41077     thunk64_vkCmdSetPrimitiveTopologyEXT,
41078     thunk64_vkCmdSetProvokingVertexModeEXT,
41079     thunk64_vkCmdSetRasterizationSamplesEXT,
41080     thunk64_vkCmdSetRasterizationStreamEXT,
41081     thunk64_vkCmdSetRasterizerDiscardEnable,
41082     thunk64_vkCmdSetRasterizerDiscardEnableEXT,
41083     thunk64_vkCmdSetRayTracingPipelineStackSizeKHR,
41084     thunk64_vkCmdSetRepresentativeFragmentTestEnableNV,
41085     thunk64_vkCmdSetSampleLocationsEXT,
41086     thunk64_vkCmdSetSampleLocationsEnableEXT,
41087     thunk64_vkCmdSetSampleMaskEXT,
41088     thunk64_vkCmdSetScissor,
41089     thunk64_vkCmdSetScissorWithCount,
41090     thunk64_vkCmdSetScissorWithCountEXT,
41091     thunk64_vkCmdSetShadingRateImageEnableNV,
41092     thunk64_vkCmdSetStencilCompareMask,
41093     thunk64_vkCmdSetStencilOp,
41094     thunk64_vkCmdSetStencilOpEXT,
41095     thunk64_vkCmdSetStencilReference,
41096     thunk64_vkCmdSetStencilTestEnable,
41097     thunk64_vkCmdSetStencilTestEnableEXT,
41098     thunk64_vkCmdSetStencilWriteMask,
41099     thunk64_vkCmdSetTessellationDomainOriginEXT,
41100     thunk64_vkCmdSetVertexInputEXT,
41101     thunk64_vkCmdSetViewport,
41102     thunk64_vkCmdSetViewportShadingRatePaletteNV,
41103     thunk64_vkCmdSetViewportSwizzleNV,
41104     thunk64_vkCmdSetViewportWScalingEnableNV,
41105     thunk64_vkCmdSetViewportWScalingNV,
41106     thunk64_vkCmdSetViewportWithCount,
41107     thunk64_vkCmdSetViewportWithCountEXT,
41108     thunk64_vkCmdSubpassShadingHUAWEI,
41109     thunk64_vkCmdTraceRaysIndirect2KHR,
41110     thunk64_vkCmdTraceRaysIndirectKHR,
41111     thunk64_vkCmdTraceRaysKHR,
41112     thunk64_vkCmdTraceRaysNV,
41113     thunk64_vkCmdUpdateBuffer,
41114     thunk64_vkCmdWaitEvents,
41115     thunk64_vkCmdWaitEvents2,
41116     thunk64_vkCmdWaitEvents2KHR,
41117     thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR,
41118     thunk64_vkCmdWriteAccelerationStructuresPropertiesNV,
41119     thunk64_vkCmdWriteBufferMarker2AMD,
41120     thunk64_vkCmdWriteBufferMarkerAMD,
41121     thunk64_vkCmdWriteMicromapsPropertiesEXT,
41122     thunk64_vkCmdWriteTimestamp,
41123     thunk64_vkCmdWriteTimestamp2,
41124     thunk64_vkCmdWriteTimestamp2KHR,
41125     thunk64_vkCompileDeferredNV,
41126     thunk64_vkCopyAccelerationStructureKHR,
41127     thunk64_vkCopyAccelerationStructureToMemoryKHR,
41128     thunk64_vkCopyMemoryToAccelerationStructureKHR,
41129     thunk64_vkCopyMemoryToMicromapEXT,
41130     thunk64_vkCopyMicromapEXT,
41131     thunk64_vkCopyMicromapToMemoryEXT,
41132     thunk64_vkCreateAccelerationStructureKHR,
41133     thunk64_vkCreateAccelerationStructureNV,
41134     thunk64_vkCreateBuffer,
41135     thunk64_vkCreateBufferView,
41136     thunk64_vkCreateCommandPool,
41137     thunk64_vkCreateComputePipelines,
41138     thunk64_vkCreateCuFunctionNVX,
41139     thunk64_vkCreateCuModuleNVX,
41140     thunk64_vkCreateDebugReportCallbackEXT,
41141     thunk64_vkCreateDebugUtilsMessengerEXT,
41142     thunk64_vkCreateDeferredOperationKHR,
41143     thunk64_vkCreateDescriptorPool,
41144     thunk64_vkCreateDescriptorSetLayout,
41145     thunk64_vkCreateDescriptorUpdateTemplate,
41146     thunk64_vkCreateDescriptorUpdateTemplateKHR,
41147     thunk64_vkCreateDevice,
41148     thunk64_vkCreateEvent,
41149     thunk64_vkCreateFence,
41150     thunk64_vkCreateFramebuffer,
41151     thunk64_vkCreateGraphicsPipelines,
41152     thunk64_vkCreateImage,
41153     thunk64_vkCreateImageView,
41154     thunk64_vkCreateIndirectCommandsLayoutNV,
41155     thunk64_vkCreateInstance,
41156     thunk64_vkCreateMicromapEXT,
41157     thunk64_vkCreateOpticalFlowSessionNV,
41158     thunk64_vkCreatePipelineCache,
41159     thunk64_vkCreatePipelineLayout,
41160     thunk64_vkCreatePrivateDataSlot,
41161     thunk64_vkCreatePrivateDataSlotEXT,
41162     thunk64_vkCreateQueryPool,
41163     thunk64_vkCreateRayTracingPipelinesKHR,
41164     thunk64_vkCreateRayTracingPipelinesNV,
41165     thunk64_vkCreateRenderPass,
41166     thunk64_vkCreateRenderPass2,
41167     thunk64_vkCreateRenderPass2KHR,
41168     thunk64_vkCreateSampler,
41169     thunk64_vkCreateSamplerYcbcrConversion,
41170     thunk64_vkCreateSamplerYcbcrConversionKHR,
41171     thunk64_vkCreateSemaphore,
41172     thunk64_vkCreateShaderModule,
41173     thunk64_vkCreateSwapchainKHR,
41174     thunk64_vkCreateValidationCacheEXT,
41175     thunk64_vkCreateWin32SurfaceKHR,
41176     thunk64_vkDebugMarkerSetObjectNameEXT,
41177     thunk64_vkDebugMarkerSetObjectTagEXT,
41178     thunk64_vkDebugReportMessageEXT,
41179     thunk64_vkDeferredOperationJoinKHR,
41180     thunk64_vkDestroyAccelerationStructureKHR,
41181     thunk64_vkDestroyAccelerationStructureNV,
41182     thunk64_vkDestroyBuffer,
41183     thunk64_vkDestroyBufferView,
41184     thunk64_vkDestroyCommandPool,
41185     thunk64_vkDestroyCuFunctionNVX,
41186     thunk64_vkDestroyCuModuleNVX,
41187     thunk64_vkDestroyDebugReportCallbackEXT,
41188     thunk64_vkDestroyDebugUtilsMessengerEXT,
41189     thunk64_vkDestroyDeferredOperationKHR,
41190     thunk64_vkDestroyDescriptorPool,
41191     thunk64_vkDestroyDescriptorSetLayout,
41192     thunk64_vkDestroyDescriptorUpdateTemplate,
41193     thunk64_vkDestroyDescriptorUpdateTemplateKHR,
41194     thunk64_vkDestroyDevice,
41195     thunk64_vkDestroyEvent,
41196     thunk64_vkDestroyFence,
41197     thunk64_vkDestroyFramebuffer,
41198     thunk64_vkDestroyImage,
41199     thunk64_vkDestroyImageView,
41200     thunk64_vkDestroyIndirectCommandsLayoutNV,
41201     thunk64_vkDestroyInstance,
41202     thunk64_vkDestroyMicromapEXT,
41203     thunk64_vkDestroyOpticalFlowSessionNV,
41204     thunk64_vkDestroyPipeline,
41205     thunk64_vkDestroyPipelineCache,
41206     thunk64_vkDestroyPipelineLayout,
41207     thunk64_vkDestroyPrivateDataSlot,
41208     thunk64_vkDestroyPrivateDataSlotEXT,
41209     thunk64_vkDestroyQueryPool,
41210     thunk64_vkDestroyRenderPass,
41211     thunk64_vkDestroySampler,
41212     thunk64_vkDestroySamplerYcbcrConversion,
41213     thunk64_vkDestroySamplerYcbcrConversionKHR,
41214     thunk64_vkDestroySemaphore,
41215     thunk64_vkDestroyShaderModule,
41216     thunk64_vkDestroySurfaceKHR,
41217     thunk64_vkDestroySwapchainKHR,
41218     thunk64_vkDestroyValidationCacheEXT,
41219     thunk64_vkDeviceWaitIdle,
41220     thunk64_vkEndCommandBuffer,
41221     thunk64_vkEnumerateDeviceExtensionProperties,
41222     thunk64_vkEnumerateDeviceLayerProperties,
41223     thunk64_vkEnumerateInstanceExtensionProperties,
41224     thunk64_vkEnumerateInstanceVersion,
41225     thunk64_vkEnumeratePhysicalDeviceGroups,
41226     thunk64_vkEnumeratePhysicalDeviceGroupsKHR,
41227     thunk64_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
41228     thunk64_vkEnumeratePhysicalDevices,
41229     thunk64_vkFlushMappedMemoryRanges,
41230     thunk64_vkFreeCommandBuffers,
41231     thunk64_vkFreeDescriptorSets,
41232     thunk64_vkFreeMemory,
41233     thunk64_vkGetAccelerationStructureBuildSizesKHR,
41234     thunk64_vkGetAccelerationStructureDeviceAddressKHR,
41235     thunk64_vkGetAccelerationStructureHandleNV,
41236     thunk64_vkGetAccelerationStructureMemoryRequirementsNV,
41237     thunk64_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
41238     thunk64_vkGetBufferDeviceAddress,
41239     thunk64_vkGetBufferDeviceAddressEXT,
41240     thunk64_vkGetBufferDeviceAddressKHR,
41241     thunk64_vkGetBufferMemoryRequirements,
41242     thunk64_vkGetBufferMemoryRequirements2,
41243     thunk64_vkGetBufferMemoryRequirements2KHR,
41244     thunk64_vkGetBufferOpaqueCaptureAddress,
41245     thunk64_vkGetBufferOpaqueCaptureAddressKHR,
41246     thunk64_vkGetBufferOpaqueCaptureDescriptorDataEXT,
41247     thunk64_vkGetCalibratedTimestampsEXT,
41248     thunk64_vkGetDeferredOperationMaxConcurrencyKHR,
41249     thunk64_vkGetDeferredOperationResultKHR,
41250     thunk64_vkGetDescriptorEXT,
41251     thunk64_vkGetDescriptorSetHostMappingVALVE,
41252     thunk64_vkGetDescriptorSetLayoutBindingOffsetEXT,
41253     thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
41254     thunk64_vkGetDescriptorSetLayoutSizeEXT,
41255     thunk64_vkGetDescriptorSetLayoutSupport,
41256     thunk64_vkGetDescriptorSetLayoutSupportKHR,
41257     thunk64_vkGetDeviceAccelerationStructureCompatibilityKHR,
41258     thunk64_vkGetDeviceBufferMemoryRequirements,
41259     thunk64_vkGetDeviceBufferMemoryRequirementsKHR,
41260     thunk64_vkGetDeviceFaultInfoEXT,
41261     thunk64_vkGetDeviceGroupPeerMemoryFeatures,
41262     thunk64_vkGetDeviceGroupPeerMemoryFeaturesKHR,
41263     thunk64_vkGetDeviceGroupPresentCapabilitiesKHR,
41264     thunk64_vkGetDeviceGroupSurfacePresentModesKHR,
41265     thunk64_vkGetDeviceImageMemoryRequirements,
41266     thunk64_vkGetDeviceImageMemoryRequirementsKHR,
41267     thunk64_vkGetDeviceImageSparseMemoryRequirements,
41268     thunk64_vkGetDeviceImageSparseMemoryRequirementsKHR,
41269     thunk64_vkGetDeviceMemoryCommitment,
41270     thunk64_vkGetDeviceMemoryOpaqueCaptureAddress,
41271     thunk64_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
41272     thunk64_vkGetDeviceMicromapCompatibilityEXT,
41273     thunk64_vkGetDeviceQueue,
41274     thunk64_vkGetDeviceQueue2,
41275     thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
41276     thunk64_vkGetDynamicRenderingTilePropertiesQCOM,
41277     thunk64_vkGetEventStatus,
41278     thunk64_vkGetFenceStatus,
41279     thunk64_vkGetFramebufferTilePropertiesQCOM,
41280     thunk64_vkGetGeneratedCommandsMemoryRequirementsNV,
41281     thunk64_vkGetImageMemoryRequirements,
41282     thunk64_vkGetImageMemoryRequirements2,
41283     thunk64_vkGetImageMemoryRequirements2KHR,
41284     thunk64_vkGetImageOpaqueCaptureDescriptorDataEXT,
41285     thunk64_vkGetImageSparseMemoryRequirements,
41286     thunk64_vkGetImageSparseMemoryRequirements2,
41287     thunk64_vkGetImageSparseMemoryRequirements2KHR,
41288     thunk64_vkGetImageSubresourceLayout,
41289     thunk64_vkGetImageSubresourceLayout2EXT,
41290     thunk64_vkGetImageViewAddressNVX,
41291     thunk64_vkGetImageViewHandleNVX,
41292     thunk64_vkGetImageViewOpaqueCaptureDescriptorDataEXT,
41293     thunk64_vkGetMemoryHostPointerPropertiesEXT,
41294     thunk64_vkGetMicromapBuildSizesEXT,
41295     thunk64_vkGetPerformanceParameterINTEL,
41296     thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
41297     thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
41298     thunk64_vkGetPhysicalDeviceExternalBufferProperties,
41299     thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
41300     thunk64_vkGetPhysicalDeviceExternalFenceProperties,
41301     thunk64_vkGetPhysicalDeviceExternalFencePropertiesKHR,
41302     thunk64_vkGetPhysicalDeviceExternalSemaphoreProperties,
41303     thunk64_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
41304     thunk64_vkGetPhysicalDeviceFeatures,
41305     thunk64_vkGetPhysicalDeviceFeatures2,
41306     thunk64_vkGetPhysicalDeviceFeatures2KHR,
41307     thunk64_vkGetPhysicalDeviceFormatProperties,
41308     thunk64_vkGetPhysicalDeviceFormatProperties2,
41309     thunk64_vkGetPhysicalDeviceFormatProperties2KHR,
41310     thunk64_vkGetPhysicalDeviceFragmentShadingRatesKHR,
41311     thunk64_vkGetPhysicalDeviceImageFormatProperties,
41312     thunk64_vkGetPhysicalDeviceImageFormatProperties2,
41313     thunk64_vkGetPhysicalDeviceImageFormatProperties2KHR,
41314     thunk64_vkGetPhysicalDeviceMemoryProperties,
41315     thunk64_vkGetPhysicalDeviceMemoryProperties2,
41316     thunk64_vkGetPhysicalDeviceMemoryProperties2KHR,
41317     thunk64_vkGetPhysicalDeviceMultisamplePropertiesEXT,
41318     thunk64_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
41319     thunk64_vkGetPhysicalDevicePresentRectanglesKHR,
41320     thunk64_vkGetPhysicalDeviceProperties,
41321     thunk64_vkGetPhysicalDeviceProperties2,
41322     thunk64_vkGetPhysicalDeviceProperties2KHR,
41323     thunk64_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
41324     thunk64_vkGetPhysicalDeviceQueueFamilyProperties,
41325     thunk64_vkGetPhysicalDeviceQueueFamilyProperties2,
41326     thunk64_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
41327     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties,
41328     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2,
41329     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
41330     thunk64_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
41331     thunk64_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
41332     thunk64_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
41333     thunk64_vkGetPhysicalDeviceSurfaceFormats2KHR,
41334     thunk64_vkGetPhysicalDeviceSurfaceFormatsKHR,
41335     thunk64_vkGetPhysicalDeviceSurfacePresentModesKHR,
41336     thunk64_vkGetPhysicalDeviceSurfaceSupportKHR,
41337     thunk64_vkGetPhysicalDeviceToolProperties,
41338     thunk64_vkGetPhysicalDeviceToolPropertiesEXT,
41339     thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR,
41340     thunk64_vkGetPipelineCacheData,
41341     thunk64_vkGetPipelineExecutableInternalRepresentationsKHR,
41342     thunk64_vkGetPipelineExecutablePropertiesKHR,
41343     thunk64_vkGetPipelineExecutableStatisticsKHR,
41344     thunk64_vkGetPipelinePropertiesEXT,
41345     thunk64_vkGetPrivateData,
41346     thunk64_vkGetPrivateDataEXT,
41347     thunk64_vkGetQueryPoolResults,
41348     thunk64_vkGetQueueCheckpointData2NV,
41349     thunk64_vkGetQueueCheckpointDataNV,
41350     thunk64_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
41351     thunk64_vkGetRayTracingShaderGroupHandlesKHR,
41352     thunk64_vkGetRayTracingShaderGroupHandlesNV,
41353     thunk64_vkGetRayTracingShaderGroupStackSizeKHR,
41354     thunk64_vkGetRenderAreaGranularity,
41355     thunk64_vkGetSamplerOpaqueCaptureDescriptorDataEXT,
41356     thunk64_vkGetSemaphoreCounterValue,
41357     thunk64_vkGetSemaphoreCounterValueKHR,
41358     thunk64_vkGetShaderInfoAMD,
41359     thunk64_vkGetShaderModuleCreateInfoIdentifierEXT,
41360     thunk64_vkGetShaderModuleIdentifierEXT,
41361     thunk64_vkGetSwapchainImagesKHR,
41362     thunk64_vkGetValidationCacheDataEXT,
41363     thunk64_vkInitializePerformanceApiINTEL,
41364     thunk64_vkInvalidateMappedMemoryRanges,
41365     thunk64_vkMapMemory,
41366     thunk64_vkMergePipelineCaches,
41367     thunk64_vkMergeValidationCachesEXT,
41368     thunk64_vkQueueBeginDebugUtilsLabelEXT,
41369     thunk64_vkQueueBindSparse,
41370     thunk64_vkQueueEndDebugUtilsLabelEXT,
41371     thunk64_vkQueueInsertDebugUtilsLabelEXT,
41372     thunk64_vkQueuePresentKHR,
41373     thunk64_vkQueueSetPerformanceConfigurationINTEL,
41374     thunk64_vkQueueSubmit,
41375     thunk64_vkQueueSubmit2,
41376     thunk64_vkQueueSubmit2KHR,
41377     thunk64_vkQueueWaitIdle,
41378     thunk64_vkReleasePerformanceConfigurationINTEL,
41379     thunk64_vkReleaseProfilingLockKHR,
41380     thunk64_vkResetCommandBuffer,
41381     thunk64_vkResetCommandPool,
41382     thunk64_vkResetDescriptorPool,
41383     thunk64_vkResetEvent,
41384     thunk64_vkResetFences,
41385     thunk64_vkResetQueryPool,
41386     thunk64_vkResetQueryPoolEXT,
41387     thunk64_vkSetDebugUtilsObjectNameEXT,
41388     thunk64_vkSetDebugUtilsObjectTagEXT,
41389     thunk64_vkSetDeviceMemoryPriorityEXT,
41390     thunk64_vkSetEvent,
41391     thunk64_vkSetPrivateData,
41392     thunk64_vkSetPrivateDataEXT,
41393     thunk64_vkSignalSemaphore,
41394     thunk64_vkSignalSemaphoreKHR,
41395     thunk64_vkSubmitDebugUtilsMessageEXT,
41396     thunk64_vkTrimCommandPool,
41397     thunk64_vkTrimCommandPoolKHR,
41398     thunk64_vkUninitializePerformanceApiINTEL,
41399     thunk64_vkUnmapMemory,
41400     thunk64_vkUpdateDescriptorSetWithTemplate,
41401     thunk64_vkUpdateDescriptorSetWithTemplateKHR,
41402     thunk64_vkUpdateDescriptorSets,
41403     thunk64_vkWaitForFences,
41404     thunk64_vkWaitForPresentKHR,
41405     thunk64_vkWaitSemaphores,
41406     thunk64_vkWaitSemaphoresKHR,
41407     thunk64_vkWriteAccelerationStructuresPropertiesKHR,
41408     thunk64_vkWriteMicromapsPropertiesEXT,
41409 };
41410 C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);
41411
41412 #endif /* _WIN64 */
41413
41414 #ifdef _WIN64
41415 const unixlib_entry_t __wine_unix_call_wow64_funcs[] =
41416 #else
41417 const unixlib_entry_t __wine_unix_call_funcs[] =
41418 #endif
41419 {
41420     init_vulkan32,
41421     vk_is_available_instance_function32,
41422     vk_is_available_device_function32,
41423     thunk32_vkAcquireNextImage2KHR,
41424     thunk32_vkAcquireNextImageKHR,
41425     thunk32_vkAcquirePerformanceConfigurationINTEL,
41426     thunk32_vkAcquireProfilingLockKHR,
41427     thunk32_vkAllocateCommandBuffers,
41428     thunk32_vkAllocateDescriptorSets,
41429     thunk32_vkAllocateMemory,
41430     thunk32_vkBeginCommandBuffer,
41431     thunk32_vkBindAccelerationStructureMemoryNV,
41432     thunk32_vkBindBufferMemory,
41433     thunk32_vkBindBufferMemory2,
41434     thunk32_vkBindBufferMemory2KHR,
41435     thunk32_vkBindImageMemory,
41436     thunk32_vkBindImageMemory2,
41437     thunk32_vkBindImageMemory2KHR,
41438     thunk32_vkBindOpticalFlowSessionImageNV,
41439     thunk32_vkBuildAccelerationStructuresKHR,
41440     thunk32_vkBuildMicromapsEXT,
41441     thunk32_vkCmdBeginConditionalRenderingEXT,
41442     thunk32_vkCmdBeginDebugUtilsLabelEXT,
41443     thunk32_vkCmdBeginQuery,
41444     thunk32_vkCmdBeginQueryIndexedEXT,
41445     thunk32_vkCmdBeginRenderPass,
41446     thunk32_vkCmdBeginRenderPass2,
41447     thunk32_vkCmdBeginRenderPass2KHR,
41448     thunk32_vkCmdBeginRendering,
41449     thunk32_vkCmdBeginRenderingKHR,
41450     thunk32_vkCmdBeginTransformFeedbackEXT,
41451     thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
41452     thunk32_vkCmdBindDescriptorBuffersEXT,
41453     thunk32_vkCmdBindDescriptorSets,
41454     thunk32_vkCmdBindIndexBuffer,
41455     thunk32_vkCmdBindInvocationMaskHUAWEI,
41456     thunk32_vkCmdBindPipeline,
41457     thunk32_vkCmdBindPipelineShaderGroupNV,
41458     thunk32_vkCmdBindShadingRateImageNV,
41459     thunk32_vkCmdBindTransformFeedbackBuffersEXT,
41460     thunk32_vkCmdBindVertexBuffers,
41461     thunk32_vkCmdBindVertexBuffers2,
41462     thunk32_vkCmdBindVertexBuffers2EXT,
41463     thunk32_vkCmdBlitImage,
41464     thunk32_vkCmdBlitImage2,
41465     thunk32_vkCmdBlitImage2KHR,
41466     thunk32_vkCmdBuildAccelerationStructureNV,
41467     thunk32_vkCmdBuildAccelerationStructuresIndirectKHR,
41468     thunk32_vkCmdBuildAccelerationStructuresKHR,
41469     thunk32_vkCmdBuildMicromapsEXT,
41470     thunk32_vkCmdClearAttachments,
41471     thunk32_vkCmdClearColorImage,
41472     thunk32_vkCmdClearDepthStencilImage,
41473     thunk32_vkCmdCopyAccelerationStructureKHR,
41474     thunk32_vkCmdCopyAccelerationStructureNV,
41475     thunk32_vkCmdCopyAccelerationStructureToMemoryKHR,
41476     thunk32_vkCmdCopyBuffer,
41477     thunk32_vkCmdCopyBuffer2,
41478     thunk32_vkCmdCopyBuffer2KHR,
41479     thunk32_vkCmdCopyBufferToImage,
41480     thunk32_vkCmdCopyBufferToImage2,
41481     thunk32_vkCmdCopyBufferToImage2KHR,
41482     thunk32_vkCmdCopyImage,
41483     thunk32_vkCmdCopyImage2,
41484     thunk32_vkCmdCopyImage2KHR,
41485     thunk32_vkCmdCopyImageToBuffer,
41486     thunk32_vkCmdCopyImageToBuffer2,
41487     thunk32_vkCmdCopyImageToBuffer2KHR,
41488     thunk32_vkCmdCopyMemoryIndirectNV,
41489     thunk32_vkCmdCopyMemoryToAccelerationStructureKHR,
41490     thunk32_vkCmdCopyMemoryToImageIndirectNV,
41491     thunk32_vkCmdCopyMemoryToMicromapEXT,
41492     thunk32_vkCmdCopyMicromapEXT,
41493     thunk32_vkCmdCopyMicromapToMemoryEXT,
41494     thunk32_vkCmdCopyQueryPoolResults,
41495     thunk32_vkCmdCuLaunchKernelNVX,
41496     thunk32_vkCmdDebugMarkerBeginEXT,
41497     thunk32_vkCmdDebugMarkerEndEXT,
41498     thunk32_vkCmdDebugMarkerInsertEXT,
41499     thunk32_vkCmdDecompressMemoryIndirectCountNV,
41500     thunk32_vkCmdDecompressMemoryNV,
41501     thunk32_vkCmdDispatch,
41502     thunk32_vkCmdDispatchBase,
41503     thunk32_vkCmdDispatchBaseKHR,
41504     thunk32_vkCmdDispatchIndirect,
41505     thunk32_vkCmdDraw,
41506     thunk32_vkCmdDrawIndexed,
41507     thunk32_vkCmdDrawIndexedIndirect,
41508     thunk32_vkCmdDrawIndexedIndirectCount,
41509     thunk32_vkCmdDrawIndexedIndirectCountAMD,
41510     thunk32_vkCmdDrawIndexedIndirectCountKHR,
41511     thunk32_vkCmdDrawIndirect,
41512     thunk32_vkCmdDrawIndirectByteCountEXT,
41513     thunk32_vkCmdDrawIndirectCount,
41514     thunk32_vkCmdDrawIndirectCountAMD,
41515     thunk32_vkCmdDrawIndirectCountKHR,
41516     thunk32_vkCmdDrawMeshTasksEXT,
41517     thunk32_vkCmdDrawMeshTasksIndirectCountEXT,
41518     thunk32_vkCmdDrawMeshTasksIndirectCountNV,
41519     thunk32_vkCmdDrawMeshTasksIndirectEXT,
41520     thunk32_vkCmdDrawMeshTasksIndirectNV,
41521     thunk32_vkCmdDrawMeshTasksNV,
41522     thunk32_vkCmdDrawMultiEXT,
41523     thunk32_vkCmdDrawMultiIndexedEXT,
41524     thunk32_vkCmdEndConditionalRenderingEXT,
41525     thunk32_vkCmdEndDebugUtilsLabelEXT,
41526     thunk32_vkCmdEndQuery,
41527     thunk32_vkCmdEndQueryIndexedEXT,
41528     thunk32_vkCmdEndRenderPass,
41529     thunk32_vkCmdEndRenderPass2,
41530     thunk32_vkCmdEndRenderPass2KHR,
41531     thunk32_vkCmdEndRendering,
41532     thunk32_vkCmdEndRenderingKHR,
41533     thunk32_vkCmdEndTransformFeedbackEXT,
41534     thunk32_vkCmdExecuteCommands,
41535     thunk32_vkCmdExecuteGeneratedCommandsNV,
41536     thunk32_vkCmdFillBuffer,
41537     thunk32_vkCmdInsertDebugUtilsLabelEXT,
41538     thunk32_vkCmdNextSubpass,
41539     thunk32_vkCmdNextSubpass2,
41540     thunk32_vkCmdNextSubpass2KHR,
41541     thunk32_vkCmdOpticalFlowExecuteNV,
41542     thunk32_vkCmdPipelineBarrier,
41543     thunk32_vkCmdPipelineBarrier2,
41544     thunk32_vkCmdPipelineBarrier2KHR,
41545     thunk32_vkCmdPreprocessGeneratedCommandsNV,
41546     thunk32_vkCmdPushConstants,
41547     thunk32_vkCmdPushDescriptorSetKHR,
41548     thunk32_vkCmdPushDescriptorSetWithTemplateKHR,
41549     thunk32_vkCmdResetEvent,
41550     thunk32_vkCmdResetEvent2,
41551     thunk32_vkCmdResetEvent2KHR,
41552     thunk32_vkCmdResetQueryPool,
41553     thunk32_vkCmdResolveImage,
41554     thunk32_vkCmdResolveImage2,
41555     thunk32_vkCmdResolveImage2KHR,
41556     thunk32_vkCmdSetAlphaToCoverageEnableEXT,
41557     thunk32_vkCmdSetAlphaToOneEnableEXT,
41558     thunk32_vkCmdSetBlendConstants,
41559     thunk32_vkCmdSetCheckpointNV,
41560     thunk32_vkCmdSetCoarseSampleOrderNV,
41561     thunk32_vkCmdSetColorBlendAdvancedEXT,
41562     thunk32_vkCmdSetColorBlendEnableEXT,
41563     thunk32_vkCmdSetColorBlendEquationEXT,
41564     thunk32_vkCmdSetColorWriteEnableEXT,
41565     thunk32_vkCmdSetColorWriteMaskEXT,
41566     thunk32_vkCmdSetConservativeRasterizationModeEXT,
41567     thunk32_vkCmdSetCoverageModulationModeNV,
41568     thunk32_vkCmdSetCoverageModulationTableEnableNV,
41569     thunk32_vkCmdSetCoverageModulationTableNV,
41570     thunk32_vkCmdSetCoverageReductionModeNV,
41571     thunk32_vkCmdSetCoverageToColorEnableNV,
41572     thunk32_vkCmdSetCoverageToColorLocationNV,
41573     thunk32_vkCmdSetCullMode,
41574     thunk32_vkCmdSetCullModeEXT,
41575     thunk32_vkCmdSetDepthBias,
41576     thunk32_vkCmdSetDepthBiasEnable,
41577     thunk32_vkCmdSetDepthBiasEnableEXT,
41578     thunk32_vkCmdSetDepthBounds,
41579     thunk32_vkCmdSetDepthBoundsTestEnable,
41580     thunk32_vkCmdSetDepthBoundsTestEnableEXT,
41581     thunk32_vkCmdSetDepthClampEnableEXT,
41582     thunk32_vkCmdSetDepthClipEnableEXT,
41583     thunk32_vkCmdSetDepthClipNegativeOneToOneEXT,
41584     thunk32_vkCmdSetDepthCompareOp,
41585     thunk32_vkCmdSetDepthCompareOpEXT,
41586     thunk32_vkCmdSetDepthTestEnable,
41587     thunk32_vkCmdSetDepthTestEnableEXT,
41588     thunk32_vkCmdSetDepthWriteEnable,
41589     thunk32_vkCmdSetDepthWriteEnableEXT,
41590     thunk32_vkCmdSetDescriptorBufferOffsetsEXT,
41591     thunk32_vkCmdSetDeviceMask,
41592     thunk32_vkCmdSetDeviceMaskKHR,
41593     thunk32_vkCmdSetDiscardRectangleEXT,
41594     thunk32_vkCmdSetEvent,
41595     thunk32_vkCmdSetEvent2,
41596     thunk32_vkCmdSetEvent2KHR,
41597     thunk32_vkCmdSetExclusiveScissorNV,
41598     thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
41599     thunk32_vkCmdSetFragmentShadingRateEnumNV,
41600     thunk32_vkCmdSetFragmentShadingRateKHR,
41601     thunk32_vkCmdSetFrontFace,
41602     thunk32_vkCmdSetFrontFaceEXT,
41603     thunk32_vkCmdSetLineRasterizationModeEXT,
41604     thunk32_vkCmdSetLineStippleEXT,
41605     thunk32_vkCmdSetLineStippleEnableEXT,
41606     thunk32_vkCmdSetLineWidth,
41607     thunk32_vkCmdSetLogicOpEXT,
41608     thunk32_vkCmdSetLogicOpEnableEXT,
41609     thunk32_vkCmdSetPatchControlPointsEXT,
41610     thunk32_vkCmdSetPerformanceMarkerINTEL,
41611     thunk32_vkCmdSetPerformanceOverrideINTEL,
41612     thunk32_vkCmdSetPerformanceStreamMarkerINTEL,
41613     thunk32_vkCmdSetPolygonModeEXT,
41614     thunk32_vkCmdSetPrimitiveRestartEnable,
41615     thunk32_vkCmdSetPrimitiveRestartEnableEXT,
41616     thunk32_vkCmdSetPrimitiveTopology,
41617     thunk32_vkCmdSetPrimitiveTopologyEXT,
41618     thunk32_vkCmdSetProvokingVertexModeEXT,
41619     thunk32_vkCmdSetRasterizationSamplesEXT,
41620     thunk32_vkCmdSetRasterizationStreamEXT,
41621     thunk32_vkCmdSetRasterizerDiscardEnable,
41622     thunk32_vkCmdSetRasterizerDiscardEnableEXT,
41623     thunk32_vkCmdSetRayTracingPipelineStackSizeKHR,
41624     thunk32_vkCmdSetRepresentativeFragmentTestEnableNV,
41625     thunk32_vkCmdSetSampleLocationsEXT,
41626     thunk32_vkCmdSetSampleLocationsEnableEXT,
41627     thunk32_vkCmdSetSampleMaskEXT,
41628     thunk32_vkCmdSetScissor,
41629     thunk32_vkCmdSetScissorWithCount,
41630     thunk32_vkCmdSetScissorWithCountEXT,
41631     thunk32_vkCmdSetShadingRateImageEnableNV,
41632     thunk32_vkCmdSetStencilCompareMask,
41633     thunk32_vkCmdSetStencilOp,
41634     thunk32_vkCmdSetStencilOpEXT,
41635     thunk32_vkCmdSetStencilReference,
41636     thunk32_vkCmdSetStencilTestEnable,
41637     thunk32_vkCmdSetStencilTestEnableEXT,
41638     thunk32_vkCmdSetStencilWriteMask,
41639     thunk32_vkCmdSetTessellationDomainOriginEXT,
41640     thunk32_vkCmdSetVertexInputEXT,
41641     thunk32_vkCmdSetViewport,
41642     thunk32_vkCmdSetViewportShadingRatePaletteNV,
41643     thunk32_vkCmdSetViewportSwizzleNV,
41644     thunk32_vkCmdSetViewportWScalingEnableNV,
41645     thunk32_vkCmdSetViewportWScalingNV,
41646     thunk32_vkCmdSetViewportWithCount,
41647     thunk32_vkCmdSetViewportWithCountEXT,
41648     thunk32_vkCmdSubpassShadingHUAWEI,
41649     thunk32_vkCmdTraceRaysIndirect2KHR,
41650     thunk32_vkCmdTraceRaysIndirectKHR,
41651     thunk32_vkCmdTraceRaysKHR,
41652     thunk32_vkCmdTraceRaysNV,
41653     thunk32_vkCmdUpdateBuffer,
41654     thunk32_vkCmdWaitEvents,
41655     thunk32_vkCmdWaitEvents2,
41656     thunk32_vkCmdWaitEvents2KHR,
41657     thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR,
41658     thunk32_vkCmdWriteAccelerationStructuresPropertiesNV,
41659     thunk32_vkCmdWriteBufferMarker2AMD,
41660     thunk32_vkCmdWriteBufferMarkerAMD,
41661     thunk32_vkCmdWriteMicromapsPropertiesEXT,
41662     thunk32_vkCmdWriteTimestamp,
41663     thunk32_vkCmdWriteTimestamp2,
41664     thunk32_vkCmdWriteTimestamp2KHR,
41665     thunk32_vkCompileDeferredNV,
41666     thunk32_vkCopyAccelerationStructureKHR,
41667     thunk32_vkCopyAccelerationStructureToMemoryKHR,
41668     thunk32_vkCopyMemoryToAccelerationStructureKHR,
41669     thunk32_vkCopyMemoryToMicromapEXT,
41670     thunk32_vkCopyMicromapEXT,
41671     thunk32_vkCopyMicromapToMemoryEXT,
41672     thunk32_vkCreateAccelerationStructureKHR,
41673     thunk32_vkCreateAccelerationStructureNV,
41674     thunk32_vkCreateBuffer,
41675     thunk32_vkCreateBufferView,
41676     thunk32_vkCreateCommandPool,
41677     thunk32_vkCreateComputePipelines,
41678     thunk32_vkCreateCuFunctionNVX,
41679     thunk32_vkCreateCuModuleNVX,
41680     thunk32_vkCreateDebugReportCallbackEXT,
41681     thunk32_vkCreateDebugUtilsMessengerEXT,
41682     thunk32_vkCreateDeferredOperationKHR,
41683     thunk32_vkCreateDescriptorPool,
41684     thunk32_vkCreateDescriptorSetLayout,
41685     thunk32_vkCreateDescriptorUpdateTemplate,
41686     thunk32_vkCreateDescriptorUpdateTemplateKHR,
41687     thunk32_vkCreateDevice,
41688     thunk32_vkCreateEvent,
41689     thunk32_vkCreateFence,
41690     thunk32_vkCreateFramebuffer,
41691     thunk32_vkCreateGraphicsPipelines,
41692     thunk32_vkCreateImage,
41693     thunk32_vkCreateImageView,
41694     thunk32_vkCreateIndirectCommandsLayoutNV,
41695     thunk32_vkCreateInstance,
41696     thunk32_vkCreateMicromapEXT,
41697     thunk32_vkCreateOpticalFlowSessionNV,
41698     thunk32_vkCreatePipelineCache,
41699     thunk32_vkCreatePipelineLayout,
41700     thunk32_vkCreatePrivateDataSlot,
41701     thunk32_vkCreatePrivateDataSlotEXT,
41702     thunk32_vkCreateQueryPool,
41703     thunk32_vkCreateRayTracingPipelinesKHR,
41704     thunk32_vkCreateRayTracingPipelinesNV,
41705     thunk32_vkCreateRenderPass,
41706     thunk32_vkCreateRenderPass2,
41707     thunk32_vkCreateRenderPass2KHR,
41708     thunk32_vkCreateSampler,
41709     thunk32_vkCreateSamplerYcbcrConversion,
41710     thunk32_vkCreateSamplerYcbcrConversionKHR,
41711     thunk32_vkCreateSemaphore,
41712     thunk32_vkCreateShaderModule,
41713     thunk32_vkCreateSwapchainKHR,
41714     thunk32_vkCreateValidationCacheEXT,
41715     thunk32_vkCreateWin32SurfaceKHR,
41716     thunk32_vkDebugMarkerSetObjectNameEXT,
41717     thunk32_vkDebugMarkerSetObjectTagEXT,
41718     thunk32_vkDebugReportMessageEXT,
41719     thunk32_vkDeferredOperationJoinKHR,
41720     thunk32_vkDestroyAccelerationStructureKHR,
41721     thunk32_vkDestroyAccelerationStructureNV,
41722     thunk32_vkDestroyBuffer,
41723     thunk32_vkDestroyBufferView,
41724     thunk32_vkDestroyCommandPool,
41725     thunk32_vkDestroyCuFunctionNVX,
41726     thunk32_vkDestroyCuModuleNVX,
41727     thunk32_vkDestroyDebugReportCallbackEXT,
41728     thunk32_vkDestroyDebugUtilsMessengerEXT,
41729     thunk32_vkDestroyDeferredOperationKHR,
41730     thunk32_vkDestroyDescriptorPool,
41731     thunk32_vkDestroyDescriptorSetLayout,
41732     thunk32_vkDestroyDescriptorUpdateTemplate,
41733     thunk32_vkDestroyDescriptorUpdateTemplateKHR,
41734     thunk32_vkDestroyDevice,
41735     thunk32_vkDestroyEvent,
41736     thunk32_vkDestroyFence,
41737     thunk32_vkDestroyFramebuffer,
41738     thunk32_vkDestroyImage,
41739     thunk32_vkDestroyImageView,
41740     thunk32_vkDestroyIndirectCommandsLayoutNV,
41741     thunk32_vkDestroyInstance,
41742     thunk32_vkDestroyMicromapEXT,
41743     thunk32_vkDestroyOpticalFlowSessionNV,
41744     thunk32_vkDestroyPipeline,
41745     thunk32_vkDestroyPipelineCache,
41746     thunk32_vkDestroyPipelineLayout,
41747     thunk32_vkDestroyPrivateDataSlot,
41748     thunk32_vkDestroyPrivateDataSlotEXT,
41749     thunk32_vkDestroyQueryPool,
41750     thunk32_vkDestroyRenderPass,
41751     thunk32_vkDestroySampler,
41752     thunk32_vkDestroySamplerYcbcrConversion,
41753     thunk32_vkDestroySamplerYcbcrConversionKHR,
41754     thunk32_vkDestroySemaphore,
41755     thunk32_vkDestroyShaderModule,
41756     thunk32_vkDestroySurfaceKHR,
41757     thunk32_vkDestroySwapchainKHR,
41758     thunk32_vkDestroyValidationCacheEXT,
41759     thunk32_vkDeviceWaitIdle,
41760     thunk32_vkEndCommandBuffer,
41761     thunk32_vkEnumerateDeviceExtensionProperties,
41762     thunk32_vkEnumerateDeviceLayerProperties,
41763     thunk32_vkEnumerateInstanceExtensionProperties,
41764     thunk32_vkEnumerateInstanceVersion,
41765     thunk32_vkEnumeratePhysicalDeviceGroups,
41766     thunk32_vkEnumeratePhysicalDeviceGroupsKHR,
41767     thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
41768     thunk32_vkEnumeratePhysicalDevices,
41769     thunk32_vkFlushMappedMemoryRanges,
41770     thunk32_vkFreeCommandBuffers,
41771     thunk32_vkFreeDescriptorSets,
41772     thunk32_vkFreeMemory,
41773     thunk32_vkGetAccelerationStructureBuildSizesKHR,
41774     thunk32_vkGetAccelerationStructureDeviceAddressKHR,
41775     thunk32_vkGetAccelerationStructureHandleNV,
41776     thunk32_vkGetAccelerationStructureMemoryRequirementsNV,
41777     thunk32_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
41778     thunk32_vkGetBufferDeviceAddress,
41779     thunk32_vkGetBufferDeviceAddressEXT,
41780     thunk32_vkGetBufferDeviceAddressKHR,
41781     thunk32_vkGetBufferMemoryRequirements,
41782     thunk32_vkGetBufferMemoryRequirements2,
41783     thunk32_vkGetBufferMemoryRequirements2KHR,
41784     thunk32_vkGetBufferOpaqueCaptureAddress,
41785     thunk32_vkGetBufferOpaqueCaptureAddressKHR,
41786     thunk32_vkGetBufferOpaqueCaptureDescriptorDataEXT,
41787     thunk32_vkGetCalibratedTimestampsEXT,
41788     thunk32_vkGetDeferredOperationMaxConcurrencyKHR,
41789     thunk32_vkGetDeferredOperationResultKHR,
41790     thunk32_vkGetDescriptorEXT,
41791     thunk32_vkGetDescriptorSetHostMappingVALVE,
41792     thunk32_vkGetDescriptorSetLayoutBindingOffsetEXT,
41793     thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
41794     thunk32_vkGetDescriptorSetLayoutSizeEXT,
41795     thunk32_vkGetDescriptorSetLayoutSupport,
41796     thunk32_vkGetDescriptorSetLayoutSupportKHR,
41797     thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR,
41798     thunk32_vkGetDeviceBufferMemoryRequirements,
41799     thunk32_vkGetDeviceBufferMemoryRequirementsKHR,
41800     thunk32_vkGetDeviceFaultInfoEXT,
41801     thunk32_vkGetDeviceGroupPeerMemoryFeatures,
41802     thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR,
41803     thunk32_vkGetDeviceGroupPresentCapabilitiesKHR,
41804     thunk32_vkGetDeviceGroupSurfacePresentModesKHR,
41805     thunk32_vkGetDeviceImageMemoryRequirements,
41806     thunk32_vkGetDeviceImageMemoryRequirementsKHR,
41807     thunk32_vkGetDeviceImageSparseMemoryRequirements,
41808     thunk32_vkGetDeviceImageSparseMemoryRequirementsKHR,
41809     thunk32_vkGetDeviceMemoryCommitment,
41810     thunk32_vkGetDeviceMemoryOpaqueCaptureAddress,
41811     thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
41812     thunk32_vkGetDeviceMicromapCompatibilityEXT,
41813     thunk32_vkGetDeviceQueue,
41814     thunk32_vkGetDeviceQueue2,
41815     thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
41816     thunk32_vkGetDynamicRenderingTilePropertiesQCOM,
41817     thunk32_vkGetEventStatus,
41818     thunk32_vkGetFenceStatus,
41819     thunk32_vkGetFramebufferTilePropertiesQCOM,
41820     thunk32_vkGetGeneratedCommandsMemoryRequirementsNV,
41821     thunk32_vkGetImageMemoryRequirements,
41822     thunk32_vkGetImageMemoryRequirements2,
41823     thunk32_vkGetImageMemoryRequirements2KHR,
41824     thunk32_vkGetImageOpaqueCaptureDescriptorDataEXT,
41825     thunk32_vkGetImageSparseMemoryRequirements,
41826     thunk32_vkGetImageSparseMemoryRequirements2,
41827     thunk32_vkGetImageSparseMemoryRequirements2KHR,
41828     thunk32_vkGetImageSubresourceLayout,
41829     thunk32_vkGetImageSubresourceLayout2EXT,
41830     thunk32_vkGetImageViewAddressNVX,
41831     thunk32_vkGetImageViewHandleNVX,
41832     thunk32_vkGetImageViewOpaqueCaptureDescriptorDataEXT,
41833     thunk32_vkGetMemoryHostPointerPropertiesEXT,
41834     thunk32_vkGetMicromapBuildSizesEXT,
41835     thunk32_vkGetPerformanceParameterINTEL,
41836     thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
41837     thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
41838     thunk32_vkGetPhysicalDeviceExternalBufferProperties,
41839     thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
41840     thunk32_vkGetPhysicalDeviceExternalFenceProperties,
41841     thunk32_vkGetPhysicalDeviceExternalFencePropertiesKHR,
41842     thunk32_vkGetPhysicalDeviceExternalSemaphoreProperties,
41843     thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
41844     thunk32_vkGetPhysicalDeviceFeatures,
41845     thunk32_vkGetPhysicalDeviceFeatures2,
41846     thunk32_vkGetPhysicalDeviceFeatures2KHR,
41847     thunk32_vkGetPhysicalDeviceFormatProperties,
41848     thunk32_vkGetPhysicalDeviceFormatProperties2,
41849     thunk32_vkGetPhysicalDeviceFormatProperties2KHR,
41850     thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR,
41851     thunk32_vkGetPhysicalDeviceImageFormatProperties,
41852     thunk32_vkGetPhysicalDeviceImageFormatProperties2,
41853     thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR,
41854     thunk32_vkGetPhysicalDeviceMemoryProperties,
41855     thunk32_vkGetPhysicalDeviceMemoryProperties2,
41856     thunk32_vkGetPhysicalDeviceMemoryProperties2KHR,
41857     thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT,
41858     thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
41859     thunk32_vkGetPhysicalDevicePresentRectanglesKHR,
41860     thunk32_vkGetPhysicalDeviceProperties,
41861     thunk32_vkGetPhysicalDeviceProperties2,
41862     thunk32_vkGetPhysicalDeviceProperties2KHR,
41863     thunk32_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
41864     thunk32_vkGetPhysicalDeviceQueueFamilyProperties,
41865     thunk32_vkGetPhysicalDeviceQueueFamilyProperties2,
41866     thunk32_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
41867     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties,
41868     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2,
41869     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
41870     thunk32_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
41871     thunk32_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
41872     thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
41873     thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR,
41874     thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR,
41875     thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR,
41876     thunk32_vkGetPhysicalDeviceSurfaceSupportKHR,
41877     thunk32_vkGetPhysicalDeviceToolProperties,
41878     thunk32_vkGetPhysicalDeviceToolPropertiesEXT,
41879     thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR,
41880     thunk32_vkGetPipelineCacheData,
41881     thunk32_vkGetPipelineExecutableInternalRepresentationsKHR,
41882     thunk32_vkGetPipelineExecutablePropertiesKHR,
41883     thunk32_vkGetPipelineExecutableStatisticsKHR,
41884     thunk32_vkGetPipelinePropertiesEXT,
41885     thunk32_vkGetPrivateData,
41886     thunk32_vkGetPrivateDataEXT,
41887     thunk32_vkGetQueryPoolResults,
41888     thunk32_vkGetQueueCheckpointData2NV,
41889     thunk32_vkGetQueueCheckpointDataNV,
41890     thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
41891     thunk32_vkGetRayTracingShaderGroupHandlesKHR,
41892     thunk32_vkGetRayTracingShaderGroupHandlesNV,
41893     thunk32_vkGetRayTracingShaderGroupStackSizeKHR,
41894     thunk32_vkGetRenderAreaGranularity,
41895     thunk32_vkGetSamplerOpaqueCaptureDescriptorDataEXT,
41896     thunk32_vkGetSemaphoreCounterValue,
41897     thunk32_vkGetSemaphoreCounterValueKHR,
41898     thunk32_vkGetShaderInfoAMD,
41899     thunk32_vkGetShaderModuleCreateInfoIdentifierEXT,
41900     thunk32_vkGetShaderModuleIdentifierEXT,
41901     thunk32_vkGetSwapchainImagesKHR,
41902     thunk32_vkGetValidationCacheDataEXT,
41903     thunk32_vkInitializePerformanceApiINTEL,
41904     thunk32_vkInvalidateMappedMemoryRanges,
41905     thunk32_vkMapMemory,
41906     thunk32_vkMergePipelineCaches,
41907     thunk32_vkMergeValidationCachesEXT,
41908     thunk32_vkQueueBeginDebugUtilsLabelEXT,
41909     thunk32_vkQueueBindSparse,
41910     thunk32_vkQueueEndDebugUtilsLabelEXT,
41911     thunk32_vkQueueInsertDebugUtilsLabelEXT,
41912     thunk32_vkQueuePresentKHR,
41913     thunk32_vkQueueSetPerformanceConfigurationINTEL,
41914     thunk32_vkQueueSubmit,
41915     thunk32_vkQueueSubmit2,
41916     thunk32_vkQueueSubmit2KHR,
41917     thunk32_vkQueueWaitIdle,
41918     thunk32_vkReleasePerformanceConfigurationINTEL,
41919     thunk32_vkReleaseProfilingLockKHR,
41920     thunk32_vkResetCommandBuffer,
41921     thunk32_vkResetCommandPool,
41922     thunk32_vkResetDescriptorPool,
41923     thunk32_vkResetEvent,
41924     thunk32_vkResetFences,
41925     thunk32_vkResetQueryPool,
41926     thunk32_vkResetQueryPoolEXT,
41927     thunk32_vkSetDebugUtilsObjectNameEXT,
41928     thunk32_vkSetDebugUtilsObjectTagEXT,
41929     thunk32_vkSetDeviceMemoryPriorityEXT,
41930     thunk32_vkSetEvent,
41931     thunk32_vkSetPrivateData,
41932     thunk32_vkSetPrivateDataEXT,
41933     thunk32_vkSignalSemaphore,
41934     thunk32_vkSignalSemaphoreKHR,
41935     thunk32_vkSubmitDebugUtilsMessageEXT,
41936     thunk32_vkTrimCommandPool,
41937     thunk32_vkTrimCommandPoolKHR,
41938     thunk32_vkUninitializePerformanceApiINTEL,
41939     thunk32_vkUnmapMemory,
41940     thunk32_vkUpdateDescriptorSetWithTemplate,
41941     thunk32_vkUpdateDescriptorSetWithTemplateKHR,
41942     thunk32_vkUpdateDescriptorSets,
41943     thunk32_vkWaitForFences,
41944     thunk32_vkWaitForPresentKHR,
41945     thunk32_vkWaitSemaphores,
41946     thunk32_vkWaitSemaphoresKHR,
41947     thunk32_vkWriteAccelerationStructuresPropertiesKHR,
41948     thunk32_vkWriteMicromapsPropertiesEXT,
41949 };
41950 C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);
41951
41952 NTSTATUS WINAPI vk_direct_unix_call(unixlib_handle_t handle, unsigned int code, void *params)
41953 {
41954     return __wine_unix_call_funcs[code](params);
41955 }