dlls/winevulkan/vulkan_thunks.c

   1 /* Automatically generated from Vulkan vk.xml; DO NOT EDIT!
   2  *
   3  * This file is generated from Vulkan vk.xml file covered
   4  * by the following copyright and permission notice:
   5  *
   6  * Copyright 2015-2022 The Khronos Group Inc.
   7  *
   8  * SPDX-License-Identifier: Apache-2.0 OR MIT
   9  *
  10  */
  11
  12 #if 0
  13 #pragma makedep unix
  14 #endif
  15
  16 #include "config.h"
  17
  18 #include <stdlib.h>
  19
  20 #include "vulkan_private.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
  23
  24 #if defined(USE_STRUCT_CONVERSION)
  25
  26 typedef struct VkAcquireNextImageInfoKHR32
  27 {
  28     VkStructureType sType;
  29     const void *pNext;
  30     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
  31     uint64_t DECLSPEC_ALIGN(8) timeout;
  32     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
  33     VkFence DECLSPEC_ALIGN(8) fence;
  34     uint32_t deviceMask;
  35 } VkAcquireNextImageInfoKHR32;
  36
  37 typedef struct VkAcquireProfilingLockInfoKHR32
  38 {
  39     VkStructureType sType;
  40     const void *pNext;
  41     VkAcquireProfilingLockFlagsKHR flags;
  42     uint64_t DECLSPEC_ALIGN(8) timeout;
  43 } VkAcquireProfilingLockInfoKHR32;
  44
  45 typedef struct VkCommandBufferAllocateInfo32
  46 {
  47     VkStructureType sType;
  48     const void *pNext;
  49     VkCommandPool DECLSPEC_ALIGN(8) commandPool;
  50     VkCommandBufferLevel level;
  51     uint32_t commandBufferCount;
  52 } VkCommandBufferAllocateInfo32;
  53
  54 typedef struct VkDescriptorSetAllocateInfo32
  55 {
  56     VkStructureType sType;
  57     const void *pNext;
  58     VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
  59     uint32_t descriptorSetCount;
  60     const VkDescriptorSetLayout *pSetLayouts;
  61 } VkDescriptorSetAllocateInfo32;
  62
  63 typedef struct VkDedicatedAllocationMemoryAllocateInfoNV32
  64 {
  65     VkStructureType sType;
  66     const void *pNext;
  67     VkImage DECLSPEC_ALIGN(8) image;
  68     VkBuffer DECLSPEC_ALIGN(8) buffer;
  69 } VkDedicatedAllocationMemoryAllocateInfoNV32;
  70
  71 typedef struct VkMemoryDedicatedAllocateInfo32
  72 {
  73     VkStructureType sType;
  74     const void *pNext;
  75     VkImage DECLSPEC_ALIGN(8) image;
  76     VkBuffer DECLSPEC_ALIGN(8) buffer;
  77 } VkMemoryDedicatedAllocateInfo32;
  78 typedef VkMemoryDedicatedAllocateInfo32 VkMemoryDedicatedAllocateInfoKHR32;
  79
  80 typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo32
  81 {
  82     VkStructureType sType;
  83     const void *pNext;
  84     uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
  85 } VkMemoryOpaqueCaptureAddressAllocateInfo32;
  86 typedef VkMemoryOpaqueCaptureAddressAllocateInfo32 VkMemoryOpaqueCaptureAddressAllocateInfoKHR32;
  87
  88 typedef struct VkMemoryAllocateInfo32
  89 {
  90     VkStructureType sType;
  91     const void *pNext;
  92     VkDeviceSize DECLSPEC_ALIGN(8) allocationSize;
  93     uint32_t memoryTypeIndex;
  94 } VkMemoryAllocateInfo32;
  95
  96 typedef struct VkCommandBufferInheritanceInfo32
  97 {
  98     VkStructureType sType;
  99     const void *pNext;
 100     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
 101     uint32_t subpass;
 102     VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
 103     VkBool32 occlusionQueryEnable;
 104     VkQueryControlFlags queryFlags;
 105     VkQueryPipelineStatisticFlags pipelineStatistics;
 106 } VkCommandBufferInheritanceInfo32;
 107
 108 typedef struct VkCommandBufferBeginInfo32
 109 {
 110     VkStructureType sType;
 111     const void *pNext;
 112     VkCommandBufferUsageFlags flags;
 113     const VkCommandBufferInheritanceInfo32 *pInheritanceInfo;
 114 } VkCommandBufferBeginInfo32;
 115
 116 typedef struct VkBindAccelerationStructureMemoryInfoNV32
 117 {
 118     VkStructureType sType;
 119     const void *pNext;
 120     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
 121     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
 122     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
 123     uint32_t deviceIndexCount;
 124     const uint32_t *pDeviceIndices;
 125 } VkBindAccelerationStructureMemoryInfoNV32;
 126
 127 typedef struct VkBindBufferMemoryInfo32
 128 {
 129     VkStructureType sType;
 130     const void *pNext;
 131     VkBuffer DECLSPEC_ALIGN(8) buffer;
 132     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
 133     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
 134 } VkBindBufferMemoryInfo32;
 135 typedef VkBindBufferMemoryInfo32 VkBindBufferMemoryInfoKHR32;
 136
 137 typedef struct VkBindImageMemorySwapchainInfoKHR32
 138 {
 139     VkStructureType sType;
 140     const void *pNext;
 141     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
 142     uint32_t imageIndex;
 143 } VkBindImageMemorySwapchainInfoKHR32;
 144
 145 typedef struct VkBindImageMemoryInfo32
 146 {
 147     VkStructureType sType;
 148     const void *pNext;
 149     VkImage DECLSPEC_ALIGN(8) image;
 150     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
 151     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
 152 } VkBindImageMemoryInfo32;
 153 typedef VkBindImageMemoryInfo32 VkBindImageMemoryInfoKHR32;
 154
 155 typedef struct VkAccelerationStructureGeometryKHR32
 156 {
 157     VkStructureType sType;
 158     const void *pNext;
 159     VkGeometryTypeKHR geometryType;
 160     VkAccelerationStructureGeometryDataKHR DECLSPEC_ALIGN(8) geometry;
 161     VkGeometryFlagsKHR flags;
 162 } VkAccelerationStructureGeometryKHR32;
 163
 164 typedef struct VkAccelerationStructureBuildGeometryInfoKHR32
 165 {
 166     VkStructureType sType;
 167     const void *pNext;
 168     VkAccelerationStructureTypeKHR type;
 169     VkBuildAccelerationStructureFlagsKHR flags;
 170     VkBuildAccelerationStructureModeKHR mode;
 171     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) srcAccelerationStructure;
 172     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dstAccelerationStructure;
 173     uint32_t geometryCount;
 174     const VkAccelerationStructureGeometryKHR32 *pGeometries;
 175     const VkAccelerationStructureGeometryKHR32 * const*ppGeometries;
 176     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData;
 177 } VkAccelerationStructureBuildGeometryInfoKHR32;
 178
 179 typedef struct VkMicromapBuildInfoEXT32
 180 {
 181     VkStructureType sType;
 182     const void *pNext;
 183     VkMicromapTypeEXT type;
 184     VkBuildMicromapFlagsEXT flags;
 185     VkBuildMicromapModeEXT mode;
 186     VkMicromapEXT DECLSPEC_ALIGN(8) dstMicromap;
 187     uint32_t usageCountsCount;
 188     const VkMicromapUsageEXT *pUsageCounts;
 189     const VkMicromapUsageEXT * const*ppUsageCounts;
 190     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
 191     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData;
 192     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) triangleArray;
 193     VkDeviceSize DECLSPEC_ALIGN(8) triangleArrayStride;
 194 } VkMicromapBuildInfoEXT32;
 195
 196 typedef struct VkConditionalRenderingBeginInfoEXT32
 197 {
 198     VkStructureType sType;
 199     const void *pNext;
 200     VkBuffer DECLSPEC_ALIGN(8) buffer;
 201     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 202     VkConditionalRenderingFlagsEXT flags;
 203 } VkConditionalRenderingBeginInfoEXT32;
 204
 205 typedef struct VkRenderPassBeginInfo32
 206 {
 207     VkStructureType sType;
 208     const void *pNext;
 209     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
 210     VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
 211     VkRect2D renderArea;
 212     uint32_t clearValueCount;
 213     const VkClearValue *pClearValues;
 214 } VkRenderPassBeginInfo32;
 215
 216 typedef struct VkRenderingAttachmentInfo32
 217 {
 218     VkStructureType sType;
 219     const void *pNext;
 220     VkImageView DECLSPEC_ALIGN(8) imageView;
 221     VkImageLayout imageLayout;
 222     VkResolveModeFlagBits resolveMode;
 223     VkImageView DECLSPEC_ALIGN(8) resolveImageView;
 224     VkImageLayout resolveImageLayout;
 225     VkAttachmentLoadOp loadOp;
 226     VkAttachmentStoreOp storeOp;
 227     VkClearValue clearValue;
 228 } VkRenderingAttachmentInfo32;
 229 typedef VkRenderingAttachmentInfo32 VkRenderingAttachmentInfoKHR32;
 230
 231 typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR32
 232 {
 233     VkStructureType sType;
 234     const void *pNext;
 235     VkImageView DECLSPEC_ALIGN(8) imageView;
 236     VkImageLayout imageLayout;
 237     VkExtent2D shadingRateAttachmentTexelSize;
 238 } VkRenderingFragmentShadingRateAttachmentInfoKHR32;
 239
 240 typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT32
 241 {
 242     VkStructureType sType;
 243     const void *pNext;
 244     VkImageView DECLSPEC_ALIGN(8) imageView;
 245     VkImageLayout imageLayout;
 246 } VkRenderingFragmentDensityMapAttachmentInfoEXT32;
 247
 248 typedef struct VkRenderingInfo32
 249 {
 250     VkStructureType sType;
 251     const void *pNext;
 252     VkRenderingFlags flags;
 253     VkRect2D renderArea;
 254     uint32_t layerCount;
 255     uint32_t viewMask;
 256     uint32_t colorAttachmentCount;
 257     const VkRenderingAttachmentInfo32 *pColorAttachments;
 258     const VkRenderingAttachmentInfo32 *pDepthAttachment;
 259     const VkRenderingAttachmentInfo32 *pStencilAttachment;
 260 } VkRenderingInfo32;
 261 typedef VkRenderingInfo32 VkRenderingInfoKHR32;
 262
 263 typedef struct VkBlitImageInfo232
 264 {
 265     VkStructureType sType;
 266     const void *pNext;
 267     VkImage DECLSPEC_ALIGN(8) srcImage;
 268     VkImageLayout srcImageLayout;
 269     VkImage DECLSPEC_ALIGN(8) dstImage;
 270     VkImageLayout dstImageLayout;
 271     uint32_t regionCount;
 272     const VkImageBlit2 *pRegions;
 273     VkFilter filter;
 274 } VkBlitImageInfo232;
 275 typedef VkBlitImageInfo232 VkBlitImageInfo2KHR32;
 276
 277 typedef struct VkGeometryTrianglesNV32
 278 {
 279     VkStructureType sType;
 280     const void *pNext;
 281     VkBuffer DECLSPEC_ALIGN(8) vertexData;
 282     VkDeviceSize DECLSPEC_ALIGN(8) vertexOffset;
 283     uint32_t vertexCount;
 284     VkDeviceSize DECLSPEC_ALIGN(8) vertexStride;
 285     VkFormat vertexFormat;
 286     VkBuffer DECLSPEC_ALIGN(8) indexData;
 287     VkDeviceSize DECLSPEC_ALIGN(8) indexOffset;
 288     uint32_t indexCount;
 289     VkIndexType indexType;
 290     VkBuffer DECLSPEC_ALIGN(8) transformData;
 291     VkDeviceSize DECLSPEC_ALIGN(8) transformOffset;
 292 } VkGeometryTrianglesNV32;
 293
 294 typedef struct VkGeometryAABBNV32
 295 {
 296     VkStructureType sType;
 297     const void *pNext;
 298     VkBuffer DECLSPEC_ALIGN(8) aabbData;
 299     uint32_t numAABBs;
 300     uint32_t stride;
 301     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 302 } VkGeometryAABBNV32;
 303
 304 typedef struct VkGeometryDataNV32
 305 {
 306     VkGeometryTrianglesNV32 DECLSPEC_ALIGN(8) triangles;
 307     VkGeometryAABBNV32 DECLSPEC_ALIGN(8) aabbs;
 308 } VkGeometryDataNV32;
 309
 310 typedef struct VkGeometryNV32
 311 {
 312     VkStructureType sType;
 313     const void *pNext;
 314     VkGeometryTypeKHR geometryType;
 315     VkGeometryDataNV32 DECLSPEC_ALIGN(8) geometry;
 316     VkGeometryFlagsKHR flags;
 317 } VkGeometryNV32;
 318
 319 typedef struct VkAccelerationStructureInfoNV32
 320 {
 321     VkStructureType sType;
 322     const void *pNext;
 323     VkAccelerationStructureTypeNV type;
 324     VkBuildAccelerationStructureFlagsNV flags;
 325     uint32_t instanceCount;
 326     uint32_t geometryCount;
 327     const VkGeometryNV32 *pGeometries;
 328 } VkAccelerationStructureInfoNV32;
 329
 330 typedef struct VkCopyAccelerationStructureInfoKHR32
 331 {
 332     VkStructureType sType;
 333     const void *pNext;
 334     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
 335     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
 336     VkCopyAccelerationStructureModeKHR mode;
 337 } VkCopyAccelerationStructureInfoKHR32;
 338
 339 typedef struct VkCopyAccelerationStructureToMemoryInfoKHR32
 340 {
 341     VkStructureType sType;
 342     const void *pNext;
 343     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
 344     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
 345     VkCopyAccelerationStructureModeKHR mode;
 346 } VkCopyAccelerationStructureToMemoryInfoKHR32;
 347
 348 typedef struct VkBufferCopy32
 349 {
 350     VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
 351     VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
 352     VkDeviceSize DECLSPEC_ALIGN(8) size;
 353 } VkBufferCopy32;
 354
 355 typedef struct VkBufferCopy232
 356 {
 357     VkStructureType sType;
 358     const void *pNext;
 359     VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
 360     VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
 361     VkDeviceSize DECLSPEC_ALIGN(8) size;
 362 } VkBufferCopy232;
 363 typedef VkBufferCopy232 VkBufferCopy2KHR32;
 364
 365 typedef struct VkCopyBufferInfo232
 366 {
 367     VkStructureType sType;
 368     const void *pNext;
 369     VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
 370     VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
 371     uint32_t regionCount;
 372     const VkBufferCopy232 *pRegions;
 373 } VkCopyBufferInfo232;
 374 typedef VkCopyBufferInfo232 VkCopyBufferInfo2KHR32;
 375
 376 typedef struct VkBufferImageCopy32
 377 {
 378     VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
 379     uint32_t bufferRowLength;
 380     uint32_t bufferImageHeight;
 381     VkImageSubresourceLayers imageSubresource;
 382     VkOffset3D imageOffset;
 383     VkExtent3D imageExtent;
 384 } VkBufferImageCopy32;
 385
 386 typedef struct VkBufferImageCopy232
 387 {
 388     VkStructureType sType;
 389     const void *pNext;
 390     VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
 391     uint32_t bufferRowLength;
 392     uint32_t bufferImageHeight;
 393     VkImageSubresourceLayers imageSubresource;
 394     VkOffset3D imageOffset;
 395     VkExtent3D imageExtent;
 396 } VkBufferImageCopy232;
 397 typedef VkBufferImageCopy232 VkBufferImageCopy2KHR32;
 398
 399 typedef struct VkCopyBufferToImageInfo232
 400 {
 401     VkStructureType sType;
 402     const void *pNext;
 403     VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
 404     VkImage DECLSPEC_ALIGN(8) dstImage;
 405     VkImageLayout dstImageLayout;
 406     uint32_t regionCount;
 407     const VkBufferImageCopy232 *pRegions;
 408 } VkCopyBufferToImageInfo232;
 409 typedef VkCopyBufferToImageInfo232 VkCopyBufferToImageInfo2KHR32;
 410
 411 typedef struct VkCopyImageInfo232
 412 {
 413     VkStructureType sType;
 414     const void *pNext;
 415     VkImage DECLSPEC_ALIGN(8) srcImage;
 416     VkImageLayout srcImageLayout;
 417     VkImage DECLSPEC_ALIGN(8) dstImage;
 418     VkImageLayout dstImageLayout;
 419     uint32_t regionCount;
 420     const VkImageCopy2 *pRegions;
 421 } VkCopyImageInfo232;
 422 typedef VkCopyImageInfo232 VkCopyImageInfo2KHR32;
 423
 424 typedef struct VkCopyImageToBufferInfo232
 425 {
 426     VkStructureType sType;
 427     const void *pNext;
 428     VkImage DECLSPEC_ALIGN(8) srcImage;
 429     VkImageLayout srcImageLayout;
 430     VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
 431     uint32_t regionCount;
 432     const VkBufferImageCopy232 *pRegions;
 433 } VkCopyImageToBufferInfo232;
 434 typedef VkCopyImageToBufferInfo232 VkCopyImageToBufferInfo2KHR32;
 435
 436 typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32
 437 {
 438     VkStructureType sType;
 439     const void *pNext;
 440     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
 441     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
 442     VkCopyAccelerationStructureModeKHR mode;
 443 } VkCopyMemoryToAccelerationStructureInfoKHR32;
 444
 445 typedef struct VkCopyMemoryToMicromapInfoEXT32
 446 {
 447     VkStructureType sType;
 448     const void *pNext;
 449     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
 450     VkMicromapEXT DECLSPEC_ALIGN(8) dst;
 451     VkCopyMicromapModeEXT mode;
 452 } VkCopyMemoryToMicromapInfoEXT32;
 453
 454 typedef struct VkCopyMicromapInfoEXT32
 455 {
 456     VkStructureType sType;
 457     const void *pNext;
 458     VkMicromapEXT DECLSPEC_ALIGN(8) src;
 459     VkMicromapEXT DECLSPEC_ALIGN(8) dst;
 460     VkCopyMicromapModeEXT mode;
 461 } VkCopyMicromapInfoEXT32;
 462
 463 typedef struct VkCopyMicromapToMemoryInfoEXT32
 464 {
 465     VkStructureType sType;
 466     const void *pNext;
 467     VkMicromapEXT DECLSPEC_ALIGN(8) src;
 468     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
 469     VkCopyMicromapModeEXT mode;
 470 } VkCopyMicromapToMemoryInfoEXT32;
 471
 472 typedef struct VkCuLaunchInfoNVX32
 473 {
 474     VkStructureType sType;
 475     const void *pNext;
 476     VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
 477     uint32_t gridDimX;
 478     uint32_t gridDimY;
 479     uint32_t gridDimZ;
 480     uint32_t blockDimX;
 481     uint32_t blockDimY;
 482     uint32_t blockDimZ;
 483     uint32_t sharedMemBytes;
 484     size_t paramCount;
 485     const void * const *pParams;
 486     size_t extraCount;
 487     const void * const *pExtras;
 488 } VkCuLaunchInfoNVX32;
 489
 490 typedef struct VkDecompressMemoryRegionNV32
 491 {
 492     VkDeviceAddress DECLSPEC_ALIGN(8) srcAddress;
 493     VkDeviceAddress DECLSPEC_ALIGN(8) dstAddress;
 494     VkDeviceSize DECLSPEC_ALIGN(8) compressedSize;
 495     VkDeviceSize DECLSPEC_ALIGN(8) decompressedSize;
 496     VkMemoryDecompressionMethodFlagsNV decompressionMethod;
 497 } VkDecompressMemoryRegionNV32;
 498
 499 typedef struct VkIndirectCommandsStreamNV32
 500 {
 501     VkBuffer DECLSPEC_ALIGN(8) buffer;
 502     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 503 } VkIndirectCommandsStreamNV32;
 504
 505 typedef struct VkGeneratedCommandsInfoNV32
 506 {
 507     VkStructureType sType;
 508     const void *pNext;
 509     VkPipelineBindPoint pipelineBindPoint;
 510     VkPipeline DECLSPEC_ALIGN(8) pipeline;
 511     VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
 512     uint32_t streamCount;
 513     const VkIndirectCommandsStreamNV32 *pStreams;
 514     uint32_t sequencesCount;
 515     VkBuffer DECLSPEC_ALIGN(8) preprocessBuffer;
 516     VkDeviceSize DECLSPEC_ALIGN(8) preprocessOffset;
 517     VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize;
 518     VkBuffer DECLSPEC_ALIGN(8) sequencesCountBuffer;
 519     VkDeviceSize DECLSPEC_ALIGN(8) sequencesCountOffset;
 520     VkBuffer DECLSPEC_ALIGN(8) sequencesIndexBuffer;
 521     VkDeviceSize DECLSPEC_ALIGN(8) sequencesIndexOffset;
 522 } VkGeneratedCommandsInfoNV32;
 523
 524 typedef struct VkBufferMemoryBarrier32
 525 {
 526     VkStructureType sType;
 527     const void *pNext;
 528     VkAccessFlags srcAccessMask;
 529     VkAccessFlags dstAccessMask;
 530     uint32_t srcQueueFamilyIndex;
 531     uint32_t dstQueueFamilyIndex;
 532     VkBuffer DECLSPEC_ALIGN(8) buffer;
 533     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 534     VkDeviceSize DECLSPEC_ALIGN(8) size;
 535 } VkBufferMemoryBarrier32;
 536
 537 typedef struct VkImageMemoryBarrier32
 538 {
 539     VkStructureType sType;
 540     const void *pNext;
 541     VkAccessFlags srcAccessMask;
 542     VkAccessFlags dstAccessMask;
 543     VkImageLayout oldLayout;
 544     VkImageLayout newLayout;
 545     uint32_t srcQueueFamilyIndex;
 546     uint32_t dstQueueFamilyIndex;
 547     VkImage DECLSPEC_ALIGN(8) image;
 548     VkImageSubresourceRange subresourceRange;
 549 } VkImageMemoryBarrier32;
 550
 551 typedef struct VkBufferMemoryBarrier232
 552 {
 553     VkStructureType sType;
 554     const void *pNext;
 555     VkPipelineStageFlags2 srcStageMask;
 556     VkAccessFlags2 srcAccessMask;
 557     VkPipelineStageFlags2 dstStageMask;
 558     VkAccessFlags2 dstAccessMask;
 559     uint32_t srcQueueFamilyIndex;
 560     uint32_t dstQueueFamilyIndex;
 561     VkBuffer DECLSPEC_ALIGN(8) buffer;
 562     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 563     VkDeviceSize DECLSPEC_ALIGN(8) size;
 564 } VkBufferMemoryBarrier232;
 565 typedef VkBufferMemoryBarrier232 VkBufferMemoryBarrier2KHR32;
 566
 567 typedef struct VkImageMemoryBarrier232
 568 {
 569     VkStructureType sType;
 570     const void *pNext;
 571     VkPipelineStageFlags2 srcStageMask;
 572     VkAccessFlags2 srcAccessMask;
 573     VkPipelineStageFlags2 dstStageMask;
 574     VkAccessFlags2 dstAccessMask;
 575     VkImageLayout oldLayout;
 576     VkImageLayout newLayout;
 577     uint32_t srcQueueFamilyIndex;
 578     uint32_t dstQueueFamilyIndex;
 579     VkImage DECLSPEC_ALIGN(8) image;
 580     VkImageSubresourceRange subresourceRange;
 581 } VkImageMemoryBarrier232;
 582 typedef VkImageMemoryBarrier232 VkImageMemoryBarrier2KHR32;
 583
 584 typedef struct VkDependencyInfo32
 585 {
 586     VkStructureType sType;
 587     const void *pNext;
 588     VkDependencyFlags dependencyFlags;
 589     uint32_t memoryBarrierCount;
 590     const VkMemoryBarrier2 *pMemoryBarriers;
 591     uint32_t bufferMemoryBarrierCount;
 592     const VkBufferMemoryBarrier232 *pBufferMemoryBarriers;
 593     uint32_t imageMemoryBarrierCount;
 594     const VkImageMemoryBarrier232 *pImageMemoryBarriers;
 595 } VkDependencyInfo32;
 596 typedef VkDependencyInfo32 VkDependencyInfoKHR32;
 597
 598 typedef struct VkDescriptorImageInfo32
 599 {
 600     VkSampler DECLSPEC_ALIGN(8) sampler;
 601     VkImageView DECLSPEC_ALIGN(8) imageView;
 602     VkImageLayout imageLayout;
 603 } VkDescriptorImageInfo32;
 604
 605 typedef struct VkDescriptorBufferInfo32
 606 {
 607     VkBuffer DECLSPEC_ALIGN(8) buffer;
 608     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 609     VkDeviceSize DECLSPEC_ALIGN(8) range;
 610 } VkDescriptorBufferInfo32;
 611
 612 typedef struct VkWriteDescriptorSet32
 613 {
 614     VkStructureType sType;
 615     const void *pNext;
 616     VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
 617     uint32_t dstBinding;
 618     uint32_t dstArrayElement;
 619     uint32_t descriptorCount;
 620     VkDescriptorType descriptorType;
 621     const VkDescriptorImageInfo32 *pImageInfo;
 622     const VkDescriptorBufferInfo32 *pBufferInfo;
 623     const VkBufferView *pTexelBufferView;
 624 } VkWriteDescriptorSet32;
 625
 626 typedef struct VkResolveImageInfo232
 627 {
 628     VkStructureType sType;
 629     const void *pNext;
 630     VkImage DECLSPEC_ALIGN(8) srcImage;
 631     VkImageLayout srcImageLayout;
 632     VkImage DECLSPEC_ALIGN(8) dstImage;
 633     VkImageLayout dstImageLayout;
 634     uint32_t regionCount;
 635     const VkImageResolve2 *pRegions;
 636 } VkResolveImageInfo232;
 637 typedef VkResolveImageInfo232 VkResolveImageInfo2KHR32;
 638
 639 typedef struct VkPerformanceMarkerInfoINTEL32
 640 {
 641     VkStructureType sType;
 642     const void *pNext;
 643     uint64_t DECLSPEC_ALIGN(8) marker;
 644 } VkPerformanceMarkerInfoINTEL32;
 645
 646 typedef struct VkPerformanceOverrideInfoINTEL32
 647 {
 648     VkStructureType sType;
 649     const void *pNext;
 650     VkPerformanceOverrideTypeINTEL type;
 651     VkBool32 enable;
 652     uint64_t DECLSPEC_ALIGN(8) parameter;
 653 } VkPerformanceOverrideInfoINTEL32;
 654
 655 typedef struct VkStridedDeviceAddressRegionKHR32
 656 {
 657     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
 658     VkDeviceSize DECLSPEC_ALIGN(8) stride;
 659     VkDeviceSize DECLSPEC_ALIGN(8) size;
 660 } VkStridedDeviceAddressRegionKHR32;
 661
 662 typedef struct VkAccelerationStructureCreateInfoKHR32
 663 {
 664     VkStructureType sType;
 665     const void *pNext;
 666     VkAccelerationStructureCreateFlagsKHR createFlags;
 667     VkBuffer DECLSPEC_ALIGN(8) buffer;
 668     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 669     VkDeviceSize DECLSPEC_ALIGN(8) size;
 670     VkAccelerationStructureTypeKHR type;
 671     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
 672 } VkAccelerationStructureCreateInfoKHR32;
 673
 674 typedef struct VkAccelerationStructureCreateInfoNV32
 675 {
 676     VkStructureType sType;
 677     const void *pNext;
 678     VkDeviceSize DECLSPEC_ALIGN(8) compactedSize;
 679     VkAccelerationStructureInfoNV32 info;
 680 } VkAccelerationStructureCreateInfoNV32;
 681
 682 typedef struct VkBufferOpaqueCaptureAddressCreateInfo32
 683 {
 684     VkStructureType sType;
 685     const void *pNext;
 686     uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
 687 } VkBufferOpaqueCaptureAddressCreateInfo32;
 688 typedef VkBufferOpaqueCaptureAddressCreateInfo32 VkBufferOpaqueCaptureAddressCreateInfoKHR32;
 689
 690 typedef struct VkBufferDeviceAddressCreateInfoEXT32
 691 {
 692     VkStructureType sType;
 693     const void *pNext;
 694     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
 695 } VkBufferDeviceAddressCreateInfoEXT32;
 696
 697 typedef struct VkBufferCreateInfo32
 698 {
 699     VkStructureType sType;
 700     const void *pNext;
 701     VkBufferCreateFlags flags;
 702     VkDeviceSize DECLSPEC_ALIGN(8) size;
 703     VkBufferUsageFlags usage;
 704     VkSharingMode sharingMode;
 705     uint32_t queueFamilyIndexCount;
 706     const uint32_t *pQueueFamilyIndices;
 707 } VkBufferCreateInfo32;
 708
 709 typedef struct VkBufferViewCreateInfo32
 710 {
 711     VkStructureType sType;
 712     const void *pNext;
 713     VkBufferViewCreateFlags flags;
 714     VkBuffer DECLSPEC_ALIGN(8) buffer;
 715     VkFormat format;
 716     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 717     VkDeviceSize DECLSPEC_ALIGN(8) range;
 718 } VkBufferViewCreateInfo32;
 719
 720 typedef struct VkPipelineCreationFeedback32
 721 {
 722     VkPipelineCreationFeedbackFlags flags;
 723     uint64_t DECLSPEC_ALIGN(8) duration;
 724 } VkPipelineCreationFeedback32;
 725 typedef VkPipelineCreationFeedback32 VkPipelineCreationFeedbackEXT32;
 726
 727 typedef struct VkShaderModuleValidationCacheCreateInfoEXT32
 728 {
 729     VkStructureType sType;
 730     const void *pNext;
 731     VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
 732 } VkShaderModuleValidationCacheCreateInfoEXT32;
 733
 734 typedef struct VkDebugUtilsObjectNameInfoEXT32
 735 {
 736     VkStructureType sType;
 737     const void *pNext;
 738     VkObjectType objectType;
 739     uint64_t DECLSPEC_ALIGN(8) objectHandle;
 740     const char *pObjectName;
 741 } VkDebugUtilsObjectNameInfoEXT32;
 742
 743 typedef struct VkPipelineShaderStageCreateInfo32
 744 {
 745     VkStructureType sType;
 746     const void *pNext;
 747     VkPipelineShaderStageCreateFlags flags;
 748     VkShaderStageFlagBits stage;
 749     VkShaderModule DECLSPEC_ALIGN(8) module;
 750     const char *pName;
 751     const VkSpecializationInfo *pSpecializationInfo;
 752 } VkPipelineShaderStageCreateInfo32;
 753
 754 typedef struct VkPipelineCreationFeedbackCreateInfo32
 755 {
 756     VkStructureType sType;
 757     const void *pNext;
 758     VkPipelineCreationFeedback32 *pPipelineCreationFeedback;
 759     uint32_t pipelineStageCreationFeedbackCount;
 760     VkPipelineCreationFeedback32 *pPipelineStageCreationFeedbacks;
 761 } VkPipelineCreationFeedbackCreateInfo32;
 762 typedef VkPipelineCreationFeedbackCreateInfo32 VkPipelineCreationFeedbackCreateInfoEXT32;
 763
 764 typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI32
 765 {
 766     VkStructureType sType;
 767     void *pNext;
 768     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
 769     uint32_t subpass;
 770 } VkSubpassShadingPipelineCreateInfoHUAWEI32;
 771
 772 typedef struct VkComputePipelineCreateInfo32
 773 {
 774     VkStructureType sType;
 775     const void *pNext;
 776     VkPipelineCreateFlags flags;
 777     VkPipelineShaderStageCreateInfo32 DECLSPEC_ALIGN(8) stage;
 778     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
 779     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
 780     int32_t basePipelineIndex;
 781 } VkComputePipelineCreateInfo32;
 782
 783 typedef struct VkCuFunctionCreateInfoNVX32
 784 {
 785     VkStructureType sType;
 786     const void *pNext;
 787     VkCuModuleNVX DECLSPEC_ALIGN(8) module;
 788     const char *pName;
 789 } VkCuFunctionCreateInfoNVX32;
 790
 791 typedef struct VkDescriptorUpdateTemplateCreateInfo32
 792 {
 793     VkStructureType sType;
 794     const void *pNext;
 795     VkDescriptorUpdateTemplateCreateFlags flags;
 796     uint32_t descriptorUpdateEntryCount;
 797     const VkDescriptorUpdateTemplateEntry *pDescriptorUpdateEntries;
 798     VkDescriptorUpdateTemplateType templateType;
 799     VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
 800     VkPipelineBindPoint pipelineBindPoint;
 801     VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
 802     uint32_t set;
 803 } VkDescriptorUpdateTemplateCreateInfo32;
 804 typedef VkDescriptorUpdateTemplateCreateInfo32 VkDescriptorUpdateTemplateCreateInfoKHR32;
 805
 806 typedef struct VkFramebufferCreateInfo32
 807 {
 808     VkStructureType sType;
 809     const void *pNext;
 810     VkFramebufferCreateFlags flags;
 811     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
 812     uint32_t attachmentCount;
 813     const VkImageView *pAttachments;
 814     uint32_t width;
 815     uint32_t height;
 816     uint32_t layers;
 817 } VkFramebufferCreateInfo32;
 818
 819 typedef struct VkGraphicsShaderGroupCreateInfoNV32
 820 {
 821     VkStructureType sType;
 822     const void *pNext;
 823     uint32_t stageCount;
 824     const VkPipelineShaderStageCreateInfo32 *pStages;
 825     const VkPipelineVertexInputStateCreateInfo *pVertexInputState;
 826     const VkPipelineTessellationStateCreateInfo *pTessellationState;
 827 } VkGraphicsShaderGroupCreateInfoNV32;
 828
 829 typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV32
 830 {
 831     VkStructureType sType;
 832     const void *pNext;
 833     uint32_t groupCount;
 834     const VkGraphicsShaderGroupCreateInfoNV32 *pGroups;
 835     uint32_t pipelineCount;
 836     const VkPipeline *pPipelines;
 837 } VkGraphicsPipelineShaderGroupsCreateInfoNV32;
 838
 839 typedef struct VkGraphicsPipelineCreateInfo32
 840 {
 841     VkStructureType sType;
 842     const void *pNext;
 843     VkPipelineCreateFlags flags;
 844     uint32_t stageCount;
 845     const VkPipelineShaderStageCreateInfo32 *pStages;
 846     const VkPipelineVertexInputStateCreateInfo *pVertexInputState;
 847     const VkPipelineInputAssemblyStateCreateInfo *pInputAssemblyState;
 848     const VkPipelineTessellationStateCreateInfo *pTessellationState;
 849     const VkPipelineViewportStateCreateInfo *pViewportState;
 850     const VkPipelineRasterizationStateCreateInfo *pRasterizationState;
 851     const VkPipelineMultisampleStateCreateInfo *pMultisampleState;
 852     const VkPipelineDepthStencilStateCreateInfo *pDepthStencilState;
 853     const VkPipelineColorBlendStateCreateInfo *pColorBlendState;
 854     const VkPipelineDynamicStateCreateInfo *pDynamicState;
 855     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
 856     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
 857     uint32_t subpass;
 858     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
 859     int32_t basePipelineIndex;
 860 } VkGraphicsPipelineCreateInfo32;
 861
 862 typedef struct VkImageSwapchainCreateInfoKHR32
 863 {
 864     VkStructureType sType;
 865     const void *pNext;
 866     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
 867 } VkImageSwapchainCreateInfoKHR32;
 868
 869 typedef struct VkSamplerYcbcrConversionInfo32
 870 {
 871     VkStructureType sType;
 872     const void *pNext;
 873     VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) conversion;
 874 } VkSamplerYcbcrConversionInfo32;
 875 typedef VkSamplerYcbcrConversionInfo32 VkSamplerYcbcrConversionInfoKHR32;
 876
 877 typedef struct VkImageViewCreateInfo32
 878 {
 879     VkStructureType sType;
 880     const void *pNext;
 881     VkImageViewCreateFlags flags;
 882     VkImage DECLSPEC_ALIGN(8) image;
 883     VkImageViewType viewType;
 884     VkFormat format;
 885     VkComponentMapping components;
 886     VkImageSubresourceRange subresourceRange;
 887 } VkImageViewCreateInfo32;
 888
 889 typedef struct VkIndirectCommandsLayoutTokenNV32
 890 {
 891     VkStructureType sType;
 892     const void *pNext;
 893     VkIndirectCommandsTokenTypeNV tokenType;
 894     uint32_t stream;
 895     uint32_t offset;
 896     uint32_t vertexBindingUnit;
 897     VkBool32 vertexDynamicStride;
 898     VkPipelineLayout DECLSPEC_ALIGN(8) pushconstantPipelineLayout;
 899     VkShaderStageFlags pushconstantShaderStageFlags;
 900     uint32_t pushconstantOffset;
 901     uint32_t pushconstantSize;
 902     VkIndirectStateFlagsNV indirectStateFlags;
 903     uint32_t indexTypeCount;
 904     const VkIndexType *pIndexTypes;
 905     const uint32_t *pIndexTypeValues;
 906 } VkIndirectCommandsLayoutTokenNV32;
 907
 908 typedef struct VkIndirectCommandsLayoutCreateInfoNV32
 909 {
 910     VkStructureType sType;
 911     const void *pNext;
 912     VkIndirectCommandsLayoutUsageFlagsNV flags;
 913     VkPipelineBindPoint pipelineBindPoint;
 914     uint32_t tokenCount;
 915     const VkIndirectCommandsLayoutTokenNV32 *pTokens;
 916     uint32_t streamCount;
 917     const uint32_t *pStreamStrides;
 918 } VkIndirectCommandsLayoutCreateInfoNV32;
 919
 920 typedef struct VkMicromapCreateInfoEXT32
 921 {
 922     VkStructureType sType;
 923     const void *pNext;
 924     VkMicromapCreateFlagsEXT createFlags;
 925     VkBuffer DECLSPEC_ALIGN(8) buffer;
 926     VkDeviceSize DECLSPEC_ALIGN(8) offset;
 927     VkDeviceSize DECLSPEC_ALIGN(8) size;
 928     VkMicromapTypeEXT type;
 929     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
 930 } VkMicromapCreateInfoEXT32;
 931
 932 typedef struct VkRayTracingPipelineCreateInfoKHR32
 933 {
 934     VkStructureType sType;
 935     const void *pNext;
 936     VkPipelineCreateFlags flags;
 937     uint32_t stageCount;
 938     const VkPipelineShaderStageCreateInfo32 *pStages;
 939     uint32_t groupCount;
 940     const VkRayTracingShaderGroupCreateInfoKHR *pGroups;
 941     uint32_t maxPipelineRayRecursionDepth;
 942     const VkPipelineLibraryCreateInfoKHR *pLibraryInfo;
 943     const VkRayTracingPipelineInterfaceCreateInfoKHR *pLibraryInterface;
 944     const VkPipelineDynamicStateCreateInfo *pDynamicState;
 945     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
 946     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
 947     int32_t basePipelineIndex;
 948 } VkRayTracingPipelineCreateInfoKHR32;
 949
 950 typedef struct VkRayTracingPipelineCreateInfoNV32
 951 {
 952     VkStructureType sType;
 953     const void *pNext;
 954     VkPipelineCreateFlags flags;
 955     uint32_t stageCount;
 956     const VkPipelineShaderStageCreateInfo32 *pStages;
 957     uint32_t groupCount;
 958     const VkRayTracingShaderGroupCreateInfoNV *pGroups;
 959     uint32_t maxRecursionDepth;
 960     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
 961     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
 962     int32_t basePipelineIndex;
 963 } VkRayTracingPipelineCreateInfoNV32;
 964
 965 typedef struct VkSemaphoreTypeCreateInfo32
 966 {
 967     VkStructureType sType;
 968     const void *pNext;
 969     VkSemaphoreType semaphoreType;
 970     uint64_t DECLSPEC_ALIGN(8) initialValue;
 971 } VkSemaphoreTypeCreateInfo32;
 972 typedef VkSemaphoreTypeCreateInfo32 VkSemaphoreTypeCreateInfoKHR32;
 973
 974 typedef struct VkSwapchainCreateInfoKHR32
 975 {
 976     VkStructureType sType;
 977     const void *pNext;
 978     VkSwapchainCreateFlagsKHR flags;
 979     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
 980     uint32_t minImageCount;
 981     VkFormat imageFormat;
 982     VkColorSpaceKHR imageColorSpace;
 983     VkExtent2D imageExtent;
 984     uint32_t imageArrayLayers;
 985     VkImageUsageFlags imageUsage;
 986     VkSharingMode imageSharingMode;
 987     uint32_t queueFamilyIndexCount;
 988     const uint32_t *pQueueFamilyIndices;
 989     VkSurfaceTransformFlagBitsKHR preTransform;
 990     VkCompositeAlphaFlagBitsKHR compositeAlpha;
 991     VkPresentModeKHR presentMode;
 992     VkBool32 clipped;
 993     VkSwapchainKHR DECLSPEC_ALIGN(8) oldSwapchain;
 994 } VkSwapchainCreateInfoKHR32;
 995
 996 typedef struct VkDebugMarkerObjectNameInfoEXT32
 997 {
 998     VkStructureType sType;
 999     const void *pNext;
1000     VkDebugReportObjectTypeEXT objectType;
1001     uint64_t DECLSPEC_ALIGN(8) object;
1002     const char *pObjectName;
1003 } VkDebugMarkerObjectNameInfoEXT32;
1004
1005 typedef struct VkDebugMarkerObjectTagInfoEXT32
1006 {
1007     VkStructureType sType;
1008     const void *pNext;
1009     VkDebugReportObjectTypeEXT objectType;
1010     uint64_t DECLSPEC_ALIGN(8) object;
1011     uint64_t DECLSPEC_ALIGN(8) tagName;
1012     size_t tagSize;
1013     const void *pTag;
1014 } VkDebugMarkerObjectTagInfoEXT32;
1015
1016 typedef struct VkMappedMemoryRange32
1017 {
1018     VkStructureType sType;
1019     const void *pNext;
1020     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
1021     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1022     VkDeviceSize DECLSPEC_ALIGN(8) size;
1023 } VkMappedMemoryRange32;
1024
1025 typedef struct VkAccelerationStructureBuildSizesInfoKHR32
1026 {
1027     VkStructureType sType;
1028     const void *pNext;
1029     VkDeviceSize DECLSPEC_ALIGN(8) accelerationStructureSize;
1030     VkDeviceSize DECLSPEC_ALIGN(8) updateScratchSize;
1031     VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
1032 } VkAccelerationStructureBuildSizesInfoKHR32;
1033
1034 typedef struct VkAccelerationStructureDeviceAddressInfoKHR32
1035 {
1036     VkStructureType sType;
1037     const void *pNext;
1038     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
1039 } VkAccelerationStructureDeviceAddressInfoKHR32;
1040
1041 typedef struct VkAccelerationStructureMemoryRequirementsInfoNV32
1042 {
1043     VkStructureType sType;
1044     const void *pNext;
1045     VkAccelerationStructureMemoryRequirementsTypeNV type;
1046     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
1047 } VkAccelerationStructureMemoryRequirementsInfoNV32;
1048
1049 typedef struct VkMemoryRequirements32
1050 {
1051     VkDeviceSize DECLSPEC_ALIGN(8) size;
1052     VkDeviceSize DECLSPEC_ALIGN(8) alignment;
1053     uint32_t memoryTypeBits;
1054 } VkMemoryRequirements32;
1055
1056
1057 typedef struct VkBufferDeviceAddressInfo32
1058 {
1059     VkStructureType sType;
1060     const void *pNext;
1061     VkBuffer DECLSPEC_ALIGN(8) buffer;
1062 } VkBufferDeviceAddressInfo32;
1063 typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoKHR32;
1064 typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoEXT32;
1065
1066 typedef struct VkBufferMemoryRequirementsInfo232
1067 {
1068     VkStructureType sType;
1069     const void *pNext;
1070     VkBuffer DECLSPEC_ALIGN(8) buffer;
1071 } VkBufferMemoryRequirementsInfo232;
1072 typedef VkBufferMemoryRequirementsInfo232 VkBufferMemoryRequirementsInfo2KHR32;
1073
1074 typedef struct VkMemoryRequirements232
1075 {
1076     VkStructureType sType;
1077     void *pNext;
1078     VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
1079 } VkMemoryRequirements232;
1080 typedef VkMemoryRequirements232 VkMemoryRequirements2KHR32;
1081
1082 typedef struct VkDescriptorSetBindingReferenceVALVE32
1083 {
1084     VkStructureType sType;
1085     const void *pNext;
1086     VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
1087     uint32_t binding;
1088 } VkDescriptorSetBindingReferenceVALVE32;
1089
1090 typedef struct VkDeviceBufferMemoryRequirements32
1091 {
1092     VkStructureType sType;
1093     const void *pNext;
1094     const VkBufferCreateInfo32 *pCreateInfo;
1095 } VkDeviceBufferMemoryRequirements32;
1096 typedef VkDeviceBufferMemoryRequirements32 VkDeviceBufferMemoryRequirementsKHR32;
1097
1098 typedef struct VkDeviceFaultCountsEXT32
1099 {
1100     VkStructureType sType;
1101     void *pNext;
1102     uint32_t addressInfoCount;
1103     uint32_t vendorInfoCount;
1104     VkDeviceSize DECLSPEC_ALIGN(8) vendorBinarySize;
1105 } VkDeviceFaultCountsEXT32;
1106
1107 typedef struct VkDeviceFaultAddressInfoEXT32
1108 {
1109     VkDeviceFaultAddressTypeEXT addressType;
1110     VkDeviceAddress DECLSPEC_ALIGN(8) reportedAddress;
1111     VkDeviceSize DECLSPEC_ALIGN(8) addressPrecision;
1112 } VkDeviceFaultAddressInfoEXT32;
1113
1114 typedef struct VkDeviceFaultVendorInfoEXT32
1115 {
1116     char description[VK_MAX_DESCRIPTION_SIZE];
1117     uint64_t DECLSPEC_ALIGN(8) vendorFaultCode;
1118     uint64_t DECLSPEC_ALIGN(8) vendorFaultData;
1119 } VkDeviceFaultVendorInfoEXT32;
1120
1121 typedef struct VkDeviceFaultInfoEXT32
1122 {
1123     VkStructureType sType;
1124     void *pNext;
1125     char description[VK_MAX_DESCRIPTION_SIZE];
1126     VkDeviceFaultAddressInfoEXT32 *pAddressInfos;
1127     VkDeviceFaultVendorInfoEXT32 *pVendorInfos;
1128     void *pVendorBinaryData;
1129 } VkDeviceFaultInfoEXT32;
1130
1131 typedef struct VkSparseImageMemoryRequirements32
1132 {
1133     VkSparseImageFormatProperties formatProperties;
1134     uint32_t imageMipTailFirstLod;
1135     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailSize;
1136     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailOffset;
1137     VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailStride;
1138 } VkSparseImageMemoryRequirements32;
1139
1140 typedef struct VkSparseImageMemoryRequirements232
1141 {
1142     VkStructureType sType;
1143     void *pNext;
1144     VkSparseImageMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
1145 } VkSparseImageMemoryRequirements232;
1146 typedef VkSparseImageMemoryRequirements232 VkSparseImageMemoryRequirements2KHR32;
1147
1148 typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo32
1149 {
1150     VkStructureType sType;
1151     const void *pNext;
1152     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
1153 } VkDeviceMemoryOpaqueCaptureAddressInfo32;
1154 typedef VkDeviceMemoryOpaqueCaptureAddressInfo32 VkDeviceMemoryOpaqueCaptureAddressInfoKHR32;
1155
1156 typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV32
1157 {
1158     VkStructureType sType;
1159     const void *pNext;
1160     VkPipelineBindPoint pipelineBindPoint;
1161     VkPipeline DECLSPEC_ALIGN(8) pipeline;
1162     VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
1163     uint32_t maxSequencesCount;
1164 } VkGeneratedCommandsMemoryRequirementsInfoNV32;
1165
1166 typedef struct VkImageMemoryRequirementsInfo232
1167 {
1168     VkStructureType sType;
1169     const void *pNext;
1170     VkImage DECLSPEC_ALIGN(8) image;
1171 } VkImageMemoryRequirementsInfo232;
1172 typedef VkImageMemoryRequirementsInfo232 VkImageMemoryRequirementsInfo2KHR32;
1173
1174 typedef struct VkImageSparseMemoryRequirementsInfo232
1175 {
1176     VkStructureType sType;
1177     const void *pNext;
1178     VkImage DECLSPEC_ALIGN(8) image;
1179 } VkImageSparseMemoryRequirementsInfo232;
1180 typedef VkImageSparseMemoryRequirementsInfo232 VkImageSparseMemoryRequirementsInfo2KHR32;
1181
1182 typedef struct VkSubresourceLayout32
1183 {
1184     VkDeviceSize DECLSPEC_ALIGN(8) offset;
1185     VkDeviceSize DECLSPEC_ALIGN(8) size;
1186     VkDeviceSize DECLSPEC_ALIGN(8) rowPitch;
1187     VkDeviceSize DECLSPEC_ALIGN(8) arrayPitch;
1188     VkDeviceSize DECLSPEC_ALIGN(8) depthPitch;
1189 } VkSubresourceLayout32;
1190
1191 typedef struct VkSubresourceLayout2EXT32
1192 {
1193     VkStructureType sType;
1194     void *pNext;
1195     VkSubresourceLayout32 DECLSPEC_ALIGN(8) subresourceLayout;
1196 } VkSubresourceLayout2EXT32;
1197
1198 typedef struct VkImageViewAddressPropertiesNVX32
1199 {
1200     VkStructureType sType;
1201     void *pNext;
1202     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
1203     VkDeviceSize DECLSPEC_ALIGN(8) size;
1204 } VkImageViewAddressPropertiesNVX32;
1205
1206 typedef struct VkImageViewHandleInfoNVX32
1207 {
1208     VkStructureType sType;
1209     const void *pNext;
1210     VkImageView DECLSPEC_ALIGN(8) imageView;
1211     VkDescriptorType descriptorType;
1212     VkSampler DECLSPEC_ALIGN(8) sampler;
1213 } VkImageViewHandleInfoNVX32;
1214
1215 typedef struct VkMicromapBuildSizesInfoEXT32
1216 {
1217     VkStructureType sType;
1218     const void *pNext;
1219     VkDeviceSize DECLSPEC_ALIGN(8) micromapSize;
1220     VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
1221     VkBool32 discardable;
1222 } VkMicromapBuildSizesInfoEXT32;
1223
1224 typedef struct VkPerformanceValueINTEL32
1225 {
1226     VkPerformanceValueTypeINTEL type;
1227     VkPerformanceValueDataINTEL DECLSPEC_ALIGN(8) data;
1228 } VkPerformanceValueINTEL32;
1229
1230 typedef struct VkImageFormatProperties32
1231 {
1232     VkExtent3D maxExtent;
1233     uint32_t maxMipLevels;
1234     uint32_t maxArrayLayers;
1235     VkSampleCountFlags sampleCounts;
1236     VkDeviceSize DECLSPEC_ALIGN(8) maxResourceSize;
1237 } VkImageFormatProperties32;
1238
1239 typedef struct VkImageFormatProperties232
1240 {
1241     VkStructureType sType;
1242     void *pNext;
1243     VkImageFormatProperties32 DECLSPEC_ALIGN(8) imageFormatProperties;
1244 } VkImageFormatProperties232;
1245 typedef VkImageFormatProperties232 VkImageFormatProperties2KHR32;
1246
1247 typedef struct VkMemoryHeap32
1248 {
1249     VkDeviceSize DECLSPEC_ALIGN(8) size;
1250     VkMemoryHeapFlags flags;
1251 } VkMemoryHeap32;
1252
1253 typedef struct VkPhysicalDeviceMemoryProperties32
1254 {
1255     uint32_t memoryTypeCount;
1256     VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
1257     uint32_t memoryHeapCount;
1258     VkMemoryHeap32 DECLSPEC_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS];
1259 } VkPhysicalDeviceMemoryProperties32;
1260
1261 typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT32
1262 {
1263     VkStructureType sType;
1264     void *pNext;
1265     VkDeviceSize DECLSPEC_ALIGN(8) heapBudget[VK_MAX_MEMORY_HEAPS];
1266     VkDeviceSize DECLSPEC_ALIGN(8) heapUsage[VK_MAX_MEMORY_HEAPS];
1267 } VkPhysicalDeviceMemoryBudgetPropertiesEXT32;
1268
1269 typedef struct VkPhysicalDeviceMemoryProperties232
1270 {
1271     VkStructureType sType;
1272     void *pNext;
1273     VkPhysicalDeviceMemoryProperties32 DECLSPEC_ALIGN(8) memoryProperties;
1274 } VkPhysicalDeviceMemoryProperties232;
1275 typedef VkPhysicalDeviceMemoryProperties232 VkPhysicalDeviceMemoryProperties2KHR32;
1276
1277 typedef struct VkPhysicalDeviceLimits32
1278 {
1279     uint32_t maxImageDimension1D;
1280     uint32_t maxImageDimension2D;
1281     uint32_t maxImageDimension3D;
1282     uint32_t maxImageDimensionCube;
1283     uint32_t maxImageArrayLayers;
1284     uint32_t maxTexelBufferElements;
1285     uint32_t maxUniformBufferRange;
1286     uint32_t maxStorageBufferRange;
1287     uint32_t maxPushConstantsSize;
1288     uint32_t maxMemoryAllocationCount;
1289     uint32_t maxSamplerAllocationCount;
1290     VkDeviceSize DECLSPEC_ALIGN(8) bufferImageGranularity;
1291     VkDeviceSize DECLSPEC_ALIGN(8) sparseAddressSpaceSize;
1292     uint32_t maxBoundDescriptorSets;
1293     uint32_t maxPerStageDescriptorSamplers;
1294     uint32_t maxPerStageDescriptorUniformBuffers;
1295     uint32_t maxPerStageDescriptorStorageBuffers;
1296     uint32_t maxPerStageDescriptorSampledImages;
1297     uint32_t maxPerStageDescriptorStorageImages;
1298     uint32_t maxPerStageDescriptorInputAttachments;
1299     uint32_t maxPerStageResources;
1300     uint32_t maxDescriptorSetSamplers;
1301     uint32_t maxDescriptorSetUniformBuffers;
1302     uint32_t maxDescriptorSetUniformBuffersDynamic;
1303     uint32_t maxDescriptorSetStorageBuffers;
1304     uint32_t maxDescriptorSetStorageBuffersDynamic;
1305     uint32_t maxDescriptorSetSampledImages;
1306     uint32_t maxDescriptorSetStorageImages;
1307     uint32_t maxDescriptorSetInputAttachments;
1308     uint32_t maxVertexInputAttributes;
1309     uint32_t maxVertexInputBindings;
1310     uint32_t maxVertexInputAttributeOffset;
1311     uint32_t maxVertexInputBindingStride;
1312     uint32_t maxVertexOutputComponents;
1313     uint32_t maxTessellationGenerationLevel;
1314     uint32_t maxTessellationPatchSize;
1315     uint32_t maxTessellationControlPerVertexInputComponents;
1316     uint32_t maxTessellationControlPerVertexOutputComponents;
1317     uint32_t maxTessellationControlPerPatchOutputComponents;
1318     uint32_t maxTessellationControlTotalOutputComponents;
1319     uint32_t maxTessellationEvaluationInputComponents;
1320     uint32_t maxTessellationEvaluationOutputComponents;
1321     uint32_t maxGeometryShaderInvocations;
1322     uint32_t maxGeometryInputComponents;
1323     uint32_t maxGeometryOutputComponents;
1324     uint32_t maxGeometryOutputVertices;
1325     uint32_t maxGeometryTotalOutputComponents;
1326     uint32_t maxFragmentInputComponents;
1327     uint32_t maxFragmentOutputAttachments;
1328     uint32_t maxFragmentDualSrcAttachments;
1329     uint32_t maxFragmentCombinedOutputResources;
1330     uint32_t maxComputeSharedMemorySize;
1331     uint32_t maxComputeWorkGroupCount[3];
1332     uint32_t maxComputeWorkGroupInvocations;
1333     uint32_t maxComputeWorkGroupSize[3];
1334     uint32_t subPixelPrecisionBits;
1335     uint32_t subTexelPrecisionBits;
1336     uint32_t mipmapPrecisionBits;
1337     uint32_t maxDrawIndexedIndexValue;
1338     uint32_t maxDrawIndirectCount;
1339     float maxSamplerLodBias;
1340     float maxSamplerAnisotropy;
1341     uint32_t maxViewports;
1342     uint32_t maxViewportDimensions[2];
1343     float viewportBoundsRange[2];
1344     uint32_t viewportSubPixelBits;
1345     size_t minMemoryMapAlignment;
1346     VkDeviceSize DECLSPEC_ALIGN(8) minTexelBufferOffsetAlignment;
1347     VkDeviceSize DECLSPEC_ALIGN(8) minUniformBufferOffsetAlignment;
1348     VkDeviceSize DECLSPEC_ALIGN(8) minStorageBufferOffsetAlignment;
1349     int32_t minTexelOffset;
1350     uint32_t maxTexelOffset;
1351     int32_t minTexelGatherOffset;
1352     uint32_t maxTexelGatherOffset;
1353     float minInterpolationOffset;
1354     float maxInterpolationOffset;
1355     uint32_t subPixelInterpolationOffsetBits;
1356     uint32_t maxFramebufferWidth;
1357     uint32_t maxFramebufferHeight;
1358     uint32_t maxFramebufferLayers;
1359     VkSampleCountFlags framebufferColorSampleCounts;
1360     VkSampleCountFlags framebufferDepthSampleCounts;
1361     VkSampleCountFlags framebufferStencilSampleCounts;
1362     VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
1363     uint32_t maxColorAttachments;
1364     VkSampleCountFlags sampledImageColorSampleCounts;
1365     VkSampleCountFlags sampledImageIntegerSampleCounts;
1366     VkSampleCountFlags sampledImageDepthSampleCounts;
1367     VkSampleCountFlags sampledImageStencilSampleCounts;
1368     VkSampleCountFlags storageImageSampleCounts;
1369     uint32_t maxSampleMaskWords;
1370     VkBool32 timestampComputeAndGraphics;
1371     float timestampPeriod;
1372     uint32_t maxClipDistances;
1373     uint32_t maxCullDistances;
1374     uint32_t maxCombinedClipAndCullDistances;
1375     uint32_t discreteQueuePriorities;
1376     float pointSizeRange[2];
1377     float lineWidthRange[2];
1378     float pointSizeGranularity;
1379     float lineWidthGranularity;
1380     VkBool32 strictLines;
1381     VkBool32 standardSampleLocations;
1382     VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyOffsetAlignment;
1383     VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyRowPitchAlignment;
1384     VkDeviceSize DECLSPEC_ALIGN(8) nonCoherentAtomSize;
1385 } VkPhysicalDeviceLimits32;
1386
1387 typedef struct VkPhysicalDeviceProperties32
1388 {
1389     uint32_t apiVersion;
1390     uint32_t driverVersion;
1391     uint32_t vendorID;
1392     uint32_t deviceID;
1393     VkPhysicalDeviceType deviceType;
1394     char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
1395     uint8_t pipelineCacheUUID[VK_UUID_SIZE];
1396     VkPhysicalDeviceLimits32 DECLSPEC_ALIGN(8) limits;
1397     VkPhysicalDeviceSparseProperties sparseProperties;
1398 } VkPhysicalDeviceProperties32;
1399
1400 typedef struct VkPhysicalDeviceMaintenance3Properties32
1401 {
1402     VkStructureType sType;
1403     void *pNext;
1404     uint32_t maxPerSetDescriptors;
1405     VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
1406 } VkPhysicalDeviceMaintenance3Properties32;
1407 typedef VkPhysicalDeviceMaintenance3Properties32 VkPhysicalDeviceMaintenance3PropertiesKHR32;
1408
1409 typedef struct VkPhysicalDeviceMaintenance4Properties32
1410 {
1411     VkStructureType sType;
1412     void *pNext;
1413     VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
1414 } VkPhysicalDeviceMaintenance4Properties32;
1415 typedef VkPhysicalDeviceMaintenance4Properties32 VkPhysicalDeviceMaintenance4PropertiesKHR32;
1416
1417 typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT32
1418 {
1419     VkStructureType sType;
1420     void *pNext;
1421     VkDeviceSize DECLSPEC_ALIGN(8) minImportedHostPointerAlignment;
1422 } VkPhysicalDeviceExternalMemoryHostPropertiesEXT32;
1423
1424 typedef struct VkPhysicalDeviceTimelineSemaphoreProperties32
1425 {
1426     VkStructureType sType;
1427     void *pNext;
1428     uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
1429 } VkPhysicalDeviceTimelineSemaphoreProperties32;
1430 typedef VkPhysicalDeviceTimelineSemaphoreProperties32 VkPhysicalDeviceTimelineSemaphorePropertiesKHR32;
1431
1432 typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT32
1433 {
1434     VkStructureType sType;
1435     void *pNext;
1436     uint32_t maxTransformFeedbackStreams;
1437     uint32_t maxTransformFeedbackBuffers;
1438     VkDeviceSize DECLSPEC_ALIGN(8) maxTransformFeedbackBufferSize;
1439     uint32_t maxTransformFeedbackStreamDataSize;
1440     uint32_t maxTransformFeedbackBufferDataSize;
1441     uint32_t maxTransformFeedbackBufferDataStride;
1442     VkBool32 transformFeedbackQueries;
1443     VkBool32 transformFeedbackStreamsLinesTriangles;
1444     VkBool32 transformFeedbackRasterizationStreamSelect;
1445     VkBool32 transformFeedbackDraw;
1446 } VkPhysicalDeviceTransformFeedbackPropertiesEXT32;
1447
1448 typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV32
1449 {
1450     VkStructureType sType;
1451     void *pNext;
1452     VkMemoryDecompressionMethodFlagsNV decompressionMethods;
1453     uint64_t DECLSPEC_ALIGN(8) maxDecompressionIndirectCount;
1454 } VkPhysicalDeviceMemoryDecompressionPropertiesNV32;
1455
1456 typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR32
1457 {
1458     VkStructureType sType;
1459     void *pNext;
1460     uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
1461     uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
1462     uint64_t DECLSPEC_ALIGN(8) maxPrimitiveCount;
1463     uint32_t maxPerStageDescriptorAccelerationStructures;
1464     uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
1465     uint32_t maxDescriptorSetAccelerationStructures;
1466     uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures;
1467     uint32_t minAccelerationStructureScratchOffsetAlignment;
1468 } VkPhysicalDeviceAccelerationStructurePropertiesKHR32;
1469
1470 typedef struct VkPhysicalDeviceRayTracingPropertiesNV32
1471 {
1472     VkStructureType sType;
1473     void *pNext;
1474     uint32_t shaderGroupHandleSize;
1475     uint32_t maxRecursionDepth;
1476     uint32_t maxShaderGroupStride;
1477     uint32_t shaderGroupBaseAlignment;
1478     uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
1479     uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
1480     uint64_t DECLSPEC_ALIGN(8) maxTriangleCount;
1481     uint32_t maxDescriptorSetAccelerationStructures;
1482 } VkPhysicalDeviceRayTracingPropertiesNV32;
1483
1484 typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties32
1485 {
1486     VkStructureType sType;
1487     void *pNext;
1488     VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
1489     VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
1490     VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
1491     VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
1492 } VkPhysicalDeviceTexelBufferAlignmentProperties32;
1493 typedef VkPhysicalDeviceTexelBufferAlignmentProperties32 VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT32;
1494
1495 typedef struct VkPhysicalDeviceVulkan11Properties32
1496 {
1497     VkStructureType sType;
1498     void *pNext;
1499     uint8_t deviceUUID[VK_UUID_SIZE];
1500     uint8_t driverUUID[VK_UUID_SIZE];
1501     uint8_t deviceLUID[VK_LUID_SIZE];
1502     uint32_t deviceNodeMask;
1503     VkBool32 deviceLUIDValid;
1504     uint32_t subgroupSize;
1505     VkShaderStageFlags subgroupSupportedStages;
1506     VkSubgroupFeatureFlags subgroupSupportedOperations;
1507     VkBool32 subgroupQuadOperationsInAllStages;
1508     VkPointClippingBehavior pointClippingBehavior;
1509     uint32_t maxMultiviewViewCount;
1510     uint32_t maxMultiviewInstanceIndex;
1511     VkBool32 protectedNoFault;
1512     uint32_t maxPerSetDescriptors;
1513     VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
1514 } VkPhysicalDeviceVulkan11Properties32;
1515
1516 typedef struct VkPhysicalDeviceVulkan12Properties32
1517 {
1518     VkStructureType sType;
1519     void *pNext;
1520     VkDriverId driverID;
1521     char driverName[VK_MAX_DRIVER_NAME_SIZE];
1522     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
1523     VkConformanceVersion conformanceVersion;
1524     VkShaderFloatControlsIndependence denormBehaviorIndependence;
1525     VkShaderFloatControlsIndependence roundingModeIndependence;
1526     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
1527     VkBool32 shaderSignedZeroInfNanPreserveFloat32;
1528     VkBool32 shaderSignedZeroInfNanPreserveFloat64;
1529     VkBool32 shaderDenormPreserveFloat16;
1530     VkBool32 shaderDenormPreserveFloat32;
1531     VkBool32 shaderDenormPreserveFloat64;
1532     VkBool32 shaderDenormFlushToZeroFloat16;
1533     VkBool32 shaderDenormFlushToZeroFloat32;
1534     VkBool32 shaderDenormFlushToZeroFloat64;
1535     VkBool32 shaderRoundingModeRTEFloat16;
1536     VkBool32 shaderRoundingModeRTEFloat32;
1537     VkBool32 shaderRoundingModeRTEFloat64;
1538     VkBool32 shaderRoundingModeRTZFloat16;
1539     VkBool32 shaderRoundingModeRTZFloat32;
1540     VkBool32 shaderRoundingModeRTZFloat64;
1541     uint32_t maxUpdateAfterBindDescriptorsInAllPools;
1542     VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
1543     VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
1544     VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
1545     VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
1546     VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
1547     VkBool32 robustBufferAccessUpdateAfterBind;
1548     VkBool32 quadDivergentImplicitLod;
1549     uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
1550     uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
1551     uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
1552     uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
1553     uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
1554     uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
1555     uint32_t maxPerStageUpdateAfterBindResources;
1556     uint32_t maxDescriptorSetUpdateAfterBindSamplers;
1557     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
1558     uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
1559     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
1560     uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
1561     uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
1562     uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
1563     uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
1564     VkResolveModeFlags supportedDepthResolveModes;
1565     VkResolveModeFlags supportedStencilResolveModes;
1566     VkBool32 independentResolveNone;
1567     VkBool32 independentResolve;
1568     VkBool32 filterMinmaxSingleComponentFormats;
1569     VkBool32 filterMinmaxImageComponentMapping;
1570     uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
1571     VkSampleCountFlags framebufferIntegerColorSampleCounts;
1572 } VkPhysicalDeviceVulkan12Properties32;
1573
1574 typedef struct VkPhysicalDeviceVulkan13Properties32
1575 {
1576     VkStructureType sType;
1577     void *pNext;
1578     uint32_t minSubgroupSize;
1579     uint32_t maxSubgroupSize;
1580     uint32_t maxComputeWorkgroupSubgroups;
1581     VkShaderStageFlags requiredSubgroupSizeStages;
1582     uint32_t maxInlineUniformBlockSize;
1583     uint32_t maxPerStageDescriptorInlineUniformBlocks;
1584     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
1585     uint32_t maxDescriptorSetInlineUniformBlocks;
1586     uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
1587     uint32_t maxInlineUniformTotalSize;
1588     VkBool32 integerDotProduct8BitUnsignedAccelerated;
1589     VkBool32 integerDotProduct8BitSignedAccelerated;
1590     VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
1591     VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
1592     VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
1593     VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
1594     VkBool32 integerDotProduct16BitUnsignedAccelerated;
1595     VkBool32 integerDotProduct16BitSignedAccelerated;
1596     VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
1597     VkBool32 integerDotProduct32BitUnsignedAccelerated;
1598     VkBool32 integerDotProduct32BitSignedAccelerated;
1599     VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
1600     VkBool32 integerDotProduct64BitUnsignedAccelerated;
1601     VkBool32 integerDotProduct64BitSignedAccelerated;
1602     VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
1603     VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
1604     VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
1605     VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
1606     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
1607     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
1608     VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
1609     VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
1610     VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
1611     VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
1612     VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
1613     VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
1614     VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
1615     VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
1616     VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
1617     VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
1618     VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
1619     VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
1620     VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
1621     VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
1622     VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
1623 } VkPhysicalDeviceVulkan13Properties32;
1624
1625 typedef struct VkPhysicalDeviceRobustness2PropertiesEXT32
1626 {
1627     VkStructureType sType;
1628     void *pNext;
1629     VkDeviceSize DECLSPEC_ALIGN(8) robustStorageBufferAccessSizeAlignment;
1630     VkDeviceSize DECLSPEC_ALIGN(8) robustUniformBufferAccessSizeAlignment;
1631 } VkPhysicalDeviceRobustness2PropertiesEXT32;
1632
1633 typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32
1634 {
1635     VkStructureType sType;
1636     void *pNext;
1637     uint64_t DECLSPEC_ALIGN(8) shaderCoreMask;
1638     uint32_t shaderCoreCount;
1639     uint32_t shaderWarpsPerCore;
1640 } VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32;
1641
1642 typedef struct VkPhysicalDeviceProperties232
1643 {
1644     VkStructureType sType;
1645     void *pNext;
1646     VkPhysicalDeviceProperties32 DECLSPEC_ALIGN(8) properties;
1647 } VkPhysicalDeviceProperties232;
1648 typedef VkPhysicalDeviceProperties232 VkPhysicalDeviceProperties2KHR32;
1649
1650 typedef struct VkPhysicalDeviceSurfaceInfo2KHR32
1651 {
1652     VkStructureType sType;
1653     const void *pNext;
1654     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
1655 } VkPhysicalDeviceSurfaceInfo2KHR32;
1656
1657 typedef struct VkPipelineExecutableInfoKHR32
1658 {
1659     VkStructureType sType;
1660     const void *pNext;
1661     VkPipeline DECLSPEC_ALIGN(8) pipeline;
1662     uint32_t executableIndex;
1663 } VkPipelineExecutableInfoKHR32;
1664
1665 typedef struct VkPipelineInfoKHR32
1666 {
1667     VkStructureType sType;
1668     const void *pNext;
1669     VkPipeline DECLSPEC_ALIGN(8) pipeline;
1670 } VkPipelineInfoKHR32;
1671 typedef VkPipelineInfoKHR32 VkPipelineInfoEXT32;
1672
1673 typedef struct VkPipelineExecutableStatisticKHR32
1674 {
1675     VkStructureType sType;
1676     void *pNext;
1677     char name[VK_MAX_DESCRIPTION_SIZE];
1678     char description[VK_MAX_DESCRIPTION_SIZE];
1679     VkPipelineExecutableStatisticFormatKHR format;
1680     VkPipelineExecutableStatisticValueKHR DECLSPEC_ALIGN(8) value;
1681 } VkPipelineExecutableStatisticKHR32;
1682
1683
1684 typedef struct VkSparseMemoryBind32
1685 {
1686     VkDeviceSize DECLSPEC_ALIGN(8) resourceOffset;
1687     VkDeviceSize DECLSPEC_ALIGN(8) size;
1688     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
1689     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
1690     VkSparseMemoryBindFlags flags;
1691 } VkSparseMemoryBind32;
1692
1693 typedef struct VkSparseBufferMemoryBindInfo32
1694 {
1695     VkBuffer DECLSPEC_ALIGN(8) buffer;
1696     uint32_t bindCount;
1697     const VkSparseMemoryBind32 *pBinds;
1698 } VkSparseBufferMemoryBindInfo32;
1699
1700 typedef struct VkSparseImageOpaqueMemoryBindInfo32
1701 {
1702     VkImage DECLSPEC_ALIGN(8) image;
1703     uint32_t bindCount;
1704     const VkSparseMemoryBind32 *pBinds;
1705 } VkSparseImageOpaqueMemoryBindInfo32;
1706
1707 typedef struct VkSparseImageMemoryBind32
1708 {
1709     VkImageSubresource subresource;
1710     VkOffset3D offset;
1711     VkExtent3D extent;
1712     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
1713     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
1714     VkSparseMemoryBindFlags flags;
1715 } VkSparseImageMemoryBind32;
1716
1717 typedef struct VkSparseImageMemoryBindInfo32
1718 {
1719     VkImage DECLSPEC_ALIGN(8) image;
1720     uint32_t bindCount;
1721     const VkSparseImageMemoryBind32 *pBinds;
1722 } VkSparseImageMemoryBindInfo32;
1723
1724 typedef struct VkBindSparseInfo32
1725 {
1726     VkStructureType sType;
1727     const void *pNext;
1728     uint32_t waitSemaphoreCount;
1729     const VkSemaphore *pWaitSemaphores;
1730     uint32_t bufferBindCount;
1731     const VkSparseBufferMemoryBindInfo32 *pBufferBinds;
1732     uint32_t imageOpaqueBindCount;
1733     const VkSparseImageOpaqueMemoryBindInfo32 *pImageOpaqueBinds;
1734     uint32_t imageBindCount;
1735     const VkSparseImageMemoryBindInfo32 *pImageBinds;
1736     uint32_t signalSemaphoreCount;
1737     const VkSemaphore *pSignalSemaphores;
1738 } VkBindSparseInfo32;
1739
1740 typedef struct VkSemaphoreSubmitInfo32
1741 {
1742     VkStructureType sType;
1743     const void *pNext;
1744     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
1745     uint64_t DECLSPEC_ALIGN(8) value;
1746     VkPipelineStageFlags2 stageMask;
1747     uint32_t deviceIndex;
1748 } VkSemaphoreSubmitInfo32;
1749 typedef VkSemaphoreSubmitInfo32 VkSemaphoreSubmitInfoKHR32;
1750
1751 typedef struct VkSubmitInfo232
1752 {
1753     VkStructureType sType;
1754     const void *pNext;
1755     VkSubmitFlags flags;
1756     uint32_t waitSemaphoreInfoCount;
1757     const VkSemaphoreSubmitInfo32 *pWaitSemaphoreInfos;
1758     uint32_t commandBufferInfoCount;
1759     const VkCommandBufferSubmitInfo *pCommandBufferInfos;
1760     uint32_t signalSemaphoreInfoCount;
1761     const VkSemaphoreSubmitInfo32 *pSignalSemaphoreInfos;
1762 } VkSubmitInfo232;
1763 typedef VkSubmitInfo232 VkSubmitInfo2KHR32;
1764
1765 typedef struct VkDebugUtilsObjectTagInfoEXT32
1766 {
1767     VkStructureType sType;
1768     const void *pNext;
1769     VkObjectType objectType;
1770     uint64_t DECLSPEC_ALIGN(8) objectHandle;
1771     uint64_t DECLSPEC_ALIGN(8) tagName;
1772     size_t tagSize;
1773     const void *pTag;
1774 } VkDebugUtilsObjectTagInfoEXT32;
1775
1776 typedef struct VkSemaphoreSignalInfo32
1777 {
1778     VkStructureType sType;
1779     const void *pNext;
1780     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
1781     uint64_t DECLSPEC_ALIGN(8) value;
1782 } VkSemaphoreSignalInfo32;
1783 typedef VkSemaphoreSignalInfo32 VkSemaphoreSignalInfoKHR32;
1784
1785 typedef struct VkDeviceAddressBindingCallbackDataEXT32
1786 {
1787     VkStructureType sType;
1788     void *pNext;
1789     VkDeviceAddressBindingFlagsEXT flags;
1790     VkDeviceAddress DECLSPEC_ALIGN(8) baseAddress;
1791     VkDeviceSize DECLSPEC_ALIGN(8) size;
1792     VkDeviceAddressBindingTypeEXT bindingType;
1793 } VkDeviceAddressBindingCallbackDataEXT32;
1794
1795 typedef struct VkDebugUtilsMessengerCallbackDataEXT32
1796 {
1797     VkStructureType sType;
1798     const void *pNext;
1799     VkDebugUtilsMessengerCallbackDataFlagsEXT flags;
1800     const char *pMessageIdName;
1801     int32_t messageIdNumber;
1802     const char *pMessage;
1803     uint32_t queueLabelCount;
1804     const VkDebugUtilsLabelEXT *pQueueLabels;
1805     uint32_t cmdBufLabelCount;
1806     const VkDebugUtilsLabelEXT *pCmdBufLabels;
1807     uint32_t objectCount;
1808     const VkDebugUtilsObjectNameInfoEXT32 *pObjects;
1809 } VkDebugUtilsMessengerCallbackDataEXT32;
1810
1811 typedef struct VkCopyDescriptorSet32
1812 {
1813     VkStructureType sType;
1814     const void *pNext;
1815     VkDescriptorSet DECLSPEC_ALIGN(8) srcSet;
1816     uint32_t srcBinding;
1817     uint32_t srcArrayElement;
1818     VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
1819     uint32_t dstBinding;
1820     uint32_t dstArrayElement;
1821     uint32_t descriptorCount;
1822 } VkCopyDescriptorSet32;
1823
1824 #endif /* USE_STRUCT_CONVERSION */
1825
1826 static uint64_t wine_vk_unwrap_handle(uint32_t type, uint64_t handle)
1827 {
1828     switch(type)
1829     {
1830     case VK_OBJECT_TYPE_COMMAND_BUFFER:
1831         return (uint64_t) (uintptr_t) wine_cmd_buffer_from_handle(((VkCommandBuffer) (uintptr_t) handle))->command_buffer;
1832     case VK_OBJECT_TYPE_COMMAND_POOL:
1833         return (uint64_t) wine_cmd_pool_from_handle(handle)->command_pool;
1834     case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:
1835         return (uint64_t) wine_debug_report_callback_from_handle(handle)->debug_callback;
1836     case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
1837         return (uint64_t) wine_debug_utils_messenger_from_handle(handle)->debug_messenger;
1838     case VK_OBJECT_TYPE_DEVICE:
1839         return (uint64_t) (uintptr_t) wine_device_from_handle(((VkDevice) (uintptr_t) handle))->device;
1840     case VK_OBJECT_TYPE_INSTANCE:
1841         return (uint64_t) (uintptr_t) wine_instance_from_handle(((VkInstance) (uintptr_t) handle))->instance;
1842     case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
1843         return (uint64_t) (uintptr_t) wine_phys_dev_from_handle(((VkPhysicalDevice) (uintptr_t) handle))->phys_dev;
1844     case VK_OBJECT_TYPE_QUEUE:
1845         return (uint64_t) (uintptr_t) wine_queue_from_handle(((VkQueue) (uintptr_t) handle))->queue;
1846     case VK_OBJECT_TYPE_SURFACE_KHR:
1847         return (uint64_t) wine_surface_from_handle(handle)->surface;
1848     default:
1849        return handle;
1850     }
1851 }
1852
1853 #if defined(USE_STRUCT_CONVERSION)
1854 static inline void convert_VkAcquireNextImageInfoKHR_win32_to_host(const VkAcquireNextImageInfoKHR32 *in, VkAcquireNextImageInfoKHR *out)
1855 {
1856     if (!in) return;
1857
1858     out->sType = in->sType;
1859     out->pNext = in->pNext;
1860     out->swapchain = in->swapchain;
1861     out->timeout = in->timeout;
1862     out->semaphore = in->semaphore;
1863     out->fence = in->fence;
1864     out->deviceMask = in->deviceMask;
1865 }
1866 #endif /* USE_STRUCT_CONVERSION */
1867
1868 #if defined(USE_STRUCT_CONVERSION)
1869 static inline void convert_VkAcquireProfilingLockInfoKHR_win32_to_host(const VkAcquireProfilingLockInfoKHR32 *in, VkAcquireProfilingLockInfoKHR *out)
1870 {
1871     if (!in) return;
1872
1873     out->sType = in->sType;
1874     out->pNext = in->pNext;
1875     out->flags = in->flags;
1876     out->timeout = in->timeout;
1877 }
1878 #endif /* USE_STRUCT_CONVERSION */
1879
1880 #if defined(USE_STRUCT_CONVERSION)
1881 static inline void convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(const VkCommandBufferAllocateInfo32 *in, VkCommandBufferAllocateInfo *out)
1882 {
1883     if (!in) return;
1884
1885     out->sType = in->sType;
1886     out->pNext = in->pNext;
1887     out->commandPool = in->commandPool;
1888     out->level = in->level;
1889     out->commandBufferCount = in->commandBufferCount;
1890 }
1891 #endif /* USE_STRUCT_CONVERSION */
1892
1893 #if defined(USE_STRUCT_CONVERSION)
1894 static inline void convert_VkDescriptorSetAllocateInfo_win32_to_host(const VkDescriptorSetAllocateInfo32 *in, VkDescriptorSetAllocateInfo *out)
1895 {
1896     if (!in) return;
1897
1898     out->sType = in->sType;
1899     out->pNext = in->pNext;
1900     out->descriptorPool = in->descriptorPool;
1901     out->descriptorSetCount = in->descriptorSetCount;
1902     out->pSetLayouts = in->pSetLayouts;
1903 }
1904 #endif /* USE_STRUCT_CONVERSION */
1905
1906 #if defined(USE_STRUCT_CONVERSION)
1907 static inline void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryAllocateInfo32 *in, VkMemoryAllocateInfo *out)
1908 {
1909     const VkBaseInStructure *in_header;
1910     VkBaseOutStructure *out_header = (void *)out;
1911
1912     if (!in) return;
1913
1914     out->sType = in->sType;
1915     out->pNext = NULL;
1916     out->allocationSize = in->allocationSize;
1917     out->memoryTypeIndex = in->memoryTypeIndex;
1918
1919     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
1920     {
1921         switch (in_header->sType)
1922         {
1923         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
1924         {
1925             VkDedicatedAllocationMemoryAllocateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
1926             const VkDedicatedAllocationMemoryAllocateInfoNV32 *in_ext = (const VkDedicatedAllocationMemoryAllocateInfoNV32 *)in_header;
1927             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV;
1928             out_ext->pNext = NULL;
1929             out_ext->image = in_ext->image;
1930             out_ext->buffer = in_ext->buffer;
1931             out_header->pNext = (void *)out_ext;
1932             out_header = (void *)out_ext;
1933             break;
1934         }
1935         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
1936         {
1937             VkExportMemoryAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
1938             const VkExportMemoryAllocateInfo *in_ext = (const VkExportMemoryAllocateInfo *)in_header;
1939             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
1940             out_ext->pNext = NULL;
1941             out_ext->handleTypes = in_ext->handleTypes;
1942             out_header->pNext = (void *)out_ext;
1943             out_header = (void *)out_ext;
1944             break;
1945         }
1946         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
1947         {
1948             VkImportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
1949             const VkImportMemoryWin32HandleInfoKHR *in_ext = (const VkImportMemoryWin32HandleInfoKHR *)in_header;
1950             out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
1951             out_ext->pNext = NULL;
1952             out_ext->handleType = in_ext->handleType;
1953             out_ext->handle = in_ext->handle;
1954             out_ext->name = in_ext->name;
1955             out_header->pNext = (void *)out_ext;
1956             out_header = (void *)out_ext;
1957             break;
1958         }
1959         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
1960         {
1961             VkExportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
1962             const VkExportMemoryWin32HandleInfoKHR *in_ext = (const VkExportMemoryWin32HandleInfoKHR *)in_header;
1963             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
1964             out_ext->pNext = NULL;
1965             out_ext->pAttributes = in_ext->pAttributes;
1966             out_ext->dwAccess = in_ext->dwAccess;
1967             out_ext->name = in_ext->name;
1968             out_header->pNext = (void *)out_ext;
1969             out_header = (void *)out_ext;
1970             break;
1971         }
1972         case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
1973         {
1974             VkMemoryAllocateFlagsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
1975             const VkMemoryAllocateFlagsInfo *in_ext = (const VkMemoryAllocateFlagsInfo *)in_header;
1976             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO;
1977             out_ext->pNext = NULL;
1978             out_ext->flags = in_ext->flags;
1979             out_ext->deviceMask = in_ext->deviceMask;
1980             out_header->pNext = (void *)out_ext;
1981             out_header = (void *)out_ext;
1982             break;
1983         }
1984         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
1985         {
1986             VkMemoryDedicatedAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
1987             const VkMemoryDedicatedAllocateInfo32 *in_ext = (const VkMemoryDedicatedAllocateInfo32 *)in_header;
1988             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
1989             out_ext->pNext = NULL;
1990             out_ext->image = in_ext->image;
1991             out_ext->buffer = in_ext->buffer;
1992             out_header->pNext = (void *)out_ext;
1993             out_header = (void *)out_ext;
1994             break;
1995         }
1996         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
1997         {
1998             VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
1999             const VkImportMemoryHostPointerInfoEXT *in_ext = (const VkImportMemoryHostPointerInfoEXT *)in_header;
2000             out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT;
2001             out_ext->pNext = NULL;
2002             out_ext->handleType = in_ext->handleType;
2003             out_ext->pHostPointer = in_ext->pHostPointer;
2004             out_header->pNext = (void *)out_ext;
2005             out_header = (void *)out_ext;
2006             break;
2007         }
2008         case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
2009         {
2010             VkMemoryPriorityAllocateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
2011             const VkMemoryPriorityAllocateInfoEXT *in_ext = (const VkMemoryPriorityAllocateInfoEXT *)in_header;
2012             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT;
2013             out_ext->pNext = NULL;
2014             out_ext->priority = in_ext->priority;
2015             out_header->pNext = (void *)out_ext;
2016             out_header = (void *)out_ext;
2017             break;
2018         }
2019         case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
2020         {
2021             VkMemoryOpaqueCaptureAddressAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
2022             const VkMemoryOpaqueCaptureAddressAllocateInfo32 *in_ext = (const VkMemoryOpaqueCaptureAddressAllocateInfo32 *)in_header;
2023             out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
2024             out_ext->pNext = NULL;
2025             out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress;
2026             out_header->pNext = (void *)out_ext;
2027             out_header = (void *)out_ext;
2028             break;
2029         }
2030         default:
2031             FIXME("Unhandled sType %u.", in_header->sType);
2032             break;
2033         }
2034     }
2035 }
2036 #endif /* USE_STRUCT_CONVERSION */
2037
2038 #if defined(USE_STRUCT_CONVERSION)
2039 static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(const VkCommandBufferInheritanceInfo32 *in, VkCommandBufferInheritanceInfo *out)
2040 {
2041     if (!in) return;
2042
2043     out->sType = in->sType;
2044     out->pNext = in->pNext;
2045     out->renderPass = in->renderPass;
2046     out->subpass = in->subpass;
2047     out->framebuffer = in->framebuffer;
2048     out->occlusionQueryEnable = in->occlusionQueryEnable;
2049     out->queryFlags = in->queryFlags;
2050     out->pipelineStatistics = in->pipelineStatistics;
2051 }
2052 #endif /* USE_STRUCT_CONVERSION */
2053
2054 #if defined(USE_STRUCT_CONVERSION)
2055 static inline const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInheritanceInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, uint32_t count)
2056 {
2057     VkCommandBufferInheritanceInfo *out;
2058     unsigned int i;
2059
2060     if (!in || !count) return NULL;
2061
2062     out = conversion_context_alloc(ctx, count * sizeof(*out));
2063     for (i = 0; i < count; i++)
2064     {
2065         convert_VkCommandBufferInheritanceInfo_win32_to_host(&in[i], &out[i]);
2066     }
2067
2068     return out;
2069 }
2070 #endif /* USE_STRUCT_CONVERSION */
2071
2072 #if defined(USE_STRUCT_CONVERSION)
2073 static inline void convert_VkCommandBufferBeginInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferBeginInfo32 *in, VkCommandBufferBeginInfo *out)
2074 {
2075     if (!in) return;
2076
2077     out->sType = in->sType;
2078     out->pNext = in->pNext;
2079     out->flags = in->flags;
2080     out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win32_to_host(ctx, in->pInheritanceInfo, 1);
2081 }
2082 #endif /* USE_STRUCT_CONVERSION */
2083
2084 #if defined(USE_STRUCT_CONVERSION)
2085 static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(const VkBindAccelerationStructureMemoryInfoNV32 *in, VkBindAccelerationStructureMemoryInfoNV *out)
2086 {
2087     if (!in) return;
2088
2089     out->sType = in->sType;
2090     out->pNext = in->pNext;
2091     out->accelerationStructure = in->accelerationStructure;
2092     out->memory = in->memory;
2093     out->memoryOffset = in->memoryOffset;
2094     out->deviceIndexCount = in->deviceIndexCount;
2095     out->pDeviceIndices = in->pDeviceIndices;
2096 }
2097 #endif /* USE_STRUCT_CONVERSION */
2098
2099 #if defined(USE_STRUCT_CONVERSION)
2100 static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV32 *in, uint32_t count)
2101 {
2102     VkBindAccelerationStructureMemoryInfoNV *out;
2103     unsigned int i;
2104
2105     if (!in || !count) return NULL;
2106
2107     out = conversion_context_alloc(ctx, count * sizeof(*out));
2108     for (i = 0; i < count; i++)
2109     {
2110         convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(&in[i], &out[i]);
2111     }
2112
2113     return out;
2114 }
2115 #endif /* USE_STRUCT_CONVERSION */
2116
2117 #if defined(USE_STRUCT_CONVERSION)
2118 static inline void convert_VkBindBufferMemoryInfo_win32_to_host(const VkBindBufferMemoryInfo32 *in, VkBindBufferMemoryInfo *out)
2119 {
2120     if (!in) return;
2121
2122     out->sType = in->sType;
2123     out->pNext = in->pNext;
2124     out->buffer = in->buffer;
2125     out->memory = in->memory;
2126     out->memoryOffset = in->memoryOffset;
2127 }
2128 #endif /* USE_STRUCT_CONVERSION */
2129
2130 #if defined(USE_STRUCT_CONVERSION)
2131 static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, uint32_t count)
2132 {
2133     VkBindBufferMemoryInfo *out;
2134     unsigned int i;
2135
2136     if (!in || !count) return NULL;
2137
2138     out = conversion_context_alloc(ctx, count * sizeof(*out));
2139     for (i = 0; i < count; i++)
2140     {
2141         convert_VkBindBufferMemoryInfo_win32_to_host(&in[i], &out[i]);
2142     }
2143
2144     return out;
2145 }
2146 #endif /* USE_STRUCT_CONVERSION */
2147
2148 #if defined(USE_STRUCT_CONVERSION)
2149 static inline void convert_VkBindImageMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, VkBindImageMemoryInfo *out)
2150 {
2151     const VkBaseInStructure *in_header;
2152     VkBaseOutStructure *out_header = (void *)out;
2153
2154     if (!in) return;
2155
2156     out->sType = in->sType;
2157     out->pNext = NULL;
2158     out->image = in->image;
2159     out->memory = in->memory;
2160     out->memoryOffset = in->memoryOffset;
2161
2162     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
2163     {
2164         switch (in_header->sType)
2165         {
2166         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
2167         {
2168             VkBindImageMemoryDeviceGroupInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
2169             const VkBindImageMemoryDeviceGroupInfo *in_ext = (const VkBindImageMemoryDeviceGroupInfo *)in_header;
2170             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
2171             out_ext->pNext = NULL;
2172             out_ext->deviceIndexCount = in_ext->deviceIndexCount;
2173             out_ext->pDeviceIndices = in_ext->pDeviceIndices;
2174             out_ext->splitInstanceBindRegionCount = in_ext->splitInstanceBindRegionCount;
2175             out_ext->pSplitInstanceBindRegions = in_ext->pSplitInstanceBindRegions;
2176             out_header->pNext = (void *)out_ext;
2177             out_header = (void *)out_ext;
2178             break;
2179         }
2180         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
2181         {
2182             VkBindImageMemorySwapchainInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
2183             const VkBindImageMemorySwapchainInfoKHR32 *in_ext = (const VkBindImageMemorySwapchainInfoKHR32 *)in_header;
2184             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR;
2185             out_ext->pNext = NULL;
2186             out_ext->swapchain = in_ext->swapchain;
2187             out_ext->imageIndex = in_ext->imageIndex;
2188             out_header->pNext = (void *)out_ext;
2189             out_header = (void *)out_ext;
2190             break;
2191         }
2192         case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
2193         {
2194             VkBindImagePlaneMemoryInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
2195             const VkBindImagePlaneMemoryInfo *in_ext = (const VkBindImagePlaneMemoryInfo *)in_header;
2196             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO;
2197             out_ext->pNext = NULL;
2198             out_ext->planeAspect = in_ext->planeAspect;
2199             out_header->pNext = (void *)out_ext;
2200             out_header = (void *)out_ext;
2201             break;
2202         }
2203         default:
2204             FIXME("Unhandled sType %u.", in_header->sType);
2205             break;
2206         }
2207     }
2208 }
2209 #endif /* USE_STRUCT_CONVERSION */
2210
2211 #if defined(USE_STRUCT_CONVERSION)
2212 static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, uint32_t count)
2213 {
2214     VkBindImageMemoryInfo *out;
2215     unsigned int i;
2216
2217     if (!in || !count) return NULL;
2218
2219     out = conversion_context_alloc(ctx, count * sizeof(*out));
2220     for (i = 0; i < count; i++)
2221     {
2222         convert_VkBindImageMemoryInfo_win32_to_host(ctx, &in[i], &out[i]);
2223     }
2224
2225     return out;
2226 }
2227 #endif /* USE_STRUCT_CONVERSION */
2228
2229 #if defined(USE_STRUCT_CONVERSION)
2230 static inline void convert_VkAccelerationStructureGeometryKHR_win32_to_host(const VkAccelerationStructureGeometryKHR32 *in, VkAccelerationStructureGeometryKHR *out)
2231 {
2232     if (!in) return;
2233
2234     out->sType = in->sType;
2235     out->pNext = in->pNext;
2236     out->geometryType = in->geometryType;
2237     out->geometry = in->geometry;
2238     out->flags = in->flags;
2239 }
2240 #endif /* USE_STRUCT_CONVERSION */
2241
2242 #if defined(USE_STRUCT_CONVERSION)
2243 static inline const VkAccelerationStructureGeometryKHR *convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, uint32_t count)
2244 {
2245     VkAccelerationStructureGeometryKHR *out;
2246     unsigned int i;
2247
2248     if (!in || !count) return NULL;
2249
2250     out = conversion_context_alloc(ctx, count * sizeof(*out));
2251     for (i = 0; i < count; i++)
2252     {
2253         convert_VkAccelerationStructureGeometryKHR_win32_to_host(&in[i], &out[i]);
2254     }
2255
2256     return out;
2257 }
2258 #endif /* USE_STRUCT_CONVERSION */
2259
2260 #if defined(USE_STRUCT_CONVERSION)
2261 static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 * const*in, uint32_t count)
2262 {
2263     VkAccelerationStructureGeometryKHR **out;
2264     unsigned int i;
2265
2266     if (!in || !count) return NULL;
2267
2268     out = conversion_context_alloc(ctx, count * sizeof(*out));
2269     for (i = 0; i < count; i++)
2270     {
2271         if (in[i])
2272         {
2273             out[i] = conversion_context_alloc(ctx, sizeof(*out[i]));
2274             convert_VkAccelerationStructureGeometryKHR_win32_to_host(in[i], out[i]);
2275         }
2276         else
2277             out[i] = NULL;
2278     }
2279
2280     return (void *)out;
2281 }
2282 #endif /* USE_STRUCT_CONVERSION */
2283
2284 #if defined(USE_STRUCT_CONVERSION)
2285 static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, VkAccelerationStructureBuildGeometryInfoKHR *out)
2286 {
2287     if (!in) return;
2288
2289     out->sType = in->sType;
2290     out->pNext = in->pNext;
2291     out->type = in->type;
2292     out->flags = in->flags;
2293     out->mode = in->mode;
2294     out->srcAccelerationStructure = in->srcAccelerationStructure;
2295     out->dstAccelerationStructure = in->dstAccelerationStructure;
2296     out->geometryCount = in->geometryCount;
2297     out->pGeometries = convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(ctx, in->pGeometries, in->geometryCount);
2298     out->ppGeometries = convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(ctx, in->ppGeometries, in->geometryCount);
2299     out->scratchData = in->scratchData;
2300 }
2301 #endif /* USE_STRUCT_CONVERSION */
2302
2303 #if defined(USE_STRUCT_CONVERSION)
2304 static inline const VkAccelerationStructureBuildGeometryInfoKHR *convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, uint32_t count)
2305 {
2306     VkAccelerationStructureBuildGeometryInfoKHR *out;
2307     unsigned int i;
2308
2309     if (!in || !count) return NULL;
2310
2311     out = conversion_context_alloc(ctx, count * sizeof(*out));
2312     for (i = 0; i < count; i++)
2313     {
2314         convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
2315     }
2316
2317     return out;
2318 }
2319 #endif /* USE_STRUCT_CONVERSION */
2320
2321 #if defined(USE_STRUCT_CONVERSION)
2322 static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(const VkMicromapBuildInfoEXT32 *in, VkMicromapBuildInfoEXT *out)
2323 {
2324     if (!in) return;
2325
2326     out->sType = in->sType;
2327     out->pNext = in->pNext;
2328     out->type = in->type;
2329     out->flags = in->flags;
2330     out->mode = in->mode;
2331     out->dstMicromap = in->dstMicromap;
2332     out->usageCountsCount = in->usageCountsCount;
2333     out->pUsageCounts = in->pUsageCounts;
2334     out->ppUsageCounts = in->ppUsageCounts;
2335     out->data = in->data;
2336     out->scratchData = in->scratchData;
2337     out->triangleArray = in->triangleArray;
2338     out->triangleArrayStride = in->triangleArrayStride;
2339 }
2340 #endif /* USE_STRUCT_CONVERSION */
2341
2342 #if defined(USE_STRUCT_CONVERSION)
2343 static inline const VkMicromapBuildInfoEXT *convert_VkMicromapBuildInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, uint32_t count)
2344 {
2345     VkMicromapBuildInfoEXT *out;
2346     unsigned int i;
2347
2348     if (!in || !count) return NULL;
2349
2350     out = conversion_context_alloc(ctx, count * sizeof(*out));
2351     for (i = 0; i < count; i++)
2352     {
2353         convert_VkMicromapBuildInfoEXT_win32_to_host(&in[i], &out[i]);
2354     }
2355
2356     return out;
2357 }
2358 #endif /* USE_STRUCT_CONVERSION */
2359
2360 #if defined(USE_STRUCT_CONVERSION)
2361 static inline void convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(const VkConditionalRenderingBeginInfoEXT32 *in, VkConditionalRenderingBeginInfoEXT *out)
2362 {
2363     if (!in) return;
2364
2365     out->sType = in->sType;
2366     out->pNext = in->pNext;
2367     out->buffer = in->buffer;
2368     out->offset = in->offset;
2369     out->flags = in->flags;
2370 }
2371 #endif /* USE_STRUCT_CONVERSION */
2372
2373 #if defined(USE_STRUCT_CONVERSION)
2374 static inline void convert_VkRenderPassBeginInfo_win32_to_host(const VkRenderPassBeginInfo32 *in, VkRenderPassBeginInfo *out)
2375 {
2376     if (!in) return;
2377
2378     out->sType = in->sType;
2379     out->pNext = in->pNext;
2380     out->renderPass = in->renderPass;
2381     out->framebuffer = in->framebuffer;
2382     out->renderArea = in->renderArea;
2383     out->clearValueCount = in->clearValueCount;
2384     out->pClearValues = in->pClearValues;
2385 }
2386 #endif /* USE_STRUCT_CONVERSION */
2387
2388 #if defined(USE_STRUCT_CONVERSION)
2389 static inline void convert_VkRenderingAttachmentInfo_win32_to_host(const VkRenderingAttachmentInfo32 *in, VkRenderingAttachmentInfo *out)
2390 {
2391     if (!in) return;
2392
2393     out->sType = in->sType;
2394     out->pNext = in->pNext;
2395     out->imageView = in->imageView;
2396     out->imageLayout = in->imageLayout;
2397     out->resolveMode = in->resolveMode;
2398     out->resolveImageView = in->resolveImageView;
2399     out->resolveImageLayout = in->resolveImageLayout;
2400     out->loadOp = in->loadOp;
2401     out->storeOp = in->storeOp;
2402     out->clearValue = in->clearValue;
2403 }
2404 #endif /* USE_STRUCT_CONVERSION */
2405
2406 #if defined(USE_STRUCT_CONVERSION)
2407 static inline const VkRenderingAttachmentInfo *convert_VkRenderingAttachmentInfo_array_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, uint32_t count)
2408 {
2409     VkRenderingAttachmentInfo *out;
2410     unsigned int i;
2411
2412     if (!in || !count) return NULL;
2413
2414     out = conversion_context_alloc(ctx, count * sizeof(*out));
2415     for (i = 0; i < count; i++)
2416     {
2417         convert_VkRenderingAttachmentInfo_win32_to_host(&in[i], &out[i]);
2418     }
2419
2420     return out;
2421 }
2422 #endif /* USE_STRUCT_CONVERSION */
2423
2424 #if defined(USE_STRUCT_CONVERSION)
2425 static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingInfo32 *in, VkRenderingInfo *out)
2426 {
2427     const VkBaseInStructure *in_header;
2428     VkBaseOutStructure *out_header = (void *)out;
2429
2430     if (!in) return;
2431
2432     out->sType = in->sType;
2433     out->pNext = NULL;
2434     out->flags = in->flags;
2435     out->renderArea = in->renderArea;
2436     out->layerCount = in->layerCount;
2437     out->viewMask = in->viewMask;
2438     out->colorAttachmentCount = in->colorAttachmentCount;
2439     out->pColorAttachments = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, in->pColorAttachments, in->colorAttachmentCount);
2440     out->pDepthAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, in->pDepthAttachment, 1);
2441     out->pStencilAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, in->pStencilAttachment, 1);
2442
2443     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
2444     {
2445         switch (in_header->sType)
2446         {
2447         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
2448         {
2449             VkDeviceGroupRenderPassBeginInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
2450             const VkDeviceGroupRenderPassBeginInfo *in_ext = (const VkDeviceGroupRenderPassBeginInfo *)in_header;
2451             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
2452             out_ext->pNext = NULL;
2453             out_ext->deviceMask = in_ext->deviceMask;
2454             out_ext->deviceRenderAreaCount = in_ext->deviceRenderAreaCount;
2455             out_ext->pDeviceRenderAreas = in_ext->pDeviceRenderAreas;
2456             out_header->pNext = (void *)out_ext;
2457             out_header = (void *)out_ext;
2458             break;
2459         }
2460         case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
2461         {
2462             VkMultisampledRenderToSingleSampledInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
2463             const VkMultisampledRenderToSingleSampledInfoEXT *in_ext = (const VkMultisampledRenderToSingleSampledInfoEXT *)in_header;
2464             out_ext->sType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
2465             out_ext->pNext = NULL;
2466             out_ext->multisampledRenderToSingleSampledEnable = in_ext->multisampledRenderToSingleSampledEnable;
2467             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
2468             out_header->pNext = (void *)out_ext;
2469             out_header = (void *)out_ext;
2470             break;
2471         }
2472         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
2473         {
2474             VkRenderingFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
2475             const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *)in_header;
2476             out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
2477             out_ext->pNext = NULL;
2478             out_ext->imageView = in_ext->imageView;
2479             out_ext->imageLayout = in_ext->imageLayout;
2480             out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize;
2481             out_header->pNext = (void *)out_ext;
2482             out_header = (void *)out_ext;
2483             break;
2484         }
2485         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
2486         {
2487             VkRenderingFragmentDensityMapAttachmentInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
2488             const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *in_ext = (const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *)in_header;
2489             out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT;
2490             out_ext->pNext = NULL;
2491             out_ext->imageView = in_ext->imageView;
2492             out_ext->imageLayout = in_ext->imageLayout;
2493             out_header->pNext = (void *)out_ext;
2494             out_header = (void *)out_ext;
2495             break;
2496         }
2497         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
2498         {
2499             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
2500             const VkMultiviewPerViewAttributesInfoNVX *in_ext = (const VkMultiviewPerViewAttributesInfoNVX *)in_header;
2501             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
2502             out_ext->pNext = NULL;
2503             out_ext->perViewAttributes = in_ext->perViewAttributes;
2504             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
2505             out_header->pNext = (void *)out_ext;
2506             out_header = (void *)out_ext;
2507             break;
2508         }
2509         default:
2510             FIXME("Unhandled sType %u.", in_header->sType);
2511             break;
2512         }
2513     }
2514 }
2515 #endif /* USE_STRUCT_CONVERSION */
2516
2517 #if defined(USE_STRUCT_CONVERSION)
2518 static inline void convert_VkBlitImageInfo2_win32_to_host(const VkBlitImageInfo232 *in, VkBlitImageInfo2 *out)
2519 {
2520     if (!in) return;
2521
2522     out->sType = in->sType;
2523     out->pNext = in->pNext;
2524     out->srcImage = in->srcImage;
2525     out->srcImageLayout = in->srcImageLayout;
2526     out->dstImage = in->dstImage;
2527     out->dstImageLayout = in->dstImageLayout;
2528     out->regionCount = in->regionCount;
2529     out->pRegions = in->pRegions;
2530     out->filter = in->filter;
2531 }
2532 #endif /* USE_STRUCT_CONVERSION */
2533
2534 #if defined(USE_STRUCT_CONVERSION)
2535 static inline void convert_VkGeometryTrianglesNV_win32_to_host(const VkGeometryTrianglesNV32 *in, VkGeometryTrianglesNV *out)
2536 {
2537     if (!in) return;
2538
2539     out->sType = in->sType;
2540     out->pNext = in->pNext;
2541     out->vertexData = in->vertexData;
2542     out->vertexOffset = in->vertexOffset;
2543     out->vertexCount = in->vertexCount;
2544     out->vertexStride = in->vertexStride;
2545     out->vertexFormat = in->vertexFormat;
2546     out->indexData = in->indexData;
2547     out->indexOffset = in->indexOffset;
2548     out->indexCount = in->indexCount;
2549     out->indexType = in->indexType;
2550     out->transformData = in->transformData;
2551     out->transformOffset = in->transformOffset;
2552 }
2553 #endif /* USE_STRUCT_CONVERSION */
2554
2555 #if defined(USE_STRUCT_CONVERSION)
2556 static inline void convert_VkGeometryAABBNV_win32_to_host(const VkGeometryAABBNV32 *in, VkGeometryAABBNV *out)
2557 {
2558     if (!in) return;
2559
2560     out->sType = in->sType;
2561     out->pNext = in->pNext;
2562     out->aabbData = in->aabbData;
2563     out->numAABBs = in->numAABBs;
2564     out->stride = in->stride;
2565     out->offset = in->offset;
2566 }
2567 #endif /* USE_STRUCT_CONVERSION */
2568
2569 #if defined(USE_STRUCT_CONVERSION)
2570 static inline void convert_VkGeometryDataNV_win32_to_host(const VkGeometryDataNV32 *in, VkGeometryDataNV *out)
2571 {
2572     if (!in) return;
2573
2574     convert_VkGeometryTrianglesNV_win32_to_host(&in->triangles, &out->triangles);
2575     convert_VkGeometryAABBNV_win32_to_host(&in->aabbs, &out->aabbs);
2576 }
2577 #endif /* USE_STRUCT_CONVERSION */
2578
2579 #if defined(USE_STRUCT_CONVERSION)
2580 static inline void convert_VkGeometryNV_win32_to_host(const VkGeometryNV32 *in, VkGeometryNV *out)
2581 {
2582     if (!in) return;
2583
2584     out->sType = in->sType;
2585     out->pNext = in->pNext;
2586     out->geometryType = in->geometryType;
2587     convert_VkGeometryDataNV_win32_to_host(&in->geometry, &out->geometry);
2588     out->flags = in->flags;
2589 }
2590 #endif /* USE_STRUCT_CONVERSION */
2591
2592 #if defined(USE_STRUCT_CONVERSION)
2593 static inline const VkGeometryNV *convert_VkGeometryNV_array_win32_to_host(struct conversion_context *ctx, const VkGeometryNV32 *in, uint32_t count)
2594 {
2595     VkGeometryNV *out;
2596     unsigned int i;
2597
2598     if (!in || !count) return NULL;
2599
2600     out = conversion_context_alloc(ctx, count * sizeof(*out));
2601     for (i = 0; i < count; i++)
2602     {
2603         convert_VkGeometryNV_win32_to_host(&in[i], &out[i]);
2604     }
2605
2606     return out;
2607 }
2608 #endif /* USE_STRUCT_CONVERSION */
2609
2610 #if defined(USE_STRUCT_CONVERSION)
2611 static inline void convert_VkAccelerationStructureInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureInfoNV32 *in, VkAccelerationStructureInfoNV *out)
2612 {
2613     if (!in) return;
2614
2615     out->sType = in->sType;
2616     out->pNext = in->pNext;
2617     out->type = in->type;
2618     out->flags = in->flags;
2619     out->instanceCount = in->instanceCount;
2620     out->geometryCount = in->geometryCount;
2621     out->pGeometries = convert_VkGeometryNV_array_win32_to_host(ctx, in->pGeometries, in->geometryCount);
2622 }
2623 #endif /* USE_STRUCT_CONVERSION */
2624
2625 #if defined(USE_STRUCT_CONVERSION)
2626 static inline void convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(const VkCopyAccelerationStructureInfoKHR32 *in, VkCopyAccelerationStructureInfoKHR *out)
2627 {
2628     if (!in) return;
2629
2630     out->sType = in->sType;
2631     out->pNext = in->pNext;
2632     out->src = in->src;
2633     out->dst = in->dst;
2634     out->mode = in->mode;
2635 }
2636 #endif /* USE_STRUCT_CONVERSION */
2637
2638 #if defined(USE_STRUCT_CONVERSION)
2639 static inline void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(const VkCopyAccelerationStructureToMemoryInfoKHR32 *in, VkCopyAccelerationStructureToMemoryInfoKHR *out)
2640 {
2641     if (!in) return;
2642
2643     out->sType = in->sType;
2644     out->pNext = in->pNext;
2645     out->src = in->src;
2646     out->dst = in->dst;
2647     out->mode = in->mode;
2648 }
2649 #endif /* USE_STRUCT_CONVERSION */
2650
2651 #if defined(USE_STRUCT_CONVERSION)
2652 static inline void convert_VkBufferCopy_win32_to_host(const VkBufferCopy32 *in, VkBufferCopy *out)
2653 {
2654     if (!in) return;
2655
2656     out->srcOffset = in->srcOffset;
2657     out->dstOffset = in->dstOffset;
2658     out->size = in->size;
2659 }
2660 #endif /* USE_STRUCT_CONVERSION */
2661
2662 #if defined(USE_STRUCT_CONVERSION)
2663 static inline const VkBufferCopy *convert_VkBufferCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy32 *in, uint32_t count)
2664 {
2665     VkBufferCopy *out;
2666     unsigned int i;
2667
2668     if (!in || !count) return NULL;
2669
2670     out = conversion_context_alloc(ctx, count * sizeof(*out));
2671     for (i = 0; i < count; i++)
2672     {
2673         convert_VkBufferCopy_win32_to_host(&in[i], &out[i]);
2674     }
2675
2676     return out;
2677 }
2678 #endif /* USE_STRUCT_CONVERSION */
2679
2680 #if defined(USE_STRUCT_CONVERSION)
2681 static inline void convert_VkBufferCopy2_win32_to_host(const VkBufferCopy232 *in, VkBufferCopy2 *out)
2682 {
2683     if (!in) return;
2684
2685     out->sType = in->sType;
2686     out->pNext = in->pNext;
2687     out->srcOffset = in->srcOffset;
2688     out->dstOffset = in->dstOffset;
2689     out->size = in->size;
2690 }
2691 #endif /* USE_STRUCT_CONVERSION */
2692
2693 #if defined(USE_STRUCT_CONVERSION)
2694 static inline const VkBufferCopy2 *convert_VkBufferCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy232 *in, uint32_t count)
2695 {
2696     VkBufferCopy2 *out;
2697     unsigned int i;
2698
2699     if (!in || !count) return NULL;
2700
2701     out = conversion_context_alloc(ctx, count * sizeof(*out));
2702     for (i = 0; i < count; i++)
2703     {
2704         convert_VkBufferCopy2_win32_to_host(&in[i], &out[i]);
2705     }
2706
2707     return out;
2708 }
2709 #endif /* USE_STRUCT_CONVERSION */
2710
2711 #if defined(USE_STRUCT_CONVERSION)
2712 static inline void convert_VkCopyBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferInfo232 *in, VkCopyBufferInfo2 *out)
2713 {
2714     if (!in) return;
2715
2716     out->sType = in->sType;
2717     out->pNext = in->pNext;
2718     out->srcBuffer = in->srcBuffer;
2719     out->dstBuffer = in->dstBuffer;
2720     out->regionCount = in->regionCount;
2721     out->pRegions = convert_VkBufferCopy2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
2722 }
2723 #endif /* USE_STRUCT_CONVERSION */
2724
2725 #if defined(USE_STRUCT_CONVERSION)
2726 static inline void convert_VkBufferImageCopy_win32_to_host(const VkBufferImageCopy32 *in, VkBufferImageCopy *out)
2727 {
2728     if (!in) return;
2729
2730     out->bufferOffset = in->bufferOffset;
2731     out->bufferRowLength = in->bufferRowLength;
2732     out->bufferImageHeight = in->bufferImageHeight;
2733     out->imageSubresource = in->imageSubresource;
2734     out->imageOffset = in->imageOffset;
2735     out->imageExtent = in->imageExtent;
2736 }
2737 #endif /* USE_STRUCT_CONVERSION */
2738
2739 #if defined(USE_STRUCT_CONVERSION)
2740 static inline const VkBufferImageCopy *convert_VkBufferImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy32 *in, uint32_t count)
2741 {
2742     VkBufferImageCopy *out;
2743     unsigned int i;
2744
2745     if (!in || !count) return NULL;
2746
2747     out = conversion_context_alloc(ctx, count * sizeof(*out));
2748     for (i = 0; i < count; i++)
2749     {
2750         convert_VkBufferImageCopy_win32_to_host(&in[i], &out[i]);
2751     }
2752
2753     return out;
2754 }
2755 #endif /* USE_STRUCT_CONVERSION */
2756
2757 #if defined(USE_STRUCT_CONVERSION)
2758 static inline void convert_VkBufferImageCopy2_win32_to_host(const VkBufferImageCopy232 *in, VkBufferImageCopy2 *out)
2759 {
2760     if (!in) return;
2761
2762     out->sType = in->sType;
2763     out->pNext = in->pNext;
2764     out->bufferOffset = in->bufferOffset;
2765     out->bufferRowLength = in->bufferRowLength;
2766     out->bufferImageHeight = in->bufferImageHeight;
2767     out->imageSubresource = in->imageSubresource;
2768     out->imageOffset = in->imageOffset;
2769     out->imageExtent = in->imageExtent;
2770 }
2771 #endif /* USE_STRUCT_CONVERSION */
2772
2773 #if defined(USE_STRUCT_CONVERSION)
2774 static inline const VkBufferImageCopy2 *convert_VkBufferImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, uint32_t count)
2775 {
2776     VkBufferImageCopy2 *out;
2777     unsigned int i;
2778
2779     if (!in || !count) return NULL;
2780
2781     out = conversion_context_alloc(ctx, count * sizeof(*out));
2782     for (i = 0; i < count; i++)
2783     {
2784         convert_VkBufferImageCopy2_win32_to_host(&in[i], &out[i]);
2785     }
2786
2787     return out;
2788 }
2789 #endif /* USE_STRUCT_CONVERSION */
2790
2791 #if defined(USE_STRUCT_CONVERSION)
2792 static inline void convert_VkCopyBufferToImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferToImageInfo232 *in, VkCopyBufferToImageInfo2 *out)
2793 {
2794     if (!in) return;
2795
2796     out->sType = in->sType;
2797     out->pNext = in->pNext;
2798     out->srcBuffer = in->srcBuffer;
2799     out->dstImage = in->dstImage;
2800     out->dstImageLayout = in->dstImageLayout;
2801     out->regionCount = in->regionCount;
2802     out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
2803 }
2804 #endif /* USE_STRUCT_CONVERSION */
2805
2806 #if defined(USE_STRUCT_CONVERSION)
2807 static inline void convert_VkCopyImageInfo2_win32_to_host(const VkCopyImageInfo232 *in, VkCopyImageInfo2 *out)
2808 {
2809     if (!in) return;
2810
2811     out->sType = in->sType;
2812     out->pNext = in->pNext;
2813     out->srcImage = in->srcImage;
2814     out->srcImageLayout = in->srcImageLayout;
2815     out->dstImage = in->dstImage;
2816     out->dstImageLayout = in->dstImageLayout;
2817     out->regionCount = in->regionCount;
2818     out->pRegions = in->pRegions;
2819 }
2820 #endif /* USE_STRUCT_CONVERSION */
2821
2822 #if defined(USE_STRUCT_CONVERSION)
2823 static inline void convert_VkCopyImageToBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageToBufferInfo232 *in, VkCopyImageToBufferInfo2 *out)
2824 {
2825     if (!in) return;
2826
2827     out->sType = in->sType;
2828     out->pNext = in->pNext;
2829     out->srcImage = in->srcImage;
2830     out->srcImageLayout = in->srcImageLayout;
2831     out->dstBuffer = in->dstBuffer;
2832     out->regionCount = in->regionCount;
2833     out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
2834 }
2835 #endif /* USE_STRUCT_CONVERSION */
2836
2837 #if defined(USE_STRUCT_CONVERSION)
2838 static inline void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(const VkCopyMemoryToAccelerationStructureInfoKHR32 *in, VkCopyMemoryToAccelerationStructureInfoKHR *out)
2839 {
2840     if (!in) return;
2841
2842     out->sType = in->sType;
2843     out->pNext = in->pNext;
2844     out->src = in->src;
2845     out->dst = in->dst;
2846     out->mode = in->mode;
2847 }
2848 #endif /* USE_STRUCT_CONVERSION */
2849
2850 #if defined(USE_STRUCT_CONVERSION)
2851 static inline void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkCopyMemoryToMicromapInfoEXT32 *in, VkCopyMemoryToMicromapInfoEXT *out)
2852 {
2853     if (!in) return;
2854
2855     out->sType = in->sType;
2856     out->pNext = in->pNext;
2857     out->src = in->src;
2858     out->dst = in->dst;
2859     out->mode = in->mode;
2860 }
2861 #endif /* USE_STRUCT_CONVERSION */
2862
2863 #if defined(USE_STRUCT_CONVERSION)
2864 static inline void convert_VkCopyMicromapInfoEXT_win32_to_host(const VkCopyMicromapInfoEXT32 *in, VkCopyMicromapInfoEXT *out)
2865 {
2866     if (!in) return;
2867
2868     out->sType = in->sType;
2869     out->pNext = in->pNext;
2870     out->src = in->src;
2871     out->dst = in->dst;
2872     out->mode = in->mode;
2873 }
2874 #endif /* USE_STRUCT_CONVERSION */
2875
2876 #if defined(USE_STRUCT_CONVERSION)
2877 static inline void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkCopyMicromapToMemoryInfoEXT32 *in, VkCopyMicromapToMemoryInfoEXT *out)
2878 {
2879     if (!in) return;
2880
2881     out->sType = in->sType;
2882     out->pNext = in->pNext;
2883     out->src = in->src;
2884     out->dst = in->dst;
2885     out->mode = in->mode;
2886 }
2887 #endif /* USE_STRUCT_CONVERSION */
2888
2889 #if defined(USE_STRUCT_CONVERSION)
2890 static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoNVX32 *in, VkCuLaunchInfoNVX *out)
2891 {
2892     if (!in) return;
2893
2894     out->sType = in->sType;
2895     out->pNext = in->pNext;
2896     out->function = in->function;
2897     out->gridDimX = in->gridDimX;
2898     out->gridDimY = in->gridDimY;
2899     out->gridDimZ = in->gridDimZ;
2900     out->blockDimX = in->blockDimX;
2901     out->blockDimY = in->blockDimY;
2902     out->blockDimZ = in->blockDimZ;
2903     out->sharedMemBytes = in->sharedMemBytes;
2904     out->paramCount = in->paramCount;
2905     out->pParams = in->pParams;
2906     out->extraCount = in->extraCount;
2907     out->pExtras = in->pExtras;
2908 }
2909 #endif /* USE_STRUCT_CONVERSION */
2910
2911 #if defined(USE_STRUCT_CONVERSION)
2912 static inline void convert_VkDecompressMemoryRegionNV_win32_to_host(const VkDecompressMemoryRegionNV32 *in, VkDecompressMemoryRegionNV *out)
2913 {
2914     if (!in) return;
2915
2916     out->srcAddress = in->srcAddress;
2917     out->dstAddress = in->dstAddress;
2918     out->compressedSize = in->compressedSize;
2919     out->decompressedSize = in->decompressedSize;
2920     out->decompressionMethod = in->decompressionMethod;
2921 }
2922 #endif /* USE_STRUCT_CONVERSION */
2923
2924 #if defined(USE_STRUCT_CONVERSION)
2925 static inline const VkDecompressMemoryRegionNV *convert_VkDecompressMemoryRegionNV_array_win32_to_host(struct conversion_context *ctx, const VkDecompressMemoryRegionNV32 *in, uint32_t count)
2926 {
2927     VkDecompressMemoryRegionNV *out;
2928     unsigned int i;
2929
2930     if (!in || !count) return NULL;
2931
2932     out = conversion_context_alloc(ctx, count * sizeof(*out));
2933     for (i = 0; i < count; i++)
2934     {
2935         convert_VkDecompressMemoryRegionNV_win32_to_host(&in[i], &out[i]);
2936     }
2937
2938     return out;
2939 }
2940 #endif /* USE_STRUCT_CONVERSION */
2941
2942 #if !defined(USE_STRUCT_CONVERSION)
2943 static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win64_to_host(struct conversion_context *ctx, const VkCommandBuffer *in, uint32_t count)
2944 {
2945     VkCommandBuffer *out;
2946     unsigned int i;
2947
2948     if (!in || !count) return NULL;
2949
2950     out = conversion_context_alloc(ctx, count * sizeof(*out));
2951     for (i = 0; i < count; i++)
2952     {
2953         out[i] = wine_cmd_buffer_from_handle(in[i])->command_buffer;
2954     }
2955
2956     return out;
2957 }
2958 #endif /* USE_STRUCT_CONVERSION */
2959
2960 #if defined(USE_STRUCT_CONVERSION)
2961 static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host(struct conversion_context *ctx, const VkCommandBuffer *in, uint32_t count)
2962 {
2963     VkCommandBuffer *out;
2964     unsigned int i;
2965
2966     if (!in || !count) return NULL;
2967
2968     out = conversion_context_alloc(ctx, count * sizeof(*out));
2969     for (i = 0; i < count; i++)
2970     {
2971         out[i] = wine_cmd_buffer_from_handle(in[i])->command_buffer;
2972     }
2973
2974     return out;
2975 }
2976 #endif /* USE_STRUCT_CONVERSION */
2977
2978 #if defined(USE_STRUCT_CONVERSION)
2979 static inline void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndirectCommandsStreamNV32 *in, VkIndirectCommandsStreamNV *out)
2980 {
2981     if (!in) return;
2982
2983     out->buffer = in->buffer;
2984     out->offset = in->offset;
2985 }
2986 #endif /* USE_STRUCT_CONVERSION */
2987
2988 #if defined(USE_STRUCT_CONVERSION)
2989 static inline const VkIndirectCommandsStreamNV *convert_VkIndirectCommandsStreamNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsStreamNV32 *in, uint32_t count)
2990 {
2991     VkIndirectCommandsStreamNV *out;
2992     unsigned int i;
2993
2994     if (!in || !count) return NULL;
2995
2996     out = conversion_context_alloc(ctx, count * sizeof(*out));
2997     for (i = 0; i < count; i++)
2998     {
2999         convert_VkIndirectCommandsStreamNV_win32_to_host(&in[i], &out[i]);
3000     }
3001
3002     return out;
3003 }
3004 #endif /* USE_STRUCT_CONVERSION */
3005
3006 #if defined(USE_STRUCT_CONVERSION)
3007 static inline void convert_VkGeneratedCommandsInfoNV_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoNV32 *in, VkGeneratedCommandsInfoNV *out)
3008 {
3009     if (!in) return;
3010
3011     out->sType = in->sType;
3012     out->pNext = in->pNext;
3013     out->pipelineBindPoint = in->pipelineBindPoint;
3014     out->pipeline = in->pipeline;
3015     out->indirectCommandsLayout = in->indirectCommandsLayout;
3016     out->streamCount = in->streamCount;
3017     out->pStreams = convert_VkIndirectCommandsStreamNV_array_win32_to_host(ctx, in->pStreams, in->streamCount);
3018     out->sequencesCount = in->sequencesCount;
3019     out->preprocessBuffer = in->preprocessBuffer;
3020     out->preprocessOffset = in->preprocessOffset;
3021     out->preprocessSize = in->preprocessSize;
3022     out->sequencesCountBuffer = in->sequencesCountBuffer;
3023     out->sequencesCountOffset = in->sequencesCountOffset;
3024     out->sequencesIndexBuffer = in->sequencesIndexBuffer;
3025     out->sequencesIndexOffset = in->sequencesIndexOffset;
3026 }
3027 #endif /* USE_STRUCT_CONVERSION */
3028
3029 #if defined(USE_STRUCT_CONVERSION)
3030 static inline void convert_VkBufferMemoryBarrier_win32_to_host(const VkBufferMemoryBarrier32 *in, VkBufferMemoryBarrier *out)
3031 {
3032     if (!in) return;
3033
3034     out->sType = in->sType;
3035     out->pNext = in->pNext;
3036     out->srcAccessMask = in->srcAccessMask;
3037     out->dstAccessMask = in->dstAccessMask;
3038     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
3039     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
3040     out->buffer = in->buffer;
3041     out->offset = in->offset;
3042     out->size = in->size;
3043 }
3044 #endif /* USE_STRUCT_CONVERSION */
3045
3046 #if defined(USE_STRUCT_CONVERSION)
3047 static inline const VkBufferMemoryBarrier *convert_VkBufferMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, uint32_t count)
3048 {
3049     VkBufferMemoryBarrier *out;
3050     unsigned int i;
3051
3052     if (!in || !count) return NULL;
3053
3054     out = conversion_context_alloc(ctx, count * sizeof(*out));
3055     for (i = 0; i < count; i++)
3056     {
3057         convert_VkBufferMemoryBarrier_win32_to_host(&in[i], &out[i]);
3058     }
3059
3060     return out;
3061 }
3062 #endif /* USE_STRUCT_CONVERSION */
3063
3064 #if defined(USE_STRUCT_CONVERSION)
3065 static inline void convert_VkImageMemoryBarrier_win32_to_host(const VkImageMemoryBarrier32 *in, VkImageMemoryBarrier *out)
3066 {
3067     if (!in) return;
3068
3069     out->sType = in->sType;
3070     out->pNext = in->pNext;
3071     out->srcAccessMask = in->srcAccessMask;
3072     out->dstAccessMask = in->dstAccessMask;
3073     out->oldLayout = in->oldLayout;
3074     out->newLayout = in->newLayout;
3075     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
3076     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
3077     out->image = in->image;
3078     out->subresourceRange = in->subresourceRange;
3079 }
3080 #endif /* USE_STRUCT_CONVERSION */
3081
3082 #if defined(USE_STRUCT_CONVERSION)
3083 static inline const VkImageMemoryBarrier *convert_VkImageMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, uint32_t count)
3084 {
3085     VkImageMemoryBarrier *out;
3086     unsigned int i;
3087
3088     if (!in || !count) return NULL;
3089
3090     out = conversion_context_alloc(ctx, count * sizeof(*out));
3091     for (i = 0; i < count; i++)
3092     {
3093         convert_VkImageMemoryBarrier_win32_to_host(&in[i], &out[i]);
3094     }
3095
3096     return out;
3097 }
3098 #endif /* USE_STRUCT_CONVERSION */
3099
3100 #if defined(USE_STRUCT_CONVERSION)
3101 static inline void convert_VkBufferMemoryBarrier2_win32_to_host(const VkBufferMemoryBarrier232 *in, VkBufferMemoryBarrier2 *out)
3102 {
3103     if (!in) return;
3104
3105     out->sType = in->sType;
3106     out->pNext = in->pNext;
3107     out->srcStageMask = in->srcStageMask;
3108     out->srcAccessMask = in->srcAccessMask;
3109     out->dstStageMask = in->dstStageMask;
3110     out->dstAccessMask = in->dstAccessMask;
3111     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
3112     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
3113     out->buffer = in->buffer;
3114     out->offset = in->offset;
3115     out->size = in->size;
3116 }
3117 #endif /* USE_STRUCT_CONVERSION */
3118
3119 #if defined(USE_STRUCT_CONVERSION)
3120 static inline const VkBufferMemoryBarrier2 *convert_VkBufferMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, uint32_t count)
3121 {
3122     VkBufferMemoryBarrier2 *out;
3123     unsigned int i;
3124
3125     if (!in || !count) return NULL;
3126
3127     out = conversion_context_alloc(ctx, count * sizeof(*out));
3128     for (i = 0; i < count; i++)
3129     {
3130         convert_VkBufferMemoryBarrier2_win32_to_host(&in[i], &out[i]);
3131     }
3132
3133     return out;
3134 }
3135 #endif /* USE_STRUCT_CONVERSION */
3136
3137 #if defined(USE_STRUCT_CONVERSION)
3138 static inline void convert_VkImageMemoryBarrier2_win32_to_host(const VkImageMemoryBarrier232 *in, VkImageMemoryBarrier2 *out)
3139 {
3140     if (!in) return;
3141
3142     out->sType = in->sType;
3143     out->pNext = in->pNext;
3144     out->srcStageMask = in->srcStageMask;
3145     out->srcAccessMask = in->srcAccessMask;
3146     out->dstStageMask = in->dstStageMask;
3147     out->dstAccessMask = in->dstAccessMask;
3148     out->oldLayout = in->oldLayout;
3149     out->newLayout = in->newLayout;
3150     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
3151     out->dstQueueFamilyIndex = in->dstQueueFamilyIndex;
3152     out->image = in->image;
3153     out->subresourceRange = in->subresourceRange;
3154 }
3155 #endif /* USE_STRUCT_CONVERSION */
3156
3157 #if defined(USE_STRUCT_CONVERSION)
3158 static inline const VkImageMemoryBarrier2 *convert_VkImageMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, uint32_t count)
3159 {
3160     VkImageMemoryBarrier2 *out;
3161     unsigned int i;
3162
3163     if (!in || !count) return NULL;
3164
3165     out = conversion_context_alloc(ctx, count * sizeof(*out));
3166     for (i = 0; i < count; i++)
3167     {
3168         convert_VkImageMemoryBarrier2_win32_to_host(&in[i], &out[i]);
3169     }
3170
3171     return out;
3172 }
3173 #endif /* USE_STRUCT_CONVERSION */
3174
3175 #if defined(USE_STRUCT_CONVERSION)
3176 static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, VkDependencyInfo *out)
3177 {
3178     if (!in) return;
3179
3180     out->sType = in->sType;
3181     out->pNext = in->pNext;
3182     out->dependencyFlags = in->dependencyFlags;
3183     out->memoryBarrierCount = in->memoryBarrierCount;
3184     out->pMemoryBarriers = in->pMemoryBarriers;
3185     out->bufferMemoryBarrierCount = in->bufferMemoryBarrierCount;
3186     out->pBufferMemoryBarriers = convert_VkBufferMemoryBarrier2_array_win32_to_host(ctx, in->pBufferMemoryBarriers, in->bufferMemoryBarrierCount);
3187     out->imageMemoryBarrierCount = in->imageMemoryBarrierCount;
3188     out->pImageMemoryBarriers = convert_VkImageMemoryBarrier2_array_win32_to_host(ctx, in->pImageMemoryBarriers, in->imageMemoryBarrierCount);
3189 }
3190 #endif /* USE_STRUCT_CONVERSION */
3191
3192 #if defined(USE_STRUCT_CONVERSION)
3193 static inline void convert_VkDescriptorImageInfo_win32_to_host(const VkDescriptorImageInfo32 *in, VkDescriptorImageInfo *out)
3194 {
3195     if (!in) return;
3196
3197     out->sampler = in->sampler;
3198     out->imageView = in->imageView;
3199     out->imageLayout = in->imageLayout;
3200 }
3201 #endif /* USE_STRUCT_CONVERSION */
3202
3203 #if defined(USE_STRUCT_CONVERSION)
3204 static inline const VkDescriptorImageInfo *convert_VkDescriptorImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorImageInfo32 *in, uint32_t count)
3205 {
3206     VkDescriptorImageInfo *out;
3207     unsigned int i;
3208
3209     if (!in || !count) return NULL;
3210
3211     out = conversion_context_alloc(ctx, count * sizeof(*out));
3212     for (i = 0; i < count; i++)
3213     {
3214         convert_VkDescriptorImageInfo_win32_to_host(&in[i], &out[i]);
3215     }
3216
3217     return out;
3218 }
3219 #endif /* USE_STRUCT_CONVERSION */
3220
3221 #if defined(USE_STRUCT_CONVERSION)
3222 static inline void convert_VkDescriptorBufferInfo_win32_to_host(const VkDescriptorBufferInfo32 *in, VkDescriptorBufferInfo *out)
3223 {
3224     if (!in) return;
3225
3226     out->buffer = in->buffer;
3227     out->offset = in->offset;
3228     out->range = in->range;
3229 }
3230 #endif /* USE_STRUCT_CONVERSION */
3231
3232 #if defined(USE_STRUCT_CONVERSION)
3233 static inline const VkDescriptorBufferInfo *convert_VkDescriptorBufferInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferInfo32 *in, uint32_t count)
3234 {
3235     VkDescriptorBufferInfo *out;
3236     unsigned int i;
3237
3238     if (!in || !count) return NULL;
3239
3240     out = conversion_context_alloc(ctx, count * sizeof(*out));
3241     for (i = 0; i < count; i++)
3242     {
3243         convert_VkDescriptorBufferInfo_win32_to_host(&in[i], &out[i]);
3244     }
3245
3246     return out;
3247 }
3248 #endif /* USE_STRUCT_CONVERSION */
3249
3250 #if defined(USE_STRUCT_CONVERSION)
3251 static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, VkWriteDescriptorSet *out)
3252 {
3253     if (!in) return;
3254
3255     out->sType = in->sType;
3256     out->pNext = in->pNext;
3257     out->dstSet = in->dstSet;
3258     out->dstBinding = in->dstBinding;
3259     out->dstArrayElement = in->dstArrayElement;
3260     out->descriptorCount = in->descriptorCount;
3261     out->descriptorType = in->descriptorType;
3262     out->pImageInfo = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, in->pImageInfo, in->descriptorCount);
3263     out->pBufferInfo = convert_VkDescriptorBufferInfo_array_win32_to_host(ctx, in->pBufferInfo, in->descriptorCount);
3264     out->pTexelBufferView = in->pTexelBufferView;
3265 }
3266 #endif /* USE_STRUCT_CONVERSION */
3267
3268 #if defined(USE_STRUCT_CONVERSION)
3269 static inline const VkWriteDescriptorSet *convert_VkWriteDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, uint32_t count)
3270 {
3271     VkWriteDescriptorSet *out;
3272     unsigned int i;
3273
3274     if (!in || !count) return NULL;
3275
3276     out = conversion_context_alloc(ctx, count * sizeof(*out));
3277     for (i = 0; i < count; i++)
3278     {
3279         convert_VkWriteDescriptorSet_win32_to_host(ctx, &in[i], &out[i]);
3280     }
3281
3282     return out;
3283 }
3284 #endif /* USE_STRUCT_CONVERSION */
3285
3286 #if defined(USE_STRUCT_CONVERSION)
3287 static inline void convert_VkResolveImageInfo2_win32_to_host(const VkResolveImageInfo232 *in, VkResolveImageInfo2 *out)
3288 {
3289     if (!in) return;
3290
3291     out->sType = in->sType;
3292     out->pNext = in->pNext;
3293     out->srcImage = in->srcImage;
3294     out->srcImageLayout = in->srcImageLayout;
3295     out->dstImage = in->dstImage;
3296     out->dstImageLayout = in->dstImageLayout;
3297     out->regionCount = in->regionCount;
3298     out->pRegions = in->pRegions;
3299 }
3300 #endif /* USE_STRUCT_CONVERSION */
3301
3302 #if defined(USE_STRUCT_CONVERSION)
3303 static inline void convert_VkPerformanceMarkerInfoINTEL_win32_to_host(const VkPerformanceMarkerInfoINTEL32 *in, VkPerformanceMarkerInfoINTEL *out)
3304 {
3305     if (!in) return;
3306
3307     out->sType = in->sType;
3308     out->pNext = in->pNext;
3309     out->marker = in->marker;
3310 }
3311 #endif /* USE_STRUCT_CONVERSION */
3312
3313 #if defined(USE_STRUCT_CONVERSION)
3314 static inline void convert_VkPerformanceOverrideInfoINTEL_win32_to_host(const VkPerformanceOverrideInfoINTEL32 *in, VkPerformanceOverrideInfoINTEL *out)
3315 {
3316     if (!in) return;
3317
3318     out->sType = in->sType;
3319     out->pNext = in->pNext;
3320     out->type = in->type;
3321     out->enable = in->enable;
3322     out->parameter = in->parameter;
3323 }
3324 #endif /* USE_STRUCT_CONVERSION */
3325
3326 #if defined(USE_STRUCT_CONVERSION)
3327 static inline void convert_VkStridedDeviceAddressRegionKHR_win32_to_host(const VkStridedDeviceAddressRegionKHR32 *in, VkStridedDeviceAddressRegionKHR *out)
3328 {
3329     if (!in) return;
3330
3331     out->deviceAddress = in->deviceAddress;
3332     out->stride = in->stride;
3333     out->size = in->size;
3334 }
3335 #endif /* USE_STRUCT_CONVERSION */
3336
3337 #if defined(USE_STRUCT_CONVERSION)
3338 static inline const VkDependencyInfo *convert_VkDependencyInfo_array_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, uint32_t count)
3339 {
3340     VkDependencyInfo *out;
3341     unsigned int i;
3342
3343     if (!in || !count) return NULL;
3344
3345     out = conversion_context_alloc(ctx, count * sizeof(*out));
3346     for (i = 0; i < count; i++)
3347     {
3348         convert_VkDependencyInfo_win32_to_host(ctx, &in[i], &out[i]);
3349     }
3350
3351     return out;
3352 }
3353 #endif /* USE_STRUCT_CONVERSION */
3354
3355 #if defined(USE_STRUCT_CONVERSION)
3356 static inline void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(const VkAccelerationStructureCreateInfoKHR32 *in, VkAccelerationStructureCreateInfoKHR *out)
3357 {
3358     if (!in) return;
3359
3360     out->sType = in->sType;
3361     out->pNext = in->pNext;
3362     out->createFlags = in->createFlags;
3363     out->buffer = in->buffer;
3364     out->offset = in->offset;
3365     out->size = in->size;
3366     out->type = in->type;
3367     out->deviceAddress = in->deviceAddress;
3368 }
3369 #endif /* USE_STRUCT_CONVERSION */
3370
3371 #if defined(USE_STRUCT_CONVERSION)
3372 static inline void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoNV32 *in, VkAccelerationStructureCreateInfoNV *out)
3373 {
3374     if (!in) return;
3375
3376     out->sType = in->sType;
3377     out->pNext = in->pNext;
3378     out->compactedSize = in->compactedSize;
3379     convert_VkAccelerationStructureInfoNV_win32_to_host(ctx, &in->info, &out->info);
3380 }
3381 #endif /* USE_STRUCT_CONVERSION */
3382
3383 #if defined(USE_STRUCT_CONVERSION)
3384 static inline void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, VkBufferCreateInfo *out)
3385 {
3386     const VkBaseInStructure *in_header;
3387     VkBaseOutStructure *out_header = (void *)out;
3388
3389     if (!in) return;
3390
3391     out->sType = in->sType;
3392     out->pNext = NULL;
3393     out->flags = in->flags;
3394     out->size = in->size;
3395     out->usage = in->usage;
3396     out->sharingMode = in->sharingMode;
3397     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
3398     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
3399
3400     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
3401     {
3402         switch (in_header->sType)
3403         {
3404         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
3405         {
3406             VkDedicatedAllocationBufferCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3407             const VkDedicatedAllocationBufferCreateInfoNV *in_ext = (const VkDedicatedAllocationBufferCreateInfoNV *)in_header;
3408             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV;
3409             out_ext->pNext = NULL;
3410             out_ext->dedicatedAllocation = in_ext->dedicatedAllocation;
3411             out_header->pNext = (void *)out_ext;
3412             out_header = (void *)out_ext;
3413             break;
3414         }
3415         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
3416         {
3417             VkExternalMemoryBufferCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3418             const VkExternalMemoryBufferCreateInfo *in_ext = (const VkExternalMemoryBufferCreateInfo *)in_header;
3419             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
3420             out_ext->pNext = NULL;
3421             out_ext->handleTypes = in_ext->handleTypes;
3422             out_header->pNext = (void *)out_ext;
3423             out_header = (void *)out_ext;
3424             break;
3425         }
3426         case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
3427         {
3428             VkBufferOpaqueCaptureAddressCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3429             const VkBufferOpaqueCaptureAddressCreateInfo32 *in_ext = (const VkBufferOpaqueCaptureAddressCreateInfo32 *)in_header;
3430             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
3431             out_ext->pNext = NULL;
3432             out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress;
3433             out_header->pNext = (void *)out_ext;
3434             out_header = (void *)out_ext;
3435             break;
3436         }
3437         case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
3438         {
3439             VkBufferDeviceAddressCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3440             const VkBufferDeviceAddressCreateInfoEXT32 *in_ext = (const VkBufferDeviceAddressCreateInfoEXT32 *)in_header;
3441             out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT;
3442             out_ext->pNext = NULL;
3443             out_ext->deviceAddress = in_ext->deviceAddress;
3444             out_header->pNext = (void *)out_ext;
3445             out_header = (void *)out_ext;
3446             break;
3447         }
3448         default:
3449             FIXME("Unhandled sType %u.", in_header->sType);
3450             break;
3451         }
3452     }
3453 }
3454 #endif /* USE_STRUCT_CONVERSION */
3455
3456 #if defined(USE_STRUCT_CONVERSION)
3457 static inline void convert_VkBufferViewCreateInfo_win32_to_host(const VkBufferViewCreateInfo32 *in, VkBufferViewCreateInfo *out)
3458 {
3459     if (!in) return;
3460
3461     out->sType = in->sType;
3462     out->pNext = in->pNext;
3463     out->flags = in->flags;
3464     out->buffer = in->buffer;
3465     out->format = in->format;
3466     out->offset = in->offset;
3467     out->range = in->range;
3468 }
3469 #endif /* USE_STRUCT_CONVERSION */
3470
3471 #if defined(USE_STRUCT_CONVERSION)
3472 static inline void convert_VkPipelineCreationFeedback_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out)
3473 {
3474     if (!in) return;
3475
3476     out->flags = in->flags;
3477     out->duration = in->duration;
3478 }
3479 #endif /* USE_STRUCT_CONVERSION */
3480
3481 #if defined(USE_STRUCT_CONVERSION)
3482 static inline VkPipelineCreationFeedback *convert_VkPipelineCreationFeedback_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreationFeedback32 *in, uint32_t count)
3483 {
3484     VkPipelineCreationFeedback *out;
3485     if (!in || !count) return NULL;
3486
3487     out = conversion_context_alloc(ctx, count * sizeof(*out));
3488
3489     return out;
3490 }
3491 #endif /* USE_STRUCT_CONVERSION */
3492
3493 #if defined(USE_STRUCT_CONVERSION)
3494 static inline void convert_VkPipelineCreationFeedback_array_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out, uint32_t count)
3495 {
3496     unsigned int i;
3497
3498     if (!in) return;
3499
3500     for (i = 0; i < count; i++)
3501     {
3502         convert_VkPipelineCreationFeedback_host_to_win32(&in[i], &out[i]);
3503     }
3504 }
3505 #endif /* USE_STRUCT_CONVERSION */
3506
3507 #if !defined(USE_STRUCT_CONVERSION)
3508 static inline void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo *out)
3509 {
3510     const VkBaseInStructure *in_header;
3511     VkBaseOutStructure *out_header = (void *)out;
3512
3513     if (!in) return;
3514
3515     out->sType = in->sType;
3516     out->pNext = NULL;
3517     out->flags = in->flags;
3518     out->stage = in->stage;
3519     out->module = in->module;
3520     out->pName = in->pName;
3521     out->pSpecializationInfo = in->pSpecializationInfo;
3522
3523     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
3524     {
3525         switch (in_header->sType)
3526         {
3527         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
3528         {
3529             VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3530             const VkShaderModuleCreateInfo *in_ext = (const VkShaderModuleCreateInfo *)in_header;
3531             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
3532             out_ext->pNext = NULL;
3533             out_ext->flags = in_ext->flags;
3534             out_ext->codeSize = in_ext->codeSize;
3535             out_ext->pCode = in_ext->pCode;
3536             out_header->pNext = (void *)out_ext;
3537             out_header = (void *)out_ext;
3538             break;
3539         }
3540         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
3541         {
3542             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3543             const VkShaderModuleValidationCacheCreateInfoEXT *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT *)in_header;
3544             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
3545             out_ext->pNext = NULL;
3546             out_ext->validationCache = in_ext->validationCache;
3547             out_header->pNext = (void *)out_ext;
3548             out_header = (void *)out_ext;
3549             break;
3550         }
3551         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
3552         {
3553             VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3554             const VkDebugUtilsObjectNameInfoEXT *in_ext = (const VkDebugUtilsObjectNameInfoEXT *)in_header;
3555             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
3556             out_ext->pNext = NULL;
3557             out_ext->objectType = in_ext->objectType;
3558             out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
3559             out_ext->pObjectName = in_ext->pObjectName;
3560             out_header->pNext = (void *)out_ext;
3561             out_header = (void *)out_ext;
3562             break;
3563         }
3564         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
3565         {
3566             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3567             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)in_header;
3568             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
3569             out_ext->pNext = NULL;
3570             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
3571             out_header->pNext = (void *)out_ext;
3572             out_header = (void *)out_ext;
3573             break;
3574         }
3575         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
3576         {
3577             VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3578             const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *)in_header;
3579             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
3580             out_ext->pNext = NULL;
3581             out_ext->identifierSize = in_ext->identifierSize;
3582             out_ext->pIdentifier = in_ext->pIdentifier;
3583             out_header->pNext = (void *)out_ext;
3584             out_header = (void *)out_ext;
3585             break;
3586         }
3587         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
3588         {
3589             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3590             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
3591             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
3592             out_ext->pNext = NULL;
3593             out_ext->storageBuffers = in_ext->storageBuffers;
3594             out_ext->uniformBuffers = in_ext->uniformBuffers;
3595             out_ext->vertexInputs = in_ext->vertexInputs;
3596             out_ext->images = in_ext->images;
3597             out_header->pNext = (void *)out_ext;
3598             out_header = (void *)out_ext;
3599             break;
3600         }
3601         default:
3602             FIXME("Unhandled sType %u.", in_header->sType);
3603             break;
3604         }
3605     }
3606 }
3607 #endif /* USE_STRUCT_CONVERSION */
3608
3609 #if defined(USE_STRUCT_CONVERSION)
3610 static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, VkPipelineShaderStageCreateInfo *out)
3611 {
3612     const VkBaseInStructure *in_header;
3613     VkBaseOutStructure *out_header = (void *)out;
3614
3615     if (!in) return;
3616
3617     out->sType = in->sType;
3618     out->pNext = NULL;
3619     out->flags = in->flags;
3620     out->stage = in->stage;
3621     out->module = in->module;
3622     out->pName = in->pName;
3623     out->pSpecializationInfo = in->pSpecializationInfo;
3624
3625     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
3626     {
3627         switch (in_header->sType)
3628         {
3629         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
3630         {
3631             VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3632             const VkShaderModuleCreateInfo *in_ext = (const VkShaderModuleCreateInfo *)in_header;
3633             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
3634             out_ext->pNext = NULL;
3635             out_ext->flags = in_ext->flags;
3636             out_ext->codeSize = in_ext->codeSize;
3637             out_ext->pCode = in_ext->pCode;
3638             out_header->pNext = (void *)out_ext;
3639             out_header = (void *)out_ext;
3640             break;
3641         }
3642         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
3643         {
3644             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3645             const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
3646             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
3647             out_ext->pNext = NULL;
3648             out_ext->validationCache = in_ext->validationCache;
3649             out_header->pNext = (void *)out_ext;
3650             out_header = (void *)out_ext;
3651             break;
3652         }
3653         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
3654         {
3655             VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3656             const VkDebugUtilsObjectNameInfoEXT32 *in_ext = (const VkDebugUtilsObjectNameInfoEXT32 *)in_header;
3657             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
3658             out_ext->pNext = NULL;
3659             out_ext->objectType = in_ext->objectType;
3660             out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
3661             out_ext->pObjectName = in_ext->pObjectName;
3662             out_header->pNext = (void *)out_ext;
3663             out_header = (void *)out_ext;
3664             break;
3665         }
3666         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
3667         {
3668             VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3669             const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)in_header;
3670             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
3671             out_ext->pNext = NULL;
3672             out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize;
3673             out_header->pNext = (void *)out_ext;
3674             out_header = (void *)out_ext;
3675             break;
3676         }
3677         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
3678         {
3679             VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3680             const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *)in_header;
3681             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
3682             out_ext->pNext = NULL;
3683             out_ext->identifierSize = in_ext->identifierSize;
3684             out_ext->pIdentifier = in_ext->pIdentifier;
3685             out_header->pNext = (void *)out_ext;
3686             out_header = (void *)out_ext;
3687             break;
3688         }
3689         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
3690         {
3691             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3692             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
3693             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
3694             out_ext->pNext = NULL;
3695             out_ext->storageBuffers = in_ext->storageBuffers;
3696             out_ext->uniformBuffers = in_ext->uniformBuffers;
3697             out_ext->vertexInputs = in_ext->vertexInputs;
3698             out_ext->images = in_ext->images;
3699             out_header->pNext = (void *)out_ext;
3700             out_header = (void *)out_ext;
3701             break;
3702         }
3703         default:
3704             FIXME("Unhandled sType %u.", in_header->sType);
3705             break;
3706         }
3707     }
3708 }
3709 #endif /* USE_STRUCT_CONVERSION */
3710
3711 #if !defined(USE_STRUCT_CONVERSION)
3712 static inline void convert_VkComputePipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, VkComputePipelineCreateInfo *out)
3713 {
3714     if (!in) return;
3715
3716     out->sType = in->sType;
3717     out->pNext = in->pNext;
3718     out->flags = in->flags;
3719     convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in->stage, &out->stage);
3720     out->layout = in->layout;
3721     out->basePipelineHandle = in->basePipelineHandle;
3722     out->basePipelineIndex = in->basePipelineIndex;
3723 }
3724 #endif /* USE_STRUCT_CONVERSION */
3725
3726 #if defined(USE_STRUCT_CONVERSION)
3727 static inline void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, VkComputePipelineCreateInfo *out)
3728 {
3729     const VkBaseInStructure *in_header;
3730     VkBaseOutStructure *out_header = (void *)out;
3731
3732     if (!in) return;
3733
3734     out->sType = in->sType;
3735     out->pNext = NULL;
3736     out->flags = in->flags;
3737     convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in->stage, &out->stage);
3738     out->layout = in->layout;
3739     out->basePipelineHandle = in->basePipelineHandle;
3740     out->basePipelineIndex = in->basePipelineIndex;
3741
3742     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
3743     {
3744         switch (in_header->sType)
3745         {
3746         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
3747         {
3748             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3749             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
3750             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
3751             out_ext->pNext = NULL;
3752             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineCreationFeedback, 1);
3753             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
3754             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
3755             out_header->pNext = (void *)out_ext;
3756             out_header = (void *)out_ext;
3757             break;
3758         }
3759         case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
3760         {
3761             VkSubpassShadingPipelineCreateInfoHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3762             const VkSubpassShadingPipelineCreateInfoHUAWEI32 *in_ext = (const VkSubpassShadingPipelineCreateInfoHUAWEI32 *)in_header;
3763             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI;
3764             out_ext->pNext = NULL;
3765             out_ext->renderPass = in_ext->renderPass;
3766             out_ext->subpass = in_ext->subpass;
3767             out_header->pNext = (void *)out_ext;
3768             out_header = (void *)out_ext;
3769             break;
3770         }
3771         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
3772         {
3773             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3774             const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header;
3775             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
3776             out_ext->pNext = NULL;
3777             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
3778             out_header->pNext = (void *)out_ext;
3779             out_header = (void *)out_ext;
3780             break;
3781         }
3782         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
3783         {
3784             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3785             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
3786             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
3787             out_ext->pNext = NULL;
3788             out_ext->storageBuffers = in_ext->storageBuffers;
3789             out_ext->uniformBuffers = in_ext->uniformBuffers;
3790             out_ext->vertexInputs = in_ext->vertexInputs;
3791             out_ext->images = in_ext->images;
3792             out_header->pNext = (void *)out_ext;
3793             out_header = (void *)out_ext;
3794             break;
3795         }
3796         default:
3797             FIXME("Unhandled sType %u.", in_header->sType);
3798             break;
3799         }
3800     }
3801 }
3802 #endif /* USE_STRUCT_CONVERSION */
3803
3804 #if defined(USE_STRUCT_CONVERSION)
3805 static inline void convert_VkComputePipelineCreateInfo_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out)
3806 {
3807     const VkBaseInStructure *in_header;
3808     VkBaseOutStructure *out_header = (void *)out;
3809
3810     if (!in) return;
3811
3812
3813     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
3814     {
3815         switch (in_header->sType)
3816         {
3817         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
3818         {
3819             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
3820             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
3821             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
3822             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, out_ext->pPipelineCreationFeedback, 1);
3823             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, out_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
3824             out_header = (void *)out_ext;
3825             break;
3826         }
3827         default:
3828             break;
3829         }
3830     }
3831 }
3832 #endif /* USE_STRUCT_CONVERSION */
3833
3834 #if !defined(USE_STRUCT_CONVERSION)
3835 static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, uint32_t count)
3836 {
3837     VkComputePipelineCreateInfo *out;
3838     unsigned int i;
3839
3840     if (!in || !count) return NULL;
3841
3842     out = conversion_context_alloc(ctx, count * sizeof(*out));
3843     for (i = 0; i < count; i++)
3844     {
3845         convert_VkComputePipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
3846     }
3847
3848     return out;
3849 }
3850 #endif /* USE_STRUCT_CONVERSION */
3851
3852 #if defined(USE_STRUCT_CONVERSION)
3853 static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, uint32_t count)
3854 {
3855     VkComputePipelineCreateInfo *out;
3856     unsigned int i;
3857
3858     if (!in || !count) return NULL;
3859
3860     out = conversion_context_alloc(ctx, count * sizeof(*out));
3861     for (i = 0; i < count; i++)
3862     {
3863         convert_VkComputePipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
3864     }
3865
3866     return out;
3867 }
3868 #endif /* USE_STRUCT_CONVERSION */
3869
3870 #if defined(USE_STRUCT_CONVERSION)
3871 static inline void convert_VkComputePipelineCreateInfo_array_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out, uint32_t count)
3872 {
3873     unsigned int i;
3874
3875     if (!in) return;
3876
3877     for (i = 0; i < count; i++)
3878     {
3879         convert_VkComputePipelineCreateInfo_host_to_win32(&in[i], &out[i]);
3880     }
3881 }
3882 #endif /* USE_STRUCT_CONVERSION */
3883
3884 #if defined(USE_STRUCT_CONVERSION)
3885 static inline void convert_VkCuFunctionCreateInfoNVX_win32_to_host(const VkCuFunctionCreateInfoNVX32 *in, VkCuFunctionCreateInfoNVX *out)
3886 {
3887     if (!in) return;
3888
3889     out->sType = in->sType;
3890     out->pNext = in->pNext;
3891     out->module = in->module;
3892     out->pName = in->pName;
3893 }
3894 #endif /* USE_STRUCT_CONVERSION */
3895
3896 #if defined(USE_STRUCT_CONVERSION)
3897 static inline void convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(const VkDescriptorUpdateTemplateCreateInfo32 *in, VkDescriptorUpdateTemplateCreateInfo *out)
3898 {
3899     if (!in) return;
3900
3901     out->sType = in->sType;
3902     out->pNext = in->pNext;
3903     out->flags = in->flags;
3904     out->descriptorUpdateEntryCount = in->descriptorUpdateEntryCount;
3905     out->pDescriptorUpdateEntries = in->pDescriptorUpdateEntries;
3906     out->templateType = in->templateType;
3907     out->descriptorSetLayout = in->descriptorSetLayout;
3908     out->pipelineBindPoint = in->pipelineBindPoint;
3909     out->pipelineLayout = in->pipelineLayout;
3910     out->set = in->set;
3911 }
3912 #endif /* USE_STRUCT_CONVERSION */
3913
3914 #if !defined(USE_STRUCT_CONVERSION)
3915 static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win64_to_host(struct conversion_context *ctx, const VkPhysicalDevice *in, uint32_t count)
3916 {
3917     VkPhysicalDevice *out;
3918     unsigned int i;
3919
3920     if (!in || !count) return NULL;
3921
3922     out = conversion_context_alloc(ctx, count * sizeof(*out));
3923     for (i = 0; i < count; i++)
3924     {
3925         out[i] = wine_phys_dev_from_handle(in[i])->phys_dev;
3926     }
3927
3928     return out;
3929 }
3930 #endif /* USE_STRUCT_CONVERSION */
3931
3932 #if defined(USE_STRUCT_CONVERSION)
3933 static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDevice *in, uint32_t count)
3934 {
3935     VkPhysicalDevice *out;
3936     unsigned int i;
3937
3938     if (!in || !count) return NULL;
3939
3940     out = conversion_context_alloc(ctx, count * sizeof(*out));
3941     for (i = 0; i < count; i++)
3942     {
3943         out[i] = wine_phys_dev_from_handle(in[i])->phys_dev;
3944     }
3945
3946     return out;
3947 }
3948 #endif /* USE_STRUCT_CONVERSION */
3949
3950 #if !defined(USE_STRUCT_CONVERSION)
3951 static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo *in, VkDeviceCreateInfo *out)
3952 {
3953     const VkBaseInStructure *in_header;
3954     VkBaseOutStructure *out_header = (void *)out;
3955
3956     if (!in) return;
3957
3958     out->sType = in->sType;
3959     out->pNext = NULL;
3960     out->flags = in->flags;
3961     out->queueCreateInfoCount = in->queueCreateInfoCount;
3962     out->pQueueCreateInfos = in->pQueueCreateInfos;
3963     out->enabledLayerCount = in->enabledLayerCount;
3964     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
3965     out->enabledExtensionCount = in->enabledExtensionCount;
3966     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
3967     out->pEnabledFeatures = in->pEnabledFeatures;
3968
3969     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
3970     {
3971         switch (in_header->sType)
3972         {
3973         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
3974             break;
3975         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
3976         {
3977             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3978             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
3979             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
3980             out_ext->pNext = NULL;
3981             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
3982             out_header->pNext = (void *)out_ext;
3983             out_header = (void *)out_ext;
3984             break;
3985         }
3986         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
3987         {
3988             VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
3989             const VkDevicePrivateDataCreateInfo *in_ext = (const VkDevicePrivateDataCreateInfo *)in_header;
3990             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
3991             out_ext->pNext = NULL;
3992             out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
3993             out_header->pNext = (void *)out_ext;
3994             out_header = (void *)out_ext;
3995             break;
3996         }
3997         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
3998         {
3999             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4000             const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
4001             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
4002             out_ext->pNext = NULL;
4003             out_ext->privateData = in_ext->privateData;
4004             out_header->pNext = (void *)out_ext;
4005             out_header = (void *)out_ext;
4006             break;
4007         }
4008         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
4009         {
4010             VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4011             const VkPhysicalDeviceFeatures2 *in_ext = (const VkPhysicalDeviceFeatures2 *)in_header;
4012             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
4013             out_ext->pNext = NULL;
4014             out_ext->features = in_ext->features;
4015             out_header->pNext = (void *)out_ext;
4016             out_header = (void *)out_ext;
4017             break;
4018         }
4019         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
4020         {
4021             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4022             const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
4023             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
4024             out_ext->pNext = NULL;
4025             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
4026             out_ext->variablePointers = in_ext->variablePointers;
4027             out_header->pNext = (void *)out_ext;
4028             out_header = (void *)out_ext;
4029             break;
4030         }
4031         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
4032         {
4033             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4034             const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
4035             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
4036             out_ext->pNext = NULL;
4037             out_ext->multiview = in_ext->multiview;
4038             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
4039             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
4040             out_header->pNext = (void *)out_ext;
4041             out_header = (void *)out_ext;
4042             break;
4043         }
4044         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
4045         {
4046             VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4047             const VkDeviceGroupDeviceCreateInfo *in_ext = (const VkDeviceGroupDeviceCreateInfo *)in_header;
4048             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
4049             out_ext->pNext = NULL;
4050             out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
4051             out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win64_to_host(ctx, in_ext->pPhysicalDevices, in_ext->physicalDeviceCount);
4052             out_header->pNext = (void *)out_ext;
4053             out_header = (void *)out_ext;
4054             break;
4055         }
4056         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
4057         {
4058             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4059             const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
4060             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
4061             out_ext->pNext = NULL;
4062             out_ext->presentId = in_ext->presentId;
4063             out_header->pNext = (void *)out_ext;
4064             out_header = (void *)out_ext;
4065             break;
4066         }
4067         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
4068         {
4069             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4070             const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
4071             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
4072             out_ext->pNext = NULL;
4073             out_ext->presentWait = in_ext->presentWait;
4074             out_header->pNext = (void *)out_ext;
4075             out_header = (void *)out_ext;
4076             break;
4077         }
4078         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
4079         {
4080             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4081             const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
4082             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
4083             out_ext->pNext = NULL;
4084             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
4085             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
4086             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
4087             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
4088             out_header->pNext = (void *)out_ext;
4089             out_header = (void *)out_ext;
4090             break;
4091         }
4092         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
4093         {
4094             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4095             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
4096             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
4097             out_ext->pNext = NULL;
4098             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
4099             out_header->pNext = (void *)out_ext;
4100             out_header = (void *)out_ext;
4101             break;
4102         }
4103         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
4104         {
4105             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4106             const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
4107             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
4108             out_ext->pNext = NULL;
4109             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
4110             out_header->pNext = (void *)out_ext;
4111             out_header = (void *)out_ext;
4112             break;
4113         }
4114         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
4115         {
4116             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4117             const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
4118             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
4119             out_ext->pNext = NULL;
4120             out_ext->protectedMemory = in_ext->protectedMemory;
4121             out_header->pNext = (void *)out_ext;
4122             out_header = (void *)out_ext;
4123             break;
4124         }
4125         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
4126         {
4127             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4128             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
4129             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
4130             out_ext->pNext = NULL;
4131             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
4132             out_header->pNext = (void *)out_ext;
4133             out_header = (void *)out_ext;
4134             break;
4135         }
4136         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
4137         {
4138             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4139             const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
4140             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
4141             out_ext->pNext = NULL;
4142             out_ext->multiDraw = in_ext->multiDraw;
4143             out_header->pNext = (void *)out_ext;
4144             out_header = (void *)out_ext;
4145             break;
4146         }
4147         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
4148         {
4149             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4150             const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
4151             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
4152             out_ext->pNext = NULL;
4153             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
4154             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
4155             out_header->pNext = (void *)out_ext;
4156             out_header = (void *)out_ext;
4157             break;
4158         }
4159         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
4160         {
4161             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4162             const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
4163             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
4164             out_ext->pNext = NULL;
4165             out_ext->maintenance4 = in_ext->maintenance4;
4166             out_header->pNext = (void *)out_ext;
4167             out_header = (void *)out_ext;
4168             break;
4169         }
4170         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
4171         {
4172             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4173             const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
4174             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
4175             out_ext->pNext = NULL;
4176             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
4177             out_header->pNext = (void *)out_ext;
4178             out_header = (void *)out_ext;
4179             break;
4180         }
4181         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
4182         {
4183             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4184             const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
4185             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
4186             out_ext->pNext = NULL;
4187             out_ext->shaderFloat16 = in_ext->shaderFloat16;
4188             out_ext->shaderInt8 = in_ext->shaderInt8;
4189             out_header->pNext = (void *)out_ext;
4190             out_header = (void *)out_ext;
4191             break;
4192         }
4193         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
4194         {
4195             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4196             const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
4197             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
4198             out_ext->pNext = NULL;
4199             out_ext->hostQueryReset = in_ext->hostQueryReset;
4200             out_header->pNext = (void *)out_ext;
4201             out_header = (void *)out_ext;
4202             break;
4203         }
4204         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
4205         {
4206             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4207             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *)in_header;
4208             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
4209             out_ext->pNext = NULL;
4210             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
4211             out_header->pNext = (void *)out_ext;
4212             out_header = (void *)out_ext;
4213             break;
4214         }
4215         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
4216         {
4217             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4218             const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
4219             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
4220             out_ext->pNext = NULL;
4221             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
4222             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
4223             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
4224             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
4225             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
4226             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
4227             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
4228             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
4229             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
4230             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
4231             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
4232             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
4233             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
4234             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
4235             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
4236             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
4237             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
4238             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
4239             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
4240             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
4241             out_header->pNext = (void *)out_ext;
4242             out_header = (void *)out_ext;
4243             break;
4244         }
4245         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
4246         {
4247             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4248             const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
4249             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
4250             out_ext->pNext = NULL;
4251             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
4252             out_header->pNext = (void *)out_ext;
4253             out_header = (void *)out_ext;
4254             break;
4255         }
4256         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
4257         {
4258             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4259             const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
4260             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
4261             out_ext->pNext = NULL;
4262             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
4263             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
4264             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
4265             out_header->pNext = (void *)out_ext;
4266             out_header = (void *)out_ext;
4267             break;
4268         }
4269         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
4270         {
4271             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4272             const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
4273             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
4274             out_ext->pNext = NULL;
4275             out_ext->conditionalRendering = in_ext->conditionalRendering;
4276             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
4277             out_header->pNext = (void *)out_ext;
4278             out_header = (void *)out_ext;
4279             break;
4280         }
4281         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
4282         {
4283             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4284             const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
4285             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
4286             out_ext->pNext = NULL;
4287             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
4288             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
4289             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
4290             out_header->pNext = (void *)out_ext;
4291             out_header = (void *)out_ext;
4292             break;
4293         }
4294         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
4295         {
4296             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4297             const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
4298             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
4299             out_ext->pNext = NULL;
4300             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
4301             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
4302             out_header->pNext = (void *)out_ext;
4303             out_header = (void *)out_ext;
4304             break;
4305         }
4306         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
4307         {
4308             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4309             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
4310             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
4311             out_ext->pNext = NULL;
4312             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
4313             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
4314             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
4315             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
4316             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
4317             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
4318             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
4319             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
4320             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
4321             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
4322             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
4323             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
4324             out_header->pNext = (void *)out_ext;
4325             out_header = (void *)out_ext;
4326             break;
4327         }
4328         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
4329         {
4330             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4331             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
4332             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
4333             out_ext->pNext = NULL;
4334             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
4335             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
4336             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
4337             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
4338             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
4339             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
4340             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
4341             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
4342             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
4343             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
4344             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
4345             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
4346             out_header->pNext = (void *)out_ext;
4347             out_header = (void *)out_ext;
4348             break;
4349         }
4350         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
4351         {
4352             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4353             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header;
4354             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
4355             out_ext->pNext = NULL;
4356             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
4357             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
4358             out_header->pNext = (void *)out_ext;
4359             out_header = (void *)out_ext;
4360             break;
4361         }
4362         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
4363         {
4364             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4365             const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
4366             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
4367             out_ext->pNext = NULL;
4368             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
4369             out_header->pNext = (void *)out_ext;
4370             out_header = (void *)out_ext;
4371             break;
4372         }
4373         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
4374         {
4375             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4376             const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
4377             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
4378             out_ext->pNext = NULL;
4379             out_ext->transformFeedback = in_ext->transformFeedback;
4380             out_ext->geometryStreams = in_ext->geometryStreams;
4381             out_header->pNext = (void *)out_ext;
4382             out_header = (void *)out_ext;
4383             break;
4384         }
4385         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
4386         {
4387             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4388             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
4389             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
4390             out_ext->pNext = NULL;
4391             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
4392             out_header->pNext = (void *)out_ext;
4393             out_header = (void *)out_ext;
4394             break;
4395         }
4396         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
4397         {
4398             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4399             const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
4400             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
4401             out_ext->pNext = NULL;
4402             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
4403             out_header->pNext = (void *)out_ext;
4404             out_header = (void *)out_ext;
4405             break;
4406         }
4407         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
4408         {
4409             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4410             const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
4411             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
4412             out_ext->pNext = NULL;
4413             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
4414             out_header->pNext = (void *)out_ext;
4415             out_header = (void *)out_ext;
4416             break;
4417         }
4418         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
4419         {
4420             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4421             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header;
4422             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
4423             out_ext->pNext = NULL;
4424             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
4425             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
4426             out_header->pNext = (void *)out_ext;
4427             out_header = (void *)out_ext;
4428             break;
4429         }
4430         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
4431         {
4432             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4433             const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
4434             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
4435             out_ext->pNext = NULL;
4436             out_ext->imageFootprint = in_ext->imageFootprint;
4437             out_header->pNext = (void *)out_ext;
4438             out_header = (void *)out_ext;
4439             break;
4440         }
4441         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
4442         {
4443             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4444             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
4445             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
4446             out_ext->pNext = NULL;
4447             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
4448             out_header->pNext = (void *)out_ext;
4449             out_header = (void *)out_ext;
4450             break;
4451         }
4452         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
4453         {
4454             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4455             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
4456             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
4457             out_ext->pNext = NULL;
4458             out_ext->indirectCopy = in_ext->indirectCopy;
4459             out_header->pNext = (void *)out_ext;
4460             out_header = (void *)out_ext;
4461             break;
4462         }
4463         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
4464         {
4465             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4466             const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
4467             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
4468             out_ext->pNext = NULL;
4469             out_ext->memoryDecompression = in_ext->memoryDecompression;
4470             out_header->pNext = (void *)out_ext;
4471             out_header = (void *)out_ext;
4472             break;
4473         }
4474         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
4475         {
4476             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4477             const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
4478             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
4479             out_ext->pNext = NULL;
4480             out_ext->shadingRateImage = in_ext->shadingRateImage;
4481             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
4482             out_header->pNext = (void *)out_ext;
4483             out_header = (void *)out_ext;
4484             break;
4485         }
4486         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
4487         {
4488             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4489             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
4490             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
4491             out_ext->pNext = NULL;
4492             out_ext->invocationMask = in_ext->invocationMask;
4493             out_header->pNext = (void *)out_ext;
4494             out_header = (void *)out_ext;
4495             break;
4496         }
4497         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
4498         {
4499             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4500             const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
4501             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
4502             out_ext->pNext = NULL;
4503             out_ext->taskShader = in_ext->taskShader;
4504             out_ext->meshShader = in_ext->meshShader;
4505             out_header->pNext = (void *)out_ext;
4506             out_header = (void *)out_ext;
4507             break;
4508         }
4509         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
4510         {
4511             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4512             const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
4513             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
4514             out_ext->pNext = NULL;
4515             out_ext->taskShader = in_ext->taskShader;
4516             out_ext->meshShader = in_ext->meshShader;
4517             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
4518             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
4519             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
4520             out_header->pNext = (void *)out_ext;
4521             out_header = (void *)out_ext;
4522             break;
4523         }
4524         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
4525         {
4526             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4527             const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
4528             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
4529             out_ext->pNext = NULL;
4530             out_ext->accelerationStructure = in_ext->accelerationStructure;
4531             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
4532             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
4533             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
4534             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
4535             out_header->pNext = (void *)out_ext;
4536             out_header = (void *)out_ext;
4537             break;
4538         }
4539         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
4540         {
4541             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4542             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
4543             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
4544             out_ext->pNext = NULL;
4545             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
4546             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
4547             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
4548             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
4549             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
4550             out_header->pNext = (void *)out_ext;
4551             out_header = (void *)out_ext;
4552             break;
4553         }
4554         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
4555         {
4556             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4557             const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
4558             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
4559             out_ext->pNext = NULL;
4560             out_ext->rayQuery = in_ext->rayQuery;
4561             out_header->pNext = (void *)out_ext;
4562             out_header = (void *)out_ext;
4563             break;
4564         }
4565         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
4566         {
4567             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4568             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
4569             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
4570             out_ext->pNext = NULL;
4571             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
4572             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
4573             out_header->pNext = (void *)out_ext;
4574             out_header = (void *)out_ext;
4575             break;
4576         }
4577         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
4578         {
4579             VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4580             const VkDeviceMemoryOverallocationCreateInfoAMD *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD *)in_header;
4581             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
4582             out_ext->pNext = NULL;
4583             out_ext->overallocationBehavior = in_ext->overallocationBehavior;
4584             out_header->pNext = (void *)out_ext;
4585             out_header = (void *)out_ext;
4586             break;
4587         }
4588         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
4589         {
4590             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4591             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
4592             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
4593             out_ext->pNext = NULL;
4594             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
4595             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
4596             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
4597             out_header->pNext = (void *)out_ext;
4598             out_header = (void *)out_ext;
4599             break;
4600         }
4601         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
4602         {
4603             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4604             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
4605             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
4606             out_ext->pNext = NULL;
4607             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
4608             out_header->pNext = (void *)out_ext;
4609             out_header = (void *)out_ext;
4610             break;
4611         }
4612         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
4613         {
4614             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4615             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *)in_header;
4616             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
4617             out_ext->pNext = NULL;
4618             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
4619             out_header->pNext = (void *)out_ext;
4620             out_header = (void *)out_ext;
4621             break;
4622         }
4623         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
4624         {
4625             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4626             const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
4627             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
4628             out_ext->pNext = NULL;
4629             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
4630             out_header->pNext = (void *)out_ext;
4631             out_header = (void *)out_ext;
4632             break;
4633         }
4634         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
4635         {
4636             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4637             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
4638             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
4639             out_ext->pNext = NULL;
4640             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
4641             out_header->pNext = (void *)out_ext;
4642             out_header = (void *)out_ext;
4643             break;
4644         }
4645         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
4646         {
4647             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4648             const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
4649             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
4650             out_ext->pNext = NULL;
4651             out_ext->depthClipEnable = in_ext->depthClipEnable;
4652             out_header->pNext = (void *)out_ext;
4653             out_header = (void *)out_ext;
4654             break;
4655         }
4656         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
4657         {
4658             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4659             const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
4660             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
4661             out_ext->pNext = NULL;
4662             out_ext->memoryPriority = in_ext->memoryPriority;
4663             out_header->pNext = (void *)out_ext;
4664             out_header = (void *)out_ext;
4665             break;
4666         }
4667         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
4668         {
4669             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4670             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
4671             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
4672             out_ext->pNext = NULL;
4673             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
4674             out_header->pNext = (void *)out_ext;
4675             out_header = (void *)out_ext;
4676             break;
4677         }
4678         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
4679         {
4680             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4681             const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
4682             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
4683             out_ext->pNext = NULL;
4684             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
4685             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
4686             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
4687             out_header->pNext = (void *)out_ext;
4688             out_header = (void *)out_ext;
4689             break;
4690         }
4691         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
4692         {
4693             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4694             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
4695             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
4696             out_ext->pNext = NULL;
4697             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
4698             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
4699             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
4700             out_header->pNext = (void *)out_ext;
4701             out_header = (void *)out_ext;
4702             break;
4703         }
4704         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
4705         {
4706             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4707             const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
4708             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
4709             out_ext->pNext = NULL;
4710             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
4711             out_header->pNext = (void *)out_ext;
4712             out_header = (void *)out_ext;
4713             break;
4714         }
4715         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
4716         {
4717             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4718             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
4719             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
4720             out_ext->pNext = NULL;
4721             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
4722             out_header->pNext = (void *)out_ext;
4723             out_header = (void *)out_ext;
4724             break;
4725         }
4726         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
4727         {
4728             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4729             const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
4730             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
4731             out_ext->pNext = NULL;
4732             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
4733             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
4734             out_header->pNext = (void *)out_ext;
4735             out_header = (void *)out_ext;
4736             break;
4737         }
4738         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
4739         {
4740             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4741             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
4742             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
4743             out_ext->pNext = NULL;
4744             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
4745             out_header->pNext = (void *)out_ext;
4746             out_header = (void *)out_ext;
4747             break;
4748         }
4749         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
4750         {
4751             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4752             const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
4753             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
4754             out_ext->pNext = NULL;
4755             out_ext->presentBarrier = in_ext->presentBarrier;
4756             out_header->pNext = (void *)out_ext;
4757             out_header = (void *)out_ext;
4758             break;
4759         }
4760         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
4761         {
4762             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4763             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
4764             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
4765             out_ext->pNext = NULL;
4766             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
4767             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
4768             out_header->pNext = (void *)out_ext;
4769             out_header = (void *)out_ext;
4770             break;
4771         }
4772         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
4773         {
4774             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4775             const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
4776             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
4777             out_ext->pNext = NULL;
4778             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
4779             out_header->pNext = (void *)out_ext;
4780             out_header = (void *)out_ext;
4781             break;
4782         }
4783         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
4784         {
4785             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4786             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
4787             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
4788             out_ext->pNext = NULL;
4789             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
4790             out_header->pNext = (void *)out_ext;
4791             out_header = (void *)out_ext;
4792             break;
4793         }
4794         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
4795         {
4796             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4797             const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
4798             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
4799             out_ext->pNext = NULL;
4800             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
4801             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
4802             out_header->pNext = (void *)out_ext;
4803             out_header = (void *)out_ext;
4804             break;
4805         }
4806         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
4807         {
4808             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4809             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header;
4810             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
4811             out_ext->pNext = NULL;
4812             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
4813             out_header->pNext = (void *)out_ext;
4814             out_header = (void *)out_ext;
4815             break;
4816         }
4817         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
4818         {
4819             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4820             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
4821             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
4822             out_ext->pNext = NULL;
4823             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
4824             out_header->pNext = (void *)out_ext;
4825             out_header = (void *)out_ext;
4826             break;
4827         }
4828         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
4829         {
4830             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4831             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
4832             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
4833             out_ext->pNext = NULL;
4834             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
4835             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
4836             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
4837             out_header->pNext = (void *)out_ext;
4838             out_header = (void *)out_ext;
4839             break;
4840         }
4841         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
4842         {
4843             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4844             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
4845             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
4846             out_ext->pNext = NULL;
4847             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
4848             out_header->pNext = (void *)out_ext;
4849             out_header = (void *)out_ext;
4850             break;
4851         }
4852         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
4853         {
4854             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4855             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
4856             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
4857             out_ext->pNext = NULL;
4858             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
4859             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
4860             out_header->pNext = (void *)out_ext;
4861             out_header = (void *)out_ext;
4862             break;
4863         }
4864         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
4865         {
4866             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4867             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
4868             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
4869             out_ext->pNext = NULL;
4870             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
4871             out_header->pNext = (void *)out_ext;
4872             out_header = (void *)out_ext;
4873             break;
4874         }
4875         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
4876         {
4877             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4878             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
4879             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
4880             out_ext->pNext = NULL;
4881             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
4882             out_header->pNext = (void *)out_ext;
4883             out_header = (void *)out_ext;
4884             break;
4885         }
4886         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
4887         {
4888             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4889             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
4890             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
4891             out_ext->pNext = NULL;
4892             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
4893             out_header->pNext = (void *)out_ext;
4894             out_header = (void *)out_ext;
4895             break;
4896         }
4897         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
4898         {
4899             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4900             const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
4901             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
4902             out_ext->pNext = NULL;
4903             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
4904             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
4905             out_header->pNext = (void *)out_ext;
4906             out_header = (void *)out_ext;
4907             break;
4908         }
4909         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
4910         {
4911             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4912             const VkPhysicalDeviceLineRasterizationFeaturesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header;
4913             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
4914             out_ext->pNext = NULL;
4915             out_ext->rectangularLines = in_ext->rectangularLines;
4916             out_ext->bresenhamLines = in_ext->bresenhamLines;
4917             out_ext->smoothLines = in_ext->smoothLines;
4918             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
4919             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
4920             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
4921             out_header->pNext = (void *)out_ext;
4922             out_header = (void *)out_ext;
4923             break;
4924         }
4925         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
4926         {
4927             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4928             const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
4929             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
4930             out_ext->pNext = NULL;
4931             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
4932             out_header->pNext = (void *)out_ext;
4933             out_header = (void *)out_ext;
4934             break;
4935         }
4936         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
4937         {
4938             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4939             const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
4940             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
4941             out_ext->pNext = NULL;
4942             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
4943             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
4944             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
4945             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
4946             out_ext->multiview = in_ext->multiview;
4947             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
4948             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
4949             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
4950             out_ext->variablePointers = in_ext->variablePointers;
4951             out_ext->protectedMemory = in_ext->protectedMemory;
4952             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
4953             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
4954             out_header->pNext = (void *)out_ext;
4955             out_header = (void *)out_ext;
4956             break;
4957         }
4958         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
4959         {
4960             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
4961             const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
4962             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
4963             out_ext->pNext = NULL;
4964             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
4965             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
4966             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
4967             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
4968             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
4969             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
4970             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
4971             out_ext->shaderFloat16 = in_ext->shaderFloat16;
4972             out_ext->shaderInt8 = in_ext->shaderInt8;
4973             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
4974             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
4975             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
4976             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
4977             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
4978             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
4979             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
4980             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
4981             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
4982             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
4983             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
4984             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
4985             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
4986             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
4987             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
4988             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
4989             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
4990             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
4991             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
4992             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
4993             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
4994             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
4995             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
4996             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
4997             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
4998             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
4999             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
5000             out_ext->hostQueryReset = in_ext->hostQueryReset;
5001             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
5002             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
5003             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
5004             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
5005             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
5006             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
5007             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
5008             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
5009             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
5010             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
5011             out_header->pNext = (void *)out_ext;
5012             out_header = (void *)out_ext;
5013             break;
5014         }
5015         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
5016         {
5017             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5018             const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
5019             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
5020             out_ext->pNext = NULL;
5021             out_ext->robustImageAccess = in_ext->robustImageAccess;
5022             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
5023             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
5024             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
5025             out_ext->privateData = in_ext->privateData;
5026             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
5027             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
5028             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
5029             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
5030             out_ext->synchronization2 = in_ext->synchronization2;
5031             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
5032             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
5033             out_ext->dynamicRendering = in_ext->dynamicRendering;
5034             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
5035             out_ext->maintenance4 = in_ext->maintenance4;
5036             out_header->pNext = (void *)out_ext;
5037             out_header = (void *)out_ext;
5038             break;
5039         }
5040         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
5041         {
5042             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5043             const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
5044             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
5045             out_ext->pNext = NULL;
5046             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
5047             out_header->pNext = (void *)out_ext;
5048             out_header = (void *)out_ext;
5049             break;
5050         }
5051         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
5052         {
5053             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5054             const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
5055             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
5056             out_ext->pNext = NULL;
5057             out_ext->customBorderColors = in_ext->customBorderColors;
5058             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
5059             out_header->pNext = (void *)out_ext;
5060             out_header = (void *)out_ext;
5061             break;
5062         }
5063         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
5064         {
5065             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5066             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
5067             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
5068             out_ext->pNext = NULL;
5069             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
5070             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
5071             out_header->pNext = (void *)out_ext;
5072             out_header = (void *)out_ext;
5073             break;
5074         }
5075         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
5076         {
5077             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5078             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
5079             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
5080             out_ext->pNext = NULL;
5081             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
5082             out_header->pNext = (void *)out_ext;
5083             out_header = (void *)out_ext;
5084             break;
5085         }
5086         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
5087         {
5088             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5089             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
5090             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
5091             out_ext->pNext = NULL;
5092             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
5093             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
5094             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
5095             out_header->pNext = (void *)out_ext;
5096             out_header = (void *)out_ext;
5097             break;
5098         }
5099         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
5100         {
5101             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5102             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
5103             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
5104             out_ext->pNext = NULL;
5105             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
5106             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
5107             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
5108             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
5109             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
5110             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
5111             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
5112             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
5113             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
5114             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
5115             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
5116             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
5117             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
5118             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
5119             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
5120             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
5121             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
5122             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
5123             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
5124             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
5125             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
5126             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
5127             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
5128             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
5129             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
5130             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
5131             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
5132             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
5133             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
5134             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
5135             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
5136             out_header->pNext = (void *)out_ext;
5137             out_header = (void *)out_ext;
5138             break;
5139         }
5140         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
5141         {
5142             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5143             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
5144             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
5145             out_ext->pNext = NULL;
5146             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
5147             out_header->pNext = (void *)out_ext;
5148             out_header = (void *)out_ext;
5149             break;
5150         }
5151         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
5152         {
5153             VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5154             const VkDeviceDiagnosticsConfigCreateInfoNV *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV *)in_header;
5155             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
5156             out_ext->pNext = NULL;
5157             out_ext->flags = in_ext->flags;
5158             out_header->pNext = (void *)out_ext;
5159             out_header = (void *)out_ext;
5160             break;
5161         }
5162         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
5163         {
5164             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5165             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
5166             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
5167             out_ext->pNext = NULL;
5168             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
5169             out_header->pNext = (void *)out_ext;
5170             out_header = (void *)out_ext;
5171             break;
5172         }
5173         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
5174         {
5175             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5176             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
5177             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
5178             out_ext->pNext = NULL;
5179             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
5180             out_header->pNext = (void *)out_ext;
5181             out_header = (void *)out_ext;
5182             break;
5183         }
5184         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
5185         {
5186             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5187             const VkPhysicalDeviceRobustness2FeaturesEXT *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT *)in_header;
5188             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
5189             out_ext->pNext = NULL;
5190             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
5191             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
5192             out_ext->nullDescriptor = in_ext->nullDescriptor;
5193             out_header->pNext = (void *)out_ext;
5194             out_header = (void *)out_ext;
5195             break;
5196         }
5197         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
5198         {
5199             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5200             const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
5201             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
5202             out_ext->pNext = NULL;
5203             out_ext->robustImageAccess = in_ext->robustImageAccess;
5204             out_header->pNext = (void *)out_ext;
5205             out_header = (void *)out_ext;
5206             break;
5207         }
5208         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
5209         {
5210             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5211             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
5212             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
5213             out_ext->pNext = NULL;
5214             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
5215             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
5216             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
5217             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
5218             out_header->pNext = (void *)out_ext;
5219             out_header = (void *)out_ext;
5220             break;
5221         }
5222         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
5223         {
5224             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5225             const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
5226             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
5227             out_ext->pNext = NULL;
5228             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
5229             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
5230             out_header->pNext = (void *)out_ext;
5231             out_header = (void *)out_ext;
5232             break;
5233         }
5234         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
5235         {
5236             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5237             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
5238             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
5239             out_ext->pNext = NULL;
5240             out_ext->subpassShading = in_ext->subpassShading;
5241             out_header->pNext = (void *)out_ext;
5242             out_header = (void *)out_ext;
5243             break;
5244         }
5245         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
5246         {
5247             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5248             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
5249             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
5250             out_ext->pNext = NULL;
5251             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
5252             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
5253             out_header->pNext = (void *)out_ext;
5254             out_header = (void *)out_ext;
5255             break;
5256         }
5257         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
5258         {
5259             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5260             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
5261             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
5262             out_ext->pNext = NULL;
5263             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
5264             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
5265             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
5266             out_header->pNext = (void *)out_ext;
5267             out_header = (void *)out_ext;
5268             break;
5269         }
5270         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
5271         {
5272             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5273             const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
5274             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
5275             out_ext->pNext = NULL;
5276             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
5277             out_header->pNext = (void *)out_ext;
5278             out_header = (void *)out_ext;
5279             break;
5280         }
5281         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
5282         {
5283             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5284             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
5285             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
5286             out_ext->pNext = NULL;
5287             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
5288             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
5289             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
5290             out_header->pNext = (void *)out_ext;
5291             out_header = (void *)out_ext;
5292             break;
5293         }
5294         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
5295         {
5296             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5297             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
5298             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
5299             out_ext->pNext = NULL;
5300             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
5301             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
5302             out_header->pNext = (void *)out_ext;
5303             out_header = (void *)out_ext;
5304             break;
5305         }
5306         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
5307         {
5308             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5309             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
5310             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
5311             out_ext->pNext = NULL;
5312             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
5313             out_header->pNext = (void *)out_ext;
5314             out_header = (void *)out_ext;
5315             break;
5316         }
5317         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
5318         {
5319             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5320             const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
5321             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
5322             out_ext->pNext = NULL;
5323             out_ext->depthClipControl = in_ext->depthClipControl;
5324             out_header->pNext = (void *)out_ext;
5325             out_header = (void *)out_ext;
5326             break;
5327         }
5328         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
5329         {
5330             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5331             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
5332             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
5333             out_ext->pNext = NULL;
5334             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
5335             out_header->pNext = (void *)out_ext;
5336             out_header = (void *)out_ext;
5337             break;
5338         }
5339         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
5340         {
5341             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5342             const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
5343             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
5344             out_ext->pNext = NULL;
5345             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
5346             out_header->pNext = (void *)out_ext;
5347             out_header = (void *)out_ext;
5348             break;
5349         }
5350         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
5351         {
5352             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5353             const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
5354             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
5355             out_ext->pNext = NULL;
5356             out_ext->synchronization2 = in_ext->synchronization2;
5357             out_header->pNext = (void *)out_ext;
5358             out_header = (void *)out_ext;
5359             break;
5360         }
5361         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
5362         {
5363             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5364             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
5365             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
5366             out_ext->pNext = NULL;
5367             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
5368             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
5369             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
5370             out_header->pNext = (void *)out_ext;
5371             out_header = (void *)out_ext;
5372             break;
5373         }
5374         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
5375         {
5376             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5377             const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
5378             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
5379             out_ext->pNext = NULL;
5380             out_ext->legacyDithering = in_ext->legacyDithering;
5381             out_header->pNext = (void *)out_ext;
5382             out_header = (void *)out_ext;
5383             break;
5384         }
5385         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
5386         {
5387             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5388             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
5389             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
5390             out_ext->pNext = NULL;
5391             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
5392             out_header->pNext = (void *)out_ext;
5393             out_header = (void *)out_ext;
5394             break;
5395         }
5396         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
5397         {
5398             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5399             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)in_header;
5400             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
5401             out_ext->pNext = NULL;
5402             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
5403             out_header->pNext = (void *)out_ext;
5404             out_header = (void *)out_ext;
5405             break;
5406         }
5407         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
5408         {
5409             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5410             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
5411             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
5412             out_ext->pNext = NULL;
5413             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
5414             out_header->pNext = (void *)out_ext;
5415             out_header = (void *)out_ext;
5416             break;
5417         }
5418         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
5419         {
5420             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5421             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
5422             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
5423             out_ext->pNext = NULL;
5424             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
5425             out_header->pNext = (void *)out_ext;
5426             out_header = (void *)out_ext;
5427             break;
5428         }
5429         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
5430         {
5431             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5432             const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
5433             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
5434             out_ext->pNext = NULL;
5435             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
5436             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
5437             out_header->pNext = (void *)out_ext;
5438             out_header = (void *)out_ext;
5439             break;
5440         }
5441         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
5442         {
5443             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5444             const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
5445             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
5446             out_ext->pNext = NULL;
5447             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
5448             out_header->pNext = (void *)out_ext;
5449             out_header = (void *)out_ext;
5450             break;
5451         }
5452         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
5453         {
5454             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5455             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
5456             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
5457             out_ext->pNext = NULL;
5458             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
5459             out_header->pNext = (void *)out_ext;
5460             out_header = (void *)out_ext;
5461             break;
5462         }
5463         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
5464         {
5465             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5466             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
5467             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
5468             out_ext->pNext = NULL;
5469             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
5470             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
5471             out_header->pNext = (void *)out_ext;
5472             out_header = (void *)out_ext;
5473             break;
5474         }
5475         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
5476         {
5477             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5478             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
5479             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
5480             out_ext->pNext = NULL;
5481             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
5482             out_header->pNext = (void *)out_ext;
5483             out_header = (void *)out_ext;
5484             break;
5485         }
5486         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
5487         {
5488             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5489             const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
5490             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
5491             out_ext->pNext = NULL;
5492             out_ext->dynamicRendering = in_ext->dynamicRendering;
5493             out_header->pNext = (void *)out_ext;
5494             out_header = (void *)out_ext;
5495             break;
5496         }
5497         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
5498         {
5499             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5500             const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
5501             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
5502             out_ext->pNext = NULL;
5503             out_ext->minLod = in_ext->minLod;
5504             out_header->pNext = (void *)out_ext;
5505             out_header = (void *)out_ext;
5506             break;
5507         }
5508         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
5509         {
5510             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5511             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
5512             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
5513             out_ext->pNext = NULL;
5514             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
5515             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
5516             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
5517             out_header->pNext = (void *)out_ext;
5518             out_header = (void *)out_ext;
5519             break;
5520         }
5521         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
5522         {
5523             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5524             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
5525             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
5526             out_ext->pNext = NULL;
5527             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
5528             out_header->pNext = (void *)out_ext;
5529             out_header = (void *)out_ext;
5530             break;
5531         }
5532         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
5533         {
5534             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5535             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
5536             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
5537             out_ext->pNext = NULL;
5538             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
5539             out_header->pNext = (void *)out_ext;
5540             out_header = (void *)out_ext;
5541             break;
5542         }
5543         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
5544         {
5545             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5546             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
5547             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
5548             out_ext->pNext = NULL;
5549             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
5550             out_header->pNext = (void *)out_ext;
5551             out_header = (void *)out_ext;
5552             break;
5553         }
5554         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
5555         {
5556             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5557             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
5558             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
5559             out_ext->pNext = NULL;
5560             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
5561             out_header->pNext = (void *)out_ext;
5562             out_header = (void *)out_ext;
5563             break;
5564         }
5565         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
5566         {
5567             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5568             const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
5569             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
5570             out_ext->pNext = NULL;
5571             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
5572             out_header->pNext = (void *)out_ext;
5573             out_header = (void *)out_ext;
5574             break;
5575         }
5576         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
5577         {
5578             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5579             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
5580             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
5581             out_ext->pNext = NULL;
5582             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
5583             out_header->pNext = (void *)out_ext;
5584             out_header = (void *)out_ext;
5585             break;
5586         }
5587         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
5588         {
5589             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5590             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
5591             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
5592             out_ext->pNext = NULL;
5593             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
5594             out_header->pNext = (void *)out_ext;
5595             out_header = (void *)out_ext;
5596             break;
5597         }
5598         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
5599         {
5600             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5601             const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
5602             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
5603             out_ext->pNext = NULL;
5604             out_ext->micromap = in_ext->micromap;
5605             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
5606             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
5607             out_header->pNext = (void *)out_ext;
5608             out_header = (void *)out_ext;
5609             break;
5610         }
5611         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
5612         {
5613             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5614             const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
5615             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
5616             out_ext->pNext = NULL;
5617             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
5618             out_header->pNext = (void *)out_ext;
5619             out_header = (void *)out_ext;
5620             break;
5621         }
5622         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
5623         {
5624             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5625             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header;
5626             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
5627             out_ext->pNext = NULL;
5628             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
5629             out_header->pNext = (void *)out_ext;
5630             out_header = (void *)out_ext;
5631             break;
5632         }
5633         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
5634         {
5635             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5636             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
5637             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
5638             out_ext->pNext = NULL;
5639             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
5640             out_header->pNext = (void *)out_ext;
5641             out_header = (void *)out_ext;
5642             break;
5643         }
5644         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
5645         {
5646             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5647             const VkPhysicalDevicePipelineRobustnessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT *)in_header;
5648             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
5649             out_ext->pNext = NULL;
5650             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
5651             out_header->pNext = (void *)out_ext;
5652             out_header = (void *)out_ext;
5653             break;
5654         }
5655         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
5656         {
5657             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5658             const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
5659             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
5660             out_ext->pNext = NULL;
5661             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
5662             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
5663             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
5664             out_header->pNext = (void *)out_ext;
5665             out_header = (void *)out_ext;
5666             break;
5667         }
5668         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
5669         {
5670             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5671             const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
5672             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
5673             out_ext->pNext = NULL;
5674             out_ext->tileProperties = in_ext->tileProperties;
5675             out_header->pNext = (void *)out_ext;
5676             out_header = (void *)out_ext;
5677             break;
5678         }
5679         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
5680         {
5681             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5682             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
5683             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
5684             out_ext->pNext = NULL;
5685             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
5686             out_header->pNext = (void *)out_ext;
5687             out_header = (void *)out_ext;
5688             break;
5689         }
5690         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
5691         {
5692             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5693             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *)in_header;
5694             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
5695             out_ext->pNext = NULL;
5696             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
5697             out_header->pNext = (void *)out_ext;
5698             out_header = (void *)out_ext;
5699             break;
5700         }
5701         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
5702         {
5703             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5704             const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
5705             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
5706             out_ext->pNext = NULL;
5707             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
5708             out_header->pNext = (void *)out_ext;
5709             out_header = (void *)out_ext;
5710             break;
5711         }
5712         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
5713         {
5714             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5715             const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
5716             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
5717             out_ext->pNext = NULL;
5718             out_ext->opticalFlow = in_ext->opticalFlow;
5719             out_header->pNext = (void *)out_ext;
5720             out_header = (void *)out_ext;
5721             break;
5722         }
5723         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
5724         {
5725             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5726             const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
5727             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
5728             out_ext->pNext = NULL;
5729             out_ext->deviceFault = in_ext->deviceFault;
5730             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
5731             out_header->pNext = (void *)out_ext;
5732             out_header = (void *)out_ext;
5733             break;
5734         }
5735         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
5736         {
5737             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5738             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
5739             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
5740             out_ext->pNext = NULL;
5741             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
5742             out_header->pNext = (void *)out_ext;
5743             out_header = (void *)out_ext;
5744             break;
5745         }
5746         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
5747         {
5748             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5749             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
5750             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
5751             out_ext->pNext = NULL;
5752             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
5753             out_header->pNext = (void *)out_ext;
5754             out_header = (void *)out_ext;
5755             break;
5756         }
5757         default:
5758             FIXME("Unhandled sType %u.", in_header->sType);
5759             break;
5760         }
5761     }
5762 }
5763 #endif /* USE_STRUCT_CONVERSION */
5764
5765 #if defined(USE_STRUCT_CONVERSION)
5766 static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo *in, VkDeviceCreateInfo *out)
5767 {
5768     const VkBaseInStructure *in_header;
5769     VkBaseOutStructure *out_header = (void *)out;
5770
5771     if (!in) return;
5772
5773     out->sType = in->sType;
5774     out->pNext = NULL;
5775     out->flags = in->flags;
5776     out->queueCreateInfoCount = in->queueCreateInfoCount;
5777     out->pQueueCreateInfos = in->pQueueCreateInfos;
5778     out->enabledLayerCount = in->enabledLayerCount;
5779     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
5780     out->enabledExtensionCount = in->enabledExtensionCount;
5781     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
5782     out->pEnabledFeatures = in->pEnabledFeatures;
5783
5784     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
5785     {
5786         switch (in_header->sType)
5787         {
5788         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
5789             break;
5790         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
5791         {
5792             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5793             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
5794             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
5795             out_ext->pNext = NULL;
5796             out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
5797             out_header->pNext = (void *)out_ext;
5798             out_header = (void *)out_ext;
5799             break;
5800         }
5801         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
5802         {
5803             VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5804             const VkDevicePrivateDataCreateInfo *in_ext = (const VkDevicePrivateDataCreateInfo *)in_header;
5805             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
5806             out_ext->pNext = NULL;
5807             out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount;
5808             out_header->pNext = (void *)out_ext;
5809             out_header = (void *)out_ext;
5810             break;
5811         }
5812         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
5813         {
5814             VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5815             const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header;
5816             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
5817             out_ext->pNext = NULL;
5818             out_ext->privateData = in_ext->privateData;
5819             out_header->pNext = (void *)out_ext;
5820             out_header = (void *)out_ext;
5821             break;
5822         }
5823         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
5824         {
5825             VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5826             const VkPhysicalDeviceFeatures2 *in_ext = (const VkPhysicalDeviceFeatures2 *)in_header;
5827             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
5828             out_ext->pNext = NULL;
5829             out_ext->features = in_ext->features;
5830             out_header->pNext = (void *)out_ext;
5831             out_header = (void *)out_ext;
5832             break;
5833         }
5834         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
5835         {
5836             VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5837             const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
5838             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
5839             out_ext->pNext = NULL;
5840             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
5841             out_ext->variablePointers = in_ext->variablePointers;
5842             out_header->pNext = (void *)out_ext;
5843             out_header = (void *)out_ext;
5844             break;
5845         }
5846         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
5847         {
5848             VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5849             const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
5850             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
5851             out_ext->pNext = NULL;
5852             out_ext->multiview = in_ext->multiview;
5853             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
5854             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
5855             out_header->pNext = (void *)out_ext;
5856             out_header = (void *)out_ext;
5857             break;
5858         }
5859         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
5860         {
5861             VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5862             const VkDeviceGroupDeviceCreateInfo *in_ext = (const VkDeviceGroupDeviceCreateInfo *)in_header;
5863             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
5864             out_ext->pNext = NULL;
5865             out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
5866             out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win32_to_host(ctx, in_ext->pPhysicalDevices, in_ext->physicalDeviceCount);
5867             out_header->pNext = (void *)out_ext;
5868             out_header = (void *)out_ext;
5869             break;
5870         }
5871         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
5872         {
5873             VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5874             const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header;
5875             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
5876             out_ext->pNext = NULL;
5877             out_ext->presentId = in_ext->presentId;
5878             out_header->pNext = (void *)out_ext;
5879             out_header = (void *)out_ext;
5880             break;
5881         }
5882         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
5883         {
5884             VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5885             const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header;
5886             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
5887             out_ext->pNext = NULL;
5888             out_ext->presentWait = in_ext->presentWait;
5889             out_header->pNext = (void *)out_ext;
5890             out_header = (void *)out_ext;
5891             break;
5892         }
5893         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
5894         {
5895             VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5896             const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
5897             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
5898             out_ext->pNext = NULL;
5899             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
5900             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
5901             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
5902             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
5903             out_header->pNext = (void *)out_ext;
5904             out_header = (void *)out_ext;
5905             break;
5906         }
5907         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
5908         {
5909             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5910             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
5911             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
5912             out_ext->pNext = NULL;
5913             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
5914             out_header->pNext = (void *)out_ext;
5915             out_header = (void *)out_ext;
5916             break;
5917         }
5918         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
5919         {
5920             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5921             const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
5922             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
5923             out_ext->pNext = NULL;
5924             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
5925             out_header->pNext = (void *)out_ext;
5926             out_header = (void *)out_ext;
5927             break;
5928         }
5929         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
5930         {
5931             VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5932             const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
5933             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
5934             out_ext->pNext = NULL;
5935             out_ext->protectedMemory = in_ext->protectedMemory;
5936             out_header->pNext = (void *)out_ext;
5937             out_header = (void *)out_ext;
5938             break;
5939         }
5940         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
5941         {
5942             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5943             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
5944             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
5945             out_ext->pNext = NULL;
5946             out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations;
5947             out_header->pNext = (void *)out_ext;
5948             out_header = (void *)out_ext;
5949             break;
5950         }
5951         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
5952         {
5953             VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5954             const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header;
5955             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
5956             out_ext->pNext = NULL;
5957             out_ext->multiDraw = in_ext->multiDraw;
5958             out_header->pNext = (void *)out_ext;
5959             out_header = (void *)out_ext;
5960             break;
5961         }
5962         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
5963         {
5964             VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5965             const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header;
5966             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
5967             out_ext->pNext = NULL;
5968             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
5969             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
5970             out_header->pNext = (void *)out_ext;
5971             out_header = (void *)out_ext;
5972             break;
5973         }
5974         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
5975         {
5976             VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5977             const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header;
5978             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
5979             out_ext->pNext = NULL;
5980             out_ext->maintenance4 = in_ext->maintenance4;
5981             out_header->pNext = (void *)out_ext;
5982             out_header = (void *)out_ext;
5983             break;
5984         }
5985         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
5986         {
5987             VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5988             const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
5989             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
5990             out_ext->pNext = NULL;
5991             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
5992             out_header->pNext = (void *)out_ext;
5993             out_header = (void *)out_ext;
5994             break;
5995         }
5996         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
5997         {
5998             VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
5999             const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
6000             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
6001             out_ext->pNext = NULL;
6002             out_ext->shaderFloat16 = in_ext->shaderFloat16;
6003             out_ext->shaderInt8 = in_ext->shaderInt8;
6004             out_header->pNext = (void *)out_ext;
6005             out_header = (void *)out_ext;
6006             break;
6007         }
6008         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
6009         {
6010             VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6011             const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
6012             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
6013             out_ext->pNext = NULL;
6014             out_ext->hostQueryReset = in_ext->hostQueryReset;
6015             out_header->pNext = (void *)out_ext;
6016             out_header = (void *)out_ext;
6017             break;
6018         }
6019         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
6020         {
6021             VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6022             const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *)in_header;
6023             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
6024             out_ext->pNext = NULL;
6025             out_ext->globalPriorityQuery = in_ext->globalPriorityQuery;
6026             out_header->pNext = (void *)out_ext;
6027             out_header = (void *)out_ext;
6028             break;
6029         }
6030         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
6031         {
6032             VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6033             const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
6034             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
6035             out_ext->pNext = NULL;
6036             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
6037             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
6038             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
6039             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
6040             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
6041             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
6042             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
6043             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
6044             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
6045             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
6046             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
6047             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
6048             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
6049             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
6050             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
6051             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
6052             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
6053             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
6054             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
6055             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
6056             out_header->pNext = (void *)out_ext;
6057             out_header = (void *)out_ext;
6058             break;
6059         }
6060         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
6061         {
6062             VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6063             const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
6064             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
6065             out_ext->pNext = NULL;
6066             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
6067             out_header->pNext = (void *)out_ext;
6068             out_header = (void *)out_ext;
6069             break;
6070         }
6071         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
6072         {
6073             VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6074             const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
6075             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
6076             out_ext->pNext = NULL;
6077             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
6078             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
6079             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
6080             out_header->pNext = (void *)out_ext;
6081             out_header = (void *)out_ext;
6082             break;
6083         }
6084         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
6085         {
6086             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6087             const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
6088             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
6089             out_ext->pNext = NULL;
6090             out_ext->conditionalRendering = in_ext->conditionalRendering;
6091             out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering;
6092             out_header->pNext = (void *)out_ext;
6093             out_header = (void *)out_ext;
6094             break;
6095         }
6096         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
6097         {
6098             VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6099             const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
6100             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
6101             out_ext->pNext = NULL;
6102             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
6103             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
6104             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
6105             out_header->pNext = (void *)out_ext;
6106             out_header = (void *)out_ext;
6107             break;
6108         }
6109         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
6110         {
6111             VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6112             const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
6113             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
6114             out_ext->pNext = NULL;
6115             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
6116             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
6117             out_header->pNext = (void *)out_ext;
6118             out_header = (void *)out_ext;
6119             break;
6120         }
6121         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
6122         {
6123             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6124             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
6125             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
6126             out_ext->pNext = NULL;
6127             out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics;
6128             out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd;
6129             out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics;
6130             out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd;
6131             out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics;
6132             out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd;
6133             out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics;
6134             out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd;
6135             out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics;
6136             out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd;
6137             out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics;
6138             out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd;
6139             out_header->pNext = (void *)out_ext;
6140             out_header = (void *)out_ext;
6141             break;
6142         }
6143         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
6144         {
6145             VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6146             const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header;
6147             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
6148             out_ext->pNext = NULL;
6149             out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics;
6150             out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd;
6151             out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax;
6152             out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax;
6153             out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax;
6154             out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics;
6155             out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd;
6156             out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax;
6157             out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax;
6158             out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax;
6159             out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax;
6160             out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax;
6161             out_header->pNext = (void *)out_ext;
6162             out_header = (void *)out_ext;
6163             break;
6164         }
6165         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
6166         {
6167             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6168             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header;
6169             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
6170             out_ext->pNext = NULL;
6171             out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor;
6172             out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor;
6173             out_header->pNext = (void *)out_ext;
6174             out_header = (void *)out_ext;
6175             break;
6176         }
6177         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
6178         {
6179             VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6180             const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
6181             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
6182             out_ext->pNext = NULL;
6183             out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent;
6184             out_header->pNext = (void *)out_ext;
6185             out_header = (void *)out_ext;
6186             break;
6187         }
6188         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
6189         {
6190             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6191             const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
6192             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
6193             out_ext->pNext = NULL;
6194             out_ext->transformFeedback = in_ext->transformFeedback;
6195             out_ext->geometryStreams = in_ext->geometryStreams;
6196             out_header->pNext = (void *)out_ext;
6197             out_header = (void *)out_ext;
6198             break;
6199         }
6200         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
6201         {
6202             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6203             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
6204             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
6205             out_ext->pNext = NULL;
6206             out_ext->representativeFragmentTest = in_ext->representativeFragmentTest;
6207             out_header->pNext = (void *)out_ext;
6208             out_header = (void *)out_ext;
6209             break;
6210         }
6211         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
6212         {
6213             VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6214             const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
6215             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
6216             out_ext->pNext = NULL;
6217             out_ext->exclusiveScissor = in_ext->exclusiveScissor;
6218             out_header->pNext = (void *)out_ext;
6219             out_header = (void *)out_ext;
6220             break;
6221         }
6222         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
6223         {
6224             VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6225             const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
6226             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
6227             out_ext->pNext = NULL;
6228             out_ext->cornerSampledImage = in_ext->cornerSampledImage;
6229             out_header->pNext = (void *)out_ext;
6230             out_header = (void *)out_ext;
6231             break;
6232         }
6233         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
6234         {
6235             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6236             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header;
6237             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
6238             out_ext->pNext = NULL;
6239             out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads;
6240             out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear;
6241             out_header->pNext = (void *)out_ext;
6242             out_header = (void *)out_ext;
6243             break;
6244         }
6245         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
6246         {
6247             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6248             const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
6249             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
6250             out_ext->pNext = NULL;
6251             out_ext->imageFootprint = in_ext->imageFootprint;
6252             out_header->pNext = (void *)out_ext;
6253             out_header = (void *)out_ext;
6254             break;
6255         }
6256         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
6257         {
6258             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6259             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
6260             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
6261             out_ext->pNext = NULL;
6262             out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing;
6263             out_header->pNext = (void *)out_ext;
6264             out_header = (void *)out_ext;
6265             break;
6266         }
6267         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
6268         {
6269             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6270             const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header;
6271             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
6272             out_ext->pNext = NULL;
6273             out_ext->indirectCopy = in_ext->indirectCopy;
6274             out_header->pNext = (void *)out_ext;
6275             out_header = (void *)out_ext;
6276             break;
6277         }
6278         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
6279         {
6280             VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6281             const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header;
6282             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
6283             out_ext->pNext = NULL;
6284             out_ext->memoryDecompression = in_ext->memoryDecompression;
6285             out_header->pNext = (void *)out_ext;
6286             out_header = (void *)out_ext;
6287             break;
6288         }
6289         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
6290         {
6291             VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6292             const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
6293             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
6294             out_ext->pNext = NULL;
6295             out_ext->shadingRateImage = in_ext->shadingRateImage;
6296             out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder;
6297             out_header->pNext = (void *)out_ext;
6298             out_header = (void *)out_ext;
6299             break;
6300         }
6301         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
6302         {
6303             VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6304             const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header;
6305             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
6306             out_ext->pNext = NULL;
6307             out_ext->invocationMask = in_ext->invocationMask;
6308             out_header->pNext = (void *)out_ext;
6309             out_header = (void *)out_ext;
6310             break;
6311         }
6312         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
6313         {
6314             VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6315             const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
6316             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
6317             out_ext->pNext = NULL;
6318             out_ext->taskShader = in_ext->taskShader;
6319             out_ext->meshShader = in_ext->meshShader;
6320             out_header->pNext = (void *)out_ext;
6321             out_header = (void *)out_ext;
6322             break;
6323         }
6324         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
6325         {
6326             VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6327             const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header;
6328             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
6329             out_ext->pNext = NULL;
6330             out_ext->taskShader = in_ext->taskShader;
6331             out_ext->meshShader = in_ext->meshShader;
6332             out_ext->multiviewMeshShader = in_ext->multiviewMeshShader;
6333             out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader;
6334             out_ext->meshShaderQueries = in_ext->meshShaderQueries;
6335             out_header->pNext = (void *)out_ext;
6336             out_header = (void *)out_ext;
6337             break;
6338         }
6339         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
6340         {
6341             VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6342             const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header;
6343             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
6344             out_ext->pNext = NULL;
6345             out_ext->accelerationStructure = in_ext->accelerationStructure;
6346             out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay;
6347             out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild;
6348             out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands;
6349             out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind;
6350             out_header->pNext = (void *)out_ext;
6351             out_header = (void *)out_ext;
6352             break;
6353         }
6354         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
6355         {
6356             VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6357             const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header;
6358             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
6359             out_ext->pNext = NULL;
6360             out_ext->rayTracingPipeline = in_ext->rayTracingPipeline;
6361             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay;
6362             out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
6363             out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect;
6364             out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling;
6365             out_header->pNext = (void *)out_ext;
6366             out_header = (void *)out_ext;
6367             break;
6368         }
6369         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
6370         {
6371             VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6372             const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header;
6373             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
6374             out_ext->pNext = NULL;
6375             out_ext->rayQuery = in_ext->rayQuery;
6376             out_header->pNext = (void *)out_ext;
6377             out_header = (void *)out_ext;
6378             break;
6379         }
6380         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
6381         {
6382             VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6383             const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header;
6384             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
6385             out_ext->pNext = NULL;
6386             out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1;
6387             out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2;
6388             out_header->pNext = (void *)out_ext;
6389             out_header = (void *)out_ext;
6390             break;
6391         }
6392         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
6393         {
6394             VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6395             const VkDeviceMemoryOverallocationCreateInfoAMD *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD *)in_header;
6396             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
6397             out_ext->pNext = NULL;
6398             out_ext->overallocationBehavior = in_ext->overallocationBehavior;
6399             out_header->pNext = (void *)out_ext;
6400             out_header = (void *)out_ext;
6401             break;
6402         }
6403         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
6404         {
6405             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6406             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
6407             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
6408             out_ext->pNext = NULL;
6409             out_ext->fragmentDensityMap = in_ext->fragmentDensityMap;
6410             out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic;
6411             out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages;
6412             out_header->pNext = (void *)out_ext;
6413             out_header = (void *)out_ext;
6414             break;
6415         }
6416         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
6417         {
6418             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6419             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
6420             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
6421             out_ext->pNext = NULL;
6422             out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred;
6423             out_header->pNext = (void *)out_ext;
6424             out_header = (void *)out_ext;
6425             break;
6426         }
6427         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
6428         {
6429             VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6430             const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *)in_header;
6431             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
6432             out_ext->pNext = NULL;
6433             out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset;
6434             out_header->pNext = (void *)out_ext;
6435             out_header = (void *)out_ext;
6436             break;
6437         }
6438         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
6439         {
6440             VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6441             const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
6442             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
6443             out_ext->pNext = NULL;
6444             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
6445             out_header->pNext = (void *)out_ext;
6446             out_header = (void *)out_ext;
6447             break;
6448         }
6449         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
6450         {
6451             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6452             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
6453             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
6454             out_ext->pNext = NULL;
6455             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
6456             out_header->pNext = (void *)out_ext;
6457             out_header = (void *)out_ext;
6458             break;
6459         }
6460         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
6461         {
6462             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6463             const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
6464             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
6465             out_ext->pNext = NULL;
6466             out_ext->depthClipEnable = in_ext->depthClipEnable;
6467             out_header->pNext = (void *)out_ext;
6468             out_header = (void *)out_ext;
6469             break;
6470         }
6471         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
6472         {
6473             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6474             const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
6475             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
6476             out_ext->pNext = NULL;
6477             out_ext->memoryPriority = in_ext->memoryPriority;
6478             out_header->pNext = (void *)out_ext;
6479             out_header = (void *)out_ext;
6480             break;
6481         }
6482         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
6483         {
6484             VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6485             const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header;
6486             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
6487             out_ext->pNext = NULL;
6488             out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory;
6489             out_header->pNext = (void *)out_ext;
6490             out_header = (void *)out_ext;
6491             break;
6492         }
6493         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
6494         {
6495             VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6496             const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
6497             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
6498             out_ext->pNext = NULL;
6499             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
6500             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
6501             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
6502             out_header->pNext = (void *)out_ext;
6503             out_header = (void *)out_ext;
6504             break;
6505         }
6506         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
6507         {
6508             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6509             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
6510             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
6511             out_ext->pNext = NULL;
6512             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
6513             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
6514             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
6515             out_header->pNext = (void *)out_ext;
6516             out_header = (void *)out_ext;
6517             break;
6518         }
6519         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
6520         {
6521             VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6522             const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
6523             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
6524             out_ext->pNext = NULL;
6525             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
6526             out_header->pNext = (void *)out_ext;
6527             out_header = (void *)out_ext;
6528             break;
6529         }
6530         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
6531         {
6532             VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6533             const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header;
6534             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
6535             out_ext->pNext = NULL;
6536             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
6537             out_header->pNext = (void *)out_ext;
6538             out_header = (void *)out_ext;
6539             break;
6540         }
6541         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
6542         {
6543             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6544             const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
6545             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
6546             out_ext->pNext = NULL;
6547             out_ext->cooperativeMatrix = in_ext->cooperativeMatrix;
6548             out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess;
6549             out_header->pNext = (void *)out_ext;
6550             out_header = (void *)out_ext;
6551             break;
6552         }
6553         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
6554         {
6555             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6556             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
6557             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
6558             out_ext->pNext = NULL;
6559             out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays;
6560             out_header->pNext = (void *)out_ext;
6561             out_header = (void *)out_ext;
6562             break;
6563         }
6564         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
6565         {
6566             VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6567             const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header;
6568             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
6569             out_ext->pNext = NULL;
6570             out_ext->presentBarrier = in_ext->presentBarrier;
6571             out_header->pNext = (void *)out_ext;
6572             out_header = (void *)out_ext;
6573             break;
6574         }
6575         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
6576         {
6577             VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6578             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
6579             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
6580             out_ext->pNext = NULL;
6581             out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools;
6582             out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools;
6583             out_header->pNext = (void *)out_ext;
6584             out_header = (void *)out_ext;
6585             break;
6586         }
6587         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
6588         {
6589             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6590             const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
6591             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
6592             out_ext->pNext = NULL;
6593             out_ext->coverageReductionMode = in_ext->coverageReductionMode;
6594             out_header->pNext = (void *)out_ext;
6595             out_header = (void *)out_ext;
6596             break;
6597         }
6598         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
6599         {
6600             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6601             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
6602             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
6603             out_ext->pNext = NULL;
6604             out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2;
6605             out_header->pNext = (void *)out_ext;
6606             out_header = (void *)out_ext;
6607             break;
6608         }
6609         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
6610         {
6611             VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6612             const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
6613             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
6614             out_ext->pNext = NULL;
6615             out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock;
6616             out_ext->shaderDeviceClock = in_ext->shaderDeviceClock;
6617             out_header->pNext = (void *)out_ext;
6618             out_header = (void *)out_ext;
6619             break;
6620         }
6621         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
6622         {
6623             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6624             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header;
6625             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
6626             out_ext->pNext = NULL;
6627             out_ext->indexTypeUint8 = in_ext->indexTypeUint8;
6628             out_header->pNext = (void *)out_ext;
6629             out_header = (void *)out_ext;
6630             break;
6631         }
6632         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
6633         {
6634             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6635             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
6636             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
6637             out_ext->pNext = NULL;
6638             out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins;
6639             out_header->pNext = (void *)out_ext;
6640             out_header = (void *)out_ext;
6641             break;
6642         }
6643         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
6644         {
6645             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6646             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
6647             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
6648             out_ext->pNext = NULL;
6649             out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock;
6650             out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock;
6651             out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock;
6652             out_header->pNext = (void *)out_ext;
6653             out_header = (void *)out_ext;
6654             break;
6655         }
6656         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
6657         {
6658             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6659             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
6660             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
6661             out_ext->pNext = NULL;
6662             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
6663             out_header->pNext = (void *)out_ext;
6664             out_header = (void *)out_ext;
6665             break;
6666         }
6667         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
6668         {
6669             VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6670             const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header;
6671             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
6672             out_ext->pNext = NULL;
6673             out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart;
6674             out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart;
6675             out_header->pNext = (void *)out_ext;
6676             out_header = (void *)out_ext;
6677             break;
6678         }
6679         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
6680         {
6681             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6682             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
6683             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
6684             out_ext->pNext = NULL;
6685             out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo;
6686             out_header->pNext = (void *)out_ext;
6687             out_header = (void *)out_ext;
6688             break;
6689         }
6690         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
6691         {
6692             VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6693             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header;
6694             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
6695             out_ext->pNext = NULL;
6696             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
6697             out_header->pNext = (void *)out_ext;
6698             out_header = (void *)out_ext;
6699             break;
6700         }
6701         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
6702         {
6703             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6704             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
6705             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
6706             out_ext->pNext = NULL;
6707             out_ext->texelBufferAlignment = in_ext->texelBufferAlignment;
6708             out_header->pNext = (void *)out_ext;
6709             out_header = (void *)out_ext;
6710             break;
6711         }
6712         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
6713         {
6714             VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6715             const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header;
6716             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
6717             out_ext->pNext = NULL;
6718             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
6719             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
6720             out_header->pNext = (void *)out_ext;
6721             out_header = (void *)out_ext;
6722             break;
6723         }
6724         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
6725         {
6726             VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6727             const VkPhysicalDeviceLineRasterizationFeaturesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header;
6728             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
6729             out_ext->pNext = NULL;
6730             out_ext->rectangularLines = in_ext->rectangularLines;
6731             out_ext->bresenhamLines = in_ext->bresenhamLines;
6732             out_ext->smoothLines = in_ext->smoothLines;
6733             out_ext->stippledRectangularLines = in_ext->stippledRectangularLines;
6734             out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines;
6735             out_ext->stippledSmoothLines = in_ext->stippledSmoothLines;
6736             out_header->pNext = (void *)out_ext;
6737             out_header = (void *)out_ext;
6738             break;
6739         }
6740         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
6741         {
6742             VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6743             const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header;
6744             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
6745             out_ext->pNext = NULL;
6746             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
6747             out_header->pNext = (void *)out_ext;
6748             out_header = (void *)out_ext;
6749             break;
6750         }
6751         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
6752         {
6753             VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6754             const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header;
6755             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
6756             out_ext->pNext = NULL;
6757             out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess;
6758             out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess;
6759             out_ext->storagePushConstant16 = in_ext->storagePushConstant16;
6760             out_ext->storageInputOutput16 = in_ext->storageInputOutput16;
6761             out_ext->multiview = in_ext->multiview;
6762             out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader;
6763             out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader;
6764             out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer;
6765             out_ext->variablePointers = in_ext->variablePointers;
6766             out_ext->protectedMemory = in_ext->protectedMemory;
6767             out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion;
6768             out_ext->shaderDrawParameters = in_ext->shaderDrawParameters;
6769             out_header->pNext = (void *)out_ext;
6770             out_header = (void *)out_ext;
6771             break;
6772         }
6773         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
6774         {
6775             VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6776             const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header;
6777             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
6778             out_ext->pNext = NULL;
6779             out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge;
6780             out_ext->drawIndirectCount = in_ext->drawIndirectCount;
6781             out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess;
6782             out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess;
6783             out_ext->storagePushConstant8 = in_ext->storagePushConstant8;
6784             out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics;
6785             out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics;
6786             out_ext->shaderFloat16 = in_ext->shaderFloat16;
6787             out_ext->shaderInt8 = in_ext->shaderInt8;
6788             out_ext->descriptorIndexing = in_ext->descriptorIndexing;
6789             out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing;
6790             out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing;
6791             out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing;
6792             out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing;
6793             out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing;
6794             out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing;
6795             out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing;
6796             out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing;
6797             out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing;
6798             out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing;
6799             out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind;
6800             out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind;
6801             out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind;
6802             out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind;
6803             out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind;
6804             out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind;
6805             out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending;
6806             out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound;
6807             out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount;
6808             out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray;
6809             out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax;
6810             out_ext->scalarBlockLayout = in_ext->scalarBlockLayout;
6811             out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer;
6812             out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout;
6813             out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes;
6814             out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts;
6815             out_ext->hostQueryReset = in_ext->hostQueryReset;
6816             out_ext->timelineSemaphore = in_ext->timelineSemaphore;
6817             out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress;
6818             out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay;
6819             out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice;
6820             out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel;
6821             out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope;
6822             out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains;
6823             out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex;
6824             out_ext->shaderOutputLayer = in_ext->shaderOutputLayer;
6825             out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId;
6826             out_header->pNext = (void *)out_ext;
6827             out_header = (void *)out_ext;
6828             break;
6829         }
6830         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
6831         {
6832             VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6833             const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header;
6834             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
6835             out_ext->pNext = NULL;
6836             out_ext->robustImageAccess = in_ext->robustImageAccess;
6837             out_ext->inlineUniformBlock = in_ext->inlineUniformBlock;
6838             out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind;
6839             out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl;
6840             out_ext->privateData = in_ext->privateData;
6841             out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation;
6842             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
6843             out_ext->subgroupSizeControl = in_ext->subgroupSizeControl;
6844             out_ext->computeFullSubgroups = in_ext->computeFullSubgroups;
6845             out_ext->synchronization2 = in_ext->synchronization2;
6846             out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR;
6847             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
6848             out_ext->dynamicRendering = in_ext->dynamicRendering;
6849             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
6850             out_ext->maintenance4 = in_ext->maintenance4;
6851             out_header->pNext = (void *)out_ext;
6852             out_header = (void *)out_ext;
6853             break;
6854         }
6855         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
6856         {
6857             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6858             const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
6859             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
6860             out_ext->pNext = NULL;
6861             out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory;
6862             out_header->pNext = (void *)out_ext;
6863             out_header = (void *)out_ext;
6864             break;
6865         }
6866         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
6867         {
6868             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6869             const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
6870             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
6871             out_ext->pNext = NULL;
6872             out_ext->customBorderColors = in_ext->customBorderColors;
6873             out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat;
6874             out_header->pNext = (void *)out_ext;
6875             out_header = (void *)out_ext;
6876             break;
6877         }
6878         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
6879         {
6880             VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6881             const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header;
6882             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
6883             out_ext->pNext = NULL;
6884             out_ext->borderColorSwizzle = in_ext->borderColorSwizzle;
6885             out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage;
6886             out_header->pNext = (void *)out_ext;
6887             out_header = (void *)out_ext;
6888             break;
6889         }
6890         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
6891         {
6892             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6893             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
6894             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
6895             out_ext->pNext = NULL;
6896             out_ext->extendedDynamicState = in_ext->extendedDynamicState;
6897             out_header->pNext = (void *)out_ext;
6898             out_header = (void *)out_ext;
6899             break;
6900         }
6901         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
6902         {
6903             VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6904             const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header;
6905             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
6906             out_ext->pNext = NULL;
6907             out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2;
6908             out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp;
6909             out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints;
6910             out_header->pNext = (void *)out_ext;
6911             out_header = (void *)out_ext;
6912             break;
6913         }
6914         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
6915         {
6916             VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6917             const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header;
6918             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
6919             out_ext->pNext = NULL;
6920             out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin;
6921             out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable;
6922             out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode;
6923             out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples;
6924             out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask;
6925             out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable;
6926             out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable;
6927             out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable;
6928             out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable;
6929             out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation;
6930             out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask;
6931             out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream;
6932             out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode;
6933             out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize;
6934             out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable;
6935             out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable;
6936             out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced;
6937             out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode;
6938             out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode;
6939             out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable;
6940             out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne;
6941             out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable;
6942             out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle;
6943             out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable;
6944             out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation;
6945             out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode;
6946             out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable;
6947             out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable;
6948             out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode;
6949             out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable;
6950             out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable;
6951             out_header->pNext = (void *)out_ext;
6952             out_header = (void *)out_ext;
6953             break;
6954         }
6955         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
6956         {
6957             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6958             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
6959             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
6960             out_ext->pNext = NULL;
6961             out_ext->diagnosticsConfig = in_ext->diagnosticsConfig;
6962             out_header->pNext = (void *)out_ext;
6963             out_header = (void *)out_ext;
6964             break;
6965         }
6966         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
6967         {
6968             VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6969             const VkDeviceDiagnosticsConfigCreateInfoNV *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV *)in_header;
6970             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
6971             out_ext->pNext = NULL;
6972             out_ext->flags = in_ext->flags;
6973             out_header->pNext = (void *)out_ext;
6974             out_header = (void *)out_ext;
6975             break;
6976         }
6977         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
6978         {
6979             VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6980             const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header;
6981             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
6982             out_ext->pNext = NULL;
6983             out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory;
6984             out_header->pNext = (void *)out_ext;
6985             out_header = (void *)out_ext;
6986             break;
6987         }
6988         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
6989         {
6990             VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
6991             const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header;
6992             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
6993             out_ext->pNext = NULL;
6994             out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow;
6995             out_header->pNext = (void *)out_ext;
6996             out_header = (void *)out_ext;
6997             break;
6998         }
6999         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
7000         {
7001             VkPhysicalDeviceRobustness2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7002             const VkPhysicalDeviceRobustness2FeaturesEXT *in_ext = (const VkPhysicalDeviceRobustness2FeaturesEXT *)in_header;
7003             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
7004             out_ext->pNext = NULL;
7005             out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2;
7006             out_ext->robustImageAccess2 = in_ext->robustImageAccess2;
7007             out_ext->nullDescriptor = in_ext->nullDescriptor;
7008             out_header->pNext = (void *)out_ext;
7009             out_header = (void *)out_ext;
7010             break;
7011         }
7012         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
7013         {
7014             VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7015             const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header;
7016             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
7017             out_ext->pNext = NULL;
7018             out_ext->robustImageAccess = in_ext->robustImageAccess;
7019             out_header->pNext = (void *)out_ext;
7020             out_header = (void *)out_ext;
7021             break;
7022         }
7023         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
7024         {
7025             VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7026             const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header;
7027             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
7028             out_ext->pNext = NULL;
7029             out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout;
7030             out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout;
7031             out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess;
7032             out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess;
7033             out_header->pNext = (void *)out_ext;
7034             out_header = (void *)out_ext;
7035             break;
7036         }
7037         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
7038         {
7039             VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7040             const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
7041             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
7042             out_ext->pNext = NULL;
7043             out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4;
7044             out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4;
7045             out_header->pNext = (void *)out_ext;
7046             out_header = (void *)out_ext;
7047             break;
7048         }
7049         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
7050         {
7051             VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7052             const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header;
7053             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
7054             out_ext->pNext = NULL;
7055             out_ext->subpassShading = in_ext->subpassShading;
7056             out_header->pNext = (void *)out_ext;
7057             out_header = (void *)out_ext;
7058             break;
7059         }
7060         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
7061         {
7062             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7063             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
7064             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
7065             out_ext->pNext = NULL;
7066             out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics;
7067             out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics;
7068             out_header->pNext = (void *)out_ext;
7069             out_header = (void *)out_ext;
7070             break;
7071         }
7072         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
7073         {
7074             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7075             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
7076             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
7077             out_ext->pNext = NULL;
7078             out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate;
7079             out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate;
7080             out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate;
7081             out_header->pNext = (void *)out_ext;
7082             out_header = (void *)out_ext;
7083             break;
7084         }
7085         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
7086         {
7087             VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7088             const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header;
7089             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
7090             out_ext->pNext = NULL;
7091             out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation;
7092             out_header->pNext = (void *)out_ext;
7093             out_header = (void *)out_ext;
7094             break;
7095         }
7096         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
7097         {
7098             VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7099             const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header;
7100             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
7101             out_ext->pNext = NULL;
7102             out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums;
7103             out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates;
7104             out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates;
7105             out_header->pNext = (void *)out_ext;
7106             out_header = (void *)out_ext;
7107             break;
7108         }
7109         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
7110         {
7111             VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7112             const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header;
7113             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
7114             out_ext->pNext = NULL;
7115             out_ext->image2DViewOf3D = in_ext->image2DViewOf3D;
7116             out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D;
7117             out_header->pNext = (void *)out_ext;
7118             out_header = (void *)out_ext;
7119             break;
7120         }
7121         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
7122         {
7123             VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7124             const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header;
7125             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
7126             out_ext->pNext = NULL;
7127             out_ext->mutableDescriptorType = in_ext->mutableDescriptorType;
7128             out_header->pNext = (void *)out_ext;
7129             out_header = (void *)out_ext;
7130             break;
7131         }
7132         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
7133         {
7134             VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7135             const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header;
7136             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
7137             out_ext->pNext = NULL;
7138             out_ext->depthClipControl = in_ext->depthClipControl;
7139             out_header->pNext = (void *)out_ext;
7140             out_header = (void *)out_ext;
7141             break;
7142         }
7143         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
7144         {
7145             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7146             const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header;
7147             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
7148             out_ext->pNext = NULL;
7149             out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState;
7150             out_header->pNext = (void *)out_ext;
7151             out_header = (void *)out_ext;
7152             break;
7153         }
7154         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
7155         {
7156             VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7157             const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header;
7158             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
7159             out_ext->pNext = NULL;
7160             out_ext->colorWriteEnable = in_ext->colorWriteEnable;
7161             out_header->pNext = (void *)out_ext;
7162             out_header = (void *)out_ext;
7163             break;
7164         }
7165         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
7166         {
7167             VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7168             const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header;
7169             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
7170             out_ext->pNext = NULL;
7171             out_ext->synchronization2 = in_ext->synchronization2;
7172             out_header->pNext = (void *)out_ext;
7173             out_header = (void *)out_ext;
7174             break;
7175         }
7176         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
7177         {
7178             VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7179             const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header;
7180             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
7181             out_ext->pNext = NULL;
7182             out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery;
7183             out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard;
7184             out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams;
7185             out_header->pNext = (void *)out_ext;
7186             out_header = (void *)out_ext;
7187             break;
7188         }
7189         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
7190         {
7191             VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7192             const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header;
7193             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
7194             out_ext->pNext = NULL;
7195             out_ext->legacyDithering = in_ext->legacyDithering;
7196             out_header->pNext = (void *)out_ext;
7197             out_header = (void *)out_ext;
7198             break;
7199         }
7200         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
7201         {
7202             VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7203             const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header;
7204             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
7205             out_ext->pNext = NULL;
7206             out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled;
7207             out_header->pNext = (void *)out_ext;
7208             out_header = (void *)out_ext;
7209             break;
7210         }
7211         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
7212         {
7213             VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7214             const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *)in_header;
7215             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
7216             out_ext->pNext = NULL;
7217             out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess;
7218             out_header->pNext = (void *)out_ext;
7219             out_header = (void *)out_ext;
7220             break;
7221         }
7222         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
7223         {
7224             VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7225             const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header;
7226             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
7227             out_ext->pNext = NULL;
7228             out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D;
7229             out_header->pNext = (void *)out_ext;
7230             out_header = (void *)out_ext;
7231             break;
7232         }
7233         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
7234         {
7235             VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7236             const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header;
7237             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
7238             out_ext->pNext = NULL;
7239             out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats;
7240             out_header->pNext = (void *)out_ext;
7241             out_header = (void *)out_ext;
7242             break;
7243         }
7244         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
7245         {
7246             VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7247             const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header;
7248             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
7249             out_ext->pNext = NULL;
7250             out_ext->provokingVertexLast = in_ext->provokingVertexLast;
7251             out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex;
7252             out_header->pNext = (void *)out_ext;
7253             out_header = (void *)out_ext;
7254             break;
7255         }
7256         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
7257         {
7258             VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7259             const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header;
7260             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
7261             out_ext->pNext = NULL;
7262             out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct;
7263             out_header->pNext = (void *)out_ext;
7264             out_header = (void *)out_ext;
7265             break;
7266         }
7267         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
7268         {
7269             VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7270             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header;
7271             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
7272             out_ext->pNext = NULL;
7273             out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric;
7274             out_header->pNext = (void *)out_ext;
7275             out_header = (void *)out_ext;
7276             break;
7277         }
7278         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
7279         {
7280             VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7281             const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header;
7282             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
7283             out_ext->pNext = NULL;
7284             out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur;
7285             out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect;
7286             out_header->pNext = (void *)out_ext;
7287             out_header = (void *)out_ext;
7288             break;
7289         }
7290         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
7291         {
7292             VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7293             const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header;
7294             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
7295             out_ext->pNext = NULL;
7296             out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler;
7297             out_header->pNext = (void *)out_ext;
7298             out_header = (void *)out_ext;
7299             break;
7300         }
7301         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
7302         {
7303             VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7304             const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header;
7305             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
7306             out_ext->pNext = NULL;
7307             out_ext->dynamicRendering = in_ext->dynamicRendering;
7308             out_header->pNext = (void *)out_ext;
7309             out_header = (void *)out_ext;
7310             break;
7311         }
7312         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
7313         {
7314             VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7315             const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header;
7316             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
7317             out_ext->pNext = NULL;
7318             out_ext->minLod = in_ext->minLod;
7319             out_header->pNext = (void *)out_ext;
7320             out_header = (void *)out_ext;
7321             break;
7322         }
7323         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
7324         {
7325             VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7326             const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header;
7327             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
7328             out_ext->pNext = NULL;
7329             out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess;
7330             out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess;
7331             out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess;
7332             out_header->pNext = (void *)out_ext;
7333             out_header = (void *)out_ext;
7334             break;
7335         }
7336         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
7337         {
7338             VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7339             const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header;
7340             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
7341             out_ext->pNext = NULL;
7342             out_ext->linearColorAttachment = in_ext->linearColorAttachment;
7343             out_header->pNext = (void *)out_ext;
7344             out_header = (void *)out_ext;
7345             break;
7346         }
7347         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
7348         {
7349             VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7350             const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header;
7351             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
7352             out_ext->pNext = NULL;
7353             out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary;
7354             out_header->pNext = (void *)out_ext;
7355             out_header = (void *)out_ext;
7356             break;
7357         }
7358         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
7359         {
7360             VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7361             const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header;
7362             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
7363             out_ext->pNext = NULL;
7364             out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping;
7365             out_header->pNext = (void *)out_ext;
7366             out_header = (void *)out_ext;
7367             break;
7368         }
7369         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
7370         {
7371             VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7372             const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header;
7373             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
7374             out_ext->pNext = NULL;
7375             out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier;
7376             out_header->pNext = (void *)out_ext;
7377             out_header = (void *)out_ext;
7378             break;
7379         }
7380         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
7381         {
7382             VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7383             const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header;
7384             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
7385             out_ext->pNext = NULL;
7386             out_ext->imageCompressionControl = in_ext->imageCompressionControl;
7387             out_header->pNext = (void *)out_ext;
7388             out_header = (void *)out_ext;
7389             break;
7390         }
7391         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
7392         {
7393             VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7394             const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header;
7395             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
7396             out_ext->pNext = NULL;
7397             out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain;
7398             out_header->pNext = (void *)out_ext;
7399             out_header = (void *)out_ext;
7400             break;
7401         }
7402         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
7403         {
7404             VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7405             const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header;
7406             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
7407             out_ext->pNext = NULL;
7408             out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback;
7409             out_header->pNext = (void *)out_ext;
7410             out_header = (void *)out_ext;
7411             break;
7412         }
7413         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
7414         {
7415             VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7416             const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header;
7417             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
7418             out_ext->pNext = NULL;
7419             out_ext->micromap = in_ext->micromap;
7420             out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay;
7421             out_ext->micromapHostCommands = in_ext->micromapHostCommands;
7422             out_header->pNext = (void *)out_ext;
7423             out_header = (void *)out_ext;
7424             break;
7425         }
7426         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
7427         {
7428             VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7429             const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header;
7430             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
7431             out_ext->pNext = NULL;
7432             out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier;
7433             out_header->pNext = (void *)out_ext;
7434             out_header = (void *)out_ext;
7435             break;
7436         }
7437         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
7438         {
7439             VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7440             const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header;
7441             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
7442             out_ext->pNext = NULL;
7443             out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests;
7444             out_header->pNext = (void *)out_ext;
7445             out_header = (void *)out_ext;
7446             break;
7447         }
7448         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
7449         {
7450             VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7451             const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header;
7452             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
7453             out_ext->pNext = NULL;
7454             out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap;
7455             out_header->pNext = (void *)out_ext;
7456             out_header = (void *)out_ext;
7457             break;
7458         }
7459         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
7460         {
7461             VkPhysicalDevicePipelineRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7462             const VkPhysicalDevicePipelineRobustnessFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessFeaturesEXT *)in_header;
7463             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
7464             out_ext->pNext = NULL;
7465             out_ext->pipelineRobustness = in_ext->pipelineRobustness;
7466             out_header->pNext = (void *)out_ext;
7467             out_header = (void *)out_ext;
7468             break;
7469         }
7470         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
7471         {
7472             VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7473             const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header;
7474             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
7475             out_ext->pNext = NULL;
7476             out_ext->textureSampleWeighted = in_ext->textureSampleWeighted;
7477             out_ext->textureBoxFilter = in_ext->textureBoxFilter;
7478             out_ext->textureBlockMatch = in_ext->textureBlockMatch;
7479             out_header->pNext = (void *)out_ext;
7480             out_header = (void *)out_ext;
7481             break;
7482         }
7483         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
7484         {
7485             VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7486             const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header;
7487             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
7488             out_ext->pNext = NULL;
7489             out_ext->tileProperties = in_ext->tileProperties;
7490             out_header->pNext = (void *)out_ext;
7491             out_header = (void *)out_ext;
7492             break;
7493         }
7494         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
7495         {
7496             VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7497             const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header;
7498             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
7499             out_ext->pNext = NULL;
7500             out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout;
7501             out_header->pNext = (void *)out_ext;
7502             out_header = (void *)out_ext;
7503             break;
7504         }
7505         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
7506         {
7507             VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7508             const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *)in_header;
7509             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
7510             out_ext->pNext = NULL;
7511             out_ext->depthClampZeroOne = in_ext->depthClampZeroOne;
7512             out_header->pNext = (void *)out_ext;
7513             out_header = (void *)out_ext;
7514             break;
7515         }
7516         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
7517         {
7518             VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7519             const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header;
7520             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
7521             out_ext->pNext = NULL;
7522             out_ext->reportAddressBinding = in_ext->reportAddressBinding;
7523             out_header->pNext = (void *)out_ext;
7524             out_header = (void *)out_ext;
7525             break;
7526         }
7527         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
7528         {
7529             VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7530             const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header;
7531             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
7532             out_ext->pNext = NULL;
7533             out_ext->opticalFlow = in_ext->opticalFlow;
7534             out_header->pNext = (void *)out_ext;
7535             out_header = (void *)out_ext;
7536             break;
7537         }
7538         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
7539         {
7540             VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7541             const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header;
7542             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
7543             out_ext->pNext = NULL;
7544             out_ext->deviceFault = in_ext->deviceFault;
7545             out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary;
7546             out_header->pNext = (void *)out_ext;
7547             out_header = (void *)out_ext;
7548             break;
7549         }
7550         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
7551         {
7552             VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7553             const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header;
7554             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
7555             out_ext->pNext = NULL;
7556             out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins;
7557             out_header->pNext = (void *)out_ext;
7558             out_header = (void *)out_ext;
7559             break;
7560         }
7561         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
7562         {
7563             VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7564             const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header;
7565             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
7566             out_ext->pNext = NULL;
7567             out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder;
7568             out_header->pNext = (void *)out_ext;
7569             out_header = (void *)out_ext;
7570             break;
7571         }
7572         default:
7573             FIXME("Unhandled sType %u.", in_header->sType);
7574             break;
7575         }
7576     }
7577 }
7578 #endif /* USE_STRUCT_CONVERSION */
7579
7580 #if defined(USE_STRUCT_CONVERSION)
7581 static inline void convert_VkFramebufferCreateInfo_win32_to_host(const VkFramebufferCreateInfo32 *in, VkFramebufferCreateInfo *out)
7582 {
7583     if (!in) return;
7584
7585     out->sType = in->sType;
7586     out->pNext = in->pNext;
7587     out->flags = in->flags;
7588     out->renderPass = in->renderPass;
7589     out->attachmentCount = in->attachmentCount;
7590     out->pAttachments = in->pAttachments;
7591     out->width = in->width;
7592     out->height = in->height;
7593     out->layers = in->layers;
7594 }
7595 #endif /* USE_STRUCT_CONVERSION */
7596
7597 #if !defined(USE_STRUCT_CONVERSION)
7598 static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, uint32_t count)
7599 {
7600     VkPipelineShaderStageCreateInfo *out;
7601     unsigned int i;
7602
7603     if (!in || !count) return NULL;
7604
7605     out = conversion_context_alloc(ctx, count * sizeof(*out));
7606     for (i = 0; i < count; i++)
7607     {
7608         convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
7609     }
7610
7611     return out;
7612 }
7613 #endif /* USE_STRUCT_CONVERSION */
7614
7615 #if defined(USE_STRUCT_CONVERSION)
7616 static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, uint32_t count)
7617 {
7618     VkPipelineShaderStageCreateInfo *out;
7619     unsigned int i;
7620
7621     if (!in || !count) return NULL;
7622
7623     out = conversion_context_alloc(ctx, count * sizeof(*out));
7624     for (i = 0; i < count; i++)
7625     {
7626         convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
7627     }
7628
7629     return out;
7630 }
7631 #endif /* USE_STRUCT_CONVERSION */
7632
7633 #if !defined(USE_STRUCT_CONVERSION)
7634 static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, VkGraphicsShaderGroupCreateInfoNV *out)
7635 {
7636     if (!in) return;
7637
7638     out->sType = in->sType;
7639     out->pNext = in->pNext;
7640     out->stageCount = in->stageCount;
7641     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
7642     out->pVertexInputState = in->pVertexInputState;
7643     out->pTessellationState = in->pTessellationState;
7644 }
7645 #endif /* USE_STRUCT_CONVERSION */
7646
7647 #if defined(USE_STRUCT_CONVERSION)
7648 static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, VkGraphicsShaderGroupCreateInfoNV *out)
7649 {
7650     if (!in) return;
7651
7652     out->sType = in->sType;
7653     out->pNext = in->pNext;
7654     out->stageCount = in->stageCount;
7655     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
7656     out->pVertexInputState = in->pVertexInputState;
7657     out->pTessellationState = in->pTessellationState;
7658 }
7659 #endif /* USE_STRUCT_CONVERSION */
7660
7661 #if !defined(USE_STRUCT_CONVERSION)
7662 static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, uint32_t count)
7663 {
7664     VkGraphicsShaderGroupCreateInfoNV *out;
7665     unsigned int i;
7666
7667     if (!in || !count) return NULL;
7668
7669     out = conversion_context_alloc(ctx, count * sizeof(*out));
7670     for (i = 0; i < count; i++)
7671     {
7672         convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
7673     }
7674
7675     return out;
7676 }
7677 #endif /* USE_STRUCT_CONVERSION */
7678
7679 #if defined(USE_STRUCT_CONVERSION)
7680 static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, uint32_t count)
7681 {
7682     VkGraphicsShaderGroupCreateInfoNV *out;
7683     unsigned int i;
7684
7685     if (!in || !count) return NULL;
7686
7687     out = conversion_context_alloc(ctx, count * sizeof(*out));
7688     for (i = 0; i < count; i++)
7689     {
7690         convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
7691     }
7692
7693     return out;
7694 }
7695 #endif /* USE_STRUCT_CONVERSION */
7696
7697 #if !defined(USE_STRUCT_CONVERSION)
7698 static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, VkGraphicsPipelineCreateInfo *out)
7699 {
7700     const VkBaseInStructure *in_header;
7701     VkBaseOutStructure *out_header = (void *)out;
7702
7703     if (!in) return;
7704
7705     out->sType = in->sType;
7706     out->pNext = NULL;
7707     out->flags = in->flags;
7708     out->stageCount = in->stageCount;
7709     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
7710     out->pVertexInputState = in->pVertexInputState;
7711     out->pInputAssemblyState = in->pInputAssemblyState;
7712     out->pTessellationState = in->pTessellationState;
7713     out->pViewportState = in->pViewportState;
7714     out->pRasterizationState = in->pRasterizationState;
7715     out->pMultisampleState = in->pMultisampleState;
7716     out->pDepthStencilState = in->pDepthStencilState;
7717     out->pColorBlendState = in->pColorBlendState;
7718     out->pDynamicState = in->pDynamicState;
7719     out->layout = in->layout;
7720     out->renderPass = in->renderPass;
7721     out->subpass = in->subpass;
7722     out->basePipelineHandle = in->basePipelineHandle;
7723     out->basePipelineIndex = in->basePipelineIndex;
7724
7725     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
7726     {
7727         switch (in_header->sType)
7728         {
7729         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
7730         {
7731             VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7732             const VkGraphicsPipelineShaderGroupsCreateInfoNV *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV *)in_header;
7733             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
7734             out_ext->pNext = NULL;
7735             out_ext->groupCount = in_ext->groupCount;
7736             out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(ctx, in_ext->pGroups, in_ext->groupCount);
7737             out_ext->pipelineCount = in_ext->pipelineCount;
7738             out_ext->pPipelines = in_ext->pPipelines;
7739             out_header->pNext = (void *)out_ext;
7740             out_header = (void *)out_ext;
7741             break;
7742         }
7743         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
7744         {
7745             VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7746             const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header;
7747             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
7748             out_ext->pNext = NULL;
7749             out_ext->flags = in_ext->flags;
7750             out_ext->discardRectangleMode = in_ext->discardRectangleMode;
7751             out_ext->discardRectangleCount = in_ext->discardRectangleCount;
7752             out_ext->pDiscardRectangles = in_ext->pDiscardRectangles;
7753             out_header->pNext = (void *)out_ext;
7754             out_header = (void *)out_ext;
7755             break;
7756         }
7757         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
7758         {
7759             VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7760             const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header;
7761             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
7762             out_ext->pNext = NULL;
7763             out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
7764             out_header->pNext = (void *)out_ext;
7765             out_header = (void *)out_ext;
7766             break;
7767         }
7768         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
7769         {
7770             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7771             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
7772             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
7773             out_ext->pNext = NULL;
7774             out_ext->pPipelineCreationFeedback = in_ext->pPipelineCreationFeedback;
7775             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
7776             out_ext->pPipelineStageCreationFeedbacks = in_ext->pPipelineStageCreationFeedbacks;
7777             out_header->pNext = (void *)out_ext;
7778             out_header = (void *)out_ext;
7779             break;
7780         }
7781         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
7782         {
7783             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7784             const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header;
7785             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
7786             out_ext->pNext = NULL;
7787             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
7788             out_header->pNext = (void *)out_ext;
7789             out_header = (void *)out_ext;
7790             break;
7791         }
7792         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
7793         {
7794             VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7795             const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header;
7796             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
7797             out_ext->pNext = NULL;
7798             out_ext->libraryCount = in_ext->libraryCount;
7799             out_ext->pLibraries = in_ext->pLibraries;
7800             out_header->pNext = (void *)out_ext;
7801             out_header = (void *)out_ext;
7802             break;
7803         }
7804         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
7805         {
7806             VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7807             const VkPipelineFragmentShadingRateStateCreateInfoKHR *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR *)in_header;
7808             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
7809             out_ext->pNext = NULL;
7810             out_ext->fragmentSize = in_ext->fragmentSize;
7811             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
7812             out_header->pNext = (void *)out_ext;
7813             out_header = (void *)out_ext;
7814             break;
7815         }
7816         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
7817         {
7818             VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7819             const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header;
7820             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
7821             out_ext->pNext = NULL;
7822             out_ext->shadingRateType = in_ext->shadingRateType;
7823             out_ext->shadingRate = in_ext->shadingRate;
7824             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
7825             out_header->pNext = (void *)out_ext;
7826             out_header = (void *)out_ext;
7827             break;
7828         }
7829         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
7830         {
7831             VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7832             const VkPipelineRenderingCreateInfo *in_ext = (const VkPipelineRenderingCreateInfo *)in_header;
7833             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
7834             out_ext->pNext = NULL;
7835             out_ext->viewMask = in_ext->viewMask;
7836             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
7837             out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats;
7838             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
7839             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
7840             out_header->pNext = (void *)out_ext;
7841             out_header = (void *)out_ext;
7842             break;
7843         }
7844         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
7845         {
7846             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7847             const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header;
7848             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
7849             out_ext->pNext = NULL;
7850             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
7851             out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
7852             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
7853             out_header->pNext = (void *)out_ext;
7854             out_header = (void *)out_ext;
7855             break;
7856         }
7857         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
7858         {
7859             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7860             const VkMultiviewPerViewAttributesInfoNVX *in_ext = (const VkMultiviewPerViewAttributesInfoNVX *)in_header;
7861             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
7862             out_ext->pNext = NULL;
7863             out_ext->perViewAttributes = in_ext->perViewAttributes;
7864             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
7865             out_header->pNext = (void *)out_ext;
7866             out_header = (void *)out_ext;
7867             break;
7868         }
7869         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
7870         {
7871             VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7872             const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header;
7873             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
7874             out_ext->pNext = NULL;
7875             out_ext->flags = in_ext->flags;
7876             out_header->pNext = (void *)out_ext;
7877             out_header = (void *)out_ext;
7878             break;
7879         }
7880         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
7881         {
7882             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7883             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
7884             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
7885             out_ext->pNext = NULL;
7886             out_ext->storageBuffers = in_ext->storageBuffers;
7887             out_ext->uniformBuffers = in_ext->uniformBuffers;
7888             out_ext->vertexInputs = in_ext->vertexInputs;
7889             out_ext->images = in_ext->images;
7890             out_header->pNext = (void *)out_ext;
7891             out_header = (void *)out_ext;
7892             break;
7893         }
7894         default:
7895             FIXME("Unhandled sType %u.", in_header->sType);
7896             break;
7897         }
7898     }
7899 }
7900 #endif /* USE_STRUCT_CONVERSION */
7901
7902 #if defined(USE_STRUCT_CONVERSION)
7903 static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, VkGraphicsPipelineCreateInfo *out)
7904 {
7905     const VkBaseInStructure *in_header;
7906     VkBaseOutStructure *out_header = (void *)out;
7907
7908     if (!in) return;
7909
7910     out->sType = in->sType;
7911     out->pNext = NULL;
7912     out->flags = in->flags;
7913     out->stageCount = in->stageCount;
7914     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
7915     out->pVertexInputState = in->pVertexInputState;
7916     out->pInputAssemblyState = in->pInputAssemblyState;
7917     out->pTessellationState = in->pTessellationState;
7918     out->pViewportState = in->pViewportState;
7919     out->pRasterizationState = in->pRasterizationState;
7920     out->pMultisampleState = in->pMultisampleState;
7921     out->pDepthStencilState = in->pDepthStencilState;
7922     out->pColorBlendState = in->pColorBlendState;
7923     out->pDynamicState = in->pDynamicState;
7924     out->layout = in->layout;
7925     out->renderPass = in->renderPass;
7926     out->subpass = in->subpass;
7927     out->basePipelineHandle = in->basePipelineHandle;
7928     out->basePipelineIndex = in->basePipelineIndex;
7929
7930     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
7931     {
7932         switch (in_header->sType)
7933         {
7934         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
7935         {
7936             VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7937             const VkGraphicsPipelineShaderGroupsCreateInfoNV32 *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV32 *)in_header;
7938             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
7939             out_ext->pNext = NULL;
7940             out_ext->groupCount = in_ext->groupCount;
7941             out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(ctx, in_ext->pGroups, in_ext->groupCount);
7942             out_ext->pipelineCount = in_ext->pipelineCount;
7943             out_ext->pPipelines = in_ext->pPipelines;
7944             out_header->pNext = (void *)out_ext;
7945             out_header = (void *)out_ext;
7946             break;
7947         }
7948         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
7949         {
7950             VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7951             const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header;
7952             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
7953             out_ext->pNext = NULL;
7954             out_ext->flags = in_ext->flags;
7955             out_ext->discardRectangleMode = in_ext->discardRectangleMode;
7956             out_ext->discardRectangleCount = in_ext->discardRectangleCount;
7957             out_ext->pDiscardRectangles = in_ext->pDiscardRectangles;
7958             out_header->pNext = (void *)out_ext;
7959             out_header = (void *)out_ext;
7960             break;
7961         }
7962         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
7963         {
7964             VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7965             const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header;
7966             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
7967             out_ext->pNext = NULL;
7968             out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable;
7969             out_header->pNext = (void *)out_ext;
7970             out_header = (void *)out_ext;
7971             break;
7972         }
7973         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
7974         {
7975             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7976             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
7977             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
7978             out_ext->pNext = NULL;
7979             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineCreationFeedback, 1);
7980             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
7981             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
7982             out_header->pNext = (void *)out_ext;
7983             out_header = (void *)out_ext;
7984             break;
7985         }
7986         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
7987         {
7988             VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
7989             const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header;
7990             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
7991             out_ext->pNext = NULL;
7992             out_ext->compilerControlFlags = in_ext->compilerControlFlags;
7993             out_header->pNext = (void *)out_ext;
7994             out_header = (void *)out_ext;
7995             break;
7996         }
7997         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
7998         {
7999             VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8000             const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header;
8001             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
8002             out_ext->pNext = NULL;
8003             out_ext->libraryCount = in_ext->libraryCount;
8004             out_ext->pLibraries = in_ext->pLibraries;
8005             out_header->pNext = (void *)out_ext;
8006             out_header = (void *)out_ext;
8007             break;
8008         }
8009         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
8010         {
8011             VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8012             const VkPipelineFragmentShadingRateStateCreateInfoKHR *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR *)in_header;
8013             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
8014             out_ext->pNext = NULL;
8015             out_ext->fragmentSize = in_ext->fragmentSize;
8016             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
8017             out_header->pNext = (void *)out_ext;
8018             out_header = (void *)out_ext;
8019             break;
8020         }
8021         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
8022         {
8023             VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8024             const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header;
8025             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
8026             out_ext->pNext = NULL;
8027             out_ext->shadingRateType = in_ext->shadingRateType;
8028             out_ext->shadingRate = in_ext->shadingRate;
8029             memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
8030             out_header->pNext = (void *)out_ext;
8031             out_header = (void *)out_ext;
8032             break;
8033         }
8034         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
8035         {
8036             VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8037             const VkPipelineRenderingCreateInfo *in_ext = (const VkPipelineRenderingCreateInfo *)in_header;
8038             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
8039             out_ext->pNext = NULL;
8040             out_ext->viewMask = in_ext->viewMask;
8041             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
8042             out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats;
8043             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
8044             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
8045             out_header->pNext = (void *)out_ext;
8046             out_header = (void *)out_ext;
8047             break;
8048         }
8049         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
8050         {
8051             VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8052             const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header;
8053             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
8054             out_ext->pNext = NULL;
8055             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
8056             out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
8057             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
8058             out_header->pNext = (void *)out_ext;
8059             out_header = (void *)out_ext;
8060             break;
8061         }
8062         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
8063         {
8064             VkMultiviewPerViewAttributesInfoNVX *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8065             const VkMultiviewPerViewAttributesInfoNVX *in_ext = (const VkMultiviewPerViewAttributesInfoNVX *)in_header;
8066             out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
8067             out_ext->pNext = NULL;
8068             out_ext->perViewAttributes = in_ext->perViewAttributes;
8069             out_ext->perViewAttributesPositionXOnly = in_ext->perViewAttributesPositionXOnly;
8070             out_header->pNext = (void *)out_ext;
8071             out_header = (void *)out_ext;
8072             break;
8073         }
8074         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
8075         {
8076             VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8077             const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header;
8078             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
8079             out_ext->pNext = NULL;
8080             out_ext->flags = in_ext->flags;
8081             out_header->pNext = (void *)out_ext;
8082             out_header = (void *)out_ext;
8083             break;
8084         }
8085         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
8086         {
8087             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8088             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
8089             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
8090             out_ext->pNext = NULL;
8091             out_ext->storageBuffers = in_ext->storageBuffers;
8092             out_ext->uniformBuffers = in_ext->uniformBuffers;
8093             out_ext->vertexInputs = in_ext->vertexInputs;
8094             out_ext->images = in_ext->images;
8095             out_header->pNext = (void *)out_ext;
8096             out_header = (void *)out_ext;
8097             break;
8098         }
8099         default:
8100             FIXME("Unhandled sType %u.", in_header->sType);
8101             break;
8102         }
8103     }
8104 }
8105 #endif /* USE_STRUCT_CONVERSION */
8106
8107 #if defined(USE_STRUCT_CONVERSION)
8108 static inline void convert_VkGraphicsPipelineCreateInfo_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out)
8109 {
8110     const VkBaseInStructure *in_header;
8111     VkBaseOutStructure *out_header = (void *)out;
8112
8113     if (!in) return;
8114
8115
8116     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8117     {
8118         switch (in_header->sType)
8119         {
8120         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
8121         {
8122             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
8123             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
8124             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
8125             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, out_ext->pPipelineCreationFeedback, 1);
8126             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, out_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
8127             out_header = (void *)out_ext;
8128             break;
8129         }
8130         default:
8131             break;
8132         }
8133     }
8134 }
8135 #endif /* USE_STRUCT_CONVERSION */
8136
8137 #if !defined(USE_STRUCT_CONVERSION)
8138 static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, uint32_t count)
8139 {
8140     VkGraphicsPipelineCreateInfo *out;
8141     unsigned int i;
8142
8143     if (!in || !count) return NULL;
8144
8145     out = conversion_context_alloc(ctx, count * sizeof(*out));
8146     for (i = 0; i < count; i++)
8147     {
8148         convert_VkGraphicsPipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]);
8149     }
8150
8151     return out;
8152 }
8153 #endif /* USE_STRUCT_CONVERSION */
8154
8155 #if defined(USE_STRUCT_CONVERSION)
8156 static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, uint32_t count)
8157 {
8158     VkGraphicsPipelineCreateInfo *out;
8159     unsigned int i;
8160
8161     if (!in || !count) return NULL;
8162
8163     out = conversion_context_alloc(ctx, count * sizeof(*out));
8164     for (i = 0; i < count; i++)
8165     {
8166         convert_VkGraphicsPipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
8167     }
8168
8169     return out;
8170 }
8171 #endif /* USE_STRUCT_CONVERSION */
8172
8173 #if defined(USE_STRUCT_CONVERSION)
8174 static inline void convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out, uint32_t count)
8175 {
8176     unsigned int i;
8177
8178     if (!in) return;
8179
8180     for (i = 0; i < count; i++)
8181     {
8182         convert_VkGraphicsPipelineCreateInfo_host_to_win32(&in[i], &out[i]);
8183     }
8184 }
8185 #endif /* USE_STRUCT_CONVERSION */
8186
8187 #if defined(USE_STRUCT_CONVERSION)
8188 static inline void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo *in, VkImageCreateInfo *out)
8189 {
8190     const VkBaseInStructure *in_header;
8191     VkBaseOutStructure *out_header = (void *)out;
8192
8193     if (!in) return;
8194
8195     out->sType = in->sType;
8196     out->pNext = NULL;
8197     out->flags = in->flags;
8198     out->imageType = in->imageType;
8199     out->format = in->format;
8200     out->extent = in->extent;
8201     out->mipLevels = in->mipLevels;
8202     out->arrayLayers = in->arrayLayers;
8203     out->samples = in->samples;
8204     out->tiling = in->tiling;
8205     out->usage = in->usage;
8206     out->sharingMode = in->sharingMode;
8207     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
8208     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
8209     out->initialLayout = in->initialLayout;
8210
8211     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8212     {
8213         switch (in_header->sType)
8214         {
8215         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
8216         {
8217             VkDedicatedAllocationImageCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8218             const VkDedicatedAllocationImageCreateInfoNV *in_ext = (const VkDedicatedAllocationImageCreateInfoNV *)in_header;
8219             out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV;
8220             out_ext->pNext = NULL;
8221             out_ext->dedicatedAllocation = in_ext->dedicatedAllocation;
8222             out_header->pNext = (void *)out_ext;
8223             out_header = (void *)out_ext;
8224             break;
8225         }
8226         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
8227         {
8228             VkExternalMemoryImageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8229             const VkExternalMemoryImageCreateInfo *in_ext = (const VkExternalMemoryImageCreateInfo *)in_header;
8230             out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
8231             out_ext->pNext = NULL;
8232             out_ext->handleTypes = in_ext->handleTypes;
8233             out_header->pNext = (void *)out_ext;
8234             out_header = (void *)out_ext;
8235             break;
8236         }
8237         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
8238         {
8239             VkImageSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8240             const VkImageSwapchainCreateInfoKHR32 *in_ext = (const VkImageSwapchainCreateInfoKHR32 *)in_header;
8241             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR;
8242             out_ext->pNext = NULL;
8243             out_ext->swapchain = in_ext->swapchain;
8244             out_header->pNext = (void *)out_ext;
8245             out_header = (void *)out_ext;
8246             break;
8247         }
8248         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
8249         {
8250             VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8251             const VkImageFormatListCreateInfo *in_ext = (const VkImageFormatListCreateInfo *)in_header;
8252             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
8253             out_ext->pNext = NULL;
8254             out_ext->viewFormatCount = in_ext->viewFormatCount;
8255             out_ext->pViewFormats = in_ext->pViewFormats;
8256             out_header->pNext = (void *)out_ext;
8257             out_header = (void *)out_ext;
8258             break;
8259         }
8260         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
8261         {
8262             VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8263             const VkImageStencilUsageCreateInfo *in_ext = (const VkImageStencilUsageCreateInfo *)in_header;
8264             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
8265             out_ext->pNext = NULL;
8266             out_ext->stencilUsage = in_ext->stencilUsage;
8267             out_header->pNext = (void *)out_ext;
8268             out_header = (void *)out_ext;
8269             break;
8270         }
8271         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
8272         {
8273             VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8274             const VkImageCompressionControlEXT *in_ext = (const VkImageCompressionControlEXT *)in_header;
8275             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT;
8276             out_ext->pNext = NULL;
8277             out_ext->flags = in_ext->flags;
8278             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
8279             out_ext->pFixedRateFlags = in_ext->pFixedRateFlags;
8280             out_header->pNext = (void *)out_ext;
8281             out_header = (void *)out_ext;
8282             break;
8283         }
8284         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
8285         {
8286             VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8287             const VkOpticalFlowImageFormatInfoNV *in_ext = (const VkOpticalFlowImageFormatInfoNV *)in_header;
8288             out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
8289             out_ext->pNext = NULL;
8290             out_ext->usage = in_ext->usage;
8291             out_header->pNext = (void *)out_ext;
8292             out_header = (void *)out_ext;
8293             break;
8294         }
8295         default:
8296             FIXME("Unhandled sType %u.", in_header->sType);
8297             break;
8298         }
8299     }
8300 }
8301 #endif /* USE_STRUCT_CONVERSION */
8302
8303 #if defined(USE_STRUCT_CONVERSION)
8304 static inline void convert_VkImageViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageViewCreateInfo32 *in, VkImageViewCreateInfo *out)
8305 {
8306     const VkBaseInStructure *in_header;
8307     VkBaseOutStructure *out_header = (void *)out;
8308
8309     if (!in) return;
8310
8311     out->sType = in->sType;
8312     out->pNext = NULL;
8313     out->flags = in->flags;
8314     out->image = in->image;
8315     out->viewType = in->viewType;
8316     out->format = in->format;
8317     out->components = in->components;
8318     out->subresourceRange = in->subresourceRange;
8319
8320     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8321     {
8322         switch (in_header->sType)
8323         {
8324         case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
8325         {
8326             VkImageViewUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8327             const VkImageViewUsageCreateInfo *in_ext = (const VkImageViewUsageCreateInfo *)in_header;
8328             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
8329             out_ext->pNext = NULL;
8330             out_ext->usage = in_ext->usage;
8331             out_header->pNext = (void *)out_ext;
8332             out_header = (void *)out_ext;
8333             break;
8334         }
8335         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
8336         {
8337             VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8338             const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
8339             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
8340             out_ext->pNext = NULL;
8341             out_ext->conversion = in_ext->conversion;
8342             out_header->pNext = (void *)out_ext;
8343             out_header = (void *)out_ext;
8344             break;
8345         }
8346         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
8347         {
8348             VkImageViewASTCDecodeModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8349             const VkImageViewASTCDecodeModeEXT *in_ext = (const VkImageViewASTCDecodeModeEXT *)in_header;
8350             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT;
8351             out_ext->pNext = NULL;
8352             out_ext->decodeMode = in_ext->decodeMode;
8353             out_header->pNext = (void *)out_ext;
8354             out_header = (void *)out_ext;
8355             break;
8356         }
8357         case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
8358         {
8359             VkImageViewMinLodCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8360             const VkImageViewMinLodCreateInfoEXT *in_ext = (const VkImageViewMinLodCreateInfoEXT *)in_header;
8361             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT;
8362             out_ext->pNext = NULL;
8363             out_ext->minLod = in_ext->minLod;
8364             out_header->pNext = (void *)out_ext;
8365             out_header = (void *)out_ext;
8366             break;
8367         }
8368         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
8369         {
8370             VkImageViewSampleWeightCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8371             const VkImageViewSampleWeightCreateInfoQCOM *in_ext = (const VkImageViewSampleWeightCreateInfoQCOM *)in_header;
8372             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM;
8373             out_ext->pNext = NULL;
8374             out_ext->filterCenter = in_ext->filterCenter;
8375             out_ext->filterSize = in_ext->filterSize;
8376             out_ext->numPhases = in_ext->numPhases;
8377             out_header->pNext = (void *)out_ext;
8378             out_header = (void *)out_ext;
8379             break;
8380         }
8381         default:
8382             FIXME("Unhandled sType %u.", in_header->sType);
8383             break;
8384         }
8385     }
8386 }
8387 #endif /* USE_STRUCT_CONVERSION */
8388
8389 #if defined(USE_STRUCT_CONVERSION)
8390 static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const VkIndirectCommandsLayoutTokenNV32 *in, VkIndirectCommandsLayoutTokenNV *out)
8391 {
8392     if (!in) return;
8393
8394     out->sType = in->sType;
8395     out->pNext = in->pNext;
8396     out->tokenType = in->tokenType;
8397     out->stream = in->stream;
8398     out->offset = in->offset;
8399     out->vertexBindingUnit = in->vertexBindingUnit;
8400     out->vertexDynamicStride = in->vertexDynamicStride;
8401     out->pushconstantPipelineLayout = in->pushconstantPipelineLayout;
8402     out->pushconstantShaderStageFlags = in->pushconstantShaderStageFlags;
8403     out->pushconstantOffset = in->pushconstantOffset;
8404     out->pushconstantSize = in->pushconstantSize;
8405     out->indirectStateFlags = in->indirectStateFlags;
8406     out->indexTypeCount = in->indexTypeCount;
8407     out->pIndexTypes = in->pIndexTypes;
8408     out->pIndexTypeValues = in->pIndexTypeValues;
8409 }
8410 #endif /* USE_STRUCT_CONVERSION */
8411
8412 #if defined(USE_STRUCT_CONVERSION)
8413 static inline const VkIndirectCommandsLayoutTokenNV *convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenNV32 *in, uint32_t count)
8414 {
8415     VkIndirectCommandsLayoutTokenNV *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_VkIndirectCommandsLayoutTokenNV_win32_to_host(&in[i], &out[i]);
8424     }
8425
8426     return out;
8427 }
8428 #endif /* USE_STRUCT_CONVERSION */
8429
8430 #if defined(USE_STRUCT_CONVERSION)
8431 static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoNV32 *in, VkIndirectCommandsLayoutCreateInfoNV *out)
8432 {
8433     if (!in) return;
8434
8435     out->sType = in->sType;
8436     out->pNext = in->pNext;
8437     out->flags = in->flags;
8438     out->pipelineBindPoint = in->pipelineBindPoint;
8439     out->tokenCount = in->tokenCount;
8440     out->pTokens = convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(ctx, in->pTokens, in->tokenCount);
8441     out->streamCount = in->streamCount;
8442     out->pStreamStrides = in->pStreamStrides;
8443 }
8444 #endif /* USE_STRUCT_CONVERSION */
8445
8446 #if !defined(USE_STRUCT_CONVERSION)
8447 static inline void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo *in, VkInstanceCreateInfo *out)
8448 {
8449     const VkBaseInStructure *in_header;
8450     VkBaseOutStructure *out_header = (void *)out;
8451
8452     if (!in) return;
8453
8454     out->sType = in->sType;
8455     out->pNext = NULL;
8456     out->flags = in->flags;
8457     out->pApplicationInfo = in->pApplicationInfo;
8458     out->enabledLayerCount = in->enabledLayerCount;
8459     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
8460     out->enabledExtensionCount = in->enabledExtensionCount;
8461     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
8462
8463     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8464     {
8465         switch (in_header->sType)
8466         {
8467         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
8468             break;
8469         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
8470         {
8471             VkDebugReportCallbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8472             const VkDebugReportCallbackCreateInfoEXT *in_ext = (const VkDebugReportCallbackCreateInfoEXT *)in_header;
8473             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
8474             out_ext->pNext = NULL;
8475             out_ext->flags = in_ext->flags;
8476             out_ext->pfnCallback = in_ext->pfnCallback;
8477             out_ext->pUserData = in_ext->pUserData;
8478             out_header->pNext = (void *)out_ext;
8479             out_header = (void *)out_ext;
8480             break;
8481         }
8482         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
8483         {
8484             VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8485             const VkValidationFlagsEXT *in_ext = (const VkValidationFlagsEXT *)in_header;
8486             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
8487             out_ext->pNext = NULL;
8488             out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
8489             out_ext->pDisabledValidationChecks = in_ext->pDisabledValidationChecks;
8490             out_header->pNext = (void *)out_ext;
8491             out_header = (void *)out_ext;
8492             break;
8493         }
8494         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
8495         {
8496             VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8497             const VkValidationFeaturesEXT *in_ext = (const VkValidationFeaturesEXT *)in_header;
8498             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
8499             out_ext->pNext = NULL;
8500             out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount;
8501             out_ext->pEnabledValidationFeatures = in_ext->pEnabledValidationFeatures;
8502             out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount;
8503             out_ext->pDisabledValidationFeatures = in_ext->pDisabledValidationFeatures;
8504             out_header->pNext = (void *)out_ext;
8505             out_header = (void *)out_ext;
8506             break;
8507         }
8508         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
8509         {
8510             VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8511             const VkDebugUtilsMessengerCreateInfoEXT *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT *)in_header;
8512             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
8513             out_ext->pNext = NULL;
8514             out_ext->flags = in_ext->flags;
8515             out_ext->messageSeverity = in_ext->messageSeverity;
8516             out_ext->messageType = in_ext->messageType;
8517             out_ext->pfnUserCallback = in_ext->pfnUserCallback;
8518             out_ext->pUserData = in_ext->pUserData;
8519             out_header->pNext = (void *)out_ext;
8520             out_header = (void *)out_ext;
8521             break;
8522         }
8523         default:
8524             FIXME("Unhandled sType %u.", in_header->sType);
8525             break;
8526         }
8527     }
8528 }
8529 #endif /* USE_STRUCT_CONVERSION */
8530
8531 #if defined(USE_STRUCT_CONVERSION)
8532 static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo *in, VkInstanceCreateInfo *out)
8533 {
8534     const VkBaseInStructure *in_header;
8535     VkBaseOutStructure *out_header = (void *)out;
8536
8537     if (!in) return;
8538
8539     out->sType = in->sType;
8540     out->pNext = NULL;
8541     out->flags = in->flags;
8542     out->pApplicationInfo = in->pApplicationInfo;
8543     out->enabledLayerCount = in->enabledLayerCount;
8544     out->ppEnabledLayerNames = in->ppEnabledLayerNames;
8545     out->enabledExtensionCount = in->enabledExtensionCount;
8546     out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
8547
8548     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8549     {
8550         switch (in_header->sType)
8551         {
8552         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
8553             break;
8554         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
8555         {
8556             VkDebugReportCallbackCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8557             const VkDebugReportCallbackCreateInfoEXT *in_ext = (const VkDebugReportCallbackCreateInfoEXT *)in_header;
8558             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
8559             out_ext->pNext = NULL;
8560             out_ext->flags = in_ext->flags;
8561             out_ext->pfnCallback = in_ext->pfnCallback;
8562             out_ext->pUserData = in_ext->pUserData;
8563             out_header->pNext = (void *)out_ext;
8564             out_header = (void *)out_ext;
8565             break;
8566         }
8567         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
8568         {
8569             VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8570             const VkValidationFlagsEXT *in_ext = (const VkValidationFlagsEXT *)in_header;
8571             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
8572             out_ext->pNext = NULL;
8573             out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
8574             out_ext->pDisabledValidationChecks = in_ext->pDisabledValidationChecks;
8575             out_header->pNext = (void *)out_ext;
8576             out_header = (void *)out_ext;
8577             break;
8578         }
8579         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
8580         {
8581             VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8582             const VkValidationFeaturesEXT *in_ext = (const VkValidationFeaturesEXT *)in_header;
8583             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
8584             out_ext->pNext = NULL;
8585             out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount;
8586             out_ext->pEnabledValidationFeatures = in_ext->pEnabledValidationFeatures;
8587             out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount;
8588             out_ext->pDisabledValidationFeatures = in_ext->pDisabledValidationFeatures;
8589             out_header->pNext = (void *)out_ext;
8590             out_header = (void *)out_ext;
8591             break;
8592         }
8593         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
8594         {
8595             VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8596             const VkDebugUtilsMessengerCreateInfoEXT *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT *)in_header;
8597             out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
8598             out_ext->pNext = NULL;
8599             out_ext->flags = in_ext->flags;
8600             out_ext->messageSeverity = in_ext->messageSeverity;
8601             out_ext->messageType = in_ext->messageType;
8602             out_ext->pfnUserCallback = in_ext->pfnUserCallback;
8603             out_ext->pUserData = in_ext->pUserData;
8604             out_header->pNext = (void *)out_ext;
8605             out_header = (void *)out_ext;
8606             break;
8607         }
8608         default:
8609             FIXME("Unhandled sType %u.", in_header->sType);
8610             break;
8611         }
8612     }
8613 }
8614 #endif /* USE_STRUCT_CONVERSION */
8615
8616 #if defined(USE_STRUCT_CONVERSION)
8617 static inline void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicromapCreateInfoEXT32 *in, VkMicromapCreateInfoEXT *out)
8618 {
8619     if (!in) return;
8620
8621     out->sType = in->sType;
8622     out->pNext = in->pNext;
8623     out->createFlags = in->createFlags;
8624     out->buffer = in->buffer;
8625     out->offset = in->offset;
8626     out->size = in->size;
8627     out->type = in->type;
8628     out->deviceAddress = in->deviceAddress;
8629 }
8630 #endif /* USE_STRUCT_CONVERSION */
8631
8632 #if !defined(USE_STRUCT_CONVERSION)
8633 static inline void convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, VkRayTracingPipelineCreateInfoKHR *out)
8634 {
8635     if (!in) return;
8636
8637     out->sType = in->sType;
8638     out->pNext = in->pNext;
8639     out->flags = in->flags;
8640     out->stageCount = in->stageCount;
8641     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
8642     out->groupCount = in->groupCount;
8643     out->pGroups = in->pGroups;
8644     out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
8645     out->pLibraryInfo = in->pLibraryInfo;
8646     out->pLibraryInterface = in->pLibraryInterface;
8647     out->pDynamicState = in->pDynamicState;
8648     out->layout = in->layout;
8649     out->basePipelineHandle = in->basePipelineHandle;
8650     out->basePipelineIndex = in->basePipelineIndex;
8651 }
8652 #endif /* USE_STRUCT_CONVERSION */
8653
8654 #if defined(USE_STRUCT_CONVERSION)
8655 static inline void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, VkRayTracingPipelineCreateInfoKHR *out)
8656 {
8657     const VkBaseInStructure *in_header;
8658     VkBaseOutStructure *out_header = (void *)out;
8659
8660     if (!in) return;
8661
8662     out->sType = in->sType;
8663     out->pNext = NULL;
8664     out->flags = in->flags;
8665     out->stageCount = in->stageCount;
8666     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
8667     out->groupCount = in->groupCount;
8668     out->pGroups = in->pGroups;
8669     out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
8670     out->pLibraryInfo = in->pLibraryInfo;
8671     out->pLibraryInterface = in->pLibraryInterface;
8672     out->pDynamicState = in->pDynamicState;
8673     out->layout = in->layout;
8674     out->basePipelineHandle = in->basePipelineHandle;
8675     out->basePipelineIndex = in->basePipelineIndex;
8676
8677     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8678     {
8679         switch (in_header->sType)
8680         {
8681         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
8682         {
8683             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8684             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
8685             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
8686             out_ext->pNext = NULL;
8687             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineCreationFeedback, 1);
8688             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
8689             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
8690             out_header->pNext = (void *)out_ext;
8691             out_header = (void *)out_ext;
8692             break;
8693         }
8694         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
8695         {
8696             VkPipelineRobustnessCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8697             const VkPipelineRobustnessCreateInfoEXT *in_ext = (const VkPipelineRobustnessCreateInfoEXT *)in_header;
8698             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
8699             out_ext->pNext = NULL;
8700             out_ext->storageBuffers = in_ext->storageBuffers;
8701             out_ext->uniformBuffers = in_ext->uniformBuffers;
8702             out_ext->vertexInputs = in_ext->vertexInputs;
8703             out_ext->images = in_ext->images;
8704             out_header->pNext = (void *)out_ext;
8705             out_header = (void *)out_ext;
8706             break;
8707         }
8708         default:
8709             FIXME("Unhandled sType %u.", in_header->sType);
8710             break;
8711         }
8712     }
8713 }
8714 #endif /* USE_STRUCT_CONVERSION */
8715
8716 #if defined(USE_STRUCT_CONVERSION)
8717 static inline void convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out)
8718 {
8719     const VkBaseInStructure *in_header;
8720     VkBaseOutStructure *out_header = (void *)out;
8721
8722     if (!in) return;
8723
8724
8725     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8726     {
8727         switch (in_header->sType)
8728         {
8729         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
8730         {
8731             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
8732             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
8733             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
8734             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, out_ext->pPipelineCreationFeedback, 1);
8735             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, out_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
8736             out_header = (void *)out_ext;
8737             break;
8738         }
8739         default:
8740             break;
8741         }
8742     }
8743 }
8744 #endif /* USE_STRUCT_CONVERSION */
8745
8746 #if !defined(USE_STRUCT_CONVERSION)
8747 static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, uint32_t count)
8748 {
8749     VkRayTracingPipelineCreateInfoKHR *out;
8750     unsigned int i;
8751
8752     if (!in || !count) return NULL;
8753
8754     out = conversion_context_alloc(ctx, count * sizeof(*out));
8755     for (i = 0; i < count; i++)
8756     {
8757         convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(ctx, &in[i], &out[i]);
8758     }
8759
8760     return out;
8761 }
8762 #endif /* USE_STRUCT_CONVERSION */
8763
8764 #if defined(USE_STRUCT_CONVERSION)
8765 static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, uint32_t count)
8766 {
8767     VkRayTracingPipelineCreateInfoKHR *out;
8768     unsigned int i;
8769
8770     if (!in || !count) return NULL;
8771
8772     out = conversion_context_alloc(ctx, count * sizeof(*out));
8773     for (i = 0; i < count; i++)
8774     {
8775         convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(ctx, &in[i], &out[i]);
8776     }
8777
8778     return out;
8779 }
8780 #endif /* USE_STRUCT_CONVERSION */
8781
8782 #if defined(USE_STRUCT_CONVERSION)
8783 static inline void convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out, uint32_t count)
8784 {
8785     unsigned int i;
8786
8787     if (!in) return;
8788
8789     for (i = 0; i < count; i++)
8790     {
8791         convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(&in[i], &out[i]);
8792     }
8793 }
8794 #endif /* USE_STRUCT_CONVERSION */
8795
8796 #if !defined(USE_STRUCT_CONVERSION)
8797 static inline void convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, VkRayTracingPipelineCreateInfoNV *out)
8798 {
8799     if (!in) return;
8800
8801     out->sType = in->sType;
8802     out->pNext = in->pNext;
8803     out->flags = in->flags;
8804     out->stageCount = in->stageCount;
8805     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount);
8806     out->groupCount = in->groupCount;
8807     out->pGroups = in->pGroups;
8808     out->maxRecursionDepth = in->maxRecursionDepth;
8809     out->layout = in->layout;
8810     out->basePipelineHandle = in->basePipelineHandle;
8811     out->basePipelineIndex = in->basePipelineIndex;
8812 }
8813 #endif /* USE_STRUCT_CONVERSION */
8814
8815 #if defined(USE_STRUCT_CONVERSION)
8816 static inline void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, VkRayTracingPipelineCreateInfoNV *out)
8817 {
8818     const VkBaseInStructure *in_header;
8819     VkBaseOutStructure *out_header = (void *)out;
8820
8821     if (!in) return;
8822
8823     out->sType = in->sType;
8824     out->pNext = NULL;
8825     out->flags = in->flags;
8826     out->stageCount = in->stageCount;
8827     out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
8828     out->groupCount = in->groupCount;
8829     out->pGroups = in->pGroups;
8830     out->maxRecursionDepth = in->maxRecursionDepth;
8831     out->layout = in->layout;
8832     out->basePipelineHandle = in->basePipelineHandle;
8833     out->basePipelineIndex = in->basePipelineIndex;
8834
8835     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8836     {
8837         switch (in_header->sType)
8838         {
8839         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
8840         {
8841             VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8842             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
8843             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
8844             out_ext->pNext = NULL;
8845             out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineCreationFeedback, 1);
8846             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
8847             out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
8848             out_header->pNext = (void *)out_ext;
8849             out_header = (void *)out_ext;
8850             break;
8851         }
8852         default:
8853             FIXME("Unhandled sType %u.", in_header->sType);
8854             break;
8855         }
8856     }
8857 }
8858 #endif /* USE_STRUCT_CONVERSION */
8859
8860 #if defined(USE_STRUCT_CONVERSION)
8861 static inline void convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out)
8862 {
8863     const VkBaseInStructure *in_header;
8864     VkBaseOutStructure *out_header = (void *)out;
8865
8866     if (!in) return;
8867
8868
8869     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8870     {
8871         switch (in_header->sType)
8872         {
8873         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
8874         {
8875             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
8876             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
8877             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
8878             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, out_ext->pPipelineCreationFeedback, 1);
8879             convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, out_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
8880             out_header = (void *)out_ext;
8881             break;
8882         }
8883         default:
8884             break;
8885         }
8886     }
8887 }
8888 #endif /* USE_STRUCT_CONVERSION */
8889
8890 #if !defined(USE_STRUCT_CONVERSION)
8891 static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, uint32_t count)
8892 {
8893     VkRayTracingPipelineCreateInfoNV *out;
8894     unsigned int i;
8895
8896     if (!in || !count) return NULL;
8897
8898     out = conversion_context_alloc(ctx, count * sizeof(*out));
8899     for (i = 0; i < count; i++)
8900     {
8901         convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]);
8902     }
8903
8904     return out;
8905 }
8906 #endif /* USE_STRUCT_CONVERSION */
8907
8908 #if defined(USE_STRUCT_CONVERSION)
8909 static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, uint32_t count)
8910 {
8911     VkRayTracingPipelineCreateInfoNV *out;
8912     unsigned int i;
8913
8914     if (!in || !count) return NULL;
8915
8916     out = conversion_context_alloc(ctx, count * sizeof(*out));
8917     for (i = 0; i < count; i++)
8918     {
8919         convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]);
8920     }
8921
8922     return out;
8923 }
8924 #endif /* USE_STRUCT_CONVERSION */
8925
8926 #if defined(USE_STRUCT_CONVERSION)
8927 static inline void convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out, uint32_t count)
8928 {
8929     unsigned int i;
8930
8931     if (!in) return;
8932
8933     for (i = 0; i < count; i++)
8934     {
8935         convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(&in[i], &out[i]);
8936     }
8937 }
8938 #endif /* USE_STRUCT_CONVERSION */
8939
8940 #if defined(USE_STRUCT_CONVERSION)
8941 static inline void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSamplerCreateInfo *in, VkSamplerCreateInfo *out)
8942 {
8943     const VkBaseInStructure *in_header;
8944     VkBaseOutStructure *out_header = (void *)out;
8945
8946     if (!in) return;
8947
8948     out->sType = in->sType;
8949     out->pNext = NULL;
8950     out->flags = in->flags;
8951     out->magFilter = in->magFilter;
8952     out->minFilter = in->minFilter;
8953     out->mipmapMode = in->mipmapMode;
8954     out->addressModeU = in->addressModeU;
8955     out->addressModeV = in->addressModeV;
8956     out->addressModeW = in->addressModeW;
8957     out->mipLodBias = in->mipLodBias;
8958     out->anisotropyEnable = in->anisotropyEnable;
8959     out->maxAnisotropy = in->maxAnisotropy;
8960     out->compareEnable = in->compareEnable;
8961     out->compareOp = in->compareOp;
8962     out->minLod = in->minLod;
8963     out->maxLod = in->maxLod;
8964     out->borderColor = in->borderColor;
8965     out->unnormalizedCoordinates = in->unnormalizedCoordinates;
8966
8967     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
8968     {
8969         switch (in_header->sType)
8970         {
8971         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
8972         {
8973             VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8974             const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header;
8975             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
8976             out_ext->pNext = NULL;
8977             out_ext->conversion = in_ext->conversion;
8978             out_header->pNext = (void *)out_ext;
8979             out_header = (void *)out_ext;
8980             break;
8981         }
8982         case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
8983         {
8984             VkSamplerReductionModeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8985             const VkSamplerReductionModeCreateInfo *in_ext = (const VkSamplerReductionModeCreateInfo *)in_header;
8986             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO;
8987             out_ext->pNext = NULL;
8988             out_ext->reductionMode = in_ext->reductionMode;
8989             out_header->pNext = (void *)out_ext;
8990             out_header = (void *)out_ext;
8991             break;
8992         }
8993         case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
8994         {
8995             VkSamplerCustomBorderColorCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
8996             const VkSamplerCustomBorderColorCreateInfoEXT *in_ext = (const VkSamplerCustomBorderColorCreateInfoEXT *)in_header;
8997             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT;
8998             out_ext->pNext = NULL;
8999             out_ext->customBorderColor = in_ext->customBorderColor;
9000             out_ext->format = in_ext->format;
9001             out_header->pNext = (void *)out_ext;
9002             out_header = (void *)out_ext;
9003             break;
9004         }
9005         case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
9006         {
9007             VkSamplerBorderColorComponentMappingCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9008             const VkSamplerBorderColorComponentMappingCreateInfoEXT *in_ext = (const VkSamplerBorderColorComponentMappingCreateInfoEXT *)in_header;
9009             out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT;
9010             out_ext->pNext = NULL;
9011             out_ext->components = in_ext->components;
9012             out_ext->srgb = in_ext->srgb;
9013             out_header->pNext = (void *)out_ext;
9014             out_header = (void *)out_ext;
9015             break;
9016         }
9017         default:
9018             FIXME("Unhandled sType %u.", in_header->sType);
9019             break;
9020         }
9021     }
9022 }
9023 #endif /* USE_STRUCT_CONVERSION */
9024
9025 #if defined(USE_STRUCT_CONVERSION)
9026 static inline void convert_VkSemaphoreCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSemaphoreCreateInfo *in, VkSemaphoreCreateInfo *out)
9027 {
9028     const VkBaseInStructure *in_header;
9029     VkBaseOutStructure *out_header = (void *)out;
9030
9031     if (!in) return;
9032
9033     out->sType = in->sType;
9034     out->pNext = NULL;
9035     out->flags = in->flags;
9036
9037     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
9038     {
9039         switch (in_header->sType)
9040         {
9041         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
9042         {
9043             VkExportSemaphoreCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9044             const VkExportSemaphoreCreateInfo *in_ext = (const VkExportSemaphoreCreateInfo *)in_header;
9045             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO;
9046             out_ext->pNext = NULL;
9047             out_ext->handleTypes = in_ext->handleTypes;
9048             out_header->pNext = (void *)out_ext;
9049             out_header = (void *)out_ext;
9050             break;
9051         }
9052         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
9053         {
9054             VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9055             const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header;
9056             out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
9057             out_ext->pNext = NULL;
9058             out_ext->semaphoreType = in_ext->semaphoreType;
9059             out_ext->initialValue = in_ext->initialValue;
9060             out_header->pNext = (void *)out_ext;
9061             out_header = (void *)out_ext;
9062             break;
9063         }
9064         default:
9065             FIXME("Unhandled sType %u.", in_header->sType);
9066             break;
9067         }
9068     }
9069 }
9070 #endif /* USE_STRUCT_CONVERSION */
9071
9072 #if defined(USE_STRUCT_CONVERSION)
9073 static inline void convert_VkShaderModuleCreateInfo_win32_to_host(struct conversion_context *ctx, const VkShaderModuleCreateInfo *in, VkShaderModuleCreateInfo *out)
9074 {
9075     const VkBaseInStructure *in_header;
9076     VkBaseOutStructure *out_header = (void *)out;
9077
9078     if (!in) return;
9079
9080     out->sType = in->sType;
9081     out->pNext = NULL;
9082     out->flags = in->flags;
9083     out->codeSize = in->codeSize;
9084     out->pCode = in->pCode;
9085
9086     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
9087     {
9088         switch (in_header->sType)
9089         {
9090         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
9091         {
9092             VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9093             const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header;
9094             out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
9095             out_ext->pNext = NULL;
9096             out_ext->validationCache = in_ext->validationCache;
9097             out_header->pNext = (void *)out_ext;
9098             out_header = (void *)out_ext;
9099             break;
9100         }
9101         default:
9102             FIXME("Unhandled sType %u.", in_header->sType);
9103             break;
9104         }
9105     }
9106 }
9107 #endif /* USE_STRUCT_CONVERSION */
9108
9109 #if !defined(USE_STRUCT_CONVERSION)
9110 static inline void convert_VkSwapchainCreateInfoKHR_win64_to_host(const VkSwapchainCreateInfoKHR *in, VkSwapchainCreateInfoKHR *out)
9111 {
9112     if (!in) return;
9113
9114     out->sType = in->sType;
9115     out->pNext = in->pNext;
9116     out->flags = in->flags;
9117     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
9118     out->minImageCount = in->minImageCount;
9119     out->imageFormat = in->imageFormat;
9120     out->imageColorSpace = in->imageColorSpace;
9121     out->imageExtent = in->imageExtent;
9122     out->imageArrayLayers = in->imageArrayLayers;
9123     out->imageUsage = in->imageUsage;
9124     out->imageSharingMode = in->imageSharingMode;
9125     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
9126     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
9127     out->preTransform = in->preTransform;
9128     out->compositeAlpha = in->compositeAlpha;
9129     out->presentMode = in->presentMode;
9130     out->clipped = in->clipped;
9131     out->oldSwapchain = in->oldSwapchain;
9132 }
9133 #endif /* USE_STRUCT_CONVERSION */
9134
9135 #if defined(USE_STRUCT_CONVERSION)
9136 static inline void convert_VkSwapchainCreateInfoKHR_win32_to_host(const VkSwapchainCreateInfoKHR32 *in, VkSwapchainCreateInfoKHR *out)
9137 {
9138     if (!in) return;
9139
9140     out->sType = in->sType;
9141     out->pNext = in->pNext;
9142     out->flags = in->flags;
9143     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
9144     out->minImageCount = in->minImageCount;
9145     out->imageFormat = in->imageFormat;
9146     out->imageColorSpace = in->imageColorSpace;
9147     out->imageExtent = in->imageExtent;
9148     out->imageArrayLayers = in->imageArrayLayers;
9149     out->imageUsage = in->imageUsage;
9150     out->imageSharingMode = in->imageSharingMode;
9151     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
9152     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
9153     out->preTransform = in->preTransform;
9154     out->compositeAlpha = in->compositeAlpha;
9155     out->presentMode = in->presentMode;
9156     out->clipped = in->clipped;
9157     out->oldSwapchain = in->oldSwapchain;
9158 }
9159 #endif /* USE_STRUCT_CONVERSION */
9160
9161 #if !defined(USE_STRUCT_CONVERSION)
9162 static inline void convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(const VkDebugMarkerObjectNameInfoEXT *in, VkDebugMarkerObjectNameInfoEXT *out)
9163 {
9164     if (!in) return;
9165
9166     out->sType = in->sType;
9167     out->pNext = in->pNext;
9168     out->objectType = in->objectType;
9169     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
9170     out->pObjectName = in->pObjectName;
9171 }
9172 #endif /* USE_STRUCT_CONVERSION */
9173
9174 #if defined(USE_STRUCT_CONVERSION)
9175 static inline void convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(const VkDebugMarkerObjectNameInfoEXT32 *in, VkDebugMarkerObjectNameInfoEXT *out)
9176 {
9177     if (!in) return;
9178
9179     out->sType = in->sType;
9180     out->pNext = in->pNext;
9181     out->objectType = in->objectType;
9182     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
9183     out->pObjectName = in->pObjectName;
9184 }
9185 #endif /* USE_STRUCT_CONVERSION */
9186
9187 #if !defined(USE_STRUCT_CONVERSION)
9188 static inline void convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(const VkDebugMarkerObjectTagInfoEXT *in, VkDebugMarkerObjectTagInfoEXT *out)
9189 {
9190     if (!in) return;
9191
9192     out->sType = in->sType;
9193     out->pNext = in->pNext;
9194     out->objectType = in->objectType;
9195     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
9196     out->tagName = in->tagName;
9197     out->tagSize = in->tagSize;
9198     out->pTag = in->pTag;
9199 }
9200 #endif /* USE_STRUCT_CONVERSION */
9201
9202 #if defined(USE_STRUCT_CONVERSION)
9203 static inline void convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(const VkDebugMarkerObjectTagInfoEXT32 *in, VkDebugMarkerObjectTagInfoEXT *out)
9204 {
9205     if (!in) return;
9206
9207     out->sType = in->sType;
9208     out->pNext = in->pNext;
9209     out->objectType = in->objectType;
9210     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
9211     out->tagName = in->tagName;
9212     out->tagSize = in->tagSize;
9213     out->pTag = in->pTag;
9214 }
9215 #endif /* USE_STRUCT_CONVERSION */
9216
9217 #if defined(USE_STRUCT_CONVERSION)
9218 static inline void convert_VkMappedMemoryRange_win32_to_host(const VkMappedMemoryRange32 *in, VkMappedMemoryRange *out)
9219 {
9220     if (!in) return;
9221
9222     out->sType = in->sType;
9223     out->pNext = in->pNext;
9224     out->memory = in->memory;
9225     out->offset = in->offset;
9226     out->size = in->size;
9227 }
9228 #endif /* USE_STRUCT_CONVERSION */
9229
9230 #if defined(USE_STRUCT_CONVERSION)
9231 static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win32_to_host(struct conversion_context *ctx, const VkMappedMemoryRange32 *in, uint32_t count)
9232 {
9233     VkMappedMemoryRange *out;
9234     unsigned int i;
9235
9236     if (!in || !count) return NULL;
9237
9238     out = conversion_context_alloc(ctx, count * sizeof(*out));
9239     for (i = 0; i < count; i++)
9240     {
9241         convert_VkMappedMemoryRange_win32_to_host(&in[i], &out[i]);
9242     }
9243
9244     return out;
9245 }
9246 #endif /* USE_STRUCT_CONVERSION */
9247
9248 #if defined(USE_STRUCT_CONVERSION)
9249 static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host(const VkAccelerationStructureBuildSizesInfoKHR32 *in, VkAccelerationStructureBuildSizesInfoKHR *out)
9250 {
9251     if (!in) return;
9252
9253     out->sType = in->sType;
9254     out->pNext = in->pNext;
9255     out->accelerationStructureSize = in->accelerationStructureSize;
9256     out->updateScratchSize = in->updateScratchSize;
9257     out->buildScratchSize = in->buildScratchSize;
9258 }
9259 #endif /* USE_STRUCT_CONVERSION */
9260
9261 #if defined(USE_STRUCT_CONVERSION)
9262 static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(const VkAccelerationStructureBuildSizesInfoKHR *in, VkAccelerationStructureBuildSizesInfoKHR32 *out)
9263 {
9264     if (!in) return;
9265
9266     out->accelerationStructureSize = in->accelerationStructureSize;
9267     out->updateScratchSize = in->updateScratchSize;
9268     out->buildScratchSize = in->buildScratchSize;
9269 }
9270 #endif /* USE_STRUCT_CONVERSION */
9271
9272 #if defined(USE_STRUCT_CONVERSION)
9273 static inline void convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host(const VkAccelerationStructureDeviceAddressInfoKHR32 *in, VkAccelerationStructureDeviceAddressInfoKHR *out)
9274 {
9275     if (!in) return;
9276
9277     out->sType = in->sType;
9278     out->pNext = in->pNext;
9279     out->accelerationStructure = in->accelerationStructure;
9280 }
9281 #endif /* USE_STRUCT_CONVERSION */
9282
9283 #if defined(USE_STRUCT_CONVERSION)
9284 static inline void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host(const VkAccelerationStructureMemoryRequirementsInfoNV32 *in, VkAccelerationStructureMemoryRequirementsInfoNV *out)
9285 {
9286     if (!in) return;
9287
9288     out->sType = in->sType;
9289     out->pNext = in->pNext;
9290     out->type = in->type;
9291     out->accelerationStructure = in->accelerationStructure;
9292 }
9293 #endif /* USE_STRUCT_CONVERSION */
9294
9295 #if defined(USE_STRUCT_CONVERSION)
9296 static inline void convert_VkMemoryRequirements_host_to_win32(const VkMemoryRequirements *in, VkMemoryRequirements32 *out)
9297 {
9298     if (!in) return;
9299
9300     out->size = in->size;
9301     out->alignment = in->alignment;
9302     out->memoryTypeBits = in->memoryTypeBits;
9303 }
9304 #endif /* USE_STRUCT_CONVERSION */
9305
9306 #if defined(USE_STRUCT_CONVERSION)
9307 static inline void convert_VkMemoryRequirements2KHR_win32_to_host(const VkMemoryRequirements2KHR32 *in, VkMemoryRequirements2KHR *out)
9308 {
9309     if (!in) return;
9310
9311     out->sType = in->sType;
9312     out->pNext = in->pNext;
9313 }
9314 #endif /* USE_STRUCT_CONVERSION */
9315
9316 #if defined(USE_STRUCT_CONVERSION)
9317 static inline void convert_VkMemoryRequirements2KHR_host_to_win32(const VkMemoryRequirements2KHR *in, VkMemoryRequirements2KHR32 *out)
9318 {
9319     if (!in) return;
9320
9321     convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
9322 }
9323 #endif /* USE_STRUCT_CONVERSION */
9324
9325 #if defined(USE_STRUCT_CONVERSION)
9326 static inline void convert_VkBufferDeviceAddressInfo_win32_to_host(const VkBufferDeviceAddressInfo32 *in, VkBufferDeviceAddressInfo *out)
9327 {
9328     if (!in) return;
9329
9330     out->sType = in->sType;
9331     out->pNext = in->pNext;
9332     out->buffer = in->buffer;
9333 }
9334 #endif /* USE_STRUCT_CONVERSION */
9335
9336 #if defined(USE_STRUCT_CONVERSION)
9337 static inline void convert_VkBufferMemoryRequirementsInfo2_win32_to_host(const VkBufferMemoryRequirementsInfo232 *in, VkBufferMemoryRequirementsInfo2 *out)
9338 {
9339     if (!in) return;
9340
9341     out->sType = in->sType;
9342     out->pNext = in->pNext;
9343     out->buffer = in->buffer;
9344 }
9345 #endif /* USE_STRUCT_CONVERSION */
9346
9347 #if defined(USE_STRUCT_CONVERSION)
9348 static inline void convert_VkMemoryRequirements2_win32_to_host(const VkMemoryRequirements232 *in, VkMemoryRequirements2 *out)
9349 {
9350     if (!in) return;
9351
9352     out->sType = in->sType;
9353     out->pNext = in->pNext;
9354 }
9355 #endif /* USE_STRUCT_CONVERSION */
9356
9357 #if defined(USE_STRUCT_CONVERSION)
9358 static inline void convert_VkMemoryRequirements2_host_to_win32(const VkMemoryRequirements2 *in, VkMemoryRequirements232 *out)
9359 {
9360     if (!in) return;
9361
9362     convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
9363 }
9364 #endif /* USE_STRUCT_CONVERSION */
9365
9366 #if defined(USE_STRUCT_CONVERSION)
9367 static inline void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(const VkDescriptorSetBindingReferenceVALVE32 *in, VkDescriptorSetBindingReferenceVALVE *out)
9368 {
9369     if (!in) return;
9370
9371     out->sType = in->sType;
9372     out->pNext = in->pNext;
9373     out->descriptorSetLayout = in->descriptorSetLayout;
9374     out->binding = in->binding;
9375 }
9376 #endif /* USE_STRUCT_CONVERSION */
9377
9378 #if defined(USE_STRUCT_CONVERSION)
9379 static inline const VkBufferCreateInfo *convert_VkBufferCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, uint32_t count)
9380 {
9381     VkBufferCreateInfo *out;
9382     unsigned int i;
9383
9384     if (!in || !count) return NULL;
9385
9386     out = conversion_context_alloc(ctx, count * sizeof(*out));
9387     for (i = 0; i < count; i++)
9388     {
9389         convert_VkBufferCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
9390     }
9391
9392     return out;
9393 }
9394 #endif /* USE_STRUCT_CONVERSION */
9395
9396 #if defined(USE_STRUCT_CONVERSION)
9397 static inline void convert_VkDeviceBufferMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceBufferMemoryRequirements32 *in, VkDeviceBufferMemoryRequirements *out)
9398 {
9399     if (!in) return;
9400
9401     out->sType = in->sType;
9402     out->pNext = in->pNext;
9403     out->pCreateInfo = convert_VkBufferCreateInfo_array_win32_to_host(ctx, in->pCreateInfo, 1);
9404 }
9405 #endif /* USE_STRUCT_CONVERSION */
9406
9407 #if defined(USE_STRUCT_CONVERSION)
9408 static inline void convert_VkDeviceFaultCountsEXT_win32_to_host(const VkDeviceFaultCountsEXT32 *in, VkDeviceFaultCountsEXT *out)
9409 {
9410     if (!in) return;
9411
9412     out->sType = in->sType;
9413     out->pNext = in->pNext;
9414     out->addressInfoCount = in->addressInfoCount;
9415     out->vendorInfoCount = in->vendorInfoCount;
9416     out->vendorBinarySize = in->vendorBinarySize;
9417 }
9418 #endif /* USE_STRUCT_CONVERSION */
9419
9420 #if defined(USE_STRUCT_CONVERSION)
9421 static inline void convert_VkDeviceFaultCountsEXT_host_to_win32(const VkDeviceFaultCountsEXT *in, VkDeviceFaultCountsEXT32 *out)
9422 {
9423     if (!in) return;
9424
9425     out->addressInfoCount = in->addressInfoCount;
9426     out->vendorInfoCount = in->vendorInfoCount;
9427     out->vendorBinarySize = in->vendorBinarySize;
9428 }
9429 #endif /* USE_STRUCT_CONVERSION */
9430
9431 #if defined(USE_STRUCT_CONVERSION)
9432 static inline void convert_VkDeviceFaultAddressInfoEXT_win32_to_host(const VkDeviceFaultAddressInfoEXT32 *in, VkDeviceFaultAddressInfoEXT *out)
9433 {
9434     if (!in) return;
9435
9436     out->addressType = in->addressType;
9437     out->reportedAddress = in->reportedAddress;
9438     out->addressPrecision = in->addressPrecision;
9439 }
9440 #endif /* USE_STRUCT_CONVERSION */
9441
9442 #if defined(USE_STRUCT_CONVERSION)
9443 static inline void convert_VkDeviceFaultAddressInfoEXT_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out)
9444 {
9445     if (!in) return;
9446
9447     out->addressType = in->addressType;
9448     out->reportedAddress = in->reportedAddress;
9449     out->addressPrecision = in->addressPrecision;
9450 }
9451 #endif /* USE_STRUCT_CONVERSION */
9452
9453 #if defined(USE_STRUCT_CONVERSION)
9454 static inline VkDeviceFaultAddressInfoEXT *convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultAddressInfoEXT32 *in, uint32_t count)
9455 {
9456     VkDeviceFaultAddressInfoEXT *out;
9457     unsigned int i;
9458
9459     if (!in || !count) return NULL;
9460
9461     out = conversion_context_alloc(ctx, count * sizeof(*out));
9462     for (i = 0; i < count; i++)
9463     {
9464         convert_VkDeviceFaultAddressInfoEXT_win32_to_host(&in[i], &out[i]);
9465     }
9466
9467     return out;
9468 }
9469 #endif /* USE_STRUCT_CONVERSION */
9470
9471 #if defined(USE_STRUCT_CONVERSION)
9472 static inline void convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out, uint32_t count)
9473 {
9474     unsigned int i;
9475
9476     if (!in) return;
9477
9478     for (i = 0; i < count; i++)
9479     {
9480         convert_VkDeviceFaultAddressInfoEXT_host_to_win32(&in[i], &out[i]);
9481     }
9482 }
9483 #endif /* USE_STRUCT_CONVERSION */
9484
9485 #if defined(USE_STRUCT_CONVERSION)
9486 static inline void convert_VkDeviceFaultVendorInfoEXT_win32_to_host(const VkDeviceFaultVendorInfoEXT32 *in, VkDeviceFaultVendorInfoEXT *out)
9487 {
9488     if (!in) return;
9489
9490     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
9491     out->vendorFaultCode = in->vendorFaultCode;
9492     out->vendorFaultData = in->vendorFaultData;
9493 }
9494 #endif /* USE_STRUCT_CONVERSION */
9495
9496 #if defined(USE_STRUCT_CONVERSION)
9497 static inline void convert_VkDeviceFaultVendorInfoEXT_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out)
9498 {
9499     if (!in) return;
9500
9501     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
9502     out->vendorFaultCode = in->vendorFaultCode;
9503     out->vendorFaultData = in->vendorFaultData;
9504 }
9505 #endif /* USE_STRUCT_CONVERSION */
9506
9507 #if defined(USE_STRUCT_CONVERSION)
9508 static inline VkDeviceFaultVendorInfoEXT *convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultVendorInfoEXT32 *in, uint32_t count)
9509 {
9510     VkDeviceFaultVendorInfoEXT *out;
9511     unsigned int i;
9512
9513     if (!in || !count) return NULL;
9514
9515     out = conversion_context_alloc(ctx, count * sizeof(*out));
9516     for (i = 0; i < count; i++)
9517     {
9518         convert_VkDeviceFaultVendorInfoEXT_win32_to_host(&in[i], &out[i]);
9519     }
9520
9521     return out;
9522 }
9523 #endif /* USE_STRUCT_CONVERSION */
9524
9525 #if defined(USE_STRUCT_CONVERSION)
9526 static inline void convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out, uint32_t count)
9527 {
9528     unsigned int i;
9529
9530     if (!in) return;
9531
9532     for (i = 0; i < count; i++)
9533     {
9534         convert_VkDeviceFaultVendorInfoEXT_host_to_win32(&in[i], &out[i]);
9535     }
9536 }
9537 #endif /* USE_STRUCT_CONVERSION */
9538
9539 #if defined(USE_STRUCT_CONVERSION)
9540 static inline void convert_VkDeviceFaultInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultInfoEXT32 *in, VkDeviceFaultInfoEXT *out)
9541 {
9542     if (!in) return;
9543
9544     out->sType = in->sType;
9545     out->pNext = in->pNext;
9546     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
9547     out->pAddressInfos = convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(ctx, in->pAddressInfos, 1);
9548     out->pVendorInfos = convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(ctx, in->pVendorInfos, 1);
9549     out->pVendorBinaryData = in->pVendorBinaryData;
9550 }
9551 #endif /* USE_STRUCT_CONVERSION */
9552
9553 #if defined(USE_STRUCT_CONVERSION)
9554 static inline void convert_VkDeviceFaultInfoEXT_host_to_win32(const VkDeviceFaultInfoEXT *in, VkDeviceFaultInfoEXT32 *out)
9555 {
9556     if (!in) return;
9557
9558     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
9559     convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(in->pAddressInfos, out->pAddressInfos, 1);
9560     convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(in->pVendorInfos, out->pVendorInfos, 1);
9561     out->pVendorBinaryData = in->pVendorBinaryData;
9562 }
9563 #endif /* USE_STRUCT_CONVERSION */
9564
9565 #if defined(USE_STRUCT_CONVERSION)
9566 static inline const VkImageCreateInfo *convert_VkImageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo *in, uint32_t count)
9567 {
9568     VkImageCreateInfo *out;
9569     unsigned int i;
9570
9571     if (!in || !count) return NULL;
9572
9573     out = conversion_context_alloc(ctx, count * sizeof(*out));
9574     for (i = 0; i < count; i++)
9575     {
9576         convert_VkImageCreateInfo_win32_to_host(ctx, &in[i], &out[i]);
9577     }
9578
9579     return out;
9580 }
9581 #endif /* USE_STRUCT_CONVERSION */
9582
9583 #if defined(USE_STRUCT_CONVERSION)
9584 static inline void convert_VkDeviceImageMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceImageMemoryRequirements *in, VkDeviceImageMemoryRequirements *out)
9585 {
9586     if (!in) return;
9587
9588     out->sType = in->sType;
9589     out->pNext = in->pNext;
9590     out->pCreateInfo = convert_VkImageCreateInfo_array_win32_to_host(ctx, in->pCreateInfo, 1);
9591     out->planeAspect = in->planeAspect;
9592 }
9593 #endif /* USE_STRUCT_CONVERSION */
9594
9595 #if defined(USE_STRUCT_CONVERSION)
9596 static inline void convert_VkSparseImageMemoryRequirements_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out)
9597 {
9598     if (!in) return;
9599
9600     out->formatProperties = in->formatProperties;
9601     out->imageMipTailFirstLod = in->imageMipTailFirstLod;
9602     out->imageMipTailSize = in->imageMipTailSize;
9603     out->imageMipTailOffset = in->imageMipTailOffset;
9604     out->imageMipTailStride = in->imageMipTailStride;
9605 }
9606 #endif /* USE_STRUCT_CONVERSION */
9607
9608 #if defined(USE_STRUCT_CONVERSION)
9609 static inline void convert_VkSparseImageMemoryRequirements2_win32_to_host(const VkSparseImageMemoryRequirements232 *in, VkSparseImageMemoryRequirements2 *out)
9610 {
9611     if (!in) return;
9612
9613     out->sType = in->sType;
9614     out->pNext = in->pNext;
9615 }
9616 #endif /* USE_STRUCT_CONVERSION */
9617
9618 #if defined(USE_STRUCT_CONVERSION)
9619 static inline void convert_VkSparseImageMemoryRequirements2_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out)
9620 {
9621     if (!in) return;
9622
9623     convert_VkSparseImageMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements);
9624 }
9625 #endif /* USE_STRUCT_CONVERSION */
9626
9627 #if defined(USE_STRUCT_CONVERSION)
9628 static inline VkSparseImageMemoryRequirements2 *convert_VkSparseImageMemoryRequirements2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryRequirements232 *in, uint32_t count)
9629 {
9630     VkSparseImageMemoryRequirements2 *out;
9631     unsigned int i;
9632
9633     if (!in || !count) return NULL;
9634
9635     out = conversion_context_alloc(ctx, count * sizeof(*out));
9636     for (i = 0; i < count; i++)
9637     {
9638         convert_VkSparseImageMemoryRequirements2_win32_to_host(&in[i], &out[i]);
9639     }
9640
9641     return out;
9642 }
9643 #endif /* USE_STRUCT_CONVERSION */
9644
9645 #if defined(USE_STRUCT_CONVERSION)
9646 static inline void convert_VkSparseImageMemoryRequirements2_array_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out, uint32_t count)
9647 {
9648     unsigned int i;
9649
9650     if (!in) return;
9651
9652     for (i = 0; i < count; i++)
9653     {
9654         convert_VkSparseImageMemoryRequirements2_host_to_win32(&in[i], &out[i]);
9655     }
9656 }
9657 #endif /* USE_STRUCT_CONVERSION */
9658
9659 #if defined(USE_STRUCT_CONVERSION)
9660 static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo32 *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out)
9661 {
9662     if (!in) return;
9663
9664     out->sType = in->sType;
9665     out->pNext = in->pNext;
9666     out->memory = in->memory;
9667 }
9668 #endif /* USE_STRUCT_CONVERSION */
9669
9670 #if defined(USE_STRUCT_CONVERSION)
9671 static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV32 *in, VkGeneratedCommandsMemoryRequirementsInfoNV *out)
9672 {
9673     if (!in) return;
9674
9675     out->sType = in->sType;
9676     out->pNext = in->pNext;
9677     out->pipelineBindPoint = in->pipelineBindPoint;
9678     out->pipeline = in->pipeline;
9679     out->indirectCommandsLayout = in->indirectCommandsLayout;
9680     out->maxSequencesCount = in->maxSequencesCount;
9681 }
9682 #endif /* USE_STRUCT_CONVERSION */
9683
9684 #if defined(USE_STRUCT_CONVERSION)
9685 static inline void convert_VkImageMemoryRequirementsInfo2_win32_to_host(const VkImageMemoryRequirementsInfo232 *in, VkImageMemoryRequirementsInfo2 *out)
9686 {
9687     if (!in) return;
9688
9689     out->sType = in->sType;
9690     out->pNext = in->pNext;
9691     out->image = in->image;
9692 }
9693 #endif /* USE_STRUCT_CONVERSION */
9694
9695 #if defined(USE_STRUCT_CONVERSION)
9696 static inline void convert_VkSparseImageMemoryRequirements_array_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out, uint32_t count)
9697 {
9698     unsigned int i;
9699
9700     if (!in) return;
9701
9702     for (i = 0; i < count; i++)
9703     {
9704         convert_VkSparseImageMemoryRequirements_host_to_win32(&in[i], &out[i]);
9705     }
9706 }
9707 #endif /* USE_STRUCT_CONVERSION */
9708
9709 #if defined(USE_STRUCT_CONVERSION)
9710 static inline void convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(const VkImageSparseMemoryRequirementsInfo232 *in, VkImageSparseMemoryRequirementsInfo2 *out)
9711 {
9712     if (!in) return;
9713
9714     out->sType = in->sType;
9715     out->pNext = in->pNext;
9716     out->image = in->image;
9717 }
9718 #endif /* USE_STRUCT_CONVERSION */
9719
9720 #if defined(USE_STRUCT_CONVERSION)
9721 static inline void convert_VkSubresourceLayout_host_to_win32(const VkSubresourceLayout *in, VkSubresourceLayout32 *out)
9722 {
9723     if (!in) return;
9724
9725     out->offset = in->offset;
9726     out->size = in->size;
9727     out->rowPitch = in->rowPitch;
9728     out->arrayPitch = in->arrayPitch;
9729     out->depthPitch = in->depthPitch;
9730 }
9731 #endif /* USE_STRUCT_CONVERSION */
9732
9733 #if defined(USE_STRUCT_CONVERSION)
9734 static inline void convert_VkSubresourceLayout2EXT_win32_to_host(const VkSubresourceLayout2EXT32 *in, VkSubresourceLayout2EXT *out)
9735 {
9736     if (!in) return;
9737
9738     out->sType = in->sType;
9739     out->pNext = in->pNext;
9740 }
9741 #endif /* USE_STRUCT_CONVERSION */
9742
9743 #if defined(USE_STRUCT_CONVERSION)
9744 static inline void convert_VkSubresourceLayout2EXT_host_to_win32(const VkSubresourceLayout2EXT *in, VkSubresourceLayout2EXT32 *out)
9745 {
9746     if (!in) return;
9747
9748     convert_VkSubresourceLayout_host_to_win32(&in->subresourceLayout, &out->subresourceLayout);
9749 }
9750 #endif /* USE_STRUCT_CONVERSION */
9751
9752 #if defined(USE_STRUCT_CONVERSION)
9753 static inline void convert_VkImageViewAddressPropertiesNVX_win32_to_host(const VkImageViewAddressPropertiesNVX32 *in, VkImageViewAddressPropertiesNVX *out)
9754 {
9755     if (!in) return;
9756
9757     out->sType = in->sType;
9758     out->pNext = in->pNext;
9759 }
9760 #endif /* USE_STRUCT_CONVERSION */
9761
9762 #if defined(USE_STRUCT_CONVERSION)
9763 static inline void convert_VkImageViewAddressPropertiesNVX_host_to_win32(const VkImageViewAddressPropertiesNVX *in, VkImageViewAddressPropertiesNVX32 *out)
9764 {
9765     if (!in) return;
9766
9767     out->deviceAddress = in->deviceAddress;
9768     out->size = in->size;
9769 }
9770 #endif /* USE_STRUCT_CONVERSION */
9771
9772 #if defined(USE_STRUCT_CONVERSION)
9773 static inline void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageViewHandleInfoNVX32 *in, VkImageViewHandleInfoNVX *out)
9774 {
9775     if (!in) return;
9776
9777     out->sType = in->sType;
9778     out->pNext = in->pNext;
9779     out->imageView = in->imageView;
9780     out->descriptorType = in->descriptorType;
9781     out->sampler = in->sampler;
9782 }
9783 #endif /* USE_STRUCT_CONVERSION */
9784
9785 #if defined(USE_STRUCT_CONVERSION)
9786 static inline void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMicromapBuildSizesInfoEXT32 *in, VkMicromapBuildSizesInfoEXT *out)
9787 {
9788     if (!in) return;
9789
9790     out->sType = in->sType;
9791     out->pNext = in->pNext;
9792     out->micromapSize = in->micromapSize;
9793     out->buildScratchSize = in->buildScratchSize;
9794     out->discardable = in->discardable;
9795 }
9796 #endif /* USE_STRUCT_CONVERSION */
9797
9798 #if defined(USE_STRUCT_CONVERSION)
9799 static inline void convert_VkMicromapBuildSizesInfoEXT_host_to_win32(const VkMicromapBuildSizesInfoEXT *in, VkMicromapBuildSizesInfoEXT32 *out)
9800 {
9801     if (!in) return;
9802
9803     out->micromapSize = in->micromapSize;
9804     out->buildScratchSize = in->buildScratchSize;
9805     out->discardable = in->discardable;
9806 }
9807 #endif /* USE_STRUCT_CONVERSION */
9808
9809 #if defined(USE_STRUCT_CONVERSION)
9810 static inline void convert_VkPerformanceValueINTEL_win32_to_host(const VkPerformanceValueINTEL32 *in, VkPerformanceValueINTEL *out)
9811 {
9812     if (!in) return;
9813
9814     out->type = in->type;
9815     out->data = in->data;
9816 }
9817 #endif /* USE_STRUCT_CONVERSION */
9818
9819 #if defined(USE_STRUCT_CONVERSION)
9820 static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerformanceValueINTEL *in, VkPerformanceValueINTEL32 *out)
9821 {
9822     if (!in) return;
9823
9824     out->type = in->type;
9825     out->data = in->data;
9826 }
9827 #endif /* USE_STRUCT_CONVERSION */
9828
9829 #if defined(USE_STRUCT_CONVERSION)
9830 static inline void convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalSemaphoreInfo *in, VkPhysicalDeviceExternalSemaphoreInfo *out)
9831 {
9832     const VkBaseInStructure *in_header;
9833     VkBaseOutStructure *out_header = (void *)out;
9834
9835     if (!in) return;
9836
9837     out->sType = in->sType;
9838     out->pNext = NULL;
9839     out->handleType = in->handleType;
9840
9841     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
9842     {
9843         switch (in_header->sType)
9844         {
9845         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
9846         {
9847             VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9848             const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header;
9849             out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
9850             out_ext->pNext = NULL;
9851             out_ext->semaphoreType = in_ext->semaphoreType;
9852             out_ext->initialValue = in_ext->initialValue;
9853             out_header->pNext = (void *)out_ext;
9854             out_header = (void *)out_ext;
9855             break;
9856         }
9857         default:
9858             FIXME("Unhandled sType %u.", in_header->sType);
9859             break;
9860         }
9861     }
9862 }
9863 #endif /* USE_STRUCT_CONVERSION */
9864
9865 #if defined(USE_STRUCT_CONVERSION)
9866 static inline void convert_VkImageFormatProperties_host_to_win32(const VkImageFormatProperties *in, VkImageFormatProperties32 *out)
9867 {
9868     if (!in) return;
9869
9870     out->maxExtent = in->maxExtent;
9871     out->maxMipLevels = in->maxMipLevels;
9872     out->maxArrayLayers = in->maxArrayLayers;
9873     out->sampleCounts = in->sampleCounts;
9874     out->maxResourceSize = in->maxResourceSize;
9875 }
9876 #endif /* USE_STRUCT_CONVERSION */
9877
9878 #if defined(USE_STRUCT_CONVERSION)
9879 static inline void convert_VkImageFormatProperties2_win32_to_host(const VkImageFormatProperties232 *in, VkImageFormatProperties2 *out)
9880 {
9881     if (!in) return;
9882
9883     out->sType = in->sType;
9884     out->pNext = in->pNext;
9885 }
9886 #endif /* USE_STRUCT_CONVERSION */
9887
9888 #if defined(USE_STRUCT_CONVERSION)
9889 static inline void convert_VkImageFormatProperties2_host_to_win32(const VkImageFormatProperties2 *in, VkImageFormatProperties232 *out)
9890 {
9891     if (!in) return;
9892
9893     convert_VkImageFormatProperties_host_to_win32(&in->imageFormatProperties, &out->imageFormatProperties);
9894 }
9895 #endif /* USE_STRUCT_CONVERSION */
9896
9897 #if defined(USE_STRUCT_CONVERSION)
9898 static inline void convert_VkMemoryHeap_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out)
9899 {
9900     if (!in) return;
9901
9902     out->size = in->size;
9903     out->flags = in->flags;
9904 }
9905 #endif /* USE_STRUCT_CONVERSION */
9906
9907 #if defined(USE_STRUCT_CONVERSION)
9908 static inline void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out, uint32_t count)
9909 {
9910     unsigned int i;
9911
9912     if (!in) return;
9913
9914     for (i = 0; i < count; i++)
9915     {
9916         convert_VkMemoryHeap_host_to_win32(&in[i], &out[i]);
9917     }
9918 }
9919 #endif /* USE_STRUCT_CONVERSION */
9920
9921 #if defined(USE_STRUCT_CONVERSION)
9922 static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win32(const VkPhysicalDeviceMemoryProperties *in, VkPhysicalDeviceMemoryProperties32 *out)
9923 {
9924     if (!in) return;
9925
9926     out->memoryTypeCount = in->memoryTypeCount;
9927     memcpy(out->memoryTypes, in->memoryTypes, VK_MAX_MEMORY_TYPES * sizeof(VkMemoryType));
9928     out->memoryHeapCount = in->memoryHeapCount;
9929     convert_VkMemoryHeap_array_host_to_win32(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
9930 }
9931 #endif /* USE_STRUCT_CONVERSION */
9932
9933 #if defined(USE_STRUCT_CONVERSION)
9934 static inline void convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceMemoryProperties232 *in, VkPhysicalDeviceMemoryProperties2 *out)
9935 {
9936     const VkBaseInStructure *in_header;
9937     VkBaseOutStructure *out_header = (void *)out;
9938
9939     if (!in) return;
9940
9941     out->sType = in->sType;
9942     out->pNext = NULL;
9943
9944     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
9945     {
9946         switch (in_header->sType)
9947         {
9948         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
9949         {
9950             VkPhysicalDeviceMemoryBudgetPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
9951             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
9952             out_ext->pNext = NULL;
9953             out_header->pNext = (void *)out_ext;
9954             out_header = (void *)out_ext;
9955             break;
9956         }
9957         default:
9958             FIXME("Unhandled sType %u.", in_header->sType);
9959             break;
9960         }
9961     }
9962 }
9963 #endif /* USE_STRUCT_CONVERSION */
9964
9965 #if defined(USE_STRUCT_CONVERSION)
9966 static inline void convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(const VkPhysicalDeviceMemoryProperties2 *in, VkPhysicalDeviceMemoryProperties232 *out)
9967 {
9968     const VkBaseInStructure *in_header;
9969     VkBaseOutStructure *out_header = (void *)out;
9970
9971     if (!in) return;
9972
9973     convert_VkPhysicalDeviceMemoryProperties_host_to_win32(&in->memoryProperties, &out->memoryProperties);
9974
9975     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
9976     {
9977         switch (in_header->sType)
9978         {
9979         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
9980         {
9981             VkPhysicalDeviceMemoryBudgetPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT);
9982             const VkPhysicalDeviceMemoryBudgetPropertiesEXT *in_ext = (const VkPhysicalDeviceMemoryBudgetPropertiesEXT *)in_header;
9983             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
9984             memcpy(out_ext->heapBudget, in_ext->heapBudget, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
9985             memcpy(out_ext->heapUsage, in_ext->heapUsage, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
9986             out_header = (void *)out_ext;
9987             break;
9988         }
9989         default:
9990             break;
9991         }
9992     }
9993 }
9994 #endif /* USE_STRUCT_CONVERSION */
9995
9996 #if defined(USE_STRUCT_CONVERSION)
9997 static inline void convert_VkPhysicalDeviceLimits_host_to_win32(const VkPhysicalDeviceLimits *in, VkPhysicalDeviceLimits32 *out)
9998 {
9999     if (!in) return;
10000
10001     out->maxImageDimension1D = in->maxImageDimension1D;
10002     out->maxImageDimension2D = in->maxImageDimension2D;
10003     out->maxImageDimension3D = in->maxImageDimension3D;
10004     out->maxImageDimensionCube = in->maxImageDimensionCube;
10005     out->maxImageArrayLayers = in->maxImageArrayLayers;
10006     out->maxTexelBufferElements = in->maxTexelBufferElements;
10007     out->maxUniformBufferRange = in->maxUniformBufferRange;
10008     out->maxStorageBufferRange = in->maxStorageBufferRange;
10009     out->maxPushConstantsSize = in->maxPushConstantsSize;
10010     out->maxMemoryAllocationCount = in->maxMemoryAllocationCount;
10011     out->maxSamplerAllocationCount = in->maxSamplerAllocationCount;
10012     out->bufferImageGranularity = in->bufferImageGranularity;
10013     out->sparseAddressSpaceSize = in->sparseAddressSpaceSize;
10014     out->maxBoundDescriptorSets = in->maxBoundDescriptorSets;
10015     out->maxPerStageDescriptorSamplers = in->maxPerStageDescriptorSamplers;
10016     out->maxPerStageDescriptorUniformBuffers = in->maxPerStageDescriptorUniformBuffers;
10017     out->maxPerStageDescriptorStorageBuffers = in->maxPerStageDescriptorStorageBuffers;
10018     out->maxPerStageDescriptorSampledImages = in->maxPerStageDescriptorSampledImages;
10019     out->maxPerStageDescriptorStorageImages = in->maxPerStageDescriptorStorageImages;
10020     out->maxPerStageDescriptorInputAttachments = in->maxPerStageDescriptorInputAttachments;
10021     out->maxPerStageResources = in->maxPerStageResources;
10022     out->maxDescriptorSetSamplers = in->maxDescriptorSetSamplers;
10023     out->maxDescriptorSetUniformBuffers = in->maxDescriptorSetUniformBuffers;
10024     out->maxDescriptorSetUniformBuffersDynamic = in->maxDescriptorSetUniformBuffersDynamic;
10025     out->maxDescriptorSetStorageBuffers = in->maxDescriptorSetStorageBuffers;
10026     out->maxDescriptorSetStorageBuffersDynamic = in->maxDescriptorSetStorageBuffersDynamic;
10027     out->maxDescriptorSetSampledImages = in->maxDescriptorSetSampledImages;
10028     out->maxDescriptorSetStorageImages = in->maxDescriptorSetStorageImages;
10029     out->maxDescriptorSetInputAttachments = in->maxDescriptorSetInputAttachments;
10030     out->maxVertexInputAttributes = in->maxVertexInputAttributes;
10031     out->maxVertexInputBindings = in->maxVertexInputBindings;
10032     out->maxVertexInputAttributeOffset = in->maxVertexInputAttributeOffset;
10033     out->maxVertexInputBindingStride = in->maxVertexInputBindingStride;
10034     out->maxVertexOutputComponents = in->maxVertexOutputComponents;
10035     out->maxTessellationGenerationLevel = in->maxTessellationGenerationLevel;
10036     out->maxTessellationPatchSize = in->maxTessellationPatchSize;
10037     out->maxTessellationControlPerVertexInputComponents = in->maxTessellationControlPerVertexInputComponents;
10038     out->maxTessellationControlPerVertexOutputComponents = in->maxTessellationControlPerVertexOutputComponents;
10039     out->maxTessellationControlPerPatchOutputComponents = in->maxTessellationControlPerPatchOutputComponents;
10040     out->maxTessellationControlTotalOutputComponents = in->maxTessellationControlTotalOutputComponents;
10041     out->maxTessellationEvaluationInputComponents = in->maxTessellationEvaluationInputComponents;
10042     out->maxTessellationEvaluationOutputComponents = in->maxTessellationEvaluationOutputComponents;
10043     out->maxGeometryShaderInvocations = in->maxGeometryShaderInvocations;
10044     out->maxGeometryInputComponents = in->maxGeometryInputComponents;
10045     out->maxGeometryOutputComponents = in->maxGeometryOutputComponents;
10046     out->maxGeometryOutputVertices = in->maxGeometryOutputVertices;
10047     out->maxGeometryTotalOutputComponents = in->maxGeometryTotalOutputComponents;
10048     out->maxFragmentInputComponents = in->maxFragmentInputComponents;
10049     out->maxFragmentOutputAttachments = in->maxFragmentOutputAttachments;
10050     out->maxFragmentDualSrcAttachments = in->maxFragmentDualSrcAttachments;
10051     out->maxFragmentCombinedOutputResources = in->maxFragmentCombinedOutputResources;
10052     out->maxComputeSharedMemorySize = in->maxComputeSharedMemorySize;
10053     memcpy(out->maxComputeWorkGroupCount, in->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
10054     out->maxComputeWorkGroupInvocations = in->maxComputeWorkGroupInvocations;
10055     memcpy(out->maxComputeWorkGroupSize, in->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
10056     out->subPixelPrecisionBits = in->subPixelPrecisionBits;
10057     out->subTexelPrecisionBits = in->subTexelPrecisionBits;
10058     out->mipmapPrecisionBits = in->mipmapPrecisionBits;
10059     out->maxDrawIndexedIndexValue = in->maxDrawIndexedIndexValue;
10060     out->maxDrawIndirectCount = in->maxDrawIndirectCount;
10061     out->maxSamplerLodBias = in->maxSamplerLodBias;
10062     out->maxSamplerAnisotropy = in->maxSamplerAnisotropy;
10063     out->maxViewports = in->maxViewports;
10064     memcpy(out->maxViewportDimensions, in->maxViewportDimensions, 2 * sizeof(uint32_t));
10065     memcpy(out->viewportBoundsRange, in->viewportBoundsRange, 2 * sizeof(float));
10066     out->viewportSubPixelBits = in->viewportSubPixelBits;
10067     out->minMemoryMapAlignment = in->minMemoryMapAlignment;
10068     out->minTexelBufferOffsetAlignment = in->minTexelBufferOffsetAlignment;
10069     out->minUniformBufferOffsetAlignment = in->minUniformBufferOffsetAlignment;
10070     out->minStorageBufferOffsetAlignment = in->minStorageBufferOffsetAlignment;
10071     out->minTexelOffset = in->minTexelOffset;
10072     out->maxTexelOffset = in->maxTexelOffset;
10073     out->minTexelGatherOffset = in->minTexelGatherOffset;
10074     out->maxTexelGatherOffset = in->maxTexelGatherOffset;
10075     out->minInterpolationOffset = in->minInterpolationOffset;
10076     out->maxInterpolationOffset = in->maxInterpolationOffset;
10077     out->subPixelInterpolationOffsetBits = in->subPixelInterpolationOffsetBits;
10078     out->maxFramebufferWidth = in->maxFramebufferWidth;
10079     out->maxFramebufferHeight = in->maxFramebufferHeight;
10080     out->maxFramebufferLayers = in->maxFramebufferLayers;
10081     out->framebufferColorSampleCounts = in->framebufferColorSampleCounts;
10082     out->framebufferDepthSampleCounts = in->framebufferDepthSampleCounts;
10083     out->framebufferStencilSampleCounts = in->framebufferStencilSampleCounts;
10084     out->framebufferNoAttachmentsSampleCounts = in->framebufferNoAttachmentsSampleCounts;
10085     out->maxColorAttachments = in->maxColorAttachments;
10086     out->sampledImageColorSampleCounts = in->sampledImageColorSampleCounts;
10087     out->sampledImageIntegerSampleCounts = in->sampledImageIntegerSampleCounts;
10088     out->sampledImageDepthSampleCounts = in->sampledImageDepthSampleCounts;
10089     out->sampledImageStencilSampleCounts = in->sampledImageStencilSampleCounts;
10090     out->storageImageSampleCounts = in->storageImageSampleCounts;
10091     out->maxSampleMaskWords = in->maxSampleMaskWords;
10092     out->timestampComputeAndGraphics = in->timestampComputeAndGraphics;
10093     out->timestampPeriod = in->timestampPeriod;
10094     out->maxClipDistances = in->maxClipDistances;
10095     out->maxCullDistances = in->maxCullDistances;
10096     out->maxCombinedClipAndCullDistances = in->maxCombinedClipAndCullDistances;
10097     out->discreteQueuePriorities = in->discreteQueuePriorities;
10098     memcpy(out->pointSizeRange, in->pointSizeRange, 2 * sizeof(float));
10099     memcpy(out->lineWidthRange, in->lineWidthRange, 2 * sizeof(float));
10100     out->pointSizeGranularity = in->pointSizeGranularity;
10101     out->lineWidthGranularity = in->lineWidthGranularity;
10102     out->strictLines = in->strictLines;
10103     out->standardSampleLocations = in->standardSampleLocations;
10104     out->optimalBufferCopyOffsetAlignment = in->optimalBufferCopyOffsetAlignment;
10105     out->optimalBufferCopyRowPitchAlignment = in->optimalBufferCopyRowPitchAlignment;
10106     out->nonCoherentAtomSize = in->nonCoherentAtomSize;
10107 }
10108 #endif /* USE_STRUCT_CONVERSION */
10109
10110 #if defined(USE_STRUCT_CONVERSION)
10111 static inline void convert_VkPhysicalDeviceProperties_host_to_win32(const VkPhysicalDeviceProperties *in, VkPhysicalDeviceProperties32 *out)
10112 {
10113     if (!in) return;
10114
10115     out->apiVersion = in->apiVersion;
10116     out->driverVersion = in->driverVersion;
10117     out->vendorID = in->vendorID;
10118     out->deviceID = in->deviceID;
10119     out->deviceType = in->deviceType;
10120     memcpy(out->deviceName, in->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
10121     memcpy(out->pipelineCacheUUID, in->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
10122     convert_VkPhysicalDeviceLimits_host_to_win32(&in->limits, &out->limits);
10123     out->sparseProperties = in->sparseProperties;
10124 }
10125 #endif /* USE_STRUCT_CONVERSION */
10126
10127 #if defined(USE_STRUCT_CONVERSION)
10128 static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceProperties232 *in, VkPhysicalDeviceProperties2 *out)
10129 {
10130     const VkBaseInStructure *in_header;
10131     VkBaseOutStructure *out_header = (void *)out;
10132
10133     if (!in) return;
10134
10135     out->sType = in->sType;
10136     out->pNext = NULL;
10137
10138     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
10139     {
10140         switch (in_header->sType)
10141         {
10142         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
10143         {
10144             VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10145             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
10146             out_ext->pNext = NULL;
10147             out_header->pNext = (void *)out_ext;
10148             out_header = (void *)out_ext;
10149             break;
10150         }
10151         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
10152         {
10153             VkPhysicalDeviceMultiDrawPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10154             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
10155             out_ext->pNext = NULL;
10156             out_header->pNext = (void *)out_ext;
10157             out_header = (void *)out_ext;
10158             break;
10159         }
10160         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
10161         {
10162             VkPhysicalDevicePushDescriptorPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10163             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
10164             out_ext->pNext = NULL;
10165             out_header->pNext = (void *)out_ext;
10166             out_header = (void *)out_ext;
10167             break;
10168         }
10169         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
10170         {
10171             VkPhysicalDeviceDriverProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10172             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
10173             out_ext->pNext = NULL;
10174             out_header->pNext = (void *)out_ext;
10175             out_header = (void *)out_ext;
10176             break;
10177         }
10178         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
10179         {
10180             VkPhysicalDeviceIDProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10181             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
10182             out_ext->pNext = NULL;
10183             out_header->pNext = (void *)out_ext;
10184             out_header = (void *)out_ext;
10185             break;
10186         }
10187         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
10188         {
10189             VkPhysicalDeviceMultiviewProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10190             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
10191             out_ext->pNext = NULL;
10192             out_header->pNext = (void *)out_ext;
10193             out_header = (void *)out_ext;
10194             break;
10195         }
10196         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
10197         {
10198             VkPhysicalDeviceDiscardRectanglePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10199             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
10200             out_ext->pNext = NULL;
10201             out_header->pNext = (void *)out_ext;
10202             out_header = (void *)out_ext;
10203             break;
10204         }
10205         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
10206         {
10207             VkPhysicalDeviceSubgroupProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10208             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
10209             out_ext->pNext = NULL;
10210             out_header->pNext = (void *)out_ext;
10211             out_header = (void *)out_ext;
10212             break;
10213         }
10214         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
10215         {
10216             VkPhysicalDevicePointClippingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10217             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
10218             out_ext->pNext = NULL;
10219             out_header->pNext = (void *)out_ext;
10220             out_header = (void *)out_ext;
10221             break;
10222         }
10223         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
10224         {
10225             VkPhysicalDeviceProtectedMemoryProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10226             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
10227             out_ext->pNext = NULL;
10228             out_header->pNext = (void *)out_ext;
10229             out_header = (void *)out_ext;
10230             break;
10231         }
10232         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
10233         {
10234             VkPhysicalDeviceSamplerFilterMinmaxProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10235             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
10236             out_ext->pNext = NULL;
10237             out_header->pNext = (void *)out_ext;
10238             out_header = (void *)out_ext;
10239             break;
10240         }
10241         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
10242         {
10243             VkPhysicalDeviceSampleLocationsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10244             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
10245             out_ext->pNext = NULL;
10246             out_header->pNext = (void *)out_ext;
10247             out_header = (void *)out_ext;
10248             break;
10249         }
10250         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
10251         {
10252             VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10253             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
10254             out_ext->pNext = NULL;
10255             out_header->pNext = (void *)out_ext;
10256             out_header = (void *)out_ext;
10257             break;
10258         }
10259         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
10260         {
10261             VkPhysicalDeviceInlineUniformBlockProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10262             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
10263             out_ext->pNext = NULL;
10264             out_header->pNext = (void *)out_ext;
10265             out_header = (void *)out_ext;
10266             break;
10267         }
10268         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
10269         {
10270             VkPhysicalDeviceMaintenance3Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10271             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
10272             out_ext->pNext = NULL;
10273             out_header->pNext = (void *)out_ext;
10274             out_header = (void *)out_ext;
10275             break;
10276         }
10277         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
10278         {
10279             VkPhysicalDeviceMaintenance4Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10280             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
10281             out_ext->pNext = NULL;
10282             out_header->pNext = (void *)out_ext;
10283             out_header = (void *)out_ext;
10284             break;
10285         }
10286         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
10287         {
10288             VkPhysicalDeviceFloatControlsProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10289             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
10290             out_ext->pNext = NULL;
10291             out_header->pNext = (void *)out_ext;
10292             out_header = (void *)out_ext;
10293             break;
10294         }
10295         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
10296         {
10297             VkPhysicalDeviceExternalMemoryHostPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10298             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
10299             out_ext->pNext = NULL;
10300             out_header->pNext = (void *)out_ext;
10301             out_header = (void *)out_ext;
10302             break;
10303         }
10304         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
10305         {
10306             VkPhysicalDeviceConservativeRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10307             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
10308             out_ext->pNext = NULL;
10309             out_header->pNext = (void *)out_ext;
10310             out_header = (void *)out_ext;
10311             break;
10312         }
10313         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
10314         {
10315             VkPhysicalDeviceShaderCorePropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10316             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
10317             out_ext->pNext = NULL;
10318             out_header->pNext = (void *)out_ext;
10319             out_header = (void *)out_ext;
10320             break;
10321         }
10322         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
10323         {
10324             VkPhysicalDeviceShaderCoreProperties2AMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10325             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
10326             out_ext->pNext = NULL;
10327             out_header->pNext = (void *)out_ext;
10328             out_header = (void *)out_ext;
10329             break;
10330         }
10331         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
10332         {
10333             VkPhysicalDeviceDescriptorIndexingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10334             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
10335             out_ext->pNext = NULL;
10336             out_header->pNext = (void *)out_ext;
10337             out_header = (void *)out_ext;
10338             break;
10339         }
10340         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
10341         {
10342             VkPhysicalDeviceTimelineSemaphoreProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10343             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
10344             out_ext->pNext = NULL;
10345             out_header->pNext = (void *)out_ext;
10346             out_header = (void *)out_ext;
10347             break;
10348         }
10349         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
10350         {
10351             VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10352             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
10353             out_ext->pNext = NULL;
10354             out_header->pNext = (void *)out_ext;
10355             out_header = (void *)out_ext;
10356             break;
10357         }
10358         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
10359         {
10360             VkPhysicalDevicePCIBusInfoPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10361             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
10362             out_ext->pNext = NULL;
10363             out_header->pNext = (void *)out_ext;
10364             out_header = (void *)out_ext;
10365             break;
10366         }
10367         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
10368         {
10369             VkPhysicalDeviceDepthStencilResolveProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10370             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
10371             out_ext->pNext = NULL;
10372             out_header->pNext = (void *)out_ext;
10373             out_header = (void *)out_ext;
10374             break;
10375         }
10376         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
10377         {
10378             VkPhysicalDeviceTransformFeedbackPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10379             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
10380             out_ext->pNext = NULL;
10381             out_header->pNext = (void *)out_ext;
10382             out_header = (void *)out_ext;
10383             break;
10384         }
10385         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
10386         {
10387             VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10388             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
10389             out_ext->pNext = NULL;
10390             out_header->pNext = (void *)out_ext;
10391             out_header = (void *)out_ext;
10392             break;
10393         }
10394         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
10395         {
10396             VkPhysicalDeviceMemoryDecompressionPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10397             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
10398             out_ext->pNext = NULL;
10399             out_header->pNext = (void *)out_ext;
10400             out_header = (void *)out_ext;
10401             break;
10402         }
10403         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
10404         {
10405             VkPhysicalDeviceShadingRateImagePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10406             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
10407             out_ext->pNext = NULL;
10408             out_header->pNext = (void *)out_ext;
10409             out_header = (void *)out_ext;
10410             break;
10411         }
10412         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
10413         {
10414             VkPhysicalDeviceMeshShaderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10415             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
10416             out_ext->pNext = NULL;
10417             out_header->pNext = (void *)out_ext;
10418             out_header = (void *)out_ext;
10419             break;
10420         }
10421         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
10422         {
10423             VkPhysicalDeviceMeshShaderPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10424             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
10425             out_ext->pNext = NULL;
10426             out_header->pNext = (void *)out_ext;
10427             out_header = (void *)out_ext;
10428             break;
10429         }
10430         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
10431         {
10432             VkPhysicalDeviceAccelerationStructurePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10433             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
10434             out_ext->pNext = NULL;
10435             out_header->pNext = (void *)out_ext;
10436             out_header = (void *)out_ext;
10437             break;
10438         }
10439         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
10440         {
10441             VkPhysicalDeviceRayTracingPipelinePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10442             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
10443             out_ext->pNext = NULL;
10444             out_header->pNext = (void *)out_ext;
10445             out_header = (void *)out_ext;
10446             break;
10447         }
10448         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
10449         {
10450             VkPhysicalDeviceRayTracingPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10451             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
10452             out_ext->pNext = NULL;
10453             out_header->pNext = (void *)out_ext;
10454             out_header = (void *)out_ext;
10455             break;
10456         }
10457         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
10458         {
10459             VkPhysicalDeviceFragmentDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10460             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
10461             out_ext->pNext = NULL;
10462             out_header->pNext = (void *)out_ext;
10463             out_header = (void *)out_ext;
10464             break;
10465         }
10466         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
10467         {
10468             VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10469             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
10470             out_ext->pNext = NULL;
10471             out_header->pNext = (void *)out_ext;
10472             out_header = (void *)out_ext;
10473             break;
10474         }
10475         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
10476         {
10477             VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10478             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM;
10479             out_ext->pNext = NULL;
10480             out_header->pNext = (void *)out_ext;
10481             out_header = (void *)out_ext;
10482             break;
10483         }
10484         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
10485         {
10486             VkPhysicalDeviceCooperativeMatrixPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10487             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
10488             out_ext->pNext = NULL;
10489             out_header->pNext = (void *)out_ext;
10490             out_header = (void *)out_ext;
10491             break;
10492         }
10493         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
10494         {
10495             VkPhysicalDevicePerformanceQueryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10496             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
10497             out_ext->pNext = NULL;
10498             out_header->pNext = (void *)out_ext;
10499             out_header = (void *)out_ext;
10500             break;
10501         }
10502         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
10503         {
10504             VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10505             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
10506             out_ext->pNext = NULL;
10507             out_header->pNext = (void *)out_ext;
10508             out_header = (void *)out_ext;
10509             break;
10510         }
10511         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
10512         {
10513             VkPhysicalDeviceTexelBufferAlignmentProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10514             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
10515             out_ext->pNext = NULL;
10516             out_header->pNext = (void *)out_ext;
10517             out_header = (void *)out_ext;
10518             break;
10519         }
10520         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
10521         {
10522             VkPhysicalDeviceSubgroupSizeControlProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10523             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
10524             out_ext->pNext = NULL;
10525             out_header->pNext = (void *)out_ext;
10526             out_header = (void *)out_ext;
10527             break;
10528         }
10529         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
10530         {
10531             VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10532             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
10533             out_ext->pNext = NULL;
10534             out_header->pNext = (void *)out_ext;
10535             out_header = (void *)out_ext;
10536             break;
10537         }
10538         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
10539         {
10540             VkPhysicalDeviceLineRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10541             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
10542             out_ext->pNext = NULL;
10543             out_header->pNext = (void *)out_ext;
10544             out_header = (void *)out_ext;
10545             break;
10546         }
10547         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
10548         {
10549             VkPhysicalDeviceVulkan11Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10550             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
10551             out_ext->pNext = NULL;
10552             out_header->pNext = (void *)out_ext;
10553             out_header = (void *)out_ext;
10554             break;
10555         }
10556         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
10557         {
10558             VkPhysicalDeviceVulkan12Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10559             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
10560             out_ext->pNext = NULL;
10561             out_header->pNext = (void *)out_ext;
10562             out_header = (void *)out_ext;
10563             break;
10564         }
10565         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
10566         {
10567             VkPhysicalDeviceVulkan13Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10568             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
10569             out_ext->pNext = NULL;
10570             out_header->pNext = (void *)out_ext;
10571             out_header = (void *)out_ext;
10572             break;
10573         }
10574         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
10575         {
10576             VkPhysicalDeviceCustomBorderColorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10577             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
10578             out_ext->pNext = NULL;
10579             out_header->pNext = (void *)out_ext;
10580             out_header = (void *)out_ext;
10581             break;
10582         }
10583         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
10584         {
10585             VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10586             const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)in_header;
10587             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
10588             out_ext->pNext = NULL;
10589             out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted;
10590             out_header->pNext = (void *)out_ext;
10591             out_header = (void *)out_ext;
10592             break;
10593         }
10594         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
10595         {
10596             VkPhysicalDeviceRobustness2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10597             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
10598             out_ext->pNext = NULL;
10599             out_header->pNext = (void *)out_ext;
10600             out_header = (void *)out_ext;
10601             break;
10602         }
10603         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
10604         {
10605             VkPhysicalDeviceFragmentShadingRatePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10606             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
10607             out_ext->pNext = NULL;
10608             out_header->pNext = (void *)out_ext;
10609             out_header = (void *)out_ext;
10610             break;
10611         }
10612         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
10613         {
10614             VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10615             const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *)in_header;
10616             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
10617             out_ext->pNext = NULL;
10618             out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount;
10619             out_header->pNext = (void *)out_ext;
10620             out_header = (void *)out_ext;
10621             break;
10622         }
10623         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
10624         {
10625             VkPhysicalDeviceProvokingVertexPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10626             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
10627             out_ext->pNext = NULL;
10628             out_header->pNext = (void *)out_ext;
10629             out_header = (void *)out_ext;
10630             break;
10631         }
10632         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
10633         {
10634             VkPhysicalDeviceShaderIntegerDotProductProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10635             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
10636             out_ext->pNext = NULL;
10637             out_header->pNext = (void *)out_ext;
10638             out_header = (void *)out_ext;
10639             break;
10640         }
10641         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
10642         {
10643             VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10644             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
10645             out_ext->pNext = NULL;
10646             out_header->pNext = (void *)out_ext;
10647             out_header = (void *)out_ext;
10648             break;
10649         }
10650         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
10651         {
10652             VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10653             const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)in_header;
10654             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
10655             out_ext->pNext = NULL;
10656             out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking;
10657             out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration;
10658             out_header->pNext = (void *)out_ext;
10659             out_header = (void *)out_ext;
10660             break;
10661         }
10662         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
10663         {
10664             VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10665             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
10666             out_ext->pNext = NULL;
10667             out_header->pNext = (void *)out_ext;
10668             out_header = (void *)out_ext;
10669             break;
10670         }
10671         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
10672         {
10673             VkPhysicalDeviceOpacityMicromapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10674             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
10675             out_ext->pNext = NULL;
10676             out_header->pNext = (void *)out_ext;
10677             out_header = (void *)out_ext;
10678             break;
10679         }
10680         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
10681         {
10682             VkPhysicalDevicePipelineRobustnessPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10683             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT;
10684             out_ext->pNext = NULL;
10685             out_header->pNext = (void *)out_ext;
10686             out_header = (void *)out_ext;
10687             break;
10688         }
10689         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
10690         {
10691             VkPhysicalDeviceImageProcessingPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10692             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
10693             out_ext->pNext = NULL;
10694             out_header->pNext = (void *)out_ext;
10695             out_header = (void *)out_ext;
10696             break;
10697         }
10698         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
10699         {
10700             VkPhysicalDeviceOpticalFlowPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10701             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
10702             out_ext->pNext = NULL;
10703             out_header->pNext = (void *)out_ext;
10704             out_header = (void *)out_ext;
10705             break;
10706         }
10707         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
10708         {
10709             VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10710             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
10711             out_ext->pNext = NULL;
10712             out_header->pNext = (void *)out_ext;
10713             out_header = (void *)out_ext;
10714             break;
10715         }
10716         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
10717         {
10718             VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
10719             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
10720             out_ext->pNext = NULL;
10721             out_header->pNext = (void *)out_ext;
10722             out_header = (void *)out_ext;
10723             break;
10724         }
10725         default:
10726             FIXME("Unhandled sType %u.", in_header->sType);
10727             break;
10728         }
10729     }
10730 }
10731 #endif /* USE_STRUCT_CONVERSION */
10732
10733 #if defined(USE_STRUCT_CONVERSION)
10734 static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDeviceProperties2 *in, VkPhysicalDeviceProperties232 *out)
10735 {
10736     const VkBaseInStructure *in_header;
10737     VkBaseOutStructure *out_header = (void *)out;
10738
10739     if (!in) return;
10740
10741     convert_VkPhysicalDeviceProperties_host_to_win32(&in->properties, &out->properties);
10742
10743     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
10744     {
10745         switch (in_header->sType)
10746         {
10747         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
10748         {
10749             VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV);
10750             const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *)in_header;
10751             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
10752             out_ext->maxGraphicsShaderGroupCount = in_ext->maxGraphicsShaderGroupCount;
10753             out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount;
10754             out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount;
10755             out_ext->maxIndirectCommandsStreamCount = in_ext->maxIndirectCommandsStreamCount;
10756             out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset;
10757             out_ext->maxIndirectCommandsStreamStride = in_ext->maxIndirectCommandsStreamStride;
10758             out_ext->minSequencesCountBufferOffsetAlignment = in_ext->minSequencesCountBufferOffsetAlignment;
10759             out_ext->minSequencesIndexBufferOffsetAlignment = in_ext->minSequencesIndexBufferOffsetAlignment;
10760             out_ext->minIndirectCommandsBufferOffsetAlignment = in_ext->minIndirectCommandsBufferOffsetAlignment;
10761             out_header = (void *)out_ext;
10762             break;
10763         }
10764         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
10765         {
10766             VkPhysicalDeviceMultiDrawPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT);
10767             const VkPhysicalDeviceMultiDrawPropertiesEXT *in_ext = (const VkPhysicalDeviceMultiDrawPropertiesEXT *)in_header;
10768             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
10769             out_ext->maxMultiDrawCount = in_ext->maxMultiDrawCount;
10770             out_header = (void *)out_ext;
10771             break;
10772         }
10773         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
10774         {
10775             VkPhysicalDevicePushDescriptorPropertiesKHR *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR);
10776             const VkPhysicalDevicePushDescriptorPropertiesKHR *in_ext = (const VkPhysicalDevicePushDescriptorPropertiesKHR *)in_header;
10777             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
10778             out_ext->maxPushDescriptors = in_ext->maxPushDescriptors;
10779             out_header = (void *)out_ext;
10780             break;
10781         }
10782         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
10783         {
10784             VkPhysicalDeviceDriverProperties *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
10785             const VkPhysicalDeviceDriverProperties *in_ext = (const VkPhysicalDeviceDriverProperties *)in_header;
10786             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
10787             out_ext->driverID = in_ext->driverID;
10788             memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
10789             memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
10790             out_ext->conformanceVersion = in_ext->conformanceVersion;
10791             out_header = (void *)out_ext;
10792             break;
10793         }
10794         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
10795         {
10796             VkPhysicalDeviceIDProperties *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
10797             const VkPhysicalDeviceIDProperties *in_ext = (const VkPhysicalDeviceIDProperties *)in_header;
10798             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
10799             memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
10800             memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
10801             memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
10802             out_ext->deviceNodeMask = in_ext->deviceNodeMask;
10803             out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
10804             out_header = (void *)out_ext;
10805             break;
10806         }
10807         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
10808         {
10809             VkPhysicalDeviceMultiviewProperties *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
10810             const VkPhysicalDeviceMultiviewProperties *in_ext = (const VkPhysicalDeviceMultiviewProperties *)in_header;
10811             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
10812             out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
10813             out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
10814             out_header = (void *)out_ext;
10815             break;
10816         }
10817         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
10818         {
10819             VkPhysicalDeviceDiscardRectanglePropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT);
10820             const VkPhysicalDeviceDiscardRectanglePropertiesEXT *in_ext = (const VkPhysicalDeviceDiscardRectanglePropertiesEXT *)in_header;
10821             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
10822             out_ext->maxDiscardRectangles = in_ext->maxDiscardRectangles;
10823             out_header = (void *)out_ext;
10824             break;
10825         }
10826         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
10827         {
10828             VkPhysicalDeviceSubgroupProperties *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
10829             const VkPhysicalDeviceSubgroupProperties *in_ext = (const VkPhysicalDeviceSubgroupProperties *)in_header;
10830             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
10831             out_ext->subgroupSize = in_ext->subgroupSize;
10832             out_ext->supportedStages = in_ext->supportedStages;
10833             out_ext->supportedOperations = in_ext->supportedOperations;
10834             out_ext->quadOperationsInAllStages = in_ext->quadOperationsInAllStages;
10835             out_header = (void *)out_ext;
10836             break;
10837         }
10838         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
10839         {
10840             VkPhysicalDevicePointClippingProperties *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
10841             const VkPhysicalDevicePointClippingProperties *in_ext = (const VkPhysicalDevicePointClippingProperties *)in_header;
10842             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
10843             out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
10844             out_header = (void *)out_ext;
10845             break;
10846         }
10847         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
10848         {
10849             VkPhysicalDeviceProtectedMemoryProperties *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
10850             const VkPhysicalDeviceProtectedMemoryProperties *in_ext = (const VkPhysicalDeviceProtectedMemoryProperties *)in_header;
10851             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
10852             out_ext->protectedNoFault = in_ext->protectedNoFault;
10853             out_header = (void *)out_ext;
10854             break;
10855         }
10856         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
10857         {
10858             VkPhysicalDeviceSamplerFilterMinmaxProperties *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
10859             const VkPhysicalDeviceSamplerFilterMinmaxProperties *in_ext = (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)in_header;
10860             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
10861             out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
10862             out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
10863             out_header = (void *)out_ext;
10864             break;
10865         }
10866         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
10867         {
10868             VkPhysicalDeviceSampleLocationsPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT);
10869             const VkPhysicalDeviceSampleLocationsPropertiesEXT *in_ext = (const VkPhysicalDeviceSampleLocationsPropertiesEXT *)in_header;
10870             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
10871             out_ext->sampleLocationSampleCounts = in_ext->sampleLocationSampleCounts;
10872             out_ext->maxSampleLocationGridSize = in_ext->maxSampleLocationGridSize;
10873             memcpy(out_ext->sampleLocationCoordinateRange, in_ext->sampleLocationCoordinateRange, 2 * sizeof(float));
10874             out_ext->sampleLocationSubPixelBits = in_ext->sampleLocationSubPixelBits;
10875             out_ext->variableSampleLocations = in_ext->variableSampleLocations;
10876             out_header = (void *)out_ext;
10877             break;
10878         }
10879         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
10880         {
10881             VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT);
10882             const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)in_header;
10883             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
10884             out_ext->advancedBlendMaxColorAttachments = in_ext->advancedBlendMaxColorAttachments;
10885             out_ext->advancedBlendIndependentBlend = in_ext->advancedBlendIndependentBlend;
10886             out_ext->advancedBlendNonPremultipliedSrcColor = in_ext->advancedBlendNonPremultipliedSrcColor;
10887             out_ext->advancedBlendNonPremultipliedDstColor = in_ext->advancedBlendNonPremultipliedDstColor;
10888             out_ext->advancedBlendCorrelatedOverlap = in_ext->advancedBlendCorrelatedOverlap;
10889             out_ext->advancedBlendAllOperations = in_ext->advancedBlendAllOperations;
10890             out_header = (void *)out_ext;
10891             break;
10892         }
10893         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
10894         {
10895             VkPhysicalDeviceInlineUniformBlockProperties *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES);
10896             const VkPhysicalDeviceInlineUniformBlockProperties *in_ext = (const VkPhysicalDeviceInlineUniformBlockProperties *)in_header;
10897             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
10898             out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
10899             out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
10900             out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
10901             out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
10902             out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
10903             out_header = (void *)out_ext;
10904             break;
10905         }
10906         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
10907         {
10908             VkPhysicalDeviceMaintenance3Properties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
10909             const VkPhysicalDeviceMaintenance3Properties *in_ext = (const VkPhysicalDeviceMaintenance3Properties *)in_header;
10910             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
10911             out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
10912             out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
10913             out_header = (void *)out_ext;
10914             break;
10915         }
10916         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
10917         {
10918             VkPhysicalDeviceMaintenance4Properties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES);
10919             const VkPhysicalDeviceMaintenance4Properties *in_ext = (const VkPhysicalDeviceMaintenance4Properties *)in_header;
10920             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
10921             out_ext->maxBufferSize = in_ext->maxBufferSize;
10922             out_header = (void *)out_ext;
10923             break;
10924         }
10925         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
10926         {
10927             VkPhysicalDeviceFloatControlsProperties *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
10928             const VkPhysicalDeviceFloatControlsProperties *in_ext = (const VkPhysicalDeviceFloatControlsProperties *)in_header;
10929             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
10930             out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence;
10931             out_ext->roundingModeIndependence = in_ext->roundingModeIndependence;
10932             out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16;
10933             out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32;
10934             out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64;
10935             out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16;
10936             out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32;
10937             out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64;
10938             out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16;
10939             out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32;
10940             out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64;
10941             out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16;
10942             out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32;
10943             out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64;
10944             out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16;
10945             out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32;
10946             out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64;
10947             out_header = (void *)out_ext;
10948             break;
10949         }
10950         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
10951         {
10952             VkPhysicalDeviceExternalMemoryHostPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT);
10953             const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *in_ext = (const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *)in_header;
10954             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
10955             out_ext->minImportedHostPointerAlignment = in_ext->minImportedHostPointerAlignment;
10956             out_header = (void *)out_ext;
10957             break;
10958         }
10959         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
10960         {
10961             VkPhysicalDeviceConservativeRasterizationPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT);
10962             const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)in_header;
10963             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
10964             out_ext->primitiveOverestimationSize = in_ext->primitiveOverestimationSize;
10965             out_ext->maxExtraPrimitiveOverestimationSize = in_ext->maxExtraPrimitiveOverestimationSize;
10966             out_ext->extraPrimitiveOverestimationSizeGranularity = in_ext->extraPrimitiveOverestimationSizeGranularity;
10967             out_ext->primitiveUnderestimation = in_ext->primitiveUnderestimation;
10968             out_ext->conservativePointAndLineRasterization = in_ext->conservativePointAndLineRasterization;
10969             out_ext->degenerateTrianglesRasterized = in_ext->degenerateTrianglesRasterized;
10970             out_ext->degenerateLinesRasterized = in_ext->degenerateLinesRasterized;
10971             out_ext->fullyCoveredFragmentShaderInputVariable = in_ext->fullyCoveredFragmentShaderInputVariable;
10972             out_ext->conservativeRasterizationPostDepthCoverage = in_ext->conservativeRasterizationPostDepthCoverage;
10973             out_header = (void *)out_ext;
10974             break;
10975         }
10976         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
10977         {
10978             VkPhysicalDeviceShaderCorePropertiesAMD *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD);
10979             const VkPhysicalDeviceShaderCorePropertiesAMD *in_ext = (const VkPhysicalDeviceShaderCorePropertiesAMD *)in_header;
10980             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
10981             out_ext->shaderEngineCount = in_ext->shaderEngineCount;
10982             out_ext->shaderArraysPerEngineCount = in_ext->shaderArraysPerEngineCount;
10983             out_ext->computeUnitsPerShaderArray = in_ext->computeUnitsPerShaderArray;
10984             out_ext->simdPerComputeUnit = in_ext->simdPerComputeUnit;
10985             out_ext->wavefrontsPerSimd = in_ext->wavefrontsPerSimd;
10986             out_ext->wavefrontSize = in_ext->wavefrontSize;
10987             out_ext->sgprsPerSimd = in_ext->sgprsPerSimd;
10988             out_ext->minSgprAllocation = in_ext->minSgprAllocation;
10989             out_ext->maxSgprAllocation = in_ext->maxSgprAllocation;
10990             out_ext->sgprAllocationGranularity = in_ext->sgprAllocationGranularity;
10991             out_ext->vgprsPerSimd = in_ext->vgprsPerSimd;
10992             out_ext->minVgprAllocation = in_ext->minVgprAllocation;
10993             out_ext->maxVgprAllocation = in_ext->maxVgprAllocation;
10994             out_ext->vgprAllocationGranularity = in_ext->vgprAllocationGranularity;
10995             out_header = (void *)out_ext;
10996             break;
10997         }
10998         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
10999         {
11000             VkPhysicalDeviceShaderCoreProperties2AMD *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD);
11001             const VkPhysicalDeviceShaderCoreProperties2AMD *in_ext = (const VkPhysicalDeviceShaderCoreProperties2AMD *)in_header;
11002             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
11003             out_ext->shaderCoreFeatures = in_ext->shaderCoreFeatures;
11004             out_ext->activeComputeUnitCount = in_ext->activeComputeUnitCount;
11005             out_header = (void *)out_ext;
11006             break;
11007         }
11008         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
11009         {
11010             VkPhysicalDeviceDescriptorIndexingProperties *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
11011             const VkPhysicalDeviceDescriptorIndexingProperties *in_ext = (const VkPhysicalDeviceDescriptorIndexingProperties *)in_header;
11012             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
11013             out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
11014             out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
11015             out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
11016             out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
11017             out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
11018             out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
11019             out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
11020             out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
11021             out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
11022             out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
11023             out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
11024             out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
11025             out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
11026             out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
11027             out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
11028             out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
11029             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
11030             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
11031             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
11032             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
11033             out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
11034             out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
11035             out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
11036             out_header = (void *)out_ext;
11037             break;
11038         }
11039         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
11040         {
11041             VkPhysicalDeviceTimelineSemaphoreProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
11042             const VkPhysicalDeviceTimelineSemaphoreProperties *in_ext = (const VkPhysicalDeviceTimelineSemaphoreProperties *)in_header;
11043             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
11044             out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
11045             out_header = (void *)out_ext;
11046             break;
11047         }
11048         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
11049         {
11050             VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT);
11051             const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)in_header;
11052             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
11053             out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor;
11054             out_header = (void *)out_ext;
11055             break;
11056         }
11057         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
11058         {
11059             VkPhysicalDevicePCIBusInfoPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT);
11060             const VkPhysicalDevicePCIBusInfoPropertiesEXT *in_ext = (const VkPhysicalDevicePCIBusInfoPropertiesEXT *)in_header;
11061             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
11062             out_ext->pciDomain = in_ext->pciDomain;
11063             out_ext->pciBus = in_ext->pciBus;
11064             out_ext->pciDevice = in_ext->pciDevice;
11065             out_ext->pciFunction = in_ext->pciFunction;
11066             out_header = (void *)out_ext;
11067             break;
11068         }
11069         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
11070         {
11071             VkPhysicalDeviceDepthStencilResolveProperties *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
11072             const VkPhysicalDeviceDepthStencilResolveProperties *in_ext = (const VkPhysicalDeviceDepthStencilResolveProperties *)in_header;
11073             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
11074             out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
11075             out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
11076             out_ext->independentResolveNone = in_ext->independentResolveNone;
11077             out_ext->independentResolve = in_ext->independentResolve;
11078             out_header = (void *)out_ext;
11079             break;
11080         }
11081         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
11082         {
11083             VkPhysicalDeviceTransformFeedbackPropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
11084             const VkPhysicalDeviceTransformFeedbackPropertiesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)in_header;
11085             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
11086             out_ext->maxTransformFeedbackStreams = in_ext->maxTransformFeedbackStreams;
11087             out_ext->maxTransformFeedbackBuffers = in_ext->maxTransformFeedbackBuffers;
11088             out_ext->maxTransformFeedbackBufferSize = in_ext->maxTransformFeedbackBufferSize;
11089             out_ext->maxTransformFeedbackStreamDataSize = in_ext->maxTransformFeedbackStreamDataSize;
11090             out_ext->maxTransformFeedbackBufferDataSize = in_ext->maxTransformFeedbackBufferDataSize;
11091             out_ext->maxTransformFeedbackBufferDataStride = in_ext->maxTransformFeedbackBufferDataStride;
11092             out_ext->transformFeedbackQueries = in_ext->transformFeedbackQueries;
11093             out_ext->transformFeedbackStreamsLinesTriangles = in_ext->transformFeedbackStreamsLinesTriangles;
11094             out_ext->transformFeedbackRasterizationStreamSelect = in_ext->transformFeedbackRasterizationStreamSelect;
11095             out_ext->transformFeedbackDraw = in_ext->transformFeedbackDraw;
11096             out_header = (void *)out_ext;
11097             break;
11098         }
11099         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
11100         {
11101             VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV);
11102             const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *)in_header;
11103             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
11104             out_ext->supportedQueues = in_ext->supportedQueues;
11105             out_header = (void *)out_ext;
11106             break;
11107         }
11108         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
11109         {
11110             VkPhysicalDeviceMemoryDecompressionPropertiesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV);
11111             const VkPhysicalDeviceMemoryDecompressionPropertiesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionPropertiesNV *)in_header;
11112             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
11113             out_ext->decompressionMethods = in_ext->decompressionMethods;
11114             out_ext->maxDecompressionIndirectCount = in_ext->maxDecompressionIndirectCount;
11115             out_header = (void *)out_ext;
11116             break;
11117         }
11118         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
11119         {
11120             VkPhysicalDeviceShadingRateImagePropertiesNV *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV);
11121             const VkPhysicalDeviceShadingRateImagePropertiesNV *in_ext = (const VkPhysicalDeviceShadingRateImagePropertiesNV *)in_header;
11122             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
11123             out_ext->shadingRateTexelSize = in_ext->shadingRateTexelSize;
11124             out_ext->shadingRatePaletteSize = in_ext->shadingRatePaletteSize;
11125             out_ext->shadingRateMaxCoarseSamples = in_ext->shadingRateMaxCoarseSamples;
11126             out_header = (void *)out_ext;
11127             break;
11128         }
11129         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
11130         {
11131             VkPhysicalDeviceMeshShaderPropertiesNV *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV);
11132             const VkPhysicalDeviceMeshShaderPropertiesNV *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesNV *)in_header;
11133             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
11134             out_ext->maxDrawMeshTasksCount = in_ext->maxDrawMeshTasksCount;
11135             out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations;
11136             memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
11137             out_ext->maxTaskTotalMemorySize = in_ext->maxTaskTotalMemorySize;
11138             out_ext->maxTaskOutputCount = in_ext->maxTaskOutputCount;
11139             out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations;
11140             memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
11141             out_ext->maxMeshTotalMemorySize = in_ext->maxMeshTotalMemorySize;
11142             out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices;
11143             out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives;
11144             out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount;
11145             out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity;
11146             out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity;
11147             out_header = (void *)out_ext;
11148             break;
11149         }
11150         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
11151         {
11152             VkPhysicalDeviceMeshShaderPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT);
11153             const VkPhysicalDeviceMeshShaderPropertiesEXT *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesEXT *)in_header;
11154             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
11155             out_ext->maxTaskWorkGroupTotalCount = in_ext->maxTaskWorkGroupTotalCount;
11156             memcpy(out_ext->maxTaskWorkGroupCount, in_ext->maxTaskWorkGroupCount, 3 * sizeof(uint32_t));
11157             out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations;
11158             memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
11159             out_ext->maxTaskPayloadSize = in_ext->maxTaskPayloadSize;
11160             out_ext->maxTaskSharedMemorySize = in_ext->maxTaskSharedMemorySize;
11161             out_ext->maxTaskPayloadAndSharedMemorySize = in_ext->maxTaskPayloadAndSharedMemorySize;
11162             out_ext->maxMeshWorkGroupTotalCount = in_ext->maxMeshWorkGroupTotalCount;
11163             memcpy(out_ext->maxMeshWorkGroupCount, in_ext->maxMeshWorkGroupCount, 3 * sizeof(uint32_t));
11164             out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations;
11165             memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
11166             out_ext->maxMeshSharedMemorySize = in_ext->maxMeshSharedMemorySize;
11167             out_ext->maxMeshPayloadAndSharedMemorySize = in_ext->maxMeshPayloadAndSharedMemorySize;
11168             out_ext->maxMeshOutputMemorySize = in_ext->maxMeshOutputMemorySize;
11169             out_ext->maxMeshPayloadAndOutputMemorySize = in_ext->maxMeshPayloadAndOutputMemorySize;
11170             out_ext->maxMeshOutputComponents = in_ext->maxMeshOutputComponents;
11171             out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices;
11172             out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives;
11173             out_ext->maxMeshOutputLayers = in_ext->maxMeshOutputLayers;
11174             out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount;
11175             out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity;
11176             out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity;
11177             out_ext->maxPreferredTaskWorkGroupInvocations = in_ext->maxPreferredTaskWorkGroupInvocations;
11178             out_ext->maxPreferredMeshWorkGroupInvocations = in_ext->maxPreferredMeshWorkGroupInvocations;
11179             out_ext->prefersLocalInvocationVertexOutput = in_ext->prefersLocalInvocationVertexOutput;
11180             out_ext->prefersLocalInvocationPrimitiveOutput = in_ext->prefersLocalInvocationPrimitiveOutput;
11181             out_ext->prefersCompactVertexOutput = in_ext->prefersCompactVertexOutput;
11182             out_ext->prefersCompactPrimitiveOutput = in_ext->prefersCompactPrimitiveOutput;
11183             out_header = (void *)out_ext;
11184             break;
11185         }
11186         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
11187         {
11188             VkPhysicalDeviceAccelerationStructurePropertiesKHR32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR);
11189             const VkPhysicalDeviceAccelerationStructurePropertiesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructurePropertiesKHR *)in_header;
11190             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
11191             out_ext->maxGeometryCount = in_ext->maxGeometryCount;
11192             out_ext->maxInstanceCount = in_ext->maxInstanceCount;
11193             out_ext->maxPrimitiveCount = in_ext->maxPrimitiveCount;
11194             out_ext->maxPerStageDescriptorAccelerationStructures = in_ext->maxPerStageDescriptorAccelerationStructures;
11195             out_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures = in_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
11196             out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
11197             out_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures = in_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures;
11198             out_ext->minAccelerationStructureScratchOffsetAlignment = in_ext->minAccelerationStructureScratchOffsetAlignment;
11199             out_header = (void *)out_ext;
11200             break;
11201         }
11202         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
11203         {
11204             VkPhysicalDeviceRayTracingPipelinePropertiesKHR *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR);
11205             const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *)in_header;
11206             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
11207             out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
11208             out_ext->maxRayRecursionDepth = in_ext->maxRayRecursionDepth;
11209             out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
11210             out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
11211             out_ext->shaderGroupHandleCaptureReplaySize = in_ext->shaderGroupHandleCaptureReplaySize;
11212             out_ext->maxRayDispatchInvocationCount = in_ext->maxRayDispatchInvocationCount;
11213             out_ext->shaderGroupHandleAlignment = in_ext->shaderGroupHandleAlignment;
11214             out_ext->maxRayHitAttributeSize = in_ext->maxRayHitAttributeSize;
11215             out_header = (void *)out_ext;
11216             break;
11217         }
11218         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
11219         {
11220             VkPhysicalDeviceRayTracingPropertiesNV32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV);
11221             const VkPhysicalDeviceRayTracingPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingPropertiesNV *)in_header;
11222             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
11223             out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize;
11224             out_ext->maxRecursionDepth = in_ext->maxRecursionDepth;
11225             out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride;
11226             out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment;
11227             out_ext->maxGeometryCount = in_ext->maxGeometryCount;
11228             out_ext->maxInstanceCount = in_ext->maxInstanceCount;
11229             out_ext->maxTriangleCount = in_ext->maxTriangleCount;
11230             out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures;
11231             out_header = (void *)out_ext;
11232             break;
11233         }
11234         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
11235         {
11236             VkPhysicalDeviceFragmentDensityMapPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT);
11237             const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *)in_header;
11238             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
11239             out_ext->minFragmentDensityTexelSize = in_ext->minFragmentDensityTexelSize;
11240             out_ext->maxFragmentDensityTexelSize = in_ext->maxFragmentDensityTexelSize;
11241             out_ext->fragmentDensityInvocations = in_ext->fragmentDensityInvocations;
11242             out_header = (void *)out_ext;
11243             break;
11244         }
11245         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
11246         {
11247             VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT);
11248             const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *)in_header;
11249             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
11250             out_ext->subsampledLoads = in_ext->subsampledLoads;
11251             out_ext->subsampledCoarseReconstructionEarlyAccess = in_ext->subsampledCoarseReconstructionEarlyAccess;
11252             out_ext->maxSubsampledArrayLayers = in_ext->maxSubsampledArrayLayers;
11253             out_ext->maxDescriptorSetSubsampledSamplers = in_ext->maxDescriptorSetSubsampledSamplers;
11254             out_header = (void *)out_ext;
11255             break;
11256         }
11257         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
11258         {
11259             VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM);
11260             const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *)in_header;
11261             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM;
11262             out_ext->fragmentDensityOffsetGranularity = in_ext->fragmentDensityOffsetGranularity;
11263             out_header = (void *)out_ext;
11264             break;
11265         }
11266         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
11267         {
11268             VkPhysicalDeviceCooperativeMatrixPropertiesNV *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV);
11269             const VkPhysicalDeviceCooperativeMatrixPropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesNV *)in_header;
11270             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
11271             out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages;
11272             out_header = (void *)out_ext;
11273             break;
11274         }
11275         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
11276         {
11277             VkPhysicalDevicePerformanceQueryPropertiesKHR *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR);
11278             const VkPhysicalDevicePerformanceQueryPropertiesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryPropertiesKHR *)in_header;
11279             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
11280             out_ext->allowCommandBufferQueryCopies = in_ext->allowCommandBufferQueryCopies;
11281             out_header = (void *)out_ext;
11282             break;
11283         }
11284         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
11285         {
11286             VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV);
11287             const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *)in_header;
11288             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
11289             out_ext->shaderSMCount = in_ext->shaderSMCount;
11290             out_ext->shaderWarpsPerSM = in_ext->shaderWarpsPerSM;
11291             out_header = (void *)out_ext;
11292             break;
11293         }
11294         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
11295         {
11296             VkPhysicalDeviceTexelBufferAlignmentProperties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES);
11297             const VkPhysicalDeviceTexelBufferAlignmentProperties *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentProperties *)in_header;
11298             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
11299             out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
11300             out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
11301             out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
11302             out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
11303             out_header = (void *)out_ext;
11304             break;
11305         }
11306         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
11307         {
11308             VkPhysicalDeviceSubgroupSizeControlProperties *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
11309             const VkPhysicalDeviceSubgroupSizeControlProperties *in_ext = (const VkPhysicalDeviceSubgroupSizeControlProperties *)in_header;
11310             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
11311             out_ext->minSubgroupSize = in_ext->minSubgroupSize;
11312             out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
11313             out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
11314             out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
11315             out_header = (void *)out_ext;
11316             break;
11317         }
11318         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
11319         {
11320             VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI);
11321             const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *)in_header;
11322             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
11323             out_ext->maxSubpassShadingWorkgroupSizeAspectRatio = in_ext->maxSubpassShadingWorkgroupSizeAspectRatio;
11324             out_header = (void *)out_ext;
11325             break;
11326         }
11327         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
11328         {
11329             VkPhysicalDeviceLineRasterizationPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT);
11330             const VkPhysicalDeviceLineRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationPropertiesEXT *)in_header;
11331             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
11332             out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits;
11333             out_header = (void *)out_ext;
11334             break;
11335         }
11336         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
11337         {
11338             VkPhysicalDeviceVulkan11Properties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
11339             const VkPhysicalDeviceVulkan11Properties *in_ext = (const VkPhysicalDeviceVulkan11Properties *)in_header;
11340             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
11341             memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t));
11342             memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t));
11343             memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
11344             out_ext->deviceNodeMask = in_ext->deviceNodeMask;
11345             out_ext->deviceLUIDValid = in_ext->deviceLUIDValid;
11346             out_ext->subgroupSize = in_ext->subgroupSize;
11347             out_ext->subgroupSupportedStages = in_ext->subgroupSupportedStages;
11348             out_ext->subgroupSupportedOperations = in_ext->subgroupSupportedOperations;
11349             out_ext->subgroupQuadOperationsInAllStages = in_ext->subgroupQuadOperationsInAllStages;
11350             out_ext->pointClippingBehavior = in_ext->pointClippingBehavior;
11351             out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount;
11352             out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex;
11353             out_ext->protectedNoFault = in_ext->protectedNoFault;
11354             out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors;
11355             out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize;
11356             out_header = (void *)out_ext;
11357             break;
11358         }
11359         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
11360         {
11361             VkPhysicalDeviceVulkan12Properties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
11362             const VkPhysicalDeviceVulkan12Properties *in_ext = (const VkPhysicalDeviceVulkan12Properties *)in_header;
11363             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
11364             out_ext->driverID = in_ext->driverID;
11365             memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
11366             memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
11367             out_ext->conformanceVersion = in_ext->conformanceVersion;
11368             out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence;
11369             out_ext->roundingModeIndependence = in_ext->roundingModeIndependence;
11370             out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16;
11371             out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32;
11372             out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64;
11373             out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16;
11374             out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32;
11375             out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64;
11376             out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16;
11377             out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32;
11378             out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64;
11379             out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16;
11380             out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32;
11381             out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64;
11382             out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16;
11383             out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32;
11384             out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64;
11385             out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools;
11386             out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative;
11387             out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative;
11388             out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative;
11389             out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative;
11390             out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative;
11391             out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind;
11392             out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod;
11393             out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers;
11394             out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
11395             out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
11396             out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages;
11397             out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages;
11398             out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments;
11399             out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources;
11400             out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers;
11401             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers;
11402             out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
11403             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers;
11404             out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
11405             out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages;
11406             out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages;
11407             out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments;
11408             out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes;
11409             out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes;
11410             out_ext->independentResolveNone = in_ext->independentResolveNone;
11411             out_ext->independentResolve = in_ext->independentResolve;
11412             out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats;
11413             out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping;
11414             out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference;
11415             out_ext->framebufferIntegerColorSampleCounts = in_ext->framebufferIntegerColorSampleCounts;
11416             out_header = (void *)out_ext;
11417             break;
11418         }
11419         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
11420         {
11421             VkPhysicalDeviceVulkan13Properties32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES);
11422             const VkPhysicalDeviceVulkan13Properties *in_ext = (const VkPhysicalDeviceVulkan13Properties *)in_header;
11423             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
11424             out_ext->minSubgroupSize = in_ext->minSubgroupSize;
11425             out_ext->maxSubgroupSize = in_ext->maxSubgroupSize;
11426             out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups;
11427             out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages;
11428             out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize;
11429             out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks;
11430             out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
11431             out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks;
11432             out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
11433             out_ext->maxInlineUniformTotalSize = in_ext->maxInlineUniformTotalSize;
11434             out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated;
11435             out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated;
11436             out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated;
11437             out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated;
11438             out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated;
11439             out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
11440             out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated;
11441             out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated;
11442             out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated;
11443             out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated;
11444             out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated;
11445             out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated;
11446             out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated;
11447             out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated;
11448             out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated;
11449             out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
11450             out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
11451             out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
11452             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
11453             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
11454             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
11455             out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
11456             out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
11457             out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
11458             out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
11459             out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
11460             out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
11461             out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
11462             out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
11463             out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
11464             out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes;
11465             out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment;
11466             out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes;
11467             out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment;
11468             out_ext->maxBufferSize = in_ext->maxBufferSize;
11469             out_header = (void *)out_ext;
11470             break;
11471         }
11472         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
11473         {
11474             VkPhysicalDeviceCustomBorderColorPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT);
11475             const VkPhysicalDeviceCustomBorderColorPropertiesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)in_header;
11476             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
11477             out_ext->maxCustomBorderColorSamplers = in_ext->maxCustomBorderColorSamplers;
11478             out_header = (void *)out_ext;
11479             break;
11480         }
11481         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
11482         {
11483             VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT);
11484             const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)in_header;
11485             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
11486             out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted;
11487             out_header = (void *)out_ext;
11488             break;
11489         }
11490         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
11491         {
11492             VkPhysicalDeviceRobustness2PropertiesEXT32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT);
11493             const VkPhysicalDeviceRobustness2PropertiesEXT *in_ext = (const VkPhysicalDeviceRobustness2PropertiesEXT *)in_header;
11494             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
11495             out_ext->robustStorageBufferAccessSizeAlignment = in_ext->robustStorageBufferAccessSizeAlignment;
11496             out_ext->robustUniformBufferAccessSizeAlignment = in_ext->robustUniformBufferAccessSizeAlignment;
11497             out_header = (void *)out_ext;
11498             break;
11499         }
11500         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
11501         {
11502             VkPhysicalDeviceFragmentShadingRatePropertiesKHR *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR);
11503             const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)in_header;
11504             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
11505             out_ext->minFragmentShadingRateAttachmentTexelSize = in_ext->minFragmentShadingRateAttachmentTexelSize;
11506             out_ext->maxFragmentShadingRateAttachmentTexelSize = in_ext->maxFragmentShadingRateAttachmentTexelSize;
11507             out_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio = in_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
11508             out_ext->primitiveFragmentShadingRateWithMultipleViewports = in_ext->primitiveFragmentShadingRateWithMultipleViewports;
11509             out_ext->layeredShadingRateAttachments = in_ext->layeredShadingRateAttachments;
11510             out_ext->fragmentShadingRateNonTrivialCombinerOps = in_ext->fragmentShadingRateNonTrivialCombinerOps;
11511             out_ext->maxFragmentSize = in_ext->maxFragmentSize;
11512             out_ext->maxFragmentSizeAspectRatio = in_ext->maxFragmentSizeAspectRatio;
11513             out_ext->maxFragmentShadingRateCoverageSamples = in_ext->maxFragmentShadingRateCoverageSamples;
11514             out_ext->maxFragmentShadingRateRasterizationSamples = in_ext->maxFragmentShadingRateRasterizationSamples;
11515             out_ext->fragmentShadingRateWithShaderDepthStencilWrites = in_ext->fragmentShadingRateWithShaderDepthStencilWrites;
11516             out_ext->fragmentShadingRateWithSampleMask = in_ext->fragmentShadingRateWithSampleMask;
11517             out_ext->fragmentShadingRateWithShaderSampleMask = in_ext->fragmentShadingRateWithShaderSampleMask;
11518             out_ext->fragmentShadingRateWithConservativeRasterization = in_ext->fragmentShadingRateWithConservativeRasterization;
11519             out_ext->fragmentShadingRateWithFragmentShaderInterlock = in_ext->fragmentShadingRateWithFragmentShaderInterlock;
11520             out_ext->fragmentShadingRateWithCustomSampleLocations = in_ext->fragmentShadingRateWithCustomSampleLocations;
11521             out_ext->fragmentShadingRateStrictMultiplyCombiner = in_ext->fragmentShadingRateStrictMultiplyCombiner;
11522             out_header = (void *)out_ext;
11523             break;
11524         }
11525         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
11526         {
11527             VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV);
11528             const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *)in_header;
11529             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
11530             out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount;
11531             out_header = (void *)out_ext;
11532             break;
11533         }
11534         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
11535         {
11536             VkPhysicalDeviceProvokingVertexPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT);
11537             const VkPhysicalDeviceProvokingVertexPropertiesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)in_header;
11538             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
11539             out_ext->provokingVertexModePerPipeline = in_ext->provokingVertexModePerPipeline;
11540             out_ext->transformFeedbackPreservesTriangleFanProvokingVertex = in_ext->transformFeedbackPreservesTriangleFanProvokingVertex;
11541             out_header = (void *)out_ext;
11542             break;
11543         }
11544         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
11545         {
11546             VkPhysicalDeviceShaderIntegerDotProductProperties *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES);
11547             const VkPhysicalDeviceShaderIntegerDotProductProperties *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductProperties *)in_header;
11548             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
11549             out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated;
11550             out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated;
11551             out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated;
11552             out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated;
11553             out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated;
11554             out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
11555             out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated;
11556             out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated;
11557             out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated;
11558             out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated;
11559             out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated;
11560             out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated;
11561             out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated;
11562             out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated;
11563             out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated;
11564             out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
11565             out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
11566             out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
11567             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
11568             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
11569             out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
11570             out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
11571             out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
11572             out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
11573             out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
11574             out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
11575             out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
11576             out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
11577             out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
11578             out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
11579             out_header = (void *)out_ext;
11580             break;
11581         }
11582         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
11583         {
11584             VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR);
11585             const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *)in_header;
11586             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
11587             out_ext->triStripVertexOrderIndependentOfProvokingVertex = in_ext->triStripVertexOrderIndependentOfProvokingVertex;
11588             out_header = (void *)out_ext;
11589             break;
11590         }
11591         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
11592         {
11593             VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT);
11594             const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)in_header;
11595             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
11596             out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking;
11597             out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration;
11598             out_header = (void *)out_ext;
11599             break;
11600         }
11601         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
11602         {
11603             VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT);
11604             const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *)in_header;
11605             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
11606             memcpy(out_ext->shaderModuleIdentifierAlgorithmUUID, in_ext->shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE * sizeof(uint8_t));
11607             out_header = (void *)out_ext;
11608             break;
11609         }
11610         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
11611         {
11612             VkPhysicalDeviceOpacityMicromapPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT);
11613             const VkPhysicalDeviceOpacityMicromapPropertiesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapPropertiesEXT *)in_header;
11614             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
11615             out_ext->maxOpacity2StateSubdivisionLevel = in_ext->maxOpacity2StateSubdivisionLevel;
11616             out_ext->maxOpacity4StateSubdivisionLevel = in_ext->maxOpacity4StateSubdivisionLevel;
11617             out_header = (void *)out_ext;
11618             break;
11619         }
11620         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
11621         {
11622             VkPhysicalDevicePipelineRobustnessPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT);
11623             const VkPhysicalDevicePipelineRobustnessPropertiesEXT *in_ext = (const VkPhysicalDevicePipelineRobustnessPropertiesEXT *)in_header;
11624             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT;
11625             out_ext->defaultRobustnessStorageBuffers = in_ext->defaultRobustnessStorageBuffers;
11626             out_ext->defaultRobustnessUniformBuffers = in_ext->defaultRobustnessUniformBuffers;
11627             out_ext->defaultRobustnessVertexInputs = in_ext->defaultRobustnessVertexInputs;
11628             out_ext->defaultRobustnessImages = in_ext->defaultRobustnessImages;
11629             out_header = (void *)out_ext;
11630             break;
11631         }
11632         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
11633         {
11634             VkPhysicalDeviceImageProcessingPropertiesQCOM *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM);
11635             const VkPhysicalDeviceImageProcessingPropertiesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingPropertiesQCOM *)in_header;
11636             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
11637             out_ext->maxWeightFilterPhases = in_ext->maxWeightFilterPhases;
11638             out_ext->maxWeightFilterDimension = in_ext->maxWeightFilterDimension;
11639             out_ext->maxBlockMatchRegion = in_ext->maxBlockMatchRegion;
11640             out_ext->maxBoxFilterBlockSize = in_ext->maxBoxFilterBlockSize;
11641             out_header = (void *)out_ext;
11642             break;
11643         }
11644         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
11645         {
11646             VkPhysicalDeviceOpticalFlowPropertiesNV *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV);
11647             const VkPhysicalDeviceOpticalFlowPropertiesNV *in_ext = (const VkPhysicalDeviceOpticalFlowPropertiesNV *)in_header;
11648             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
11649             out_ext->supportedOutputGridSizes = in_ext->supportedOutputGridSizes;
11650             out_ext->supportedHintGridSizes = in_ext->supportedHintGridSizes;
11651             out_ext->hintSupported = in_ext->hintSupported;
11652             out_ext->costSupported = in_ext->costSupported;
11653             out_ext->bidirectionalFlowSupported = in_ext->bidirectionalFlowSupported;
11654             out_ext->globalFlowSupported = in_ext->globalFlowSupported;
11655             out_ext->minWidth = in_ext->minWidth;
11656             out_ext->minHeight = in_ext->minHeight;
11657             out_ext->maxWidth = in_ext->maxWidth;
11658             out_ext->maxHeight = in_ext->maxHeight;
11659             out_ext->maxNumRegionsOfInterest = in_ext->maxNumRegionsOfInterest;
11660             out_header = (void *)out_ext;
11661             break;
11662         }
11663         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
11664         {
11665             VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32 *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM);
11666             const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *)in_header;
11667             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
11668             out_ext->shaderCoreMask = in_ext->shaderCoreMask;
11669             out_ext->shaderCoreCount = in_ext->shaderCoreCount;
11670             out_ext->shaderWarpsPerCore = in_ext->shaderWarpsPerCore;
11671             out_header = (void *)out_ext;
11672             break;
11673         }
11674         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
11675         {
11676             VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV);
11677             const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *)in_header;
11678             out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
11679             out_ext->rayTracingInvocationReorderReorderingHint = in_ext->rayTracingInvocationReorderReorderingHint;
11680             out_header = (void *)out_ext;
11681             break;
11682         }
11683         default:
11684             break;
11685         }
11686     }
11687 }
11688 #endif /* USE_STRUCT_CONVERSION */
11689
11690 #if defined(USE_STRUCT_CONVERSION)
11691 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
11692 {
11693     if (!in) return;
11694
11695     out->sType = in->sType;
11696     out->pNext = in->pNext;
11697     out->surface = in->surface;
11698 }
11699 #endif /* USE_STRUCT_CONVERSION */
11700
11701 #if !defined(USE_STRUCT_CONVERSION)
11702 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win64_to_host(const VkPhysicalDeviceSurfaceInfo2KHR *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
11703 {
11704     if (!in) return;
11705
11706     out->sType = in->sType;
11707     out->pNext = in->pNext;
11708     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
11709 }
11710 #endif /* USE_STRUCT_CONVERSION */
11711
11712 #if defined(USE_STRUCT_CONVERSION)
11713 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host(const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out)
11714 {
11715     if (!in) return;
11716
11717     out->sType = in->sType;
11718     out->pNext = in->pNext;
11719     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
11720 }
11721 #endif /* USE_STRUCT_CONVERSION */
11722
11723 #if defined(USE_STRUCT_CONVERSION)
11724 static inline void convert_VkPipelineExecutableInfoKHR_win32_to_host(const VkPipelineExecutableInfoKHR32 *in, VkPipelineExecutableInfoKHR *out)
11725 {
11726     if (!in) return;
11727
11728     out->sType = in->sType;
11729     out->pNext = in->pNext;
11730     out->pipeline = in->pipeline;
11731     out->executableIndex = in->executableIndex;
11732 }
11733 #endif /* USE_STRUCT_CONVERSION */
11734
11735 #if defined(USE_STRUCT_CONVERSION)
11736 static inline void convert_VkPipelineInfoKHR_win32_to_host(const VkPipelineInfoKHR32 *in, VkPipelineInfoKHR *out)
11737 {
11738     if (!in) return;
11739
11740     out->sType = in->sType;
11741     out->pNext = in->pNext;
11742     out->pipeline = in->pipeline;
11743 }
11744 #endif /* USE_STRUCT_CONVERSION */
11745
11746 #if defined(USE_STRUCT_CONVERSION)
11747 static inline void convert_VkPipelineExecutableStatisticKHR_win32_to_host(const VkPipelineExecutableStatisticKHR32 *in, VkPipelineExecutableStatisticKHR *out)
11748 {
11749     if (!in) return;
11750
11751     out->sType = in->sType;
11752     out->pNext = in->pNext;
11753 }
11754 #endif /* USE_STRUCT_CONVERSION */
11755
11756 #if defined(USE_STRUCT_CONVERSION)
11757 static inline void convert_VkPipelineExecutableStatisticKHR_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out)
11758 {
11759     if (!in) return;
11760
11761     memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
11762     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
11763     out->format = in->format;
11764     out->value = in->value;
11765 }
11766 #endif /* USE_STRUCT_CONVERSION */
11767
11768 #if defined(USE_STRUCT_CONVERSION)
11769 static inline VkPipelineExecutableStatisticKHR *convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableStatisticKHR32 *in, uint32_t count)
11770 {
11771     VkPipelineExecutableStatisticKHR *out;
11772     unsigned int i;
11773
11774     if (!in || !count) return NULL;
11775
11776     out = conversion_context_alloc(ctx, count * sizeof(*out));
11777     for (i = 0; i < count; i++)
11778     {
11779         convert_VkPipelineExecutableStatisticKHR_win32_to_host(&in[i], &out[i]);
11780     }
11781
11782     return out;
11783 }
11784 #endif /* USE_STRUCT_CONVERSION */
11785
11786 #if defined(USE_STRUCT_CONVERSION)
11787 static inline void convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out, uint32_t count)
11788 {
11789     unsigned int i;
11790
11791     if (!in) return;
11792
11793     for (i = 0; i < count; i++)
11794     {
11795         convert_VkPipelineExecutableStatisticKHR_host_to_win32(&in[i], &out[i]);
11796     }
11797 }
11798 #endif /* USE_STRUCT_CONVERSION */
11799
11800 #if defined(USE_STRUCT_CONVERSION)
11801 static inline void convert_VkPipelineInfoEXT_win32_to_host(const VkPipelineInfoEXT32 *in, VkPipelineInfoEXT *out)
11802 {
11803     if (!in) return;
11804
11805     out->sType = in->sType;
11806     out->pNext = in->pNext;
11807     out->pipeline = in->pipeline;
11808 }
11809 #endif /* USE_STRUCT_CONVERSION */
11810
11811 #if defined(USE_STRUCT_CONVERSION)
11812 static inline void convert_VkSparseMemoryBind_win32_to_host(const VkSparseMemoryBind32 *in, VkSparseMemoryBind *out)
11813 {
11814     if (!in) return;
11815
11816     out->resourceOffset = in->resourceOffset;
11817     out->size = in->size;
11818     out->memory = in->memory;
11819     out->memoryOffset = in->memoryOffset;
11820     out->flags = in->flags;
11821 }
11822 #endif /* USE_STRUCT_CONVERSION */
11823
11824 #if defined(USE_STRUCT_CONVERSION)
11825 static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseMemoryBind32 *in, uint32_t count)
11826 {
11827     VkSparseMemoryBind *out;
11828     unsigned int i;
11829
11830     if (!in || !count) return NULL;
11831
11832     out = conversion_context_alloc(ctx, count * sizeof(*out));
11833     for (i = 0; i < count; i++)
11834     {
11835         convert_VkSparseMemoryBind_win32_to_host(&in[i], &out[i]);
11836     }
11837
11838     return out;
11839 }
11840 #endif /* USE_STRUCT_CONVERSION */
11841
11842 #if defined(USE_STRUCT_CONVERSION)
11843 static inline void convert_VkSparseBufferMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, VkSparseBufferMemoryBindInfo *out)
11844 {
11845     if (!in) return;
11846
11847     out->buffer = in->buffer;
11848     out->bindCount = in->bindCount;
11849     out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, in->pBinds, in->bindCount);
11850 }
11851 #endif /* USE_STRUCT_CONVERSION */
11852
11853 #if defined(USE_STRUCT_CONVERSION)
11854 static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, uint32_t count)
11855 {
11856     VkSparseBufferMemoryBindInfo *out;
11857     unsigned int i;
11858
11859     if (!in || !count) return NULL;
11860
11861     out = conversion_context_alloc(ctx, count * sizeof(*out));
11862     for (i = 0; i < count; i++)
11863     {
11864         convert_VkSparseBufferMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
11865     }
11866
11867     return out;
11868 }
11869 #endif /* USE_STRUCT_CONVERSION */
11870
11871 #if defined(USE_STRUCT_CONVERSION)
11872 static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, VkSparseImageOpaqueMemoryBindInfo *out)
11873 {
11874     if (!in) return;
11875
11876     out->image = in->image;
11877     out->bindCount = in->bindCount;
11878     out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, in->pBinds, in->bindCount);
11879 }
11880 #endif /* USE_STRUCT_CONVERSION */
11881
11882 #if defined(USE_STRUCT_CONVERSION)
11883 static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, uint32_t count)
11884 {
11885     VkSparseImageOpaqueMemoryBindInfo *out;
11886     unsigned int i;
11887
11888     if (!in || !count) return NULL;
11889
11890     out = conversion_context_alloc(ctx, count * sizeof(*out));
11891     for (i = 0; i < count; i++)
11892     {
11893         convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
11894     }
11895
11896     return out;
11897 }
11898 #endif /* USE_STRUCT_CONVERSION */
11899
11900 #if defined(USE_STRUCT_CONVERSION)
11901 static inline void convert_VkSparseImageMemoryBind_win32_to_host(const VkSparseImageMemoryBind32 *in, VkSparseImageMemoryBind *out)
11902 {
11903     if (!in) return;
11904
11905     out->subresource = in->subresource;
11906     out->offset = in->offset;
11907     out->extent = in->extent;
11908     out->memory = in->memory;
11909     out->memoryOffset = in->memoryOffset;
11910     out->flags = in->flags;
11911 }
11912 #endif /* USE_STRUCT_CONVERSION */
11913
11914 #if defined(USE_STRUCT_CONVERSION)
11915 static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind32 *in, uint32_t count)
11916 {
11917     VkSparseImageMemoryBind *out;
11918     unsigned int i;
11919
11920     if (!in || !count) return NULL;
11921
11922     out = conversion_context_alloc(ctx, count * sizeof(*out));
11923     for (i = 0; i < count; i++)
11924     {
11925         convert_VkSparseImageMemoryBind_win32_to_host(&in[i], &out[i]);
11926     }
11927
11928     return out;
11929 }
11930 #endif /* USE_STRUCT_CONVERSION */
11931
11932 #if defined(USE_STRUCT_CONVERSION)
11933 static inline void convert_VkSparseImageMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, VkSparseImageMemoryBindInfo *out)
11934 {
11935     if (!in) return;
11936
11937     out->image = in->image;
11938     out->bindCount = in->bindCount;
11939     out->pBinds = convert_VkSparseImageMemoryBind_array_win32_to_host(ctx, in->pBinds, in->bindCount);
11940 }
11941 #endif /* USE_STRUCT_CONVERSION */
11942
11943 #if defined(USE_STRUCT_CONVERSION)
11944 static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, uint32_t count)
11945 {
11946     VkSparseImageMemoryBindInfo *out;
11947     unsigned int i;
11948
11949     if (!in || !count) return NULL;
11950
11951     out = conversion_context_alloc(ctx, count * sizeof(*out));
11952     for (i = 0; i < count; i++)
11953     {
11954         convert_VkSparseImageMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]);
11955     }
11956
11957     return out;
11958 }
11959 #endif /* USE_STRUCT_CONVERSION */
11960
11961 #if defined(USE_STRUCT_CONVERSION)
11962 static inline void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, VkBindSparseInfo *out)
11963 {
11964     if (!in) return;
11965
11966     out->sType = in->sType;
11967     out->pNext = in->pNext;
11968     out->waitSemaphoreCount = in->waitSemaphoreCount;
11969     out->pWaitSemaphores = in->pWaitSemaphores;
11970     out->bufferBindCount = in->bufferBindCount;
11971     out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(ctx, in->pBufferBinds, in->bufferBindCount);
11972     out->imageOpaqueBindCount = in->imageOpaqueBindCount;
11973     out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(ctx, in->pImageOpaqueBinds, in->imageOpaqueBindCount);
11974     out->imageBindCount = in->imageBindCount;
11975     out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win32_to_host(ctx, in->pImageBinds, in->imageBindCount);
11976     out->signalSemaphoreCount = in->signalSemaphoreCount;
11977     out->pSignalSemaphores = in->pSignalSemaphores;
11978 }
11979 #endif /* USE_STRUCT_CONVERSION */
11980
11981 #if defined(USE_STRUCT_CONVERSION)
11982 static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, uint32_t count)
11983 {
11984     VkBindSparseInfo *out;
11985     unsigned int i;
11986
11987     if (!in || !count) return NULL;
11988
11989     out = conversion_context_alloc(ctx, count * sizeof(*out));
11990     for (i = 0; i < count; i++)
11991     {
11992         convert_VkBindSparseInfo_win32_to_host(ctx, &in[i], &out[i]);
11993     }
11994
11995     return out;
11996 }
11997 #endif /* USE_STRUCT_CONVERSION */
11998
11999 #if !defined(USE_STRUCT_CONVERSION)
12000 static inline void convert_VkSubmitInfo_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, VkSubmitInfo *out)
12001 {
12002     if (!in) return;
12003
12004     out->sType = in->sType;
12005     out->pNext = in->pNext;
12006     out->waitSemaphoreCount = in->waitSemaphoreCount;
12007     out->pWaitSemaphores = in->pWaitSemaphores;
12008     out->pWaitDstStageMask = in->pWaitDstStageMask;
12009     out->commandBufferCount = in->commandBufferCount;
12010     out->pCommandBuffers = convert_VkCommandBuffer_array_win64_to_host(ctx, in->pCommandBuffers, in->commandBufferCount);
12011     out->signalSemaphoreCount = in->signalSemaphoreCount;
12012     out->pSignalSemaphores = in->pSignalSemaphores;
12013 }
12014 #endif /* USE_STRUCT_CONVERSION */
12015
12016 #if defined(USE_STRUCT_CONVERSION)
12017 static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, VkSubmitInfo *out)
12018 {
12019     if (!in) return;
12020
12021     out->sType = in->sType;
12022     out->pNext = in->pNext;
12023     out->waitSemaphoreCount = in->waitSemaphoreCount;
12024     out->pWaitSemaphores = in->pWaitSemaphores;
12025     out->pWaitDstStageMask = in->pWaitDstStageMask;
12026     out->commandBufferCount = in->commandBufferCount;
12027     out->pCommandBuffers = convert_VkCommandBuffer_array_win32_to_host(ctx, in->pCommandBuffers, in->commandBufferCount);
12028     out->signalSemaphoreCount = in->signalSemaphoreCount;
12029     out->pSignalSemaphores = in->pSignalSemaphores;
12030 }
12031 #endif /* USE_STRUCT_CONVERSION */
12032
12033 #if !defined(USE_STRUCT_CONVERSION)
12034 static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, uint32_t count)
12035 {
12036     VkSubmitInfo *out;
12037     unsigned int i;
12038
12039     if (!in || !count) return NULL;
12040
12041     out = conversion_context_alloc(ctx, count * sizeof(*out));
12042     for (i = 0; i < count; i++)
12043     {
12044         convert_VkSubmitInfo_win64_to_host(ctx, &in[i], &out[i]);
12045     }
12046
12047     return out;
12048 }
12049 #endif /* USE_STRUCT_CONVERSION */
12050
12051 #if defined(USE_STRUCT_CONVERSION)
12052 static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, uint32_t count)
12053 {
12054     VkSubmitInfo *out;
12055     unsigned int i;
12056
12057     if (!in || !count) return NULL;
12058
12059     out = conversion_context_alloc(ctx, count * sizeof(*out));
12060     for (i = 0; i < count; i++)
12061     {
12062         convert_VkSubmitInfo_win32_to_host(ctx, &in[i], &out[i]);
12063     }
12064
12065     return out;
12066 }
12067 #endif /* USE_STRUCT_CONVERSION */
12068
12069 #if defined(USE_STRUCT_CONVERSION)
12070 static inline void convert_VkSemaphoreSubmitInfo_win32_to_host(const VkSemaphoreSubmitInfo32 *in, VkSemaphoreSubmitInfo *out)
12071 {
12072     if (!in) return;
12073
12074     out->sType = in->sType;
12075     out->pNext = in->pNext;
12076     out->semaphore = in->semaphore;
12077     out->value = in->value;
12078     out->stageMask = in->stageMask;
12079     out->deviceIndex = in->deviceIndex;
12080 }
12081 #endif /* USE_STRUCT_CONVERSION */
12082
12083 #if defined(USE_STRUCT_CONVERSION)
12084 static inline const VkSemaphoreSubmitInfo *convert_VkSemaphoreSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSemaphoreSubmitInfo32 *in, uint32_t count)
12085 {
12086     VkSemaphoreSubmitInfo *out;
12087     unsigned int i;
12088
12089     if (!in || !count) return NULL;
12090
12091     out = conversion_context_alloc(ctx, count * sizeof(*out));
12092     for (i = 0; i < count; i++)
12093     {
12094         convert_VkSemaphoreSubmitInfo_win32_to_host(&in[i], &out[i]);
12095     }
12096
12097     return out;
12098 }
12099 #endif /* USE_STRUCT_CONVERSION */
12100
12101 #if !defined(USE_STRUCT_CONVERSION)
12102 static inline void convert_VkCommandBufferSubmitInfo_win64_to_host(const VkCommandBufferSubmitInfo *in, VkCommandBufferSubmitInfo *out)
12103 {
12104     if (!in) return;
12105
12106     out->sType = in->sType;
12107     out->pNext = in->pNext;
12108     out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->command_buffer;
12109     out->deviceMask = in->deviceMask;
12110 }
12111 #endif /* USE_STRUCT_CONVERSION */
12112
12113 #if defined(USE_STRUCT_CONVERSION)
12114 static inline void convert_VkCommandBufferSubmitInfo_win32_to_host(const VkCommandBufferSubmitInfo *in, VkCommandBufferSubmitInfo *out)
12115 {
12116     if (!in) return;
12117
12118     out->sType = in->sType;
12119     out->pNext = in->pNext;
12120     out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->command_buffer;
12121     out->deviceMask = in->deviceMask;
12122 }
12123 #endif /* USE_STRUCT_CONVERSION */
12124
12125 #if !defined(USE_STRUCT_CONVERSION)
12126 static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo *in, uint32_t count)
12127 {
12128     VkCommandBufferSubmitInfo *out;
12129     unsigned int i;
12130
12131     if (!in || !count) return NULL;
12132
12133     out = conversion_context_alloc(ctx, count * sizeof(*out));
12134     for (i = 0; i < count; i++)
12135     {
12136         convert_VkCommandBufferSubmitInfo_win64_to_host(&in[i], &out[i]);
12137     }
12138
12139     return out;
12140 }
12141 #endif /* USE_STRUCT_CONVERSION */
12142
12143 #if defined(USE_STRUCT_CONVERSION)
12144 static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo *in, uint32_t count)
12145 {
12146     VkCommandBufferSubmitInfo *out;
12147     unsigned int i;
12148
12149     if (!in || !count) return NULL;
12150
12151     out = conversion_context_alloc(ctx, count * sizeof(*out));
12152     for (i = 0; i < count; i++)
12153     {
12154         convert_VkCommandBufferSubmitInfo_win32_to_host(&in[i], &out[i]);
12155     }
12156
12157     return out;
12158 }
12159 #endif /* USE_STRUCT_CONVERSION */
12160
12161 #if !defined(USE_STRUCT_CONVERSION)
12162 static inline void convert_VkSubmitInfo2_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, VkSubmitInfo2 *out)
12163 {
12164     if (!in) return;
12165
12166     out->sType = in->sType;
12167     out->pNext = in->pNext;
12168     out->flags = in->flags;
12169     out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
12170     out->pWaitSemaphoreInfos = in->pWaitSemaphoreInfos;
12171     out->commandBufferInfoCount = in->commandBufferInfoCount;
12172     out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win64_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount);
12173     out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
12174     out->pSignalSemaphoreInfos = in->pSignalSemaphoreInfos;
12175 }
12176 #endif /* USE_STRUCT_CONVERSION */
12177
12178 #if defined(USE_STRUCT_CONVERSION)
12179 static inline void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, VkSubmitInfo2 *out)
12180 {
12181     if (!in) return;
12182
12183     out->sType = in->sType;
12184     out->pNext = in->pNext;
12185     out->flags = in->flags;
12186     out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
12187     out->pWaitSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, in->pWaitSemaphoreInfos, in->waitSemaphoreInfoCount);
12188     out->commandBufferInfoCount = in->commandBufferInfoCount;
12189     out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win32_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount);
12190     out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
12191     out->pSignalSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, in->pSignalSemaphoreInfos, in->signalSemaphoreInfoCount);
12192 }
12193 #endif /* USE_STRUCT_CONVERSION */
12194
12195 #if !defined(USE_STRUCT_CONVERSION)
12196 static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, uint32_t count)
12197 {
12198     VkSubmitInfo2 *out;
12199     unsigned int i;
12200
12201     if (!in || !count) return NULL;
12202
12203     out = conversion_context_alloc(ctx, count * sizeof(*out));
12204     for (i = 0; i < count; i++)
12205     {
12206         convert_VkSubmitInfo2_win64_to_host(ctx, &in[i], &out[i]);
12207     }
12208
12209     return out;
12210 }
12211 #endif /* USE_STRUCT_CONVERSION */
12212
12213 #if defined(USE_STRUCT_CONVERSION)
12214 static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, uint32_t count)
12215 {
12216     VkSubmitInfo2 *out;
12217     unsigned int i;
12218
12219     if (!in || !count) return NULL;
12220
12221     out = conversion_context_alloc(ctx, count * sizeof(*out));
12222     for (i = 0; i < count; i++)
12223     {
12224         convert_VkSubmitInfo2_win32_to_host(ctx, &in[i], &out[i]);
12225     }
12226
12227     return out;
12228 }
12229 #endif /* USE_STRUCT_CONVERSION */
12230
12231 #if !defined(USE_STRUCT_CONVERSION)
12232 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(const VkDebugUtilsObjectNameInfoEXT *in, VkDebugUtilsObjectNameInfoEXT *out)
12233 {
12234     if (!in) return;
12235
12236     out->sType = in->sType;
12237     out->pNext = in->pNext;
12238     out->objectType = in->objectType;
12239     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
12240     out->pObjectName = in->pObjectName;
12241 }
12242 #endif /* USE_STRUCT_CONVERSION */
12243
12244 #if defined(USE_STRUCT_CONVERSION)
12245 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(const VkDebugUtilsObjectNameInfoEXT32 *in, VkDebugUtilsObjectNameInfoEXT *out)
12246 {
12247     if (!in) return;
12248
12249     out->sType = in->sType;
12250     out->pNext = in->pNext;
12251     out->objectType = in->objectType;
12252     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
12253     out->pObjectName = in->pObjectName;
12254 }
12255 #endif /* USE_STRUCT_CONVERSION */
12256
12257 #if !defined(USE_STRUCT_CONVERSION)
12258 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(const VkDebugUtilsObjectTagInfoEXT *in, VkDebugUtilsObjectTagInfoEXT *out)
12259 {
12260     if (!in) return;
12261
12262     out->sType = in->sType;
12263     out->pNext = in->pNext;
12264     out->objectType = in->objectType;
12265     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
12266     out->tagName = in->tagName;
12267     out->tagSize = in->tagSize;
12268     out->pTag = in->pTag;
12269 }
12270 #endif /* USE_STRUCT_CONVERSION */
12271
12272 #if defined(USE_STRUCT_CONVERSION)
12273 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(const VkDebugUtilsObjectTagInfoEXT32 *in, VkDebugUtilsObjectTagInfoEXT *out)
12274 {
12275     if (!in) return;
12276
12277     out->sType = in->sType;
12278     out->pNext = in->pNext;
12279     out->objectType = in->objectType;
12280     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
12281     out->tagName = in->tagName;
12282     out->tagSize = in->tagSize;
12283     out->pTag = in->pTag;
12284 }
12285 #endif /* USE_STRUCT_CONVERSION */
12286
12287 #if defined(USE_STRUCT_CONVERSION)
12288 static inline void convert_VkSemaphoreSignalInfo_win32_to_host(const VkSemaphoreSignalInfo32 *in, VkSemaphoreSignalInfo *out)
12289 {
12290     if (!in) return;
12291
12292     out->sType = in->sType;
12293     out->pNext = in->pNext;
12294     out->semaphore = in->semaphore;
12295     out->value = in->value;
12296 }
12297 #endif /* USE_STRUCT_CONVERSION */
12298
12299 #if !defined(USE_STRUCT_CONVERSION)
12300 static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT *in, uint32_t count)
12301 {
12302     VkDebugUtilsObjectNameInfoEXT *out;
12303     unsigned int i;
12304
12305     if (!in || !count) return NULL;
12306
12307     out = conversion_context_alloc(ctx, count * sizeof(*out));
12308     for (i = 0; i < count; i++)
12309     {
12310         convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(&in[i], &out[i]);
12311     }
12312
12313     return out;
12314 }
12315 #endif /* USE_STRUCT_CONVERSION */
12316
12317 #if defined(USE_STRUCT_CONVERSION)
12318 static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT32 *in, uint32_t count)
12319 {
12320     VkDebugUtilsObjectNameInfoEXT *out;
12321     unsigned int i;
12322
12323     if (!in || !count) return NULL;
12324
12325     out = conversion_context_alloc(ctx, count * sizeof(*out));
12326     for (i = 0; i < count; i++)
12327     {
12328         convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(&in[i], &out[i]);
12329     }
12330
12331     return out;
12332 }
12333 #endif /* USE_STRUCT_CONVERSION */
12334
12335 #if !defined(USE_STRUCT_CONVERSION)
12336 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT *in, VkDebugUtilsMessengerCallbackDataEXT *out)
12337 {
12338     if (!in) return;
12339
12340     out->sType = in->sType;
12341     out->pNext = in->pNext;
12342     out->flags = in->flags;
12343     out->pMessageIdName = in->pMessageIdName;
12344     out->messageIdNumber = in->messageIdNumber;
12345     out->pMessage = in->pMessage;
12346     out->queueLabelCount = in->queueLabelCount;
12347     out->pQueueLabels = in->pQueueLabels;
12348     out->cmdBufLabelCount = in->cmdBufLabelCount;
12349     out->pCmdBufLabels = in->pCmdBufLabels;
12350     out->objectCount = in->objectCount;
12351     out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(ctx, in->pObjects, in->objectCount);
12352 }
12353 #endif /* USE_STRUCT_CONVERSION */
12354
12355 #if defined(USE_STRUCT_CONVERSION)
12356 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT32 *in, VkDebugUtilsMessengerCallbackDataEXT *out)
12357 {
12358     const VkBaseInStructure *in_header;
12359     VkBaseOutStructure *out_header = (void *)out;
12360
12361     if (!in) return;
12362
12363     out->sType = in->sType;
12364     out->pNext = NULL;
12365     out->flags = in->flags;
12366     out->pMessageIdName = in->pMessageIdName;
12367     out->messageIdNumber = in->messageIdNumber;
12368     out->pMessage = in->pMessage;
12369     out->queueLabelCount = in->queueLabelCount;
12370     out->pQueueLabels = in->pQueueLabels;
12371     out->cmdBufLabelCount = in->cmdBufLabelCount;
12372     out->pCmdBufLabels = in->pCmdBufLabels;
12373     out->objectCount = in->objectCount;
12374     out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(ctx, in->pObjects, in->objectCount);
12375
12376     for (in_header = in->pNext; in_header; in_header = in_header->pNext)
12377     {
12378         switch (in_header->sType)
12379         {
12380         case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
12381         {
12382             VkDeviceAddressBindingCallbackDataEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
12383             const VkDeviceAddressBindingCallbackDataEXT32 *in_ext = (const VkDeviceAddressBindingCallbackDataEXT32 *)in_header;
12384             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT;
12385             out_ext->pNext = NULL;
12386             out_ext->flags = in_ext->flags;
12387             out_ext->baseAddress = in_ext->baseAddress;
12388             out_ext->size = in_ext->size;
12389             out_ext->bindingType = in_ext->bindingType;
12390             out_header->pNext = (void *)out_ext;
12391             out_header = (void *)out_ext;
12392             break;
12393         }
12394         default:
12395             FIXME("Unhandled sType %u.", in_header->sType);
12396             break;
12397         }
12398     }
12399 }
12400 #endif /* USE_STRUCT_CONVERSION */
12401
12402 #if defined(USE_STRUCT_CONVERSION)
12403 static inline void convert_VkCopyDescriptorSet_win32_to_host(const VkCopyDescriptorSet32 *in, VkCopyDescriptorSet *out)
12404 {
12405     if (!in) return;
12406
12407     out->sType = in->sType;
12408     out->pNext = in->pNext;
12409     out->srcSet = in->srcSet;
12410     out->srcBinding = in->srcBinding;
12411     out->srcArrayElement = in->srcArrayElement;
12412     out->dstSet = in->dstSet;
12413     out->dstBinding = in->dstBinding;
12414     out->dstArrayElement = in->dstArrayElement;
12415     out->descriptorCount = in->descriptorCount;
12416 }
12417 #endif /* USE_STRUCT_CONVERSION */
12418
12419 #if defined(USE_STRUCT_CONVERSION)
12420 static inline const VkCopyDescriptorSet *convert_VkCopyDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkCopyDescriptorSet32 *in, uint32_t count)
12421 {
12422     VkCopyDescriptorSet *out;
12423     unsigned int i;
12424
12425     if (!in || !count) return NULL;
12426
12427     out = conversion_context_alloc(ctx, count * sizeof(*out));
12428     for (i = 0; i < count; i++)
12429     {
12430         convert_VkCopyDescriptorSet_win32_to_host(&in[i], &out[i]);
12431     }
12432
12433     return out;
12434 }
12435 #endif /* USE_STRUCT_CONVERSION */
12436
12437 #if !defined(USE_STRUCT_CONVERSION)
12438
12439 static NTSTATUS thunk64_vkAcquireNextImage2KHR(void *args)
12440 {
12441     struct vkAcquireNextImage2KHR_params *params = args;
12442
12443     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pImageIndex);
12444
12445     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pImageIndex);
12446     return STATUS_SUCCESS;
12447 }
12448
12449 #else /* USE_STRUCT_CONVERSION */
12450
12451 static NTSTATUS thunk32_vkAcquireNextImage2KHR(void *args)
12452 {
12453     struct
12454     {
12455         VkDevice device;
12456         const VkAcquireNextImageInfoKHR32 *pAcquireInfo;
12457         uint32_t *pImageIndex;
12458         VkResult result;
12459     } *params = args;
12460     VkAcquireNextImageInfoKHR pAcquireInfo_host;
12461
12462     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pImageIndex);
12463
12464     convert_VkAcquireNextImageInfoKHR_win32_to_host(params->pAcquireInfo, &pAcquireInfo_host);
12465     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle(params->device)->device, &pAcquireInfo_host, params->pImageIndex);
12466     return STATUS_SUCCESS;
12467 }
12468
12469 #endif /* USE_STRUCT_CONVERSION */
12470
12471 #if !defined(USE_STRUCT_CONVERSION)
12472
12473 static NTSTATUS thunk64_vkAcquireNextImageKHR(void *args)
12474 {
12475     struct vkAcquireNextImageKHR_params *params = args;
12476
12477     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);
12478
12479     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);
12480     return STATUS_SUCCESS;
12481 }
12482
12483 #else /* USE_STRUCT_CONVERSION */
12484
12485 static NTSTATUS thunk32_vkAcquireNextImageKHR(void *args)
12486 {
12487     struct
12488     {
12489         VkDevice device;
12490         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
12491         uint64_t DECLSPEC_ALIGN(8) timeout;
12492         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
12493         VkFence DECLSPEC_ALIGN(8) fence;
12494         uint32_t *pImageIndex;
12495         VkResult result;
12496     } *params = args;
12497
12498     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);
12499
12500     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);
12501     return STATUS_SUCCESS;
12502 }
12503
12504 #endif /* USE_STRUCT_CONVERSION */
12505
12506 #if !defined(USE_STRUCT_CONVERSION)
12507
12508 static NTSTATUS thunk64_vkAcquirePerformanceConfigurationINTEL(void *args)
12509 {
12510     struct vkAcquirePerformanceConfigurationINTEL_params *params = args;
12511
12512     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pConfiguration);
12513
12514     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pConfiguration);
12515     return STATUS_SUCCESS;
12516 }
12517
12518 #else /* USE_STRUCT_CONVERSION */
12519
12520 static NTSTATUS thunk32_vkAcquirePerformanceConfigurationINTEL(void *args)
12521 {
12522     struct
12523     {
12524         VkDevice device;
12525         const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo;
12526         VkPerformanceConfigurationINTEL *pConfiguration;
12527         VkResult result;
12528     } *params = args;
12529
12530     TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pConfiguration);
12531
12532     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->pAcquireInfo, params->pConfiguration);
12533     return STATUS_SUCCESS;
12534 }
12535
12536 #endif /* USE_STRUCT_CONVERSION */
12537
12538 #if !defined(USE_STRUCT_CONVERSION)
12539
12540 static NTSTATUS thunk64_vkAcquireProfilingLockKHR(void *args)
12541 {
12542     struct vkAcquireProfilingLockKHR_params *params = args;
12543
12544     TRACE("%p, %p\n", params->device, params->pInfo);
12545
12546     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle(params->device)->device, params->pInfo);
12547     return STATUS_SUCCESS;
12548 }
12549
12550 #else /* USE_STRUCT_CONVERSION */
12551
12552 static NTSTATUS thunk32_vkAcquireProfilingLockKHR(void *args)
12553 {
12554     struct
12555     {
12556         VkDevice device;
12557         const VkAcquireProfilingLockInfoKHR32 *pInfo;
12558         VkResult result;
12559     } *params = args;
12560     VkAcquireProfilingLockInfoKHR pInfo_host;
12561
12562     TRACE("%p, %p\n", params->device, params->pInfo);
12563
12564     convert_VkAcquireProfilingLockInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
12565     params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
12566     return STATUS_SUCCESS;
12567 }
12568
12569 #endif /* USE_STRUCT_CONVERSION */
12570
12571 #if !defined(USE_STRUCT_CONVERSION)
12572
12573 static NTSTATUS thunk64_vkAllocateCommandBuffers(void *args)
12574 {
12575     struct vkAllocateCommandBuffers_params *params = args;
12576
12577     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pCommandBuffers);
12578
12579     params->result = wine_vkAllocateCommandBuffers(params->device, params->pAllocateInfo, params->pCommandBuffers);
12580     return STATUS_SUCCESS;
12581 }
12582
12583 #else /* USE_STRUCT_CONVERSION */
12584
12585 static NTSTATUS thunk32_vkAllocateCommandBuffers(void *args)
12586 {
12587     struct
12588     {
12589         VkDevice device;
12590         const VkCommandBufferAllocateInfo32 *pAllocateInfo;
12591         VkCommandBuffer *pCommandBuffers;
12592         VkResult result;
12593     } *params = args;
12594     VkCommandBufferAllocateInfo pAllocateInfo_host;
12595
12596     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pCommandBuffers);
12597
12598     convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(params->pAllocateInfo, &pAllocateInfo_host);
12599     params->result = wine_vkAllocateCommandBuffers(params->device, &pAllocateInfo_host, params->pCommandBuffers);
12600     return STATUS_SUCCESS;
12601 }
12602
12603 #endif /* USE_STRUCT_CONVERSION */
12604
12605 #if !defined(USE_STRUCT_CONVERSION)
12606
12607 static NTSTATUS thunk64_vkAllocateDescriptorSets(void *args)
12608 {
12609     struct vkAllocateDescriptorSets_params *params = args;
12610
12611     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pDescriptorSets);
12612
12613     params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle(params->device)->device, params->pAllocateInfo, params->pDescriptorSets);
12614     return STATUS_SUCCESS;
12615 }
12616
12617 #else /* USE_STRUCT_CONVERSION */
12618
12619 static NTSTATUS thunk32_vkAllocateDescriptorSets(void *args)
12620 {
12621     struct
12622     {
12623         VkDevice device;
12624         const VkDescriptorSetAllocateInfo32 *pAllocateInfo;
12625         VkDescriptorSet *pDescriptorSets;
12626         VkResult result;
12627     } *params = args;
12628     VkDescriptorSetAllocateInfo pAllocateInfo_host;
12629
12630     TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pDescriptorSets);
12631
12632     convert_VkDescriptorSetAllocateInfo_win32_to_host(params->pAllocateInfo, &pAllocateInfo_host);
12633     params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle(params->device)->device, &pAllocateInfo_host, params->pDescriptorSets);
12634     return STATUS_SUCCESS;
12635 }
12636
12637 #endif /* USE_STRUCT_CONVERSION */
12638
12639 #if !defined(USE_STRUCT_CONVERSION)
12640
12641 static NTSTATUS thunk64_vkAllocateMemory(void *args)
12642 {
12643     struct vkAllocateMemory_params *params = args;
12644
12645     TRACE("%p, %p, %p, %p\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
12646
12647     params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateMemory(wine_device_from_handle(params->device)->device, params->pAllocateInfo, NULL, params->pMemory);
12648     return STATUS_SUCCESS;
12649 }
12650
12651 #else /* USE_STRUCT_CONVERSION */
12652
12653 static NTSTATUS thunk32_vkAllocateMemory(void *args)
12654 {
12655     struct
12656     {
12657         VkDevice device;
12658         const VkMemoryAllocateInfo32 *pAllocateInfo;
12659         const VkAllocationCallbacks *pAllocator;
12660         VkDeviceMemory *pMemory;
12661         VkResult result;
12662     } *params = args;
12663     VkMemoryAllocateInfo pAllocateInfo_host;
12664     struct conversion_context ctx;
12665
12666     TRACE("%p, %p, %p, %p\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
12667
12668     init_conversion_context(&ctx);
12669     convert_VkMemoryAllocateInfo_win32_to_host(&ctx, params->pAllocateInfo, &pAllocateInfo_host);
12670     params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateMemory(wine_device_from_handle(params->device)->device, &pAllocateInfo_host, NULL, params->pMemory);
12671     free_conversion_context(&ctx);
12672     return STATUS_SUCCESS;
12673 }
12674
12675 #endif /* USE_STRUCT_CONVERSION */
12676
12677 #if !defined(USE_STRUCT_CONVERSION)
12678
12679 static NTSTATUS thunk64_vkBeginCommandBuffer(void *args)
12680 {
12681     struct vkBeginCommandBuffer_params *params = args;
12682
12683     TRACE("%p, %p\n", params->commandBuffer, params->pBeginInfo);
12684
12685     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBeginInfo);
12686     return STATUS_SUCCESS;
12687 }
12688
12689 #else /* USE_STRUCT_CONVERSION */
12690
12691 static NTSTATUS thunk32_vkBeginCommandBuffer(void *args)
12692 {
12693     struct
12694     {
12695         VkCommandBuffer commandBuffer;
12696         const VkCommandBufferBeginInfo32 *pBeginInfo;
12697         VkResult result;
12698     } *params = args;
12699     VkCommandBufferBeginInfo pBeginInfo_host;
12700     struct conversion_context ctx;
12701
12702     TRACE("%p, %p\n", params->commandBuffer, params->pBeginInfo);
12703
12704     init_conversion_context(&ctx);
12705     convert_VkCommandBufferBeginInfo_win32_to_host(&ctx, params->pBeginInfo, &pBeginInfo_host);
12706     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pBeginInfo_host);
12707     free_conversion_context(&ctx);
12708     return STATUS_SUCCESS;
12709 }
12710
12711 #endif /* USE_STRUCT_CONVERSION */
12712
12713 #if !defined(USE_STRUCT_CONVERSION)
12714
12715 static NTSTATUS thunk64_vkBindAccelerationStructureMemoryNV(void *args)
12716 {
12717     struct vkBindAccelerationStructureMemoryNV_params *params = args;
12718
12719     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
12720
12721     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
12722     return STATUS_SUCCESS;
12723 }
12724
12725 #else /* USE_STRUCT_CONVERSION */
12726
12727 static NTSTATUS thunk32_vkBindAccelerationStructureMemoryNV(void *args)
12728 {
12729     struct
12730     {
12731         VkDevice device;
12732         uint32_t bindInfoCount;
12733         const VkBindAccelerationStructureMemoryInfoNV32 *pBindInfos;
12734         VkResult result;
12735     } *params = args;
12736     const VkBindAccelerationStructureMemoryInfoNV *pBindInfos_host;
12737     struct conversion_context ctx;
12738
12739     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
12740
12741     init_conversion_context(&ctx);
12742     pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
12743     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
12744     free_conversion_context(&ctx);
12745     return STATUS_SUCCESS;
12746 }
12747
12748 #endif /* USE_STRUCT_CONVERSION */
12749
12750 #if !defined(USE_STRUCT_CONVERSION)
12751
12752 static NTSTATUS thunk64_vkBindBufferMemory(void *args)
12753 {
12754     struct vkBindBufferMemory_params *params = args;
12755
12756     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));
12757
12758     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory(wine_device_from_handle(params->device)->device, params->buffer, params->memory, params->memoryOffset);
12759     return STATUS_SUCCESS;
12760 }
12761
12762 #else /* USE_STRUCT_CONVERSION */
12763
12764 static NTSTATUS thunk32_vkBindBufferMemory(void *args)
12765 {
12766     struct
12767     {
12768         VkDevice device;
12769         VkBuffer DECLSPEC_ALIGN(8) buffer;
12770         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
12771         VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
12772         VkResult result;
12773     } *params = args;
12774
12775     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));
12776
12777     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory(wine_device_from_handle(params->device)->device, params->buffer, params->memory, params->memoryOffset);
12778     return STATUS_SUCCESS;
12779 }
12780
12781 #endif /* USE_STRUCT_CONVERSION */
12782
12783 #if !defined(USE_STRUCT_CONVERSION)
12784
12785 static NTSTATUS thunk64_vkBindBufferMemory2(void *args)
12786 {
12787     struct vkBindBufferMemory2_params *params = args;
12788
12789     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
12790
12791     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
12792     return STATUS_SUCCESS;
12793 }
12794
12795 #else /* USE_STRUCT_CONVERSION */
12796
12797 static NTSTATUS thunk32_vkBindBufferMemory2(void *args)
12798 {
12799     struct
12800     {
12801         VkDevice device;
12802         uint32_t bindInfoCount;
12803         const VkBindBufferMemoryInfo32 *pBindInfos;
12804         VkResult result;
12805     } *params = args;
12806     const VkBindBufferMemoryInfo *pBindInfos_host;
12807     struct conversion_context ctx;
12808
12809     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
12810
12811     init_conversion_context(&ctx);
12812     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
12813     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
12814     free_conversion_context(&ctx);
12815     return STATUS_SUCCESS;
12816 }
12817
12818 #endif /* USE_STRUCT_CONVERSION */
12819
12820 #if !defined(USE_STRUCT_CONVERSION)
12821
12822 static NTSTATUS thunk64_vkBindBufferMemory2KHR(void *args)
12823 {
12824     struct vkBindBufferMemory2KHR_params *params = args;
12825
12826     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
12827
12828     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
12829     return STATUS_SUCCESS;
12830 }
12831
12832 #else /* USE_STRUCT_CONVERSION */
12833
12834 static NTSTATUS thunk32_vkBindBufferMemory2KHR(void *args)
12835 {
12836     struct
12837     {
12838         VkDevice device;
12839         uint32_t bindInfoCount;
12840         const VkBindBufferMemoryInfo32 *pBindInfos;
12841         VkResult result;
12842     } *params = args;
12843     const VkBindBufferMemoryInfo *pBindInfos_host;
12844     struct conversion_context ctx;
12845
12846     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
12847
12848     init_conversion_context(&ctx);
12849     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
12850     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
12851     free_conversion_context(&ctx);
12852     return STATUS_SUCCESS;
12853 }
12854
12855 #endif /* USE_STRUCT_CONVERSION */
12856
12857 #if !defined(USE_STRUCT_CONVERSION)
12858
12859 static NTSTATUS thunk64_vkBindImageMemory(void *args)
12860 {
12861     struct vkBindImageMemory_params *params = args;
12862
12863     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));
12864
12865     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory(wine_device_from_handle(params->device)->device, params->image, params->memory, params->memoryOffset);
12866     return STATUS_SUCCESS;
12867 }
12868
12869 #else /* USE_STRUCT_CONVERSION */
12870
12871 static NTSTATUS thunk32_vkBindImageMemory(void *args)
12872 {
12873     struct
12874     {
12875         VkDevice device;
12876         VkImage DECLSPEC_ALIGN(8) image;
12877         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
12878         VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
12879         VkResult result;
12880     } *params = args;
12881
12882     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));
12883
12884     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory(wine_device_from_handle(params->device)->device, params->image, params->memory, params->memoryOffset);
12885     return STATUS_SUCCESS;
12886 }
12887
12888 #endif /* USE_STRUCT_CONVERSION */
12889
12890 #if !defined(USE_STRUCT_CONVERSION)
12891
12892 static NTSTATUS thunk64_vkBindImageMemory2(void *args)
12893 {
12894     struct vkBindImageMemory2_params *params = args;
12895
12896     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
12897
12898     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
12899     return STATUS_SUCCESS;
12900 }
12901
12902 #else /* USE_STRUCT_CONVERSION */
12903
12904 static NTSTATUS thunk32_vkBindImageMemory2(void *args)
12905 {
12906     struct
12907     {
12908         VkDevice device;
12909         uint32_t bindInfoCount;
12910         const VkBindImageMemoryInfo32 *pBindInfos;
12911         VkResult result;
12912     } *params = args;
12913     const VkBindImageMemoryInfo *pBindInfos_host;
12914     struct conversion_context ctx;
12915
12916     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
12917
12918     init_conversion_context(&ctx);
12919     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
12920     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
12921     free_conversion_context(&ctx);
12922     return STATUS_SUCCESS;
12923 }
12924
12925 #endif /* USE_STRUCT_CONVERSION */
12926
12927 #if !defined(USE_STRUCT_CONVERSION)
12928
12929 static NTSTATUS thunk64_vkBindImageMemory2KHR(void *args)
12930 {
12931     struct vkBindImageMemory2KHR_params *params = args;
12932
12933     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
12934
12935     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, params->pBindInfos);
12936     return STATUS_SUCCESS;
12937 }
12938
12939 #else /* USE_STRUCT_CONVERSION */
12940
12941 static NTSTATUS thunk32_vkBindImageMemory2KHR(void *args)
12942 {
12943     struct
12944     {
12945         VkDevice device;
12946         uint32_t bindInfoCount;
12947         const VkBindImageMemoryInfo32 *pBindInfos;
12948         VkResult result;
12949     } *params = args;
12950     const VkBindImageMemoryInfo *pBindInfos_host;
12951     struct conversion_context ctx;
12952
12953     TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
12954
12955     init_conversion_context(&ctx);
12956     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
12957     params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
12958     free_conversion_context(&ctx);
12959     return STATUS_SUCCESS;
12960 }
12961
12962 #endif /* USE_STRUCT_CONVERSION */
12963
12964 #if !defined(USE_STRUCT_CONVERSION)
12965
12966 static NTSTATUS thunk64_vkBindOpticalFlowSessionImageNV(void *args)
12967 {
12968     struct vkBindOpticalFlowSessionImageNV_params *params = args;
12969
12970     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);
12971
12972     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);
12973     return STATUS_SUCCESS;
12974 }
12975
12976 #else /* USE_STRUCT_CONVERSION */
12977
12978 static NTSTATUS thunk32_vkBindOpticalFlowSessionImageNV(void *args)
12979 {
12980     struct
12981     {
12982         VkDevice device;
12983         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
12984         VkOpticalFlowSessionBindingPointNV bindingPoint;
12985         VkImageView DECLSPEC_ALIGN(8) view;
12986         VkImageLayout layout;
12987         VkResult result;
12988     } *params = args;
12989
12990     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);
12991
12992     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);
12993     return STATUS_SUCCESS;
12994 }
12995
12996 #endif /* USE_STRUCT_CONVERSION */
12997
12998 #if !defined(USE_STRUCT_CONVERSION)
12999
13000 static NTSTATUS thunk64_vkBuildAccelerationStructuresKHR(void *args)
13001 {
13002     struct vkBuildAccelerationStructuresKHR_params *params = args;
13003
13004     TRACE("%p, 0x%s, %u, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);
13005
13006     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);
13007     return STATUS_SUCCESS;
13008 }
13009
13010 #else /* USE_STRUCT_CONVERSION */
13011
13012 static NTSTATUS thunk32_vkBuildAccelerationStructuresKHR(void *args)
13013 {
13014     struct
13015     {
13016         VkDevice device;
13017         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
13018         uint32_t infoCount;
13019         const VkAccelerationStructureBuildGeometryInfoKHR32 *pInfos;
13020         const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos;
13021         VkResult result;
13022     } *params = args;
13023     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
13024     struct conversion_context ctx;
13025
13026     TRACE("%p, 0x%s, %u, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);
13027
13028     init_conversion_context(&ctx);
13029     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
13030     params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildAccelerationStructuresKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, pInfos_host, params->ppBuildRangeInfos);
13031     free_conversion_context(&ctx);
13032     return STATUS_SUCCESS;
13033 }
13034
13035 #endif /* USE_STRUCT_CONVERSION */
13036
13037 #if !defined(USE_STRUCT_CONVERSION)
13038
13039 static NTSTATUS thunk64_vkBuildMicromapsEXT(void *args)
13040 {
13041     struct vkBuildMicromapsEXT_params *params = args;
13042
13043     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
13044
13045     params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildMicromapsEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, params->pInfos);
13046     return STATUS_SUCCESS;
13047 }
13048
13049 #else /* USE_STRUCT_CONVERSION */
13050
13051 static NTSTATUS thunk32_vkBuildMicromapsEXT(void *args)
13052 {
13053     struct
13054     {
13055         VkDevice device;
13056         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
13057         uint32_t infoCount;
13058         const VkMicromapBuildInfoEXT32 *pInfos;
13059         VkResult result;
13060     } *params = args;
13061     const VkMicromapBuildInfoEXT *pInfos_host;
13062     struct conversion_context ctx;
13063
13064     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
13065
13066     init_conversion_context(&ctx);
13067     pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
13068     params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildMicromapsEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, pInfos_host);
13069     free_conversion_context(&ctx);
13070     return STATUS_SUCCESS;
13071 }
13072
13073 #endif /* USE_STRUCT_CONVERSION */
13074
13075 #if !defined(USE_STRUCT_CONVERSION)
13076
13077 static NTSTATUS thunk64_vkCmdBeginConditionalRenderingEXT(void *args)
13078 {
13079     struct vkCmdBeginConditionalRenderingEXT_params *params = args;
13080
13081     TRACE("%p, %p\n", params->commandBuffer, params->pConditionalRenderingBegin);
13082
13083     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pConditionalRenderingBegin);
13084     return STATUS_SUCCESS;
13085 }
13086
13087 #else /* USE_STRUCT_CONVERSION */
13088
13089 static NTSTATUS thunk32_vkCmdBeginConditionalRenderingEXT(void *args)
13090 {
13091     struct
13092     {
13093         VkCommandBuffer commandBuffer;
13094         const VkConditionalRenderingBeginInfoEXT32 *pConditionalRenderingBegin;
13095     } *params = args;
13096     VkConditionalRenderingBeginInfoEXT pConditionalRenderingBegin_host;
13097
13098     TRACE("%p, %p\n", params->commandBuffer, params->pConditionalRenderingBegin);
13099
13100     convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(params->pConditionalRenderingBegin, &pConditionalRenderingBegin_host);
13101     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pConditionalRenderingBegin_host);
13102     return STATUS_SUCCESS;
13103 }
13104
13105 #endif /* USE_STRUCT_CONVERSION */
13106
13107 #if !defined(USE_STRUCT_CONVERSION)
13108
13109 static NTSTATUS thunk64_vkCmdBeginDebugUtilsLabelEXT(void *args)
13110 {
13111     struct vkCmdBeginDebugUtilsLabelEXT_params *params = args;
13112
13113     TRACE("%p, %p\n", params->commandBuffer, params->pLabelInfo);
13114
13115     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
13116     return STATUS_SUCCESS;
13117 }
13118
13119 #else /* USE_STRUCT_CONVERSION */
13120
13121 static NTSTATUS thunk32_vkCmdBeginDebugUtilsLabelEXT(void *args)
13122 {
13123     struct
13124     {
13125         VkCommandBuffer commandBuffer;
13126         const VkDebugUtilsLabelEXT *pLabelInfo;
13127     } *params = args;
13128
13129     TRACE("%p, %p\n", params->commandBuffer, params->pLabelInfo);
13130
13131     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
13132     return STATUS_SUCCESS;
13133 }
13134
13135 #endif /* USE_STRUCT_CONVERSION */
13136
13137 #if !defined(USE_STRUCT_CONVERSION)
13138
13139 static NTSTATUS thunk64_vkCmdBeginQuery(void *args)
13140 {
13141     struct vkCmdBeginQuery_params *params = args;
13142
13143     TRACE("%p, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags);
13144
13145     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);
13146     return STATUS_SUCCESS;
13147 }
13148
13149 #else /* USE_STRUCT_CONVERSION */
13150
13151 static NTSTATUS thunk32_vkCmdBeginQuery(void *args)
13152 {
13153     struct
13154     {
13155         VkCommandBuffer commandBuffer;
13156         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
13157         uint32_t query;
13158         VkQueryControlFlags flags;
13159     } *params = args;
13160
13161     TRACE("%p, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags);
13162
13163     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);
13164     return STATUS_SUCCESS;
13165 }
13166
13167 #endif /* USE_STRUCT_CONVERSION */
13168
13169 #if !defined(USE_STRUCT_CONVERSION)
13170
13171 static NTSTATUS thunk64_vkCmdBeginQueryIndexedEXT(void *args)
13172 {
13173     struct vkCmdBeginQueryIndexedEXT_params *params = args;
13174
13175     TRACE("%p, 0x%s, %u, %#x, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags, params->index);
13176
13177     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);
13178     return STATUS_SUCCESS;
13179 }
13180
13181 #else /* USE_STRUCT_CONVERSION */
13182
13183 static NTSTATUS thunk32_vkCmdBeginQueryIndexedEXT(void *args)
13184 {
13185     struct
13186     {
13187         VkCommandBuffer commandBuffer;
13188         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
13189         uint32_t query;
13190         VkQueryControlFlags flags;
13191         uint32_t index;
13192     } *params = args;
13193
13194     TRACE("%p, 0x%s, %u, %#x, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags, params->index);
13195
13196     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);
13197     return STATUS_SUCCESS;
13198 }
13199
13200 #endif /* USE_STRUCT_CONVERSION */
13201
13202 #if !defined(USE_STRUCT_CONVERSION)
13203
13204 static NTSTATUS thunk64_vkCmdBeginRenderPass(void *args)
13205 {
13206     struct vkCmdBeginRenderPass_params *params = args;
13207
13208     TRACE("%p, %p, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->contents);
13209
13210     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->contents);
13211     return STATUS_SUCCESS;
13212 }
13213
13214 #else /* USE_STRUCT_CONVERSION */
13215
13216 static NTSTATUS thunk32_vkCmdBeginRenderPass(void *args)
13217 {
13218     struct
13219     {
13220         VkCommandBuffer commandBuffer;
13221         const VkRenderPassBeginInfo32 *pRenderPassBegin;
13222         VkSubpassContents contents;
13223     } *params = args;
13224     VkRenderPassBeginInfo pRenderPassBegin_host;
13225
13226     TRACE("%p, %p, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->contents);
13227
13228     convert_VkRenderPassBeginInfo_win32_to_host(params->pRenderPassBegin, &pRenderPassBegin_host);
13229     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderPassBegin_host, params->contents);
13230     return STATUS_SUCCESS;
13231 }
13232
13233 #endif /* USE_STRUCT_CONVERSION */
13234
13235 #if !defined(USE_STRUCT_CONVERSION)
13236
13237 static NTSTATUS thunk64_vkCmdBeginRenderPass2(void *args)
13238 {
13239     struct vkCmdBeginRenderPass2_params *params = args;
13240
13241     TRACE("%p, %p, %p\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
13242
13243     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
13244     return STATUS_SUCCESS;
13245 }
13246
13247 #else /* USE_STRUCT_CONVERSION */
13248
13249 static NTSTATUS thunk32_vkCmdBeginRenderPass2(void *args)
13250 {
13251     struct
13252     {
13253         VkCommandBuffer commandBuffer;
13254         const VkRenderPassBeginInfo32 *pRenderPassBegin;
13255         const VkSubpassBeginInfo *pSubpassBeginInfo;
13256     } *params = args;
13257     VkRenderPassBeginInfo pRenderPassBegin_host;
13258
13259     TRACE("%p, %p, %p\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
13260
13261     convert_VkRenderPassBeginInfo_win32_to_host(params->pRenderPassBegin, &pRenderPassBegin_host);
13262     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderPassBegin_host, params->pSubpassBeginInfo);
13263     return STATUS_SUCCESS;
13264 }
13265
13266 #endif /* USE_STRUCT_CONVERSION */
13267
13268 #if !defined(USE_STRUCT_CONVERSION)
13269
13270 static NTSTATUS thunk64_vkCmdBeginRenderPass2KHR(void *args)
13271 {
13272     struct vkCmdBeginRenderPass2KHR_params *params = args;
13273
13274     TRACE("%p, %p, %p\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
13275
13276     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
13277     return STATUS_SUCCESS;
13278 }
13279
13280 #else /* USE_STRUCT_CONVERSION */
13281
13282 static NTSTATUS thunk32_vkCmdBeginRenderPass2KHR(void *args)
13283 {
13284     struct
13285     {
13286         VkCommandBuffer commandBuffer;
13287         const VkRenderPassBeginInfo32 *pRenderPassBegin;
13288         const VkSubpassBeginInfo *pSubpassBeginInfo;
13289     } *params = args;
13290     VkRenderPassBeginInfo pRenderPassBegin_host;
13291
13292     TRACE("%p, %p, %p\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
13293
13294     convert_VkRenderPassBeginInfo_win32_to_host(params->pRenderPassBegin, &pRenderPassBegin_host);
13295     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderPassBegin_host, params->pSubpassBeginInfo);
13296     return STATUS_SUCCESS;
13297 }
13298
13299 #endif /* USE_STRUCT_CONVERSION */
13300
13301 #if !defined(USE_STRUCT_CONVERSION)
13302
13303 static NTSTATUS thunk64_vkCmdBeginRendering(void *args)
13304 {
13305     struct vkCmdBeginRendering_params *params = args;
13306
13307     TRACE("%p, %p\n", params->commandBuffer, params->pRenderingInfo);
13308
13309     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
13310     return STATUS_SUCCESS;
13311 }
13312
13313 #else /* USE_STRUCT_CONVERSION */
13314
13315 static NTSTATUS thunk32_vkCmdBeginRendering(void *args)
13316 {
13317     struct
13318     {
13319         VkCommandBuffer commandBuffer;
13320         const VkRenderingInfo32 *pRenderingInfo;
13321     } *params = args;
13322     VkRenderingInfo pRenderingInfo_host;
13323     struct conversion_context ctx;
13324
13325     TRACE("%p, %p\n", params->commandBuffer, params->pRenderingInfo);
13326
13327     init_conversion_context(&ctx);
13328     convert_VkRenderingInfo_win32_to_host(&ctx, params->pRenderingInfo, &pRenderingInfo_host);
13329     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderingInfo_host);
13330     free_conversion_context(&ctx);
13331     return STATUS_SUCCESS;
13332 }
13333
13334 #endif /* USE_STRUCT_CONVERSION */
13335
13336 #if !defined(USE_STRUCT_CONVERSION)
13337
13338 static NTSTATUS thunk64_vkCmdBeginRenderingKHR(void *args)
13339 {
13340     struct vkCmdBeginRenderingKHR_params *params = args;
13341
13342     TRACE("%p, %p\n", params->commandBuffer, params->pRenderingInfo);
13343
13344     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
13345     return STATUS_SUCCESS;
13346 }
13347
13348 #else /* USE_STRUCT_CONVERSION */
13349
13350 static NTSTATUS thunk32_vkCmdBeginRenderingKHR(void *args)
13351 {
13352     struct
13353     {
13354         VkCommandBuffer commandBuffer;
13355         const VkRenderingInfo32 *pRenderingInfo;
13356     } *params = args;
13357     VkRenderingInfo pRenderingInfo_host;
13358     struct conversion_context ctx;
13359
13360     TRACE("%p, %p\n", params->commandBuffer, params->pRenderingInfo);
13361
13362     init_conversion_context(&ctx);
13363     convert_VkRenderingInfo_win32_to_host(&ctx, params->pRenderingInfo, &pRenderingInfo_host);
13364     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderingInfo_host);
13365     free_conversion_context(&ctx);
13366     return STATUS_SUCCESS;
13367 }
13368
13369 #endif /* USE_STRUCT_CONVERSION */
13370
13371 #if !defined(USE_STRUCT_CONVERSION)
13372
13373 static NTSTATUS thunk64_vkCmdBeginTransformFeedbackEXT(void *args)
13374 {
13375     struct vkCmdBeginTransformFeedbackEXT_params *params = args;
13376
13377     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
13378
13379     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);
13380     return STATUS_SUCCESS;
13381 }
13382
13383 #else /* USE_STRUCT_CONVERSION */
13384
13385 static NTSTATUS thunk32_vkCmdBeginTransformFeedbackEXT(void *args)
13386 {
13387     struct
13388     {
13389         VkCommandBuffer commandBuffer;
13390         uint32_t firstCounterBuffer;
13391         uint32_t counterBufferCount;
13392         const VkBuffer *pCounterBuffers;
13393         const VkDeviceSize *pCounterBufferOffsets;
13394     } *params = args;
13395
13396     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
13397
13398     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);
13399     return STATUS_SUCCESS;
13400 }
13401
13402 #endif /* USE_STRUCT_CONVERSION */
13403
13404 #if !defined(USE_STRUCT_CONVERSION)
13405
13406 static NTSTATUS thunk64_vkCmdBindDescriptorSets(void *args)
13407 {
13408     struct vkCmdBindDescriptorSets_params *params = args;
13409
13410     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);
13411
13412     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);
13413     return STATUS_SUCCESS;
13414 }
13415
13416 #else /* USE_STRUCT_CONVERSION */
13417
13418 static NTSTATUS thunk32_vkCmdBindDescriptorSets(void *args)
13419 {
13420     struct
13421     {
13422         VkCommandBuffer commandBuffer;
13423         VkPipelineBindPoint pipelineBindPoint;
13424         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
13425         uint32_t firstSet;
13426         uint32_t descriptorSetCount;
13427         const VkDescriptorSet *pDescriptorSets;
13428         uint32_t dynamicOffsetCount;
13429         const uint32_t *pDynamicOffsets;
13430     } *params = args;
13431
13432     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);
13433
13434     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);
13435     return STATUS_SUCCESS;
13436 }
13437
13438 #endif /* USE_STRUCT_CONVERSION */
13439
13440 #if !defined(USE_STRUCT_CONVERSION)
13441
13442 static NTSTATUS thunk64_vkCmdBindIndexBuffer(void *args)
13443 {
13444     struct vkCmdBindIndexBuffer_params *params = args;
13445
13446     TRACE("%p, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->indexType);
13447
13448     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);
13449     return STATUS_SUCCESS;
13450 }
13451
13452 #else /* USE_STRUCT_CONVERSION */
13453
13454 static NTSTATUS thunk32_vkCmdBindIndexBuffer(void *args)
13455 {
13456     struct
13457     {
13458         VkCommandBuffer commandBuffer;
13459         VkBuffer DECLSPEC_ALIGN(8) buffer;
13460         VkDeviceSize DECLSPEC_ALIGN(8) offset;
13461         VkIndexType indexType;
13462     } *params = args;
13463
13464     TRACE("%p, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->indexType);
13465
13466     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);
13467     return STATUS_SUCCESS;
13468 }
13469
13470 #endif /* USE_STRUCT_CONVERSION */
13471
13472 #if !defined(USE_STRUCT_CONVERSION)
13473
13474 static NTSTATUS thunk64_vkCmdBindInvocationMaskHUAWEI(void *args)
13475 {
13476     struct vkCmdBindInvocationMaskHUAWEI_params *params = args;
13477
13478     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
13479
13480     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
13481     return STATUS_SUCCESS;
13482 }
13483
13484 #else /* USE_STRUCT_CONVERSION */
13485
13486 static NTSTATUS thunk32_vkCmdBindInvocationMaskHUAWEI(void *args)
13487 {
13488     struct
13489     {
13490         VkCommandBuffer commandBuffer;
13491         VkImageView DECLSPEC_ALIGN(8) imageView;
13492         VkImageLayout imageLayout;
13493     } *params = args;
13494
13495     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
13496
13497     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
13498     return STATUS_SUCCESS;
13499 }
13500
13501 #endif /* USE_STRUCT_CONVERSION */
13502
13503 #if !defined(USE_STRUCT_CONVERSION)
13504
13505 static NTSTATUS thunk64_vkCmdBindPipeline(void *args)
13506 {
13507     struct vkCmdBindPipeline_params *params = args;
13508
13509     TRACE("%p, %#x, 0x%s\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline));
13510
13511     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipeline(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline);
13512     return STATUS_SUCCESS;
13513 }
13514
13515 #else /* USE_STRUCT_CONVERSION */
13516
13517 static NTSTATUS thunk32_vkCmdBindPipeline(void *args)
13518 {
13519     struct
13520     {
13521         VkCommandBuffer commandBuffer;
13522         VkPipelineBindPoint pipelineBindPoint;
13523         VkPipeline DECLSPEC_ALIGN(8) pipeline;
13524     } *params = args;
13525
13526     TRACE("%p, %#x, 0x%s\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline));
13527
13528     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipeline(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline);
13529     return STATUS_SUCCESS;
13530 }
13531
13532 #endif /* USE_STRUCT_CONVERSION */
13533
13534 #if !defined(USE_STRUCT_CONVERSION)
13535
13536 static NTSTATUS thunk64_vkCmdBindPipelineShaderGroupNV(void *args)
13537 {
13538     struct vkCmdBindPipelineShaderGroupNV_params *params = args;
13539
13540     TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline), params->groupIndex);
13541
13542     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);
13543     return STATUS_SUCCESS;
13544 }
13545
13546 #else /* USE_STRUCT_CONVERSION */
13547
13548 static NTSTATUS thunk32_vkCmdBindPipelineShaderGroupNV(void *args)
13549 {
13550     struct
13551     {
13552         VkCommandBuffer commandBuffer;
13553         VkPipelineBindPoint pipelineBindPoint;
13554         VkPipeline DECLSPEC_ALIGN(8) pipeline;
13555         uint32_t groupIndex;
13556     } *params = args;
13557
13558     TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline), params->groupIndex);
13559
13560     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);
13561     return STATUS_SUCCESS;
13562 }
13563
13564 #endif /* USE_STRUCT_CONVERSION */
13565
13566 #if !defined(USE_STRUCT_CONVERSION)
13567
13568 static NTSTATUS thunk64_vkCmdBindShadingRateImageNV(void *args)
13569 {
13570     struct vkCmdBindShadingRateImageNV_params *params = args;
13571
13572     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
13573
13574     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindShadingRateImageNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
13575     return STATUS_SUCCESS;
13576 }
13577
13578 #else /* USE_STRUCT_CONVERSION */
13579
13580 static NTSTATUS thunk32_vkCmdBindShadingRateImageNV(void *args)
13581 {
13582     struct
13583     {
13584         VkCommandBuffer commandBuffer;
13585         VkImageView DECLSPEC_ALIGN(8) imageView;
13586         VkImageLayout imageLayout;
13587     } *params = args;
13588
13589     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
13590
13591     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindShadingRateImageNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
13592     return STATUS_SUCCESS;
13593 }
13594
13595 #endif /* USE_STRUCT_CONVERSION */
13596
13597 #if !defined(USE_STRUCT_CONVERSION)
13598
13599 static NTSTATUS thunk64_vkCmdBindTransformFeedbackBuffersEXT(void *args)
13600 {
13601     struct vkCmdBindTransformFeedbackBuffersEXT_params *params = args;
13602
13603     TRACE("%p, %u, %u, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);
13604
13605     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);
13606     return STATUS_SUCCESS;
13607 }
13608
13609 #else /* USE_STRUCT_CONVERSION */
13610
13611 static NTSTATUS thunk32_vkCmdBindTransformFeedbackBuffersEXT(void *args)
13612 {
13613     struct
13614     {
13615         VkCommandBuffer commandBuffer;
13616         uint32_t firstBinding;
13617         uint32_t bindingCount;
13618         const VkBuffer *pBuffers;
13619         const VkDeviceSize *pOffsets;
13620         const VkDeviceSize *pSizes;
13621     } *params = args;
13622
13623     TRACE("%p, %u, %u, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);
13624
13625     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);
13626     return STATUS_SUCCESS;
13627 }
13628
13629 #endif /* USE_STRUCT_CONVERSION */
13630
13631 #if !defined(USE_STRUCT_CONVERSION)
13632
13633 static NTSTATUS thunk64_vkCmdBindVertexBuffers(void *args)
13634 {
13635     struct vkCmdBindVertexBuffers_params *params = args;
13636
13637     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);
13638
13639     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);
13640     return STATUS_SUCCESS;
13641 }
13642
13643 #else /* USE_STRUCT_CONVERSION */
13644
13645 static NTSTATUS thunk32_vkCmdBindVertexBuffers(void *args)
13646 {
13647     struct
13648     {
13649         VkCommandBuffer commandBuffer;
13650         uint32_t firstBinding;
13651         uint32_t bindingCount;
13652         const VkBuffer *pBuffers;
13653         const VkDeviceSize *pOffsets;
13654     } *params = args;
13655
13656     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);
13657
13658     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);
13659     return STATUS_SUCCESS;
13660 }
13661
13662 #endif /* USE_STRUCT_CONVERSION */
13663
13664 #if !defined(USE_STRUCT_CONVERSION)
13665
13666 static NTSTATUS thunk64_vkCmdBindVertexBuffers2(void *args)
13667 {
13668     struct vkCmdBindVertexBuffers2_params *params = args;
13669
13670     TRACE("%p, %u, %u, %p, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
13671
13672     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);
13673     return STATUS_SUCCESS;
13674 }
13675
13676 #else /* USE_STRUCT_CONVERSION */
13677
13678 static NTSTATUS thunk32_vkCmdBindVertexBuffers2(void *args)
13679 {
13680     struct
13681     {
13682         VkCommandBuffer commandBuffer;
13683         uint32_t firstBinding;
13684         uint32_t bindingCount;
13685         const VkBuffer *pBuffers;
13686         const VkDeviceSize *pOffsets;
13687         const VkDeviceSize *pSizes;
13688         const VkDeviceSize *pStrides;
13689     } *params = args;
13690
13691     TRACE("%p, %u, %u, %p, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
13692
13693     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);
13694     return STATUS_SUCCESS;
13695 }
13696
13697 #endif /* USE_STRUCT_CONVERSION */
13698
13699 #if !defined(USE_STRUCT_CONVERSION)
13700
13701 static NTSTATUS thunk64_vkCmdBindVertexBuffers2EXT(void *args)
13702 {
13703     struct vkCmdBindVertexBuffers2EXT_params *params = args;
13704
13705     TRACE("%p, %u, %u, %p, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
13706
13707     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);
13708     return STATUS_SUCCESS;
13709 }
13710
13711 #else /* USE_STRUCT_CONVERSION */
13712
13713 static NTSTATUS thunk32_vkCmdBindVertexBuffers2EXT(void *args)
13714 {
13715     struct
13716     {
13717         VkCommandBuffer commandBuffer;
13718         uint32_t firstBinding;
13719         uint32_t bindingCount;
13720         const VkBuffer *pBuffers;
13721         const VkDeviceSize *pOffsets;
13722         const VkDeviceSize *pSizes;
13723         const VkDeviceSize *pStrides;
13724     } *params = args;
13725
13726     TRACE("%p, %u, %u, %p, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
13727
13728     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);
13729     return STATUS_SUCCESS;
13730 }
13731
13732 #endif /* USE_STRUCT_CONVERSION */
13733
13734 #if !defined(USE_STRUCT_CONVERSION)
13735
13736 static NTSTATUS thunk64_vkCmdBlitImage(void *args)
13737 {
13738     struct vkCmdBlitImage_params *params = args;
13739
13740     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);
13741
13742     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);
13743     return STATUS_SUCCESS;
13744 }
13745
13746 #else /* USE_STRUCT_CONVERSION */
13747
13748 static NTSTATUS thunk32_vkCmdBlitImage(void *args)
13749 {
13750     struct
13751     {
13752         VkCommandBuffer commandBuffer;
13753         VkImage DECLSPEC_ALIGN(8) srcImage;
13754         VkImageLayout srcImageLayout;
13755         VkImage DECLSPEC_ALIGN(8) dstImage;
13756         VkImageLayout dstImageLayout;
13757         uint32_t regionCount;
13758         const VkImageBlit *pRegions;
13759         VkFilter filter;
13760     } *params = args;
13761
13762     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);
13763
13764     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);
13765     return STATUS_SUCCESS;
13766 }
13767
13768 #endif /* USE_STRUCT_CONVERSION */
13769
13770 #if !defined(USE_STRUCT_CONVERSION)
13771
13772 static NTSTATUS thunk64_vkCmdBlitImage2(void *args)
13773 {
13774     struct vkCmdBlitImage2_params *params = args;
13775
13776     TRACE("%p, %p\n", params->commandBuffer, params->pBlitImageInfo);
13777
13778     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
13779     return STATUS_SUCCESS;
13780 }
13781
13782 #else /* USE_STRUCT_CONVERSION */
13783
13784 static NTSTATUS thunk32_vkCmdBlitImage2(void *args)
13785 {
13786     struct
13787     {
13788         VkCommandBuffer commandBuffer;
13789         const VkBlitImageInfo232 *pBlitImageInfo;
13790     } *params = args;
13791     VkBlitImageInfo2 pBlitImageInfo_host;
13792
13793     TRACE("%p, %p\n", params->commandBuffer, params->pBlitImageInfo);
13794
13795     convert_VkBlitImageInfo2_win32_to_host(params->pBlitImageInfo, &pBlitImageInfo_host);
13796     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pBlitImageInfo_host);
13797     return STATUS_SUCCESS;
13798 }
13799
13800 #endif /* USE_STRUCT_CONVERSION */
13801
13802 #if !defined(USE_STRUCT_CONVERSION)
13803
13804 static NTSTATUS thunk64_vkCmdBlitImage2KHR(void *args)
13805 {
13806     struct vkCmdBlitImage2KHR_params *params = args;
13807
13808     TRACE("%p, %p\n", params->commandBuffer, params->pBlitImageInfo);
13809
13810     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
13811     return STATUS_SUCCESS;
13812 }
13813
13814 #else /* USE_STRUCT_CONVERSION */
13815
13816 static NTSTATUS thunk32_vkCmdBlitImage2KHR(void *args)
13817 {
13818     struct
13819     {
13820         VkCommandBuffer commandBuffer;
13821         const VkBlitImageInfo232 *pBlitImageInfo;
13822     } *params = args;
13823     VkBlitImageInfo2 pBlitImageInfo_host;
13824
13825     TRACE("%p, %p\n", params->commandBuffer, params->pBlitImageInfo);
13826
13827     convert_VkBlitImageInfo2_win32_to_host(params->pBlitImageInfo, &pBlitImageInfo_host);
13828     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pBlitImageInfo_host);
13829     return STATUS_SUCCESS;
13830 }
13831
13832 #endif /* USE_STRUCT_CONVERSION */
13833
13834 #if !defined(USE_STRUCT_CONVERSION)
13835
13836 static NTSTATUS thunk64_vkCmdBuildAccelerationStructureNV(void *args)
13837 {
13838     struct vkCmdBuildAccelerationStructureNV_params *params = args;
13839
13840     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));
13841
13842     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);
13843     return STATUS_SUCCESS;
13844 }
13845
13846 #else /* USE_STRUCT_CONVERSION */
13847
13848 static NTSTATUS thunk32_vkCmdBuildAccelerationStructureNV(void *args)
13849 {
13850     struct
13851     {
13852         VkCommandBuffer commandBuffer;
13853         const VkAccelerationStructureInfoNV32 *pInfo;
13854         VkBuffer DECLSPEC_ALIGN(8) instanceData;
13855         VkDeviceSize DECLSPEC_ALIGN(8) instanceOffset;
13856         VkBool32 update;
13857         VkAccelerationStructureNV DECLSPEC_ALIGN(8) dst;
13858         VkAccelerationStructureNV DECLSPEC_ALIGN(8) src;
13859         VkBuffer DECLSPEC_ALIGN(8) scratch;
13860         VkDeviceSize DECLSPEC_ALIGN(8) scratchOffset;
13861     } *params = args;
13862     VkAccelerationStructureInfoNV pInfo_host;
13863     struct conversion_context ctx;
13864
13865     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));
13866
13867     init_conversion_context(&ctx);
13868     convert_VkAccelerationStructureInfoNV_win32_to_host(&ctx, params->pInfo, &pInfo_host);
13869     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructureNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host, params->instanceData, params->instanceOffset, params->update, params->dst, params->src, params->scratch, params->scratchOffset);
13870     free_conversion_context(&ctx);
13871     return STATUS_SUCCESS;
13872 }
13873
13874 #endif /* USE_STRUCT_CONVERSION */
13875
13876 #if !defined(USE_STRUCT_CONVERSION)
13877
13878 static NTSTATUS thunk64_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
13879 {
13880     struct vkCmdBuildAccelerationStructuresIndirectKHR_params *params = args;
13881
13882     TRACE("%p, %u, %p, %p, %p, %p\n", params->commandBuffer, params->infoCount, params->pInfos, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
13883
13884     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);
13885     return STATUS_SUCCESS;
13886 }
13887
13888 #else /* USE_STRUCT_CONVERSION */
13889
13890 static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
13891 {
13892     struct
13893     {
13894         VkCommandBuffer commandBuffer;
13895         uint32_t infoCount;
13896         const VkAccelerationStructureBuildGeometryInfoKHR32 *pInfos;
13897         const VkDeviceAddress *pIndirectDeviceAddresses;
13898         const uint32_t *pIndirectStrides;
13899         const uint32_t * const*ppMaxPrimitiveCounts;
13900     } *params = args;
13901     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
13902     struct conversion_context ctx;
13903
13904     TRACE("%p, %u, %p, %p, %p, %p\n", params->commandBuffer, params->infoCount, params->pInfos, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
13905
13906     init_conversion_context(&ctx);
13907     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
13908     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructuresIndirectKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, pInfos_host, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
13909     free_conversion_context(&ctx);
13910     return STATUS_SUCCESS;
13911 }
13912
13913 #endif /* USE_STRUCT_CONVERSION */
13914
13915 #if !defined(USE_STRUCT_CONVERSION)
13916
13917 static NTSTATUS thunk64_vkCmdBuildAccelerationStructuresKHR(void *args)
13918 {
13919     struct vkCmdBuildAccelerationStructuresKHR_params *params = args;
13920
13921     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
13922
13923     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);
13924     return STATUS_SUCCESS;
13925 }
13926
13927 #else /* USE_STRUCT_CONVERSION */
13928
13929 static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresKHR(void *args)
13930 {
13931     struct
13932     {
13933         VkCommandBuffer commandBuffer;
13934         uint32_t infoCount;
13935         const VkAccelerationStructureBuildGeometryInfoKHR32 *pInfos;
13936         const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos;
13937     } *params = args;
13938     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
13939     struct conversion_context ctx;
13940
13941     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
13942
13943     init_conversion_context(&ctx);
13944     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
13945     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructuresKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, pInfos_host, params->ppBuildRangeInfos);
13946     free_conversion_context(&ctx);
13947     return STATUS_SUCCESS;
13948 }
13949
13950 #endif /* USE_STRUCT_CONVERSION */
13951
13952 #if !defined(USE_STRUCT_CONVERSION)
13953
13954 static NTSTATUS thunk64_vkCmdBuildMicromapsEXT(void *args)
13955 {
13956     struct vkCmdBuildMicromapsEXT_params *params = args;
13957
13958     TRACE("%p, %u, %p\n", params->commandBuffer, params->infoCount, params->pInfos);
13959
13960     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos);
13961     return STATUS_SUCCESS;
13962 }
13963
13964 #else /* USE_STRUCT_CONVERSION */
13965
13966 static NTSTATUS thunk32_vkCmdBuildMicromapsEXT(void *args)
13967 {
13968     struct
13969     {
13970         VkCommandBuffer commandBuffer;
13971         uint32_t infoCount;
13972         const VkMicromapBuildInfoEXT32 *pInfos;
13973     } *params = args;
13974     const VkMicromapBuildInfoEXT *pInfos_host;
13975     struct conversion_context ctx;
13976
13977     TRACE("%p, %u, %p\n", params->commandBuffer, params->infoCount, params->pInfos);
13978
13979     init_conversion_context(&ctx);
13980     pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
13981     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, pInfos_host);
13982     free_conversion_context(&ctx);
13983     return STATUS_SUCCESS;
13984 }
13985
13986 #endif /* USE_STRUCT_CONVERSION */
13987
13988 #if !defined(USE_STRUCT_CONVERSION)
13989
13990 static NTSTATUS thunk64_vkCmdClearAttachments(void *args)
13991 {
13992     struct vkCmdClearAttachments_params *params = args;
13993
13994     TRACE("%p, %u, %p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);
13995
13996     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);
13997     return STATUS_SUCCESS;
13998 }
13999
14000 #else /* USE_STRUCT_CONVERSION */
14001
14002 static NTSTATUS thunk32_vkCmdClearAttachments(void *args)
14003 {
14004     struct
14005     {
14006         VkCommandBuffer commandBuffer;
14007         uint32_t attachmentCount;
14008         const VkClearAttachment *pAttachments;
14009         uint32_t rectCount;
14010         const VkClearRect *pRects;
14011     } *params = args;
14012
14013     TRACE("%p, %u, %p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);
14014
14015     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);
14016     return STATUS_SUCCESS;
14017 }
14018
14019 #endif /* USE_STRUCT_CONVERSION */
14020
14021 #if !defined(USE_STRUCT_CONVERSION)
14022
14023 static NTSTATUS thunk64_vkCmdClearColorImage(void *args)
14024 {
14025     struct vkCmdClearColorImage_params *params = args;
14026
14027     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pColor, params->rangeCount, params->pRanges);
14028
14029     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);
14030     return STATUS_SUCCESS;
14031 }
14032
14033 #else /* USE_STRUCT_CONVERSION */
14034
14035 static NTSTATUS thunk32_vkCmdClearColorImage(void *args)
14036 {
14037     struct
14038     {
14039         VkCommandBuffer commandBuffer;
14040         VkImage DECLSPEC_ALIGN(8) image;
14041         VkImageLayout imageLayout;
14042         const VkClearColorValue *pColor;
14043         uint32_t rangeCount;
14044         const VkImageSubresourceRange *pRanges;
14045     } *params = args;
14046
14047     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pColor, params->rangeCount, params->pRanges);
14048
14049     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);
14050     return STATUS_SUCCESS;
14051 }
14052
14053 #endif /* USE_STRUCT_CONVERSION */
14054
14055 #if !defined(USE_STRUCT_CONVERSION)
14056
14057 static NTSTATUS thunk64_vkCmdClearDepthStencilImage(void *args)
14058 {
14059     struct vkCmdClearDepthStencilImage_params *params = args;
14060
14061     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);
14062
14063     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);
14064     return STATUS_SUCCESS;
14065 }
14066
14067 #else /* USE_STRUCT_CONVERSION */
14068
14069 static NTSTATUS thunk32_vkCmdClearDepthStencilImage(void *args)
14070 {
14071     struct
14072     {
14073         VkCommandBuffer commandBuffer;
14074         VkImage DECLSPEC_ALIGN(8) image;
14075         VkImageLayout imageLayout;
14076         const VkClearDepthStencilValue *pDepthStencil;
14077         uint32_t rangeCount;
14078         const VkImageSubresourceRange *pRanges;
14079     } *params = args;
14080
14081     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);
14082
14083     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);
14084     return STATUS_SUCCESS;
14085 }
14086
14087 #endif /* USE_STRUCT_CONVERSION */
14088
14089 #if !defined(USE_STRUCT_CONVERSION)
14090
14091 static NTSTATUS thunk64_vkCmdCopyAccelerationStructureKHR(void *args)
14092 {
14093     struct vkCmdCopyAccelerationStructureKHR_params *params = args;
14094
14095     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
14096
14097     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
14098     return STATUS_SUCCESS;
14099 }
14100
14101 #else /* USE_STRUCT_CONVERSION */
14102
14103 static NTSTATUS thunk32_vkCmdCopyAccelerationStructureKHR(void *args)
14104 {
14105     struct
14106     {
14107         VkCommandBuffer commandBuffer;
14108         const VkCopyAccelerationStructureInfoKHR32 *pInfo;
14109     } *params = args;
14110     VkCopyAccelerationStructureInfoKHR pInfo_host;
14111
14112     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
14113
14114     convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
14115     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
14116     return STATUS_SUCCESS;
14117 }
14118
14119 #endif /* USE_STRUCT_CONVERSION */
14120
14121 #if !defined(USE_STRUCT_CONVERSION)
14122
14123 static NTSTATUS thunk64_vkCmdCopyAccelerationStructureNV(void *args)
14124 {
14125     struct vkCmdCopyAccelerationStructureNV_params *params = args;
14126
14127     TRACE("%p, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), params->mode);
14128
14129     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);
14130     return STATUS_SUCCESS;
14131 }
14132
14133 #else /* USE_STRUCT_CONVERSION */
14134
14135 static NTSTATUS thunk32_vkCmdCopyAccelerationStructureNV(void *args)
14136 {
14137     struct
14138     {
14139         VkCommandBuffer commandBuffer;
14140         VkAccelerationStructureNV DECLSPEC_ALIGN(8) dst;
14141         VkAccelerationStructureNV DECLSPEC_ALIGN(8) src;
14142         VkCopyAccelerationStructureModeKHR mode;
14143     } *params = args;
14144
14145     TRACE("%p, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), params->mode);
14146
14147     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);
14148     return STATUS_SUCCESS;
14149 }
14150
14151 #endif /* USE_STRUCT_CONVERSION */
14152
14153 #if !defined(USE_STRUCT_CONVERSION)
14154
14155 static NTSTATUS thunk64_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
14156 {
14157     struct vkCmdCopyAccelerationStructureToMemoryKHR_params *params = args;
14158
14159     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
14160
14161     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
14162     return STATUS_SUCCESS;
14163 }
14164
14165 #else /* USE_STRUCT_CONVERSION */
14166
14167 static NTSTATUS thunk32_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
14168 {
14169     struct
14170     {
14171         VkCommandBuffer commandBuffer;
14172         const VkCopyAccelerationStructureToMemoryInfoKHR32 *pInfo;
14173     } *params = args;
14174     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;
14175
14176     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
14177
14178     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
14179     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
14180     return STATUS_SUCCESS;
14181 }
14182
14183 #endif /* USE_STRUCT_CONVERSION */
14184
14185 #if !defined(USE_STRUCT_CONVERSION)
14186
14187 static NTSTATUS thunk64_vkCmdCopyBuffer(void *args)
14188 {
14189     struct vkCmdCopyBuffer_params *params = args;
14190
14191     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);
14192
14193     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);
14194     return STATUS_SUCCESS;
14195 }
14196
14197 #else /* USE_STRUCT_CONVERSION */
14198
14199 static NTSTATUS thunk32_vkCmdCopyBuffer(void *args)
14200 {
14201     struct
14202     {
14203         VkCommandBuffer commandBuffer;
14204         VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
14205         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
14206         uint32_t regionCount;
14207         const VkBufferCopy32 *pRegions;
14208     } *params = args;
14209     const VkBufferCopy *pRegions_host;
14210     struct conversion_context ctx;
14211
14212     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);
14213
14214     init_conversion_context(&ctx);
14215     pRegions_host = convert_VkBufferCopy_array_win32_to_host(&ctx, params->pRegions, params->regionCount);
14216     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcBuffer, params->dstBuffer, params->regionCount, pRegions_host);
14217     free_conversion_context(&ctx);
14218     return STATUS_SUCCESS;
14219 }
14220
14221 #endif /* USE_STRUCT_CONVERSION */
14222
14223 #if !defined(USE_STRUCT_CONVERSION)
14224
14225 static NTSTATUS thunk64_vkCmdCopyBuffer2(void *args)
14226 {
14227     struct vkCmdCopyBuffer2_params *params = args;
14228
14229     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferInfo);
14230
14231     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
14232     return STATUS_SUCCESS;
14233 }
14234
14235 #else /* USE_STRUCT_CONVERSION */
14236
14237 static NTSTATUS thunk32_vkCmdCopyBuffer2(void *args)
14238 {
14239     struct
14240     {
14241         VkCommandBuffer commandBuffer;
14242         const VkCopyBufferInfo232 *pCopyBufferInfo;
14243     } *params = args;
14244     VkCopyBufferInfo2 pCopyBufferInfo_host;
14245     struct conversion_context ctx;
14246
14247     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferInfo);
14248
14249     init_conversion_context(&ctx);
14250     convert_VkCopyBufferInfo2_win32_to_host(&ctx, params->pCopyBufferInfo, &pCopyBufferInfo_host);
14251     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyBufferInfo_host);
14252     free_conversion_context(&ctx);
14253     return STATUS_SUCCESS;
14254 }
14255
14256 #endif /* USE_STRUCT_CONVERSION */
14257
14258 #if !defined(USE_STRUCT_CONVERSION)
14259
14260 static NTSTATUS thunk64_vkCmdCopyBuffer2KHR(void *args)
14261 {
14262     struct vkCmdCopyBuffer2KHR_params *params = args;
14263
14264     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferInfo);
14265
14266     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
14267     return STATUS_SUCCESS;
14268 }
14269
14270 #else /* USE_STRUCT_CONVERSION */
14271
14272 static NTSTATUS thunk32_vkCmdCopyBuffer2KHR(void *args)
14273 {
14274     struct
14275     {
14276         VkCommandBuffer commandBuffer;
14277         const VkCopyBufferInfo232 *pCopyBufferInfo;
14278     } *params = args;
14279     VkCopyBufferInfo2 pCopyBufferInfo_host;
14280     struct conversion_context ctx;
14281
14282     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferInfo);
14283
14284     init_conversion_context(&ctx);
14285     convert_VkCopyBufferInfo2_win32_to_host(&ctx, params->pCopyBufferInfo, &pCopyBufferInfo_host);
14286     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyBufferInfo_host);
14287     free_conversion_context(&ctx);
14288     return STATUS_SUCCESS;
14289 }
14290
14291 #endif /* USE_STRUCT_CONVERSION */
14292
14293 #if !defined(USE_STRUCT_CONVERSION)
14294
14295 static NTSTATUS thunk64_vkCmdCopyBufferToImage(void *args)
14296 {
14297     struct vkCmdCopyBufferToImage_params *params = args;
14298
14299     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);
14300
14301     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);
14302     return STATUS_SUCCESS;
14303 }
14304
14305 #else /* USE_STRUCT_CONVERSION */
14306
14307 static NTSTATUS thunk32_vkCmdCopyBufferToImage(void *args)
14308 {
14309     struct
14310     {
14311         VkCommandBuffer commandBuffer;
14312         VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
14313         VkImage DECLSPEC_ALIGN(8) dstImage;
14314         VkImageLayout dstImageLayout;
14315         uint32_t regionCount;
14316         const VkBufferImageCopy32 *pRegions;
14317     } *params = args;
14318     const VkBufferImageCopy *pRegions_host;
14319     struct conversion_context ctx;
14320
14321     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);
14322
14323     init_conversion_context(&ctx);
14324     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, params->pRegions, params->regionCount);
14325     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcBuffer, params->dstImage, params->dstImageLayout, params->regionCount, pRegions_host);
14326     free_conversion_context(&ctx);
14327     return STATUS_SUCCESS;
14328 }
14329
14330 #endif /* USE_STRUCT_CONVERSION */
14331
14332 #if !defined(USE_STRUCT_CONVERSION)
14333
14334 static NTSTATUS thunk64_vkCmdCopyBufferToImage2(void *args)
14335 {
14336     struct vkCmdCopyBufferToImage2_params *params = args;
14337
14338     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferToImageInfo);
14339
14340     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
14341     return STATUS_SUCCESS;
14342 }
14343
14344 #else /* USE_STRUCT_CONVERSION */
14345
14346 static NTSTATUS thunk32_vkCmdCopyBufferToImage2(void *args)
14347 {
14348     struct
14349     {
14350         VkCommandBuffer commandBuffer;
14351         const VkCopyBufferToImageInfo232 *pCopyBufferToImageInfo;
14352     } *params = args;
14353     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
14354     struct conversion_context ctx;
14355
14356     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferToImageInfo);
14357
14358     init_conversion_context(&ctx);
14359     convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, params->pCopyBufferToImageInfo, &pCopyBufferToImageInfo_host);
14360     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyBufferToImageInfo_host);
14361     free_conversion_context(&ctx);
14362     return STATUS_SUCCESS;
14363 }
14364
14365 #endif /* USE_STRUCT_CONVERSION */
14366
14367 #if !defined(USE_STRUCT_CONVERSION)
14368
14369 static NTSTATUS thunk64_vkCmdCopyBufferToImage2KHR(void *args)
14370 {
14371     struct vkCmdCopyBufferToImage2KHR_params *params = args;
14372
14373     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferToImageInfo);
14374
14375     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
14376     return STATUS_SUCCESS;
14377 }
14378
14379 #else /* USE_STRUCT_CONVERSION */
14380
14381 static NTSTATUS thunk32_vkCmdCopyBufferToImage2KHR(void *args)
14382 {
14383     struct
14384     {
14385         VkCommandBuffer commandBuffer;
14386         const VkCopyBufferToImageInfo232 *pCopyBufferToImageInfo;
14387     } *params = args;
14388     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
14389     struct conversion_context ctx;
14390
14391     TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferToImageInfo);
14392
14393     init_conversion_context(&ctx);
14394     convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, params->pCopyBufferToImageInfo, &pCopyBufferToImageInfo_host);
14395     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyBufferToImageInfo_host);
14396     free_conversion_context(&ctx);
14397     return STATUS_SUCCESS;
14398 }
14399
14400 #endif /* USE_STRUCT_CONVERSION */
14401
14402 #if !defined(USE_STRUCT_CONVERSION)
14403
14404 static NTSTATUS thunk64_vkCmdCopyImage(void *args)
14405 {
14406     struct vkCmdCopyImage_params *params = args;
14407
14408     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);
14409
14410     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);
14411     return STATUS_SUCCESS;
14412 }
14413
14414 #else /* USE_STRUCT_CONVERSION */
14415
14416 static NTSTATUS thunk32_vkCmdCopyImage(void *args)
14417 {
14418     struct
14419     {
14420         VkCommandBuffer commandBuffer;
14421         VkImage DECLSPEC_ALIGN(8) srcImage;
14422         VkImageLayout srcImageLayout;
14423         VkImage DECLSPEC_ALIGN(8) dstImage;
14424         VkImageLayout dstImageLayout;
14425         uint32_t regionCount;
14426         const VkImageCopy *pRegions;
14427     } *params = args;
14428
14429     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);
14430
14431     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);
14432     return STATUS_SUCCESS;
14433 }
14434
14435 #endif /* USE_STRUCT_CONVERSION */
14436
14437 #if !defined(USE_STRUCT_CONVERSION)
14438
14439 static NTSTATUS thunk64_vkCmdCopyImage2(void *args)
14440 {
14441     struct vkCmdCopyImage2_params *params = args;
14442
14443     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageInfo);
14444
14445     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
14446     return STATUS_SUCCESS;
14447 }
14448
14449 #else /* USE_STRUCT_CONVERSION */
14450
14451 static NTSTATUS thunk32_vkCmdCopyImage2(void *args)
14452 {
14453     struct
14454     {
14455         VkCommandBuffer commandBuffer;
14456         const VkCopyImageInfo232 *pCopyImageInfo;
14457     } *params = args;
14458     VkCopyImageInfo2 pCopyImageInfo_host;
14459
14460     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageInfo);
14461
14462     convert_VkCopyImageInfo2_win32_to_host(params->pCopyImageInfo, &pCopyImageInfo_host);
14463     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyImageInfo_host);
14464     return STATUS_SUCCESS;
14465 }
14466
14467 #endif /* USE_STRUCT_CONVERSION */
14468
14469 #if !defined(USE_STRUCT_CONVERSION)
14470
14471 static NTSTATUS thunk64_vkCmdCopyImage2KHR(void *args)
14472 {
14473     struct vkCmdCopyImage2KHR_params *params = args;
14474
14475     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageInfo);
14476
14477     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
14478     return STATUS_SUCCESS;
14479 }
14480
14481 #else /* USE_STRUCT_CONVERSION */
14482
14483 static NTSTATUS thunk32_vkCmdCopyImage2KHR(void *args)
14484 {
14485     struct
14486     {
14487         VkCommandBuffer commandBuffer;
14488         const VkCopyImageInfo232 *pCopyImageInfo;
14489     } *params = args;
14490     VkCopyImageInfo2 pCopyImageInfo_host;
14491
14492     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageInfo);
14493
14494     convert_VkCopyImageInfo2_win32_to_host(params->pCopyImageInfo, &pCopyImageInfo_host);
14495     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyImageInfo_host);
14496     return STATUS_SUCCESS;
14497 }
14498
14499 #endif /* USE_STRUCT_CONVERSION */
14500
14501 #if !defined(USE_STRUCT_CONVERSION)
14502
14503 static NTSTATUS thunk64_vkCmdCopyImageToBuffer(void *args)
14504 {
14505     struct vkCmdCopyImageToBuffer_params *params = args;
14506
14507     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);
14508
14509     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);
14510     return STATUS_SUCCESS;
14511 }
14512
14513 #else /* USE_STRUCT_CONVERSION */
14514
14515 static NTSTATUS thunk32_vkCmdCopyImageToBuffer(void *args)
14516 {
14517     struct
14518     {
14519         VkCommandBuffer commandBuffer;
14520         VkImage DECLSPEC_ALIGN(8) srcImage;
14521         VkImageLayout srcImageLayout;
14522         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
14523         uint32_t regionCount;
14524         const VkBufferImageCopy32 *pRegions;
14525     } *params = args;
14526     const VkBufferImageCopy *pRegions_host;
14527     struct conversion_context ctx;
14528
14529     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);
14530
14531     init_conversion_context(&ctx);
14532     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, params->pRegions, params->regionCount);
14533     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstBuffer, params->regionCount, pRegions_host);
14534     free_conversion_context(&ctx);
14535     return STATUS_SUCCESS;
14536 }
14537
14538 #endif /* USE_STRUCT_CONVERSION */
14539
14540 #if !defined(USE_STRUCT_CONVERSION)
14541
14542 static NTSTATUS thunk64_vkCmdCopyImageToBuffer2(void *args)
14543 {
14544     struct vkCmdCopyImageToBuffer2_params *params = args;
14545
14546     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageToBufferInfo);
14547
14548     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
14549     return STATUS_SUCCESS;
14550 }
14551
14552 #else /* USE_STRUCT_CONVERSION */
14553
14554 static NTSTATUS thunk32_vkCmdCopyImageToBuffer2(void *args)
14555 {
14556     struct
14557     {
14558         VkCommandBuffer commandBuffer;
14559         const VkCopyImageToBufferInfo232 *pCopyImageToBufferInfo;
14560     } *params = args;
14561     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
14562     struct conversion_context ctx;
14563
14564     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageToBufferInfo);
14565
14566     init_conversion_context(&ctx);
14567     convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, params->pCopyImageToBufferInfo, &pCopyImageToBufferInfo_host);
14568     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyImageToBufferInfo_host);
14569     free_conversion_context(&ctx);
14570     return STATUS_SUCCESS;
14571 }
14572
14573 #endif /* USE_STRUCT_CONVERSION */
14574
14575 #if !defined(USE_STRUCT_CONVERSION)
14576
14577 static NTSTATUS thunk64_vkCmdCopyImageToBuffer2KHR(void *args)
14578 {
14579     struct vkCmdCopyImageToBuffer2KHR_params *params = args;
14580
14581     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageToBufferInfo);
14582
14583     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
14584     return STATUS_SUCCESS;
14585 }
14586
14587 #else /* USE_STRUCT_CONVERSION */
14588
14589 static NTSTATUS thunk32_vkCmdCopyImageToBuffer2KHR(void *args)
14590 {
14591     struct
14592     {
14593         VkCommandBuffer commandBuffer;
14594         const VkCopyImageToBufferInfo232 *pCopyImageToBufferInfo;
14595     } *params = args;
14596     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
14597     struct conversion_context ctx;
14598
14599     TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageToBufferInfo);
14600
14601     init_conversion_context(&ctx);
14602     convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, params->pCopyImageToBufferInfo, &pCopyImageToBufferInfo_host);
14603     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyImageToBufferInfo_host);
14604     free_conversion_context(&ctx);
14605     return STATUS_SUCCESS;
14606 }
14607
14608 #endif /* USE_STRUCT_CONVERSION */
14609
14610 #if !defined(USE_STRUCT_CONVERSION)
14611
14612 static NTSTATUS thunk64_vkCmdCopyMemoryIndirectNV(void *args)
14613 {
14614     struct vkCmdCopyMemoryIndirectNV_params *params = args;
14615
14616     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride);
14617
14618     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);
14619     return STATUS_SUCCESS;
14620 }
14621
14622 #else /* USE_STRUCT_CONVERSION */
14623
14624 static NTSTATUS thunk32_vkCmdCopyMemoryIndirectNV(void *args)
14625 {
14626     struct
14627     {
14628         VkCommandBuffer commandBuffer;
14629         VkDeviceAddress DECLSPEC_ALIGN(8) copyBufferAddress;
14630         uint32_t copyCount;
14631         uint32_t stride;
14632     } *params = args;
14633
14634     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride);
14635
14636     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);
14637     return STATUS_SUCCESS;
14638 }
14639
14640 #endif /* USE_STRUCT_CONVERSION */
14641
14642 #if !defined(USE_STRUCT_CONVERSION)
14643
14644 static NTSTATUS thunk64_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
14645 {
14646     struct vkCmdCopyMemoryToAccelerationStructureKHR_params *params = args;
14647
14648     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
14649
14650     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
14651     return STATUS_SUCCESS;
14652 }
14653
14654 #else /* USE_STRUCT_CONVERSION */
14655
14656 static NTSTATUS thunk32_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
14657 {
14658     struct
14659     {
14660         VkCommandBuffer commandBuffer;
14661         const VkCopyMemoryToAccelerationStructureInfoKHR32 *pInfo;
14662     } *params = args;
14663     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;
14664
14665     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
14666
14667     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
14668     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
14669     return STATUS_SUCCESS;
14670 }
14671
14672 #endif /* USE_STRUCT_CONVERSION */
14673
14674 #if !defined(USE_STRUCT_CONVERSION)
14675
14676 static NTSTATUS thunk64_vkCmdCopyMemoryToImageIndirectNV(void *args)
14677 {
14678     struct vkCmdCopyMemoryToImageIndirectNV_params *params = args;
14679
14680     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);
14681
14682     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);
14683     return STATUS_SUCCESS;
14684 }
14685
14686 #else /* USE_STRUCT_CONVERSION */
14687
14688 static NTSTATUS thunk32_vkCmdCopyMemoryToImageIndirectNV(void *args)
14689 {
14690     struct
14691     {
14692         VkCommandBuffer commandBuffer;
14693         VkDeviceAddress DECLSPEC_ALIGN(8) copyBufferAddress;
14694         uint32_t copyCount;
14695         uint32_t stride;
14696         VkImage DECLSPEC_ALIGN(8) dstImage;
14697         VkImageLayout dstImageLayout;
14698         const VkImageSubresourceLayers *pImageSubresources;
14699     } *params = args;
14700
14701     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);
14702
14703     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);
14704     return STATUS_SUCCESS;
14705 }
14706
14707 #endif /* USE_STRUCT_CONVERSION */
14708
14709 #if !defined(USE_STRUCT_CONVERSION)
14710
14711 static NTSTATUS thunk64_vkCmdCopyMemoryToMicromapEXT(void *args)
14712 {
14713     struct vkCmdCopyMemoryToMicromapEXT_params *params = args;
14714
14715     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
14716
14717     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
14718     return STATUS_SUCCESS;
14719 }
14720
14721 #else /* USE_STRUCT_CONVERSION */
14722
14723 static NTSTATUS thunk32_vkCmdCopyMemoryToMicromapEXT(void *args)
14724 {
14725     struct
14726     {
14727         VkCommandBuffer commandBuffer;
14728         const VkCopyMemoryToMicromapInfoEXT32 *pInfo;
14729     } *params = args;
14730     VkCopyMemoryToMicromapInfoEXT pInfo_host;
14731
14732     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
14733
14734     convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
14735     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
14736     return STATUS_SUCCESS;
14737 }
14738
14739 #endif /* USE_STRUCT_CONVERSION */
14740
14741 #if !defined(USE_STRUCT_CONVERSION)
14742
14743 static NTSTATUS thunk64_vkCmdCopyMicromapEXT(void *args)
14744 {
14745     struct vkCmdCopyMicromapEXT_params *params = args;
14746
14747     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
14748
14749     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
14750     return STATUS_SUCCESS;
14751 }
14752
14753 #else /* USE_STRUCT_CONVERSION */
14754
14755 static NTSTATUS thunk32_vkCmdCopyMicromapEXT(void *args)
14756 {
14757     struct
14758     {
14759         VkCommandBuffer commandBuffer;
14760         const VkCopyMicromapInfoEXT32 *pInfo;
14761     } *params = args;
14762     VkCopyMicromapInfoEXT pInfo_host;
14763
14764     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
14765
14766     convert_VkCopyMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
14767     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
14768     return STATUS_SUCCESS;
14769 }
14770
14771 #endif /* USE_STRUCT_CONVERSION */
14772
14773 #if !defined(USE_STRUCT_CONVERSION)
14774
14775 static NTSTATUS thunk64_vkCmdCopyMicromapToMemoryEXT(void *args)
14776 {
14777     struct vkCmdCopyMicromapToMemoryEXT_params *params = args;
14778
14779     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
14780
14781     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
14782     return STATUS_SUCCESS;
14783 }
14784
14785 #else /* USE_STRUCT_CONVERSION */
14786
14787 static NTSTATUS thunk32_vkCmdCopyMicromapToMemoryEXT(void *args)
14788 {
14789     struct
14790     {
14791         VkCommandBuffer commandBuffer;
14792         const VkCopyMicromapToMemoryInfoEXT32 *pInfo;
14793     } *params = args;
14794     VkCopyMicromapToMemoryInfoEXT pInfo_host;
14795
14796     TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
14797
14798     convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
14799     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
14800     return STATUS_SUCCESS;
14801 }
14802
14803 #endif /* USE_STRUCT_CONVERSION */
14804
14805 #if !defined(USE_STRUCT_CONVERSION)
14806
14807 static NTSTATUS thunk64_vkCmdCopyQueryPoolResults(void *args)
14808 {
14809     struct vkCmdCopyQueryPoolResults_params *params = args;
14810
14811     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);
14812
14813     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);
14814     return STATUS_SUCCESS;
14815 }
14816
14817 #else /* USE_STRUCT_CONVERSION */
14818
14819 static NTSTATUS thunk32_vkCmdCopyQueryPoolResults(void *args)
14820 {
14821     struct
14822     {
14823         VkCommandBuffer commandBuffer;
14824         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
14825         uint32_t firstQuery;
14826         uint32_t queryCount;
14827         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
14828         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
14829         VkDeviceSize DECLSPEC_ALIGN(8) stride;
14830         VkQueryResultFlags flags;
14831     } *params = args;
14832
14833     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);
14834
14835     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);
14836     return STATUS_SUCCESS;
14837 }
14838
14839 #endif /* USE_STRUCT_CONVERSION */
14840
14841 #if !defined(USE_STRUCT_CONVERSION)
14842
14843 static NTSTATUS thunk64_vkCmdCuLaunchKernelNVX(void *args)
14844 {
14845     struct vkCmdCuLaunchKernelNVX_params *params = args;
14846
14847     TRACE("%p, %p\n", params->commandBuffer, params->pLaunchInfo);
14848
14849     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLaunchInfo);
14850     return STATUS_SUCCESS;
14851 }
14852
14853 #else /* USE_STRUCT_CONVERSION */
14854
14855 static NTSTATUS thunk32_vkCmdCuLaunchKernelNVX(void *args)
14856 {
14857     struct
14858     {
14859         VkCommandBuffer commandBuffer;
14860         const VkCuLaunchInfoNVX32 *pLaunchInfo;
14861     } *params = args;
14862     VkCuLaunchInfoNVX pLaunchInfo_host;
14863
14864     TRACE("%p, %p\n", params->commandBuffer, params->pLaunchInfo);
14865
14866     convert_VkCuLaunchInfoNVX_win32_to_host(params->pLaunchInfo, &pLaunchInfo_host);
14867     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pLaunchInfo_host);
14868     return STATUS_SUCCESS;
14869 }
14870
14871 #endif /* USE_STRUCT_CONVERSION */
14872
14873 #if !defined(USE_STRUCT_CONVERSION)
14874
14875 static NTSTATUS thunk64_vkCmdDebugMarkerBeginEXT(void *args)
14876 {
14877     struct vkCmdDebugMarkerBeginEXT_params *params = args;
14878
14879     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
14880
14881     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerBeginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
14882     return STATUS_SUCCESS;
14883 }
14884
14885 #else /* USE_STRUCT_CONVERSION */
14886
14887 static NTSTATUS thunk32_vkCmdDebugMarkerBeginEXT(void *args)
14888 {
14889     struct
14890     {
14891         VkCommandBuffer commandBuffer;
14892         const VkDebugMarkerMarkerInfoEXT *pMarkerInfo;
14893     } *params = args;
14894
14895     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
14896
14897     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerBeginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
14898     return STATUS_SUCCESS;
14899 }
14900
14901 #endif /* USE_STRUCT_CONVERSION */
14902
14903 #if !defined(USE_STRUCT_CONVERSION)
14904
14905 static NTSTATUS thunk64_vkCmdDebugMarkerEndEXT(void *args)
14906 {
14907     struct vkCmdDebugMarkerEndEXT_params *params = args;
14908
14909     TRACE("%p\n", params->commandBuffer);
14910
14911     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
14912     return STATUS_SUCCESS;
14913 }
14914
14915 #else /* USE_STRUCT_CONVERSION */
14916
14917 static NTSTATUS thunk32_vkCmdDebugMarkerEndEXT(void *args)
14918 {
14919     struct
14920     {
14921         VkCommandBuffer commandBuffer;
14922     } *params = args;
14923
14924     TRACE("%p\n", params->commandBuffer);
14925
14926     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
14927     return STATUS_SUCCESS;
14928 }
14929
14930 #endif /* USE_STRUCT_CONVERSION */
14931
14932 #if !defined(USE_STRUCT_CONVERSION)
14933
14934 static NTSTATUS thunk64_vkCmdDebugMarkerInsertEXT(void *args)
14935 {
14936     struct vkCmdDebugMarkerInsertEXT_params *params = args;
14937
14938     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
14939
14940     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerInsertEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
14941     return STATUS_SUCCESS;
14942 }
14943
14944 #else /* USE_STRUCT_CONVERSION */
14945
14946 static NTSTATUS thunk32_vkCmdDebugMarkerInsertEXT(void *args)
14947 {
14948     struct
14949     {
14950         VkCommandBuffer commandBuffer;
14951         const VkDebugMarkerMarkerInfoEXT *pMarkerInfo;
14952     } *params = args;
14953
14954     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
14955
14956     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerInsertEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
14957     return STATUS_SUCCESS;
14958 }
14959
14960 #endif /* USE_STRUCT_CONVERSION */
14961
14962 #if !defined(USE_STRUCT_CONVERSION)
14963
14964 static NTSTATUS thunk64_vkCmdDecompressMemoryIndirectCountNV(void *args)
14965 {
14966     struct vkCmdDecompressMemoryIndirectCountNV_params *params = args;
14967
14968     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectCommandsAddress), wine_dbgstr_longlong(params->indirectCommandsCountAddress), params->stride);
14969
14970     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);
14971     return STATUS_SUCCESS;
14972 }
14973
14974 #else /* USE_STRUCT_CONVERSION */
14975
14976 static NTSTATUS thunk32_vkCmdDecompressMemoryIndirectCountNV(void *args)
14977 {
14978     struct
14979     {
14980         VkCommandBuffer commandBuffer;
14981         VkDeviceAddress DECLSPEC_ALIGN(8) indirectCommandsAddress;
14982         VkDeviceAddress DECLSPEC_ALIGN(8) indirectCommandsCountAddress;
14983         uint32_t stride;
14984     } *params = args;
14985
14986     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectCommandsAddress), wine_dbgstr_longlong(params->indirectCommandsCountAddress), params->stride);
14987
14988     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);
14989     return STATUS_SUCCESS;
14990 }
14991
14992 #endif /* USE_STRUCT_CONVERSION */
14993
14994 #if !defined(USE_STRUCT_CONVERSION)
14995
14996 static NTSTATUS thunk64_vkCmdDecompressMemoryNV(void *args)
14997 {
14998     struct vkCmdDecompressMemoryNV_params *params = args;
14999
15000     TRACE("%p, %u, %p\n", params->commandBuffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
15001
15002     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
15003     return STATUS_SUCCESS;
15004 }
15005
15006 #else /* USE_STRUCT_CONVERSION */
15007
15008 static NTSTATUS thunk32_vkCmdDecompressMemoryNV(void *args)
15009 {
15010     struct
15011     {
15012         VkCommandBuffer commandBuffer;
15013         uint32_t decompressRegionCount;
15014         const VkDecompressMemoryRegionNV32 *pDecompressMemoryRegions;
15015     } *params = args;
15016     const VkDecompressMemoryRegionNV *pDecompressMemoryRegions_host;
15017     struct conversion_context ctx;
15018
15019     TRACE("%p, %u, %p\n", params->commandBuffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
15020
15021     init_conversion_context(&ctx);
15022     pDecompressMemoryRegions_host = convert_VkDecompressMemoryRegionNV_array_win32_to_host(&ctx, params->pDecompressMemoryRegions, params->decompressRegionCount);
15023     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->decompressRegionCount, pDecompressMemoryRegions_host);
15024     free_conversion_context(&ctx);
15025     return STATUS_SUCCESS;
15026 }
15027
15028 #endif /* USE_STRUCT_CONVERSION */
15029
15030 #if !defined(USE_STRUCT_CONVERSION)
15031
15032 static NTSTATUS thunk64_vkCmdDispatch(void *args)
15033 {
15034     struct vkCmdDispatch_params *params = args;
15035
15036     TRACE("%p, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
15037
15038     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);
15039     return STATUS_SUCCESS;
15040 }
15041
15042 #else /* USE_STRUCT_CONVERSION */
15043
15044 static NTSTATUS thunk32_vkCmdDispatch(void *args)
15045 {
15046     struct
15047     {
15048         VkCommandBuffer commandBuffer;
15049         uint32_t groupCountX;
15050         uint32_t groupCountY;
15051         uint32_t groupCountZ;
15052     } *params = args;
15053
15054     TRACE("%p, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
15055
15056     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);
15057     return STATUS_SUCCESS;
15058 }
15059
15060 #endif /* USE_STRUCT_CONVERSION */
15061
15062 #if !defined(USE_STRUCT_CONVERSION)
15063
15064 static NTSTATUS thunk64_vkCmdDispatchBase(void *args)
15065 {
15066     struct vkCmdDispatchBase_params *params = args;
15067
15068     TRACE("%p, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
15069
15070     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);
15071     return STATUS_SUCCESS;
15072 }
15073
15074 #else /* USE_STRUCT_CONVERSION */
15075
15076 static NTSTATUS thunk32_vkCmdDispatchBase(void *args)
15077 {
15078     struct
15079     {
15080         VkCommandBuffer commandBuffer;
15081         uint32_t baseGroupX;
15082         uint32_t baseGroupY;
15083         uint32_t baseGroupZ;
15084         uint32_t groupCountX;
15085         uint32_t groupCountY;
15086         uint32_t groupCountZ;
15087     } *params = args;
15088
15089     TRACE("%p, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
15090
15091     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);
15092     return STATUS_SUCCESS;
15093 }
15094
15095 #endif /* USE_STRUCT_CONVERSION */
15096
15097 #if !defined(USE_STRUCT_CONVERSION)
15098
15099 static NTSTATUS thunk64_vkCmdDispatchBaseKHR(void *args)
15100 {
15101     struct vkCmdDispatchBaseKHR_params *params = args;
15102
15103     TRACE("%p, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
15104
15105     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);
15106     return STATUS_SUCCESS;
15107 }
15108
15109 #else /* USE_STRUCT_CONVERSION */
15110
15111 static NTSTATUS thunk32_vkCmdDispatchBaseKHR(void *args)
15112 {
15113     struct
15114     {
15115         VkCommandBuffer commandBuffer;
15116         uint32_t baseGroupX;
15117         uint32_t baseGroupY;
15118         uint32_t baseGroupZ;
15119         uint32_t groupCountX;
15120         uint32_t groupCountY;
15121         uint32_t groupCountZ;
15122     } *params = args;
15123
15124     TRACE("%p, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
15125
15126     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);
15127     return STATUS_SUCCESS;
15128 }
15129
15130 #endif /* USE_STRUCT_CONVERSION */
15131
15132 #if !defined(USE_STRUCT_CONVERSION)
15133
15134 static NTSTATUS thunk64_vkCmdDispatchIndirect(void *args)
15135 {
15136     struct vkCmdDispatchIndirect_params *params = args;
15137
15138     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset));
15139
15140     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset);
15141     return STATUS_SUCCESS;
15142 }
15143
15144 #else /* USE_STRUCT_CONVERSION */
15145
15146 static NTSTATUS thunk32_vkCmdDispatchIndirect(void *args)
15147 {
15148     struct
15149     {
15150         VkCommandBuffer commandBuffer;
15151         VkBuffer DECLSPEC_ALIGN(8) buffer;
15152         VkDeviceSize DECLSPEC_ALIGN(8) offset;
15153     } *params = args;
15154
15155     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset));
15156
15157     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset);
15158     return STATUS_SUCCESS;
15159 }
15160
15161 #endif /* USE_STRUCT_CONVERSION */
15162
15163 #if !defined(USE_STRUCT_CONVERSION)
15164
15165 static NTSTATUS thunk64_vkCmdDraw(void *args)
15166 {
15167     struct vkCmdDraw_params *params = args;
15168
15169     TRACE("%p, %u, %u, %u, %u\n", params->commandBuffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
15170
15171     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);
15172     return STATUS_SUCCESS;
15173 }
15174
15175 #else /* USE_STRUCT_CONVERSION */
15176
15177 static NTSTATUS thunk32_vkCmdDraw(void *args)
15178 {
15179     struct
15180     {
15181         VkCommandBuffer commandBuffer;
15182         uint32_t vertexCount;
15183         uint32_t instanceCount;
15184         uint32_t firstVertex;
15185         uint32_t firstInstance;
15186     } *params = args;
15187
15188     TRACE("%p, %u, %u, %u, %u\n", params->commandBuffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
15189
15190     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);
15191     return STATUS_SUCCESS;
15192 }
15193
15194 #endif /* USE_STRUCT_CONVERSION */
15195
15196 #if !defined(USE_STRUCT_CONVERSION)
15197
15198 static NTSTATUS thunk64_vkCmdDrawIndexed(void *args)
15199 {
15200     struct vkCmdDrawIndexed_params *params = args;
15201
15202     TRACE("%p, %u, %u, %u, %d, %u\n", params->commandBuffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
15203
15204     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);
15205     return STATUS_SUCCESS;
15206 }
15207
15208 #else /* USE_STRUCT_CONVERSION */
15209
15210 static NTSTATUS thunk32_vkCmdDrawIndexed(void *args)
15211 {
15212     struct
15213     {
15214         VkCommandBuffer commandBuffer;
15215         uint32_t indexCount;
15216         uint32_t instanceCount;
15217         uint32_t firstIndex;
15218         int32_t vertexOffset;
15219         uint32_t firstInstance;
15220     } *params = args;
15221
15222     TRACE("%p, %u, %u, %u, %d, %u\n", params->commandBuffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
15223
15224     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);
15225     return STATUS_SUCCESS;
15226 }
15227
15228 #endif /* USE_STRUCT_CONVERSION */
15229
15230 #if !defined(USE_STRUCT_CONVERSION)
15231
15232 static NTSTATUS thunk64_vkCmdDrawIndexedIndirect(void *args)
15233 {
15234     struct vkCmdDrawIndexedIndirect_params *params = args;
15235
15236     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);
15237
15238     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);
15239     return STATUS_SUCCESS;
15240 }
15241
15242 #else /* USE_STRUCT_CONVERSION */
15243
15244 static NTSTATUS thunk32_vkCmdDrawIndexedIndirect(void *args)
15245 {
15246     struct
15247     {
15248         VkCommandBuffer commandBuffer;
15249         VkBuffer DECLSPEC_ALIGN(8) buffer;
15250         VkDeviceSize DECLSPEC_ALIGN(8) offset;
15251         uint32_t drawCount;
15252         uint32_t stride;
15253     } *params = args;
15254
15255     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);
15256
15257     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);
15258     return STATUS_SUCCESS;
15259 }
15260
15261 #endif /* USE_STRUCT_CONVERSION */
15262
15263 #if !defined(USE_STRUCT_CONVERSION)
15264
15265 static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCount(void *args)
15266 {
15267     struct vkCmdDrawIndexedIndirectCount_params *params = args;
15268
15269     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);
15270
15271     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);
15272     return STATUS_SUCCESS;
15273 }
15274
15275 #else /* USE_STRUCT_CONVERSION */
15276
15277 static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCount(void *args)
15278 {
15279     struct
15280     {
15281         VkCommandBuffer commandBuffer;
15282         VkBuffer DECLSPEC_ALIGN(8) buffer;
15283         VkDeviceSize DECLSPEC_ALIGN(8) offset;
15284         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
15285         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
15286         uint32_t maxDrawCount;
15287         uint32_t stride;
15288     } *params = args;
15289
15290     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);
15291
15292     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);
15293     return STATUS_SUCCESS;
15294 }
15295
15296 #endif /* USE_STRUCT_CONVERSION */
15297
15298 #if !defined(USE_STRUCT_CONVERSION)
15299
15300 static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCountAMD(void *args)
15301 {
15302     struct vkCmdDrawIndexedIndirectCountAMD_params *params = args;
15303
15304     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);
15305
15306     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);
15307     return STATUS_SUCCESS;
15308 }
15309
15310 #else /* USE_STRUCT_CONVERSION */
15311
15312 static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountAMD(void *args)
15313 {
15314     struct
15315     {
15316         VkCommandBuffer commandBuffer;
15317         VkBuffer DECLSPEC_ALIGN(8) buffer;
15318         VkDeviceSize DECLSPEC_ALIGN(8) offset;
15319         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
15320         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
15321         uint32_t maxDrawCount;
15322         uint32_t stride;
15323     } *params = args;
15324
15325     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);
15326
15327     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);
15328     return STATUS_SUCCESS;
15329 }
15330
15331 #endif /* USE_STRUCT_CONVERSION */
15332
15333 #if !defined(USE_STRUCT_CONVERSION)
15334
15335 static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCountKHR(void *args)
15336 {
15337     struct vkCmdDrawIndexedIndirectCountKHR_params *params = args;
15338
15339     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);
15340
15341     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);
15342     return STATUS_SUCCESS;
15343 }
15344
15345 #else /* USE_STRUCT_CONVERSION */
15346
15347 static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountKHR(void *args)
15348 {
15349     struct
15350     {
15351         VkCommandBuffer commandBuffer;
15352         VkBuffer DECLSPEC_ALIGN(8) buffer;
15353         VkDeviceSize DECLSPEC_ALIGN(8) offset;
15354         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
15355         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
15356         uint32_t maxDrawCount;
15357         uint32_t stride;
15358     } *params = args;
15359
15360     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);
15361
15362     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);
15363     return STATUS_SUCCESS;
15364 }
15365
15366 #endif /* USE_STRUCT_CONVERSION */
15367
15368 #if !defined(USE_STRUCT_CONVERSION)
15369
15370 static NTSTATUS thunk64_vkCmdDrawIndirect(void *args)
15371 {
15372     struct vkCmdDrawIndirect_params *params = args;
15373
15374     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);
15375
15376     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);
15377     return STATUS_SUCCESS;
15378 }
15379
15380 #else /* USE_STRUCT_CONVERSION */
15381
15382 static NTSTATUS thunk32_vkCmdDrawIndirect(void *args)
15383 {
15384     struct
15385     {
15386         VkCommandBuffer commandBuffer;
15387         VkBuffer DECLSPEC_ALIGN(8) buffer;
15388         VkDeviceSize DECLSPEC_ALIGN(8) offset;
15389         uint32_t drawCount;
15390         uint32_t stride;
15391     } *params = args;
15392
15393     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);
15394
15395     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);
15396     return STATUS_SUCCESS;
15397 }
15398
15399 #endif /* USE_STRUCT_CONVERSION */
15400
15401 #if !defined(USE_STRUCT_CONVERSION)
15402
15403 static NTSTATUS thunk64_vkCmdDrawIndirectByteCountEXT(void *args)
15404 {
15405     struct vkCmdDrawIndirectByteCountEXT_params *params = args;
15406
15407     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);
15408
15409     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);
15410     return STATUS_SUCCESS;
15411 }
15412
15413 #else /* USE_STRUCT_CONVERSION */
15414
15415 static NTSTATUS thunk32_vkCmdDrawIndirectByteCountEXT(void *args)
15416 {
15417     struct
15418     {
15419         VkCommandBuffer commandBuffer;
15420         uint32_t instanceCount;
15421         uint32_t firstInstance;
15422         VkBuffer DECLSPEC_ALIGN(8) counterBuffer;
15423         VkDeviceSize DECLSPEC_ALIGN(8) counterBufferOffset;
15424         uint32_t counterOffset;
15425         uint32_t vertexStride;
15426     } *params = args;
15427
15428     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);
15429
15430     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);
15431     return STATUS_SUCCESS;
15432 }
15433
15434 #endif /* USE_STRUCT_CONVERSION */
15435
15436 #if !defined(USE_STRUCT_CONVERSION)
15437
15438 static NTSTATUS thunk64_vkCmdDrawIndirectCount(void *args)
15439 {
15440     struct vkCmdDrawIndirectCount_params *params = args;
15441
15442     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);
15443
15444     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);
15445     return STATUS_SUCCESS;
15446 }
15447
15448 #else /* USE_STRUCT_CONVERSION */
15449
15450 static NTSTATUS thunk32_vkCmdDrawIndirectCount(void *args)
15451 {
15452     struct
15453     {
15454         VkCommandBuffer commandBuffer;
15455         VkBuffer DECLSPEC_ALIGN(8) buffer;
15456         VkDeviceSize DECLSPEC_ALIGN(8) offset;
15457         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
15458         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
15459         uint32_t maxDrawCount;
15460         uint32_t stride;
15461     } *params = args;
15462
15463     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);
15464
15465     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);
15466     return STATUS_SUCCESS;
15467 }
15468
15469 #endif /* USE_STRUCT_CONVERSION */
15470
15471 #if !defined(USE_STRUCT_CONVERSION)
15472
15473 static NTSTATUS thunk64_vkCmdDrawIndirectCountAMD(void *args)
15474 {
15475     struct vkCmdDrawIndirectCountAMD_params *params = args;
15476
15477     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);
15478
15479     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);
15480     return STATUS_SUCCESS;
15481 }
15482
15483 #else /* USE_STRUCT_CONVERSION */
15484
15485 static NTSTATUS thunk32_vkCmdDrawIndirectCountAMD(void *args)
15486 {
15487     struct
15488     {
15489         VkCommandBuffer commandBuffer;
15490         VkBuffer DECLSPEC_ALIGN(8) buffer;
15491         VkDeviceSize DECLSPEC_ALIGN(8) offset;
15492         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
15493         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
15494         uint32_t maxDrawCount;
15495         uint32_t stride;
15496     } *params = args;
15497
15498     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);
15499
15500     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);
15501     return STATUS_SUCCESS;
15502 }
15503
15504 #endif /* USE_STRUCT_CONVERSION */
15505
15506 #if !defined(USE_STRUCT_CONVERSION)
15507
15508 static NTSTATUS thunk64_vkCmdDrawIndirectCountKHR(void *args)
15509 {
15510     struct vkCmdDrawIndirectCountKHR_params *params = args;
15511
15512     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);
15513
15514     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);
15515     return STATUS_SUCCESS;
15516 }
15517
15518 #else /* USE_STRUCT_CONVERSION */
15519
15520 static NTSTATUS thunk32_vkCmdDrawIndirectCountKHR(void *args)
15521 {
15522     struct
15523     {
15524         VkCommandBuffer commandBuffer;
15525         VkBuffer DECLSPEC_ALIGN(8) buffer;
15526         VkDeviceSize DECLSPEC_ALIGN(8) offset;
15527         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
15528         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
15529         uint32_t maxDrawCount;
15530         uint32_t stride;
15531     } *params = args;
15532
15533     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);
15534
15535     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);
15536     return STATUS_SUCCESS;
15537 }
15538
15539 #endif /* USE_STRUCT_CONVERSION */
15540
15541 #if !defined(USE_STRUCT_CONVERSION)
15542
15543 static NTSTATUS thunk64_vkCmdDrawMeshTasksEXT(void *args)
15544 {
15545     struct vkCmdDrawMeshTasksEXT_params *params = args;
15546
15547     TRACE("%p, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
15548
15549     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);
15550     return STATUS_SUCCESS;
15551 }
15552
15553 #else /* USE_STRUCT_CONVERSION */
15554
15555 static NTSTATUS thunk32_vkCmdDrawMeshTasksEXT(void *args)
15556 {
15557     struct
15558     {
15559         VkCommandBuffer commandBuffer;
15560         uint32_t groupCountX;
15561         uint32_t groupCountY;
15562         uint32_t groupCountZ;
15563     } *params = args;
15564
15565     TRACE("%p, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
15566
15567     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);
15568     return STATUS_SUCCESS;
15569 }
15570
15571 #endif /* USE_STRUCT_CONVERSION */
15572
15573 #if !defined(USE_STRUCT_CONVERSION)
15574
15575 static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
15576 {
15577     struct vkCmdDrawMeshTasksIndirectCountEXT_params *params = args;
15578
15579     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);
15580
15581     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);
15582     return STATUS_SUCCESS;
15583 }
15584
15585 #else /* USE_STRUCT_CONVERSION */
15586
15587 static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
15588 {
15589     struct
15590     {
15591         VkCommandBuffer commandBuffer;
15592         VkBuffer DECLSPEC_ALIGN(8) buffer;
15593         VkDeviceSize DECLSPEC_ALIGN(8) offset;
15594         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
15595         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
15596         uint32_t maxDrawCount;
15597         uint32_t stride;
15598     } *params = args;
15599
15600     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);
15601
15602     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);
15603     return STATUS_SUCCESS;
15604 }
15605
15606 #endif /* USE_STRUCT_CONVERSION */
15607
15608 #if !defined(USE_STRUCT_CONVERSION)
15609
15610 static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectCountNV(void *args)
15611 {
15612     struct vkCmdDrawMeshTasksIndirectCountNV_params *params = args;
15613
15614     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);
15615
15616     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);
15617     return STATUS_SUCCESS;
15618 }
15619
15620 #else /* USE_STRUCT_CONVERSION */
15621
15622 static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountNV(void *args)
15623 {
15624     struct
15625     {
15626         VkCommandBuffer commandBuffer;
15627         VkBuffer DECLSPEC_ALIGN(8) buffer;
15628         VkDeviceSize DECLSPEC_ALIGN(8) offset;
15629         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
15630         VkDeviceSize DECLSPEC_ALIGN(8) countBufferOffset;
15631         uint32_t maxDrawCount;
15632         uint32_t stride;
15633     } *params = args;
15634
15635     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);
15636
15637     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);
15638     return STATUS_SUCCESS;
15639 }
15640
15641 #endif /* USE_STRUCT_CONVERSION */
15642
15643 #if !defined(USE_STRUCT_CONVERSION)
15644
15645 static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectEXT(void *args)
15646 {
15647     struct vkCmdDrawMeshTasksIndirectEXT_params *params = args;
15648
15649     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);
15650
15651     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);
15652     return STATUS_SUCCESS;
15653 }
15654
15655 #else /* USE_STRUCT_CONVERSION */
15656
15657 static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectEXT(void *args)
15658 {
15659     struct
15660     {
15661         VkCommandBuffer commandBuffer;
15662         VkBuffer DECLSPEC_ALIGN(8) buffer;
15663         VkDeviceSize DECLSPEC_ALIGN(8) offset;
15664         uint32_t drawCount;
15665         uint32_t stride;
15666     } *params = args;
15667
15668     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);
15669
15670     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);
15671     return STATUS_SUCCESS;
15672 }
15673
15674 #endif /* USE_STRUCT_CONVERSION */
15675
15676 #if !defined(USE_STRUCT_CONVERSION)
15677
15678 static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectNV(void *args)
15679 {
15680     struct vkCmdDrawMeshTasksIndirectNV_params *params = args;
15681
15682     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);
15683
15684     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);
15685     return STATUS_SUCCESS;
15686 }
15687
15688 #else /* USE_STRUCT_CONVERSION */
15689
15690 static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectNV(void *args)
15691 {
15692     struct
15693     {
15694         VkCommandBuffer commandBuffer;
15695         VkBuffer DECLSPEC_ALIGN(8) buffer;
15696         VkDeviceSize DECLSPEC_ALIGN(8) offset;
15697         uint32_t drawCount;
15698         uint32_t stride;
15699     } *params = args;
15700
15701     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);
15702
15703     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);
15704     return STATUS_SUCCESS;
15705 }
15706
15707 #endif /* USE_STRUCT_CONVERSION */
15708
15709 #if !defined(USE_STRUCT_CONVERSION)
15710
15711 static NTSTATUS thunk64_vkCmdDrawMeshTasksNV(void *args)
15712 {
15713     struct vkCmdDrawMeshTasksNV_params *params = args;
15714
15715     TRACE("%p, %u, %u\n", params->commandBuffer, params->taskCount, params->firstTask);
15716
15717     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->taskCount, params->firstTask);
15718     return STATUS_SUCCESS;
15719 }
15720
15721 #else /* USE_STRUCT_CONVERSION */
15722
15723 static NTSTATUS thunk32_vkCmdDrawMeshTasksNV(void *args)
15724 {
15725     struct
15726     {
15727         VkCommandBuffer commandBuffer;
15728         uint32_t taskCount;
15729         uint32_t firstTask;
15730     } *params = args;
15731
15732     TRACE("%p, %u, %u\n", params->commandBuffer, params->taskCount, params->firstTask);
15733
15734     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->taskCount, params->firstTask);
15735     return STATUS_SUCCESS;
15736 }
15737
15738 #endif /* USE_STRUCT_CONVERSION */
15739
15740 #if !defined(USE_STRUCT_CONVERSION)
15741
15742 static NTSTATUS thunk64_vkCmdDrawMultiEXT(void *args)
15743 {
15744     struct vkCmdDrawMultiEXT_params *params = args;
15745
15746     TRACE("%p, %u, %p, %u, %u, %u\n", params->commandBuffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);
15747
15748     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);
15749     return STATUS_SUCCESS;
15750 }
15751
15752 #else /* USE_STRUCT_CONVERSION */
15753
15754 static NTSTATUS thunk32_vkCmdDrawMultiEXT(void *args)
15755 {
15756     struct
15757     {
15758         VkCommandBuffer commandBuffer;
15759         uint32_t drawCount;
15760         const VkMultiDrawInfoEXT *pVertexInfo;
15761         uint32_t instanceCount;
15762         uint32_t firstInstance;
15763         uint32_t stride;
15764     } *params = args;
15765
15766     TRACE("%p, %u, %p, %u, %u, %u\n", params->commandBuffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);
15767
15768     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);
15769     return STATUS_SUCCESS;
15770 }
15771
15772 #endif /* USE_STRUCT_CONVERSION */
15773
15774 #if !defined(USE_STRUCT_CONVERSION)
15775
15776 static NTSTATUS thunk64_vkCmdDrawMultiIndexedEXT(void *args)
15777 {
15778     struct vkCmdDrawMultiIndexedEXT_params *params = args;
15779
15780     TRACE("%p, %u, %p, %u, %u, %u, %p\n", params->commandBuffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);
15781
15782     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);
15783     return STATUS_SUCCESS;
15784 }
15785
15786 #else /* USE_STRUCT_CONVERSION */
15787
15788 static NTSTATUS thunk32_vkCmdDrawMultiIndexedEXT(void *args)
15789 {
15790     struct
15791     {
15792         VkCommandBuffer commandBuffer;
15793         uint32_t drawCount;
15794         const VkMultiDrawIndexedInfoEXT *pIndexInfo;
15795         uint32_t instanceCount;
15796         uint32_t firstInstance;
15797         uint32_t stride;
15798         const int32_t *pVertexOffset;
15799     } *params = args;
15800
15801     TRACE("%p, %u, %p, %u, %u, %u, %p\n", params->commandBuffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);
15802
15803     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);
15804     return STATUS_SUCCESS;
15805 }
15806
15807 #endif /* USE_STRUCT_CONVERSION */
15808
15809 #if !defined(USE_STRUCT_CONVERSION)
15810
15811 static NTSTATUS thunk64_vkCmdEndConditionalRenderingEXT(void *args)
15812 {
15813     struct vkCmdEndConditionalRenderingEXT_params *params = args;
15814
15815     TRACE("%p\n", params->commandBuffer);
15816
15817     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
15818     return STATUS_SUCCESS;
15819 }
15820
15821 #else /* USE_STRUCT_CONVERSION */
15822
15823 static NTSTATUS thunk32_vkCmdEndConditionalRenderingEXT(void *args)
15824 {
15825     struct
15826     {
15827         VkCommandBuffer commandBuffer;
15828     } *params = args;
15829
15830     TRACE("%p\n", params->commandBuffer);
15831
15832     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
15833     return STATUS_SUCCESS;
15834 }
15835
15836 #endif /* USE_STRUCT_CONVERSION */
15837
15838 #if !defined(USE_STRUCT_CONVERSION)
15839
15840 static NTSTATUS thunk64_vkCmdEndDebugUtilsLabelEXT(void *args)
15841 {
15842     struct vkCmdEndDebugUtilsLabelEXT_params *params = args;
15843
15844     TRACE("%p\n", params->commandBuffer);
15845
15846     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
15847     return STATUS_SUCCESS;
15848 }
15849
15850 #else /* USE_STRUCT_CONVERSION */
15851
15852 static NTSTATUS thunk32_vkCmdEndDebugUtilsLabelEXT(void *args)
15853 {
15854     struct
15855     {
15856         VkCommandBuffer commandBuffer;
15857     } *params = args;
15858
15859     TRACE("%p\n", params->commandBuffer);
15860
15861     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
15862     return STATUS_SUCCESS;
15863 }
15864
15865 #endif /* USE_STRUCT_CONVERSION */
15866
15867 #if !defined(USE_STRUCT_CONVERSION)
15868
15869 static NTSTATUS thunk64_vkCmdEndQuery(void *args)
15870 {
15871     struct vkCmdEndQuery_params *params = args;
15872
15873     TRACE("%p, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query);
15874
15875     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query);
15876     return STATUS_SUCCESS;
15877 }
15878
15879 #else /* USE_STRUCT_CONVERSION */
15880
15881 static NTSTATUS thunk32_vkCmdEndQuery(void *args)
15882 {
15883     struct
15884     {
15885         VkCommandBuffer commandBuffer;
15886         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
15887         uint32_t query;
15888     } *params = args;
15889
15890     TRACE("%p, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query);
15891
15892     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query);
15893     return STATUS_SUCCESS;
15894 }
15895
15896 #endif /* USE_STRUCT_CONVERSION */
15897
15898 #if !defined(USE_STRUCT_CONVERSION)
15899
15900 static NTSTATUS thunk64_vkCmdEndQueryIndexedEXT(void *args)
15901 {
15902     struct vkCmdEndQueryIndexedEXT_params *params = args;
15903
15904     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->index);
15905
15906     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);
15907     return STATUS_SUCCESS;
15908 }
15909
15910 #else /* USE_STRUCT_CONVERSION */
15911
15912 static NTSTATUS thunk32_vkCmdEndQueryIndexedEXT(void *args)
15913 {
15914     struct
15915     {
15916         VkCommandBuffer commandBuffer;
15917         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
15918         uint32_t query;
15919         uint32_t index;
15920     } *params = args;
15921
15922     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->index);
15923
15924     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);
15925     return STATUS_SUCCESS;
15926 }
15927
15928 #endif /* USE_STRUCT_CONVERSION */
15929
15930 #if !defined(USE_STRUCT_CONVERSION)
15931
15932 static NTSTATUS thunk64_vkCmdEndRenderPass(void *args)
15933 {
15934     struct vkCmdEndRenderPass_params *params = args;
15935
15936     TRACE("%p\n", params->commandBuffer);
15937
15938     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
15939     return STATUS_SUCCESS;
15940 }
15941
15942 #else /* USE_STRUCT_CONVERSION */
15943
15944 static NTSTATUS thunk32_vkCmdEndRenderPass(void *args)
15945 {
15946     struct
15947     {
15948         VkCommandBuffer commandBuffer;
15949     } *params = args;
15950
15951     TRACE("%p\n", params->commandBuffer);
15952
15953     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
15954     return STATUS_SUCCESS;
15955 }
15956
15957 #endif /* USE_STRUCT_CONVERSION */
15958
15959 #if !defined(USE_STRUCT_CONVERSION)
15960
15961 static NTSTATUS thunk64_vkCmdEndRenderPass2(void *args)
15962 {
15963     struct vkCmdEndRenderPass2_params *params = args;
15964
15965     TRACE("%p, %p\n", params->commandBuffer, params->pSubpassEndInfo);
15966
15967     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
15968     return STATUS_SUCCESS;
15969 }
15970
15971 #else /* USE_STRUCT_CONVERSION */
15972
15973 static NTSTATUS thunk32_vkCmdEndRenderPass2(void *args)
15974 {
15975     struct
15976     {
15977         VkCommandBuffer commandBuffer;
15978         const VkSubpassEndInfo *pSubpassEndInfo;
15979     } *params = args;
15980
15981     TRACE("%p, %p\n", params->commandBuffer, params->pSubpassEndInfo);
15982
15983     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
15984     return STATUS_SUCCESS;
15985 }
15986
15987 #endif /* USE_STRUCT_CONVERSION */
15988
15989 #if !defined(USE_STRUCT_CONVERSION)
15990
15991 static NTSTATUS thunk64_vkCmdEndRenderPass2KHR(void *args)
15992 {
15993     struct vkCmdEndRenderPass2KHR_params *params = args;
15994
15995     TRACE("%p, %p\n", params->commandBuffer, params->pSubpassEndInfo);
15996
15997     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
15998     return STATUS_SUCCESS;
15999 }
16000
16001 #else /* USE_STRUCT_CONVERSION */
16002
16003 static NTSTATUS thunk32_vkCmdEndRenderPass2KHR(void *args)
16004 {
16005     struct
16006     {
16007         VkCommandBuffer commandBuffer;
16008         const VkSubpassEndInfo *pSubpassEndInfo;
16009     } *params = args;
16010
16011     TRACE("%p, %p\n", params->commandBuffer, params->pSubpassEndInfo);
16012
16013     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
16014     return STATUS_SUCCESS;
16015 }
16016
16017 #endif /* USE_STRUCT_CONVERSION */
16018
16019 #if !defined(USE_STRUCT_CONVERSION)
16020
16021 static NTSTATUS thunk64_vkCmdEndRendering(void *args)
16022 {
16023     struct vkCmdEndRendering_params *params = args;
16024
16025     TRACE("%p\n", params->commandBuffer);
16026
16027     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
16028     return STATUS_SUCCESS;
16029 }
16030
16031 #else /* USE_STRUCT_CONVERSION */
16032
16033 static NTSTATUS thunk32_vkCmdEndRendering(void *args)
16034 {
16035     struct
16036     {
16037         VkCommandBuffer commandBuffer;
16038     } *params = args;
16039
16040     TRACE("%p\n", params->commandBuffer);
16041
16042     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
16043     return STATUS_SUCCESS;
16044 }
16045
16046 #endif /* USE_STRUCT_CONVERSION */
16047
16048 #if !defined(USE_STRUCT_CONVERSION)
16049
16050 static NTSTATUS thunk64_vkCmdEndRenderingKHR(void *args)
16051 {
16052     struct vkCmdEndRenderingKHR_params *params = args;
16053
16054     TRACE("%p\n", params->commandBuffer);
16055
16056     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
16057     return STATUS_SUCCESS;
16058 }
16059
16060 #else /* USE_STRUCT_CONVERSION */
16061
16062 static NTSTATUS thunk32_vkCmdEndRenderingKHR(void *args)
16063 {
16064     struct
16065     {
16066         VkCommandBuffer commandBuffer;
16067     } *params = args;
16068
16069     TRACE("%p\n", params->commandBuffer);
16070
16071     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
16072     return STATUS_SUCCESS;
16073 }
16074
16075 #endif /* USE_STRUCT_CONVERSION */
16076
16077 #if !defined(USE_STRUCT_CONVERSION)
16078
16079 static NTSTATUS thunk64_vkCmdEndTransformFeedbackEXT(void *args)
16080 {
16081     struct vkCmdEndTransformFeedbackEXT_params *params = args;
16082
16083     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
16084
16085     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);
16086     return STATUS_SUCCESS;
16087 }
16088
16089 #else /* USE_STRUCT_CONVERSION */
16090
16091 static NTSTATUS thunk32_vkCmdEndTransformFeedbackEXT(void *args)
16092 {
16093     struct
16094     {
16095         VkCommandBuffer commandBuffer;
16096         uint32_t firstCounterBuffer;
16097         uint32_t counterBufferCount;
16098         const VkBuffer *pCounterBuffers;
16099         const VkDeviceSize *pCounterBufferOffsets;
16100     } *params = args;
16101
16102     TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
16103
16104     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);
16105     return STATUS_SUCCESS;
16106 }
16107
16108 #endif /* USE_STRUCT_CONVERSION */
16109
16110 #if !defined(USE_STRUCT_CONVERSION)
16111
16112 static NTSTATUS thunk64_vkCmdExecuteCommands(void *args)
16113 {
16114     struct vkCmdExecuteCommands_params *params = args;
16115     const VkCommandBuffer *pCommandBuffers_host;
16116     struct conversion_context ctx;
16117
16118     TRACE("%p, %u, %p\n", params->commandBuffer, params->commandBufferCount, params->pCommandBuffers);
16119
16120     init_conversion_context(&ctx);
16121     pCommandBuffers_host = convert_VkCommandBuffer_array_win64_to_host(&ctx, params->pCommandBuffers, params->commandBufferCount);
16122     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->commandBufferCount, pCommandBuffers_host);
16123     free_conversion_context(&ctx);
16124     return STATUS_SUCCESS;
16125 }
16126
16127 #else /* USE_STRUCT_CONVERSION */
16128
16129 static NTSTATUS thunk32_vkCmdExecuteCommands(void *args)
16130 {
16131     struct
16132     {
16133         VkCommandBuffer commandBuffer;
16134         uint32_t commandBufferCount;
16135         const VkCommandBuffer *pCommandBuffers;
16136     } *params = args;
16137     const VkCommandBuffer *pCommandBuffers_host;
16138     struct conversion_context ctx;
16139
16140     TRACE("%p, %u, %p\n", params->commandBuffer, params->commandBufferCount, params->pCommandBuffers);
16141
16142     init_conversion_context(&ctx);
16143     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_host(&ctx, params->pCommandBuffers, params->commandBufferCount);
16144     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->commandBufferCount, pCommandBuffers_host);
16145     free_conversion_context(&ctx);
16146     return STATUS_SUCCESS;
16147 }
16148
16149 #endif /* USE_STRUCT_CONVERSION */
16150
16151 #if !defined(USE_STRUCT_CONVERSION)
16152
16153 static NTSTATUS thunk64_vkCmdExecuteGeneratedCommandsNV(void *args)
16154 {
16155     struct vkCmdExecuteGeneratedCommandsNV_params *params = args;
16156
16157     TRACE("%p, %u, %p\n", params->commandBuffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
16158
16159     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
16160     return STATUS_SUCCESS;
16161 }
16162
16163 #else /* USE_STRUCT_CONVERSION */
16164
16165 static NTSTATUS thunk32_vkCmdExecuteGeneratedCommandsNV(void *args)
16166 {
16167     struct
16168     {
16169         VkCommandBuffer commandBuffer;
16170         VkBool32 isPreprocessed;
16171         const VkGeneratedCommandsInfoNV32 *pGeneratedCommandsInfo;
16172     } *params = args;
16173     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
16174     struct conversion_context ctx;
16175
16176     TRACE("%p, %u, %p\n", params->commandBuffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
16177
16178     init_conversion_context(&ctx);
16179     convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, params->pGeneratedCommandsInfo, &pGeneratedCommandsInfo_host);
16180     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->isPreprocessed, &pGeneratedCommandsInfo_host);
16181     free_conversion_context(&ctx);
16182     return STATUS_SUCCESS;
16183 }
16184
16185 #endif /* USE_STRUCT_CONVERSION */
16186
16187 #if !defined(USE_STRUCT_CONVERSION)
16188
16189 static NTSTATUS thunk64_vkCmdFillBuffer(void *args)
16190 {
16191     struct vkCmdFillBuffer_params *params = args;
16192
16193     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);
16194
16195     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);
16196     return STATUS_SUCCESS;
16197 }
16198
16199 #else /* USE_STRUCT_CONVERSION */
16200
16201 static NTSTATUS thunk32_vkCmdFillBuffer(void *args)
16202 {
16203     struct
16204     {
16205         VkCommandBuffer commandBuffer;
16206         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
16207         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
16208         VkDeviceSize DECLSPEC_ALIGN(8) size;
16209         uint32_t data;
16210     } *params = args;
16211
16212     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);
16213
16214     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);
16215     return STATUS_SUCCESS;
16216 }
16217
16218 #endif /* USE_STRUCT_CONVERSION */
16219
16220 #if !defined(USE_STRUCT_CONVERSION)
16221
16222 static NTSTATUS thunk64_vkCmdInsertDebugUtilsLabelEXT(void *args)
16223 {
16224     struct vkCmdInsertDebugUtilsLabelEXT_params *params = args;
16225
16226     TRACE("%p, %p\n", params->commandBuffer, params->pLabelInfo);
16227
16228     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
16229     return STATUS_SUCCESS;
16230 }
16231
16232 #else /* USE_STRUCT_CONVERSION */
16233
16234 static NTSTATUS thunk32_vkCmdInsertDebugUtilsLabelEXT(void *args)
16235 {
16236     struct
16237     {
16238         VkCommandBuffer commandBuffer;
16239         const VkDebugUtilsLabelEXT *pLabelInfo;
16240     } *params = args;
16241
16242     TRACE("%p, %p\n", params->commandBuffer, params->pLabelInfo);
16243
16244     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
16245     return STATUS_SUCCESS;
16246 }
16247
16248 #endif /* USE_STRUCT_CONVERSION */
16249
16250 #if !defined(USE_STRUCT_CONVERSION)
16251
16252 static NTSTATUS thunk64_vkCmdNextSubpass(void *args)
16253 {
16254     struct vkCmdNextSubpass_params *params = args;
16255
16256     TRACE("%p, %#x\n", params->commandBuffer, params->contents);
16257
16258     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->contents);
16259     return STATUS_SUCCESS;
16260 }
16261
16262 #else /* USE_STRUCT_CONVERSION */
16263
16264 static NTSTATUS thunk32_vkCmdNextSubpass(void *args)
16265 {
16266     struct
16267     {
16268         VkCommandBuffer commandBuffer;
16269         VkSubpassContents contents;
16270     } *params = args;
16271
16272     TRACE("%p, %#x\n", params->commandBuffer, params->contents);
16273
16274     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->contents);
16275     return STATUS_SUCCESS;
16276 }
16277
16278 #endif /* USE_STRUCT_CONVERSION */
16279
16280 #if !defined(USE_STRUCT_CONVERSION)
16281
16282 static NTSTATUS thunk64_vkCmdNextSubpass2(void *args)
16283 {
16284     struct vkCmdNextSubpass2_params *params = args;
16285
16286     TRACE("%p, %p, %p\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
16287
16288     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
16289     return STATUS_SUCCESS;
16290 }
16291
16292 #else /* USE_STRUCT_CONVERSION */
16293
16294 static NTSTATUS thunk32_vkCmdNextSubpass2(void *args)
16295 {
16296     struct
16297     {
16298         VkCommandBuffer commandBuffer;
16299         const VkSubpassBeginInfo *pSubpassBeginInfo;
16300         const VkSubpassEndInfo *pSubpassEndInfo;
16301     } *params = args;
16302
16303     TRACE("%p, %p, %p\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
16304
16305     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
16306     return STATUS_SUCCESS;
16307 }
16308
16309 #endif /* USE_STRUCT_CONVERSION */
16310
16311 #if !defined(USE_STRUCT_CONVERSION)
16312
16313 static NTSTATUS thunk64_vkCmdNextSubpass2KHR(void *args)
16314 {
16315     struct vkCmdNextSubpass2KHR_params *params = args;
16316
16317     TRACE("%p, %p, %p\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
16318
16319     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
16320     return STATUS_SUCCESS;
16321 }
16322
16323 #else /* USE_STRUCT_CONVERSION */
16324
16325 static NTSTATUS thunk32_vkCmdNextSubpass2KHR(void *args)
16326 {
16327     struct
16328     {
16329         VkCommandBuffer commandBuffer;
16330         const VkSubpassBeginInfo *pSubpassBeginInfo;
16331         const VkSubpassEndInfo *pSubpassEndInfo;
16332     } *params = args;
16333
16334     TRACE("%p, %p, %p\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
16335
16336     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
16337     return STATUS_SUCCESS;
16338 }
16339
16340 #endif /* USE_STRUCT_CONVERSION */
16341
16342 #if !defined(USE_STRUCT_CONVERSION)
16343
16344 static NTSTATUS thunk64_vkCmdOpticalFlowExecuteNV(void *args)
16345 {
16346     struct vkCmdOpticalFlowExecuteNV_params *params = args;
16347
16348     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->session), params->pExecuteInfo);
16349
16350     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->session, params->pExecuteInfo);
16351     return STATUS_SUCCESS;
16352 }
16353
16354 #else /* USE_STRUCT_CONVERSION */
16355
16356 static NTSTATUS thunk32_vkCmdOpticalFlowExecuteNV(void *args)
16357 {
16358     struct
16359     {
16360         VkCommandBuffer commandBuffer;
16361         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
16362         const VkOpticalFlowExecuteInfoNV *pExecuteInfo;
16363     } *params = args;
16364
16365     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->session), params->pExecuteInfo);
16366
16367     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->session, params->pExecuteInfo);
16368     return STATUS_SUCCESS;
16369 }
16370
16371 #endif /* USE_STRUCT_CONVERSION */
16372
16373 #if !defined(USE_STRUCT_CONVERSION)
16374
16375 static NTSTATUS thunk64_vkCmdPipelineBarrier(void *args)
16376 {
16377     struct vkCmdPipelineBarrier_params *params = args;
16378
16379     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);
16380
16381     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);
16382     return STATUS_SUCCESS;
16383 }
16384
16385 #else /* USE_STRUCT_CONVERSION */
16386
16387 static NTSTATUS thunk32_vkCmdPipelineBarrier(void *args)
16388 {
16389     struct
16390     {
16391         VkCommandBuffer commandBuffer;
16392         VkPipelineStageFlags srcStageMask;
16393         VkPipelineStageFlags dstStageMask;
16394         VkDependencyFlags dependencyFlags;
16395         uint32_t memoryBarrierCount;
16396         const VkMemoryBarrier *pMemoryBarriers;
16397         uint32_t bufferMemoryBarrierCount;
16398         const VkBufferMemoryBarrier32 *pBufferMemoryBarriers;
16399         uint32_t imageMemoryBarrierCount;
16400         const VkImageMemoryBarrier32 *pImageMemoryBarriers;
16401     } *params = args;
16402     const VkBufferMemoryBarrier *pBufferMemoryBarriers_host;
16403     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
16404     struct conversion_context ctx;
16405
16406     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);
16407
16408     init_conversion_context(&ctx);
16409     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(&ctx, params->pBufferMemoryBarriers, params->bufferMemoryBarrierCount);
16410     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(&ctx, params->pImageMemoryBarriers, params->imageMemoryBarrierCount);
16411     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, pBufferMemoryBarriers_host, params->imageMemoryBarrierCount, pImageMemoryBarriers_host);
16412     free_conversion_context(&ctx);
16413     return STATUS_SUCCESS;
16414 }
16415
16416 #endif /* USE_STRUCT_CONVERSION */
16417
16418 #if !defined(USE_STRUCT_CONVERSION)
16419
16420 static NTSTATUS thunk64_vkCmdPipelineBarrier2(void *args)
16421 {
16422     struct vkCmdPipelineBarrier2_params *params = args;
16423
16424     TRACE("%p, %p\n", params->commandBuffer, params->pDependencyInfo);
16425
16426     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
16427     return STATUS_SUCCESS;
16428 }
16429
16430 #else /* USE_STRUCT_CONVERSION */
16431
16432 static NTSTATUS thunk32_vkCmdPipelineBarrier2(void *args)
16433 {
16434     struct
16435     {
16436         VkCommandBuffer commandBuffer;
16437         const VkDependencyInfo32 *pDependencyInfo;
16438     } *params = args;
16439     VkDependencyInfo pDependencyInfo_host;
16440     struct conversion_context ctx;
16441
16442     TRACE("%p, %p\n", params->commandBuffer, params->pDependencyInfo);
16443
16444     init_conversion_context(&ctx);
16445     convert_VkDependencyInfo_win32_to_host(&ctx, params->pDependencyInfo, &pDependencyInfo_host);
16446     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pDependencyInfo_host);
16447     free_conversion_context(&ctx);
16448     return STATUS_SUCCESS;
16449 }
16450
16451 #endif /* USE_STRUCT_CONVERSION */
16452
16453 #if !defined(USE_STRUCT_CONVERSION)
16454
16455 static NTSTATUS thunk64_vkCmdPipelineBarrier2KHR(void *args)
16456 {
16457     struct vkCmdPipelineBarrier2KHR_params *params = args;
16458
16459     TRACE("%p, %p\n", params->commandBuffer, params->pDependencyInfo);
16460
16461     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
16462     return STATUS_SUCCESS;
16463 }
16464
16465 #else /* USE_STRUCT_CONVERSION */
16466
16467 static NTSTATUS thunk32_vkCmdPipelineBarrier2KHR(void *args)
16468 {
16469     struct
16470     {
16471         VkCommandBuffer commandBuffer;
16472         const VkDependencyInfo32 *pDependencyInfo;
16473     } *params = args;
16474     VkDependencyInfo pDependencyInfo_host;
16475     struct conversion_context ctx;
16476
16477     TRACE("%p, %p\n", params->commandBuffer, params->pDependencyInfo);
16478
16479     init_conversion_context(&ctx);
16480     convert_VkDependencyInfo_win32_to_host(&ctx, params->pDependencyInfo, &pDependencyInfo_host);
16481     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pDependencyInfo_host);
16482     free_conversion_context(&ctx);
16483     return STATUS_SUCCESS;
16484 }
16485
16486 #endif /* USE_STRUCT_CONVERSION */
16487
16488 #if !defined(USE_STRUCT_CONVERSION)
16489
16490 static NTSTATUS thunk64_vkCmdPreprocessGeneratedCommandsNV(void *args)
16491 {
16492     struct vkCmdPreprocessGeneratedCommandsNV_params *params = args;
16493
16494     TRACE("%p, %p\n", params->commandBuffer, params->pGeneratedCommandsInfo);
16495
16496     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pGeneratedCommandsInfo);
16497     return STATUS_SUCCESS;
16498 }
16499
16500 #else /* USE_STRUCT_CONVERSION */
16501
16502 static NTSTATUS thunk32_vkCmdPreprocessGeneratedCommandsNV(void *args)
16503 {
16504     struct
16505     {
16506         VkCommandBuffer commandBuffer;
16507         const VkGeneratedCommandsInfoNV32 *pGeneratedCommandsInfo;
16508     } *params = args;
16509     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
16510     struct conversion_context ctx;
16511
16512     TRACE("%p, %p\n", params->commandBuffer, params->pGeneratedCommandsInfo);
16513
16514     init_conversion_context(&ctx);
16515     convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, params->pGeneratedCommandsInfo, &pGeneratedCommandsInfo_host);
16516     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pGeneratedCommandsInfo_host);
16517     free_conversion_context(&ctx);
16518     return STATUS_SUCCESS;
16519 }
16520
16521 #endif /* USE_STRUCT_CONVERSION */
16522
16523 #if !defined(USE_STRUCT_CONVERSION)
16524
16525 static NTSTATUS thunk64_vkCmdPushConstants(void *args)
16526 {
16527     struct vkCmdPushConstants_params *params = args;
16528
16529     TRACE("%p, 0x%s, %#x, %u, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->layout), params->stageFlags, params->offset, params->size, params->pValues);
16530
16531     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);
16532     return STATUS_SUCCESS;
16533 }
16534
16535 #else /* USE_STRUCT_CONVERSION */
16536
16537 static NTSTATUS thunk32_vkCmdPushConstants(void *args)
16538 {
16539     struct
16540     {
16541         VkCommandBuffer commandBuffer;
16542         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
16543         VkShaderStageFlags stageFlags;
16544         uint32_t offset;
16545         uint32_t size;
16546         const void *pValues;
16547     } *params = args;
16548
16549     TRACE("%p, 0x%s, %#x, %u, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->layout), params->stageFlags, params->offset, params->size, params->pValues);
16550
16551     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);
16552     return STATUS_SUCCESS;
16553 }
16554
16555 #endif /* USE_STRUCT_CONVERSION */
16556
16557 #if !defined(USE_STRUCT_CONVERSION)
16558
16559 static NTSTATUS thunk64_vkCmdPushDescriptorSetKHR(void *args)
16560 {
16561     struct vkCmdPushDescriptorSetKHR_params *params = args;
16562
16563     TRACE("%p, %#x, 0x%s, %u, %u, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set, params->descriptorWriteCount, params->pDescriptorWrites);
16564
16565     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);
16566     return STATUS_SUCCESS;
16567 }
16568
16569 #else /* USE_STRUCT_CONVERSION */
16570
16571 static NTSTATUS thunk32_vkCmdPushDescriptorSetKHR(void *args)
16572 {
16573     struct
16574     {
16575         VkCommandBuffer commandBuffer;
16576         VkPipelineBindPoint pipelineBindPoint;
16577         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
16578         uint32_t set;
16579         uint32_t descriptorWriteCount;
16580         const VkWriteDescriptorSet32 *pDescriptorWrites;
16581     } *params = args;
16582     const VkWriteDescriptorSet *pDescriptorWrites_host;
16583     struct conversion_context ctx;
16584
16585     TRACE("%p, %#x, 0x%s, %u, %u, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set, params->descriptorWriteCount, params->pDescriptorWrites);
16586
16587     init_conversion_context(&ctx);
16588     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, params->pDescriptorWrites, params->descriptorWriteCount);
16589     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushDescriptorSetKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->set, params->descriptorWriteCount, pDescriptorWrites_host);
16590     free_conversion_context(&ctx);
16591     return STATUS_SUCCESS;
16592 }
16593
16594 #endif /* USE_STRUCT_CONVERSION */
16595
16596 #if !defined(USE_STRUCT_CONVERSION)
16597
16598 static NTSTATUS thunk64_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
16599 {
16600     struct vkCmdPushDescriptorSetWithTemplateKHR_params *params = args;
16601
16602     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);
16603
16604     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);
16605     return STATUS_SUCCESS;
16606 }
16607
16608 #else /* USE_STRUCT_CONVERSION */
16609
16610 static NTSTATUS thunk32_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
16611 {
16612     struct
16613     {
16614         VkCommandBuffer commandBuffer;
16615         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
16616         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
16617         uint32_t set;
16618         const void *pData;
16619     } *params = args;
16620
16621     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);
16622
16623     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);
16624     return STATUS_SUCCESS;
16625 }
16626
16627 #endif /* USE_STRUCT_CONVERSION */
16628
16629 #if !defined(USE_STRUCT_CONVERSION)
16630
16631 static NTSTATUS thunk64_vkCmdResetEvent(void *args)
16632 {
16633     struct vkCmdResetEvent_params *params = args;
16634
16635     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
16636
16637     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
16638     return STATUS_SUCCESS;
16639 }
16640
16641 #else /* USE_STRUCT_CONVERSION */
16642
16643 static NTSTATUS thunk32_vkCmdResetEvent(void *args)
16644 {
16645     struct
16646     {
16647         VkCommandBuffer commandBuffer;
16648         VkEvent DECLSPEC_ALIGN(8) event;
16649         VkPipelineStageFlags stageMask;
16650     } *params = args;
16651
16652     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
16653
16654     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
16655     return STATUS_SUCCESS;
16656 }
16657
16658 #endif /* USE_STRUCT_CONVERSION */
16659
16660 #if !defined(USE_STRUCT_CONVERSION)
16661
16662 static NTSTATUS thunk64_vkCmdResetEvent2(void *args)
16663 {
16664     struct vkCmdResetEvent2_params *params = args;
16665
16666     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
16667
16668     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
16669     return STATUS_SUCCESS;
16670 }
16671
16672 #else /* USE_STRUCT_CONVERSION */
16673
16674 static NTSTATUS thunk32_vkCmdResetEvent2(void *args)
16675 {
16676     struct
16677     {
16678         VkCommandBuffer commandBuffer;
16679         VkEvent DECLSPEC_ALIGN(8) event;
16680         VkPipelineStageFlags2 stageMask;
16681     } *params = args;
16682
16683     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
16684
16685     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
16686     return STATUS_SUCCESS;
16687 }
16688
16689 #endif /* USE_STRUCT_CONVERSION */
16690
16691 #if !defined(USE_STRUCT_CONVERSION)
16692
16693 static NTSTATUS thunk64_vkCmdResetEvent2KHR(void *args)
16694 {
16695     struct vkCmdResetEvent2KHR_params *params = args;
16696
16697     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
16698
16699     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
16700     return STATUS_SUCCESS;
16701 }
16702
16703 #else /* USE_STRUCT_CONVERSION */
16704
16705 static NTSTATUS thunk32_vkCmdResetEvent2KHR(void *args)
16706 {
16707     struct
16708     {
16709         VkCommandBuffer commandBuffer;
16710         VkEvent DECLSPEC_ALIGN(8) event;
16711         VkPipelineStageFlags2 stageMask;
16712     } *params = args;
16713
16714     TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
16715
16716     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
16717     return STATUS_SUCCESS;
16718 }
16719
16720 #endif /* USE_STRUCT_CONVERSION */
16721
16722 #if !defined(USE_STRUCT_CONVERSION)
16723
16724 static NTSTATUS thunk64_vkCmdResetQueryPool(void *args)
16725 {
16726     struct vkCmdResetQueryPool_params *params = args;
16727
16728     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
16729
16730     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);
16731     return STATUS_SUCCESS;
16732 }
16733
16734 #else /* USE_STRUCT_CONVERSION */
16735
16736 static NTSTATUS thunk32_vkCmdResetQueryPool(void *args)
16737 {
16738     struct
16739     {
16740         VkCommandBuffer commandBuffer;
16741         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
16742         uint32_t firstQuery;
16743         uint32_t queryCount;
16744     } *params = args;
16745
16746     TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
16747
16748     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);
16749     return STATUS_SUCCESS;
16750 }
16751
16752 #endif /* USE_STRUCT_CONVERSION */
16753
16754 #if !defined(USE_STRUCT_CONVERSION)
16755
16756 static NTSTATUS thunk64_vkCmdResolveImage(void *args)
16757 {
16758     struct vkCmdResolveImage_params *params = args;
16759
16760     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);
16761
16762     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);
16763     return STATUS_SUCCESS;
16764 }
16765
16766 #else /* USE_STRUCT_CONVERSION */
16767
16768 static NTSTATUS thunk32_vkCmdResolveImage(void *args)
16769 {
16770     struct
16771     {
16772         VkCommandBuffer commandBuffer;
16773         VkImage DECLSPEC_ALIGN(8) srcImage;
16774         VkImageLayout srcImageLayout;
16775         VkImage DECLSPEC_ALIGN(8) dstImage;
16776         VkImageLayout dstImageLayout;
16777         uint32_t regionCount;
16778         const VkImageResolve *pRegions;
16779     } *params = args;
16780
16781     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);
16782
16783     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);
16784     return STATUS_SUCCESS;
16785 }
16786
16787 #endif /* USE_STRUCT_CONVERSION */
16788
16789 #if !defined(USE_STRUCT_CONVERSION)
16790
16791 static NTSTATUS thunk64_vkCmdResolveImage2(void *args)
16792 {
16793     struct vkCmdResolveImage2_params *params = args;
16794
16795     TRACE("%p, %p\n", params->commandBuffer, params->pResolveImageInfo);
16796
16797     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
16798     return STATUS_SUCCESS;
16799 }
16800
16801 #else /* USE_STRUCT_CONVERSION */
16802
16803 static NTSTATUS thunk32_vkCmdResolveImage2(void *args)
16804 {
16805     struct
16806     {
16807         VkCommandBuffer commandBuffer;
16808         const VkResolveImageInfo232 *pResolveImageInfo;
16809     } *params = args;
16810     VkResolveImageInfo2 pResolveImageInfo_host;
16811
16812     TRACE("%p, %p\n", params->commandBuffer, params->pResolveImageInfo);
16813
16814     convert_VkResolveImageInfo2_win32_to_host(params->pResolveImageInfo, &pResolveImageInfo_host);
16815     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pResolveImageInfo_host);
16816     return STATUS_SUCCESS;
16817 }
16818
16819 #endif /* USE_STRUCT_CONVERSION */
16820
16821 #if !defined(USE_STRUCT_CONVERSION)
16822
16823 static NTSTATUS thunk64_vkCmdResolveImage2KHR(void *args)
16824 {
16825     struct vkCmdResolveImage2KHR_params *params = args;
16826
16827     TRACE("%p, %p\n", params->commandBuffer, params->pResolveImageInfo);
16828
16829     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
16830     return STATUS_SUCCESS;
16831 }
16832
16833 #else /* USE_STRUCT_CONVERSION */
16834
16835 static NTSTATUS thunk32_vkCmdResolveImage2KHR(void *args)
16836 {
16837     struct
16838     {
16839         VkCommandBuffer commandBuffer;
16840         const VkResolveImageInfo232 *pResolveImageInfo;
16841     } *params = args;
16842     VkResolveImageInfo2 pResolveImageInfo_host;
16843
16844     TRACE("%p, %p\n", params->commandBuffer, params->pResolveImageInfo);
16845
16846     convert_VkResolveImageInfo2_win32_to_host(params->pResolveImageInfo, &pResolveImageInfo_host);
16847     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pResolveImageInfo_host);
16848     return STATUS_SUCCESS;
16849 }
16850
16851 #endif /* USE_STRUCT_CONVERSION */
16852
16853 #if !defined(USE_STRUCT_CONVERSION)
16854
16855 static NTSTATUS thunk64_vkCmdSetAlphaToCoverageEnableEXT(void *args)
16856 {
16857     struct vkCmdSetAlphaToCoverageEnableEXT_params *params = args;
16858
16859     TRACE("%p, %u\n", params->commandBuffer, params->alphaToCoverageEnable);
16860
16861     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToCoverageEnable);
16862     return STATUS_SUCCESS;
16863 }
16864
16865 #else /* USE_STRUCT_CONVERSION */
16866
16867 static NTSTATUS thunk32_vkCmdSetAlphaToCoverageEnableEXT(void *args)
16868 {
16869     struct
16870     {
16871         VkCommandBuffer commandBuffer;
16872         VkBool32 alphaToCoverageEnable;
16873     } *params = args;
16874
16875     TRACE("%p, %u\n", params->commandBuffer, params->alphaToCoverageEnable);
16876
16877     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToCoverageEnable);
16878     return STATUS_SUCCESS;
16879 }
16880
16881 #endif /* USE_STRUCT_CONVERSION */
16882
16883 #if !defined(USE_STRUCT_CONVERSION)
16884
16885 static NTSTATUS thunk64_vkCmdSetAlphaToOneEnableEXT(void *args)
16886 {
16887     struct vkCmdSetAlphaToOneEnableEXT_params *params = args;
16888
16889     TRACE("%p, %u\n", params->commandBuffer, params->alphaToOneEnable);
16890
16891     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToOneEnable);
16892     return STATUS_SUCCESS;
16893 }
16894
16895 #else /* USE_STRUCT_CONVERSION */
16896
16897 static NTSTATUS thunk32_vkCmdSetAlphaToOneEnableEXT(void *args)
16898 {
16899     struct
16900     {
16901         VkCommandBuffer commandBuffer;
16902         VkBool32 alphaToOneEnable;
16903     } *params = args;
16904
16905     TRACE("%p, %u\n", params->commandBuffer, params->alphaToOneEnable);
16906
16907     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToOneEnable);
16908     return STATUS_SUCCESS;
16909 }
16910
16911 #endif /* USE_STRUCT_CONVERSION */
16912
16913 #if !defined(USE_STRUCT_CONVERSION)
16914
16915 static NTSTATUS thunk64_vkCmdSetBlendConstants(void *args)
16916 {
16917     struct vkCmdSetBlendConstants_params *params = args;
16918
16919     TRACE("%p, %p\n", params->commandBuffer, params->blendConstants);
16920
16921     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->blendConstants);
16922     return STATUS_SUCCESS;
16923 }
16924
16925 #else /* USE_STRUCT_CONVERSION */
16926
16927 static NTSTATUS thunk32_vkCmdSetBlendConstants(void *args)
16928 {
16929     struct
16930     {
16931         VkCommandBuffer commandBuffer;
16932         const float *blendConstants;
16933     } *params = args;
16934
16935     TRACE("%p, %p\n", params->commandBuffer, params->blendConstants);
16936
16937     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->blendConstants);
16938     return STATUS_SUCCESS;
16939 }
16940
16941 #endif /* USE_STRUCT_CONVERSION */
16942
16943 #if !defined(USE_STRUCT_CONVERSION)
16944
16945 static NTSTATUS thunk64_vkCmdSetCheckpointNV(void *args)
16946 {
16947     struct vkCmdSetCheckpointNV_params *params = args;
16948
16949     TRACE("%p, %p\n", params->commandBuffer, params->pCheckpointMarker);
16950
16951     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCheckpointMarker);
16952     return STATUS_SUCCESS;
16953 }
16954
16955 #else /* USE_STRUCT_CONVERSION */
16956
16957 static NTSTATUS thunk32_vkCmdSetCheckpointNV(void *args)
16958 {
16959     struct
16960     {
16961         VkCommandBuffer commandBuffer;
16962         const void *pCheckpointMarker;
16963     } *params = args;
16964
16965     TRACE("%p, %p\n", params->commandBuffer, params->pCheckpointMarker);
16966
16967     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCheckpointMarker);
16968     return STATUS_SUCCESS;
16969 }
16970
16971 #endif /* USE_STRUCT_CONVERSION */
16972
16973 #if !defined(USE_STRUCT_CONVERSION)
16974
16975 static NTSTATUS thunk64_vkCmdSetCoarseSampleOrderNV(void *args)
16976 {
16977     struct vkCmdSetCoarseSampleOrderNV_params *params = args;
16978
16979     TRACE("%p, %#x, %u, %p\n", params->commandBuffer, params->sampleOrderType, params->customSampleOrderCount, params->pCustomSampleOrders);
16980
16981     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);
16982     return STATUS_SUCCESS;
16983 }
16984
16985 #else /* USE_STRUCT_CONVERSION */
16986
16987 static NTSTATUS thunk32_vkCmdSetCoarseSampleOrderNV(void *args)
16988 {
16989     struct
16990     {
16991         VkCommandBuffer commandBuffer;
16992         VkCoarseSampleOrderTypeNV sampleOrderType;
16993         uint32_t customSampleOrderCount;
16994         const VkCoarseSampleOrderCustomNV *pCustomSampleOrders;
16995     } *params = args;
16996
16997     TRACE("%p, %#x, %u, %p\n", params->commandBuffer, params->sampleOrderType, params->customSampleOrderCount, params->pCustomSampleOrders);
16998
16999     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);
17000     return STATUS_SUCCESS;
17001 }
17002
17003 #endif /* USE_STRUCT_CONVERSION */
17004
17005 #if !defined(USE_STRUCT_CONVERSION)
17006
17007 static NTSTATUS thunk64_vkCmdSetColorBlendAdvancedEXT(void *args)
17008 {
17009     struct vkCmdSetColorBlendAdvancedEXT_params *params = args;
17010
17011     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
17012
17013     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);
17014     return STATUS_SUCCESS;
17015 }
17016
17017 #else /* USE_STRUCT_CONVERSION */
17018
17019 static NTSTATUS thunk32_vkCmdSetColorBlendAdvancedEXT(void *args)
17020 {
17021     struct
17022     {
17023         VkCommandBuffer commandBuffer;
17024         uint32_t firstAttachment;
17025         uint32_t attachmentCount;
17026         const VkColorBlendAdvancedEXT *pColorBlendAdvanced;
17027     } *params = args;
17028
17029     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
17030
17031     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);
17032     return STATUS_SUCCESS;
17033 }
17034
17035 #endif /* USE_STRUCT_CONVERSION */
17036
17037 #if !defined(USE_STRUCT_CONVERSION)
17038
17039 static NTSTATUS thunk64_vkCmdSetColorBlendEnableEXT(void *args)
17040 {
17041     struct vkCmdSetColorBlendEnableEXT_params *params = args;
17042
17043     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
17044
17045     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);
17046     return STATUS_SUCCESS;
17047 }
17048
17049 #else /* USE_STRUCT_CONVERSION */
17050
17051 static NTSTATUS thunk32_vkCmdSetColorBlendEnableEXT(void *args)
17052 {
17053     struct
17054     {
17055         VkCommandBuffer commandBuffer;
17056         uint32_t firstAttachment;
17057         uint32_t attachmentCount;
17058         const VkBool32 *pColorBlendEnables;
17059     } *params = args;
17060
17061     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
17062
17063     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);
17064     return STATUS_SUCCESS;
17065 }
17066
17067 #endif /* USE_STRUCT_CONVERSION */
17068
17069 #if !defined(USE_STRUCT_CONVERSION)
17070
17071 static NTSTATUS thunk64_vkCmdSetColorBlendEquationEXT(void *args)
17072 {
17073     struct vkCmdSetColorBlendEquationEXT_params *params = args;
17074
17075     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
17076
17077     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);
17078     return STATUS_SUCCESS;
17079 }
17080
17081 #else /* USE_STRUCT_CONVERSION */
17082
17083 static NTSTATUS thunk32_vkCmdSetColorBlendEquationEXT(void *args)
17084 {
17085     struct
17086     {
17087         VkCommandBuffer commandBuffer;
17088         uint32_t firstAttachment;
17089         uint32_t attachmentCount;
17090         const VkColorBlendEquationEXT *pColorBlendEquations;
17091     } *params = args;
17092
17093     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
17094
17095     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);
17096     return STATUS_SUCCESS;
17097 }
17098
17099 #endif /* USE_STRUCT_CONVERSION */
17100
17101 #if !defined(USE_STRUCT_CONVERSION)
17102
17103 static NTSTATUS thunk64_vkCmdSetColorWriteEnableEXT(void *args)
17104 {
17105     struct vkCmdSetColorWriteEnableEXT_params *params = args;
17106
17107     TRACE("%p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pColorWriteEnables);
17108
17109     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
17110     return STATUS_SUCCESS;
17111 }
17112
17113 #else /* USE_STRUCT_CONVERSION */
17114
17115 static NTSTATUS thunk32_vkCmdSetColorWriteEnableEXT(void *args)
17116 {
17117     struct
17118     {
17119         VkCommandBuffer commandBuffer;
17120         uint32_t attachmentCount;
17121         const VkBool32 *pColorWriteEnables;
17122     } *params = args;
17123
17124     TRACE("%p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pColorWriteEnables);
17125
17126     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
17127     return STATUS_SUCCESS;
17128 }
17129
17130 #endif /* USE_STRUCT_CONVERSION */
17131
17132 #if !defined(USE_STRUCT_CONVERSION)
17133
17134 static NTSTATUS thunk64_vkCmdSetColorWriteMaskEXT(void *args)
17135 {
17136     struct vkCmdSetColorWriteMaskEXT_params *params = args;
17137
17138     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
17139
17140     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);
17141     return STATUS_SUCCESS;
17142 }
17143
17144 #else /* USE_STRUCT_CONVERSION */
17145
17146 static NTSTATUS thunk32_vkCmdSetColorWriteMaskEXT(void *args)
17147 {
17148     struct
17149     {
17150         VkCommandBuffer commandBuffer;
17151         uint32_t firstAttachment;
17152         uint32_t attachmentCount;
17153         const VkColorComponentFlags *pColorWriteMasks;
17154     } *params = args;
17155
17156     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
17157
17158     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);
17159     return STATUS_SUCCESS;
17160 }
17161
17162 #endif /* USE_STRUCT_CONVERSION */
17163
17164 #if !defined(USE_STRUCT_CONVERSION)
17165
17166 static NTSTATUS thunk64_vkCmdSetConservativeRasterizationModeEXT(void *args)
17167 {
17168     struct vkCmdSetConservativeRasterizationModeEXT_params *params = args;
17169
17170     TRACE("%p, %#x\n", params->commandBuffer, params->conservativeRasterizationMode);
17171
17172     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->conservativeRasterizationMode);
17173     return STATUS_SUCCESS;
17174 }
17175
17176 #else /* USE_STRUCT_CONVERSION */
17177
17178 static NTSTATUS thunk32_vkCmdSetConservativeRasterizationModeEXT(void *args)
17179 {
17180     struct
17181     {
17182         VkCommandBuffer commandBuffer;
17183         VkConservativeRasterizationModeEXT conservativeRasterizationMode;
17184     } *params = args;
17185
17186     TRACE("%p, %#x\n", params->commandBuffer, params->conservativeRasterizationMode);
17187
17188     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->conservativeRasterizationMode);
17189     return STATUS_SUCCESS;
17190 }
17191
17192 #endif /* USE_STRUCT_CONVERSION */
17193
17194 #if !defined(USE_STRUCT_CONVERSION)
17195
17196 static NTSTATUS thunk64_vkCmdSetCoverageModulationModeNV(void *args)
17197 {
17198     struct vkCmdSetCoverageModulationModeNV_params *params = args;
17199
17200     TRACE("%p, %#x\n", params->commandBuffer, params->coverageModulationMode);
17201
17202     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationMode);
17203     return STATUS_SUCCESS;
17204 }
17205
17206 #else /* USE_STRUCT_CONVERSION */
17207
17208 static NTSTATUS thunk32_vkCmdSetCoverageModulationModeNV(void *args)
17209 {
17210     struct
17211     {
17212         VkCommandBuffer commandBuffer;
17213         VkCoverageModulationModeNV coverageModulationMode;
17214     } *params = args;
17215
17216     TRACE("%p, %#x\n", params->commandBuffer, params->coverageModulationMode);
17217
17218     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationMode);
17219     return STATUS_SUCCESS;
17220 }
17221
17222 #endif /* USE_STRUCT_CONVERSION */
17223
17224 #if !defined(USE_STRUCT_CONVERSION)
17225
17226 static NTSTATUS thunk64_vkCmdSetCoverageModulationTableEnableNV(void *args)
17227 {
17228     struct vkCmdSetCoverageModulationTableEnableNV_params *params = args;
17229
17230     TRACE("%p, %u\n", params->commandBuffer, params->coverageModulationTableEnable);
17231
17232     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableEnable);
17233     return STATUS_SUCCESS;
17234 }
17235
17236 #else /* USE_STRUCT_CONVERSION */
17237
17238 static NTSTATUS thunk32_vkCmdSetCoverageModulationTableEnableNV(void *args)
17239 {
17240     struct
17241     {
17242         VkCommandBuffer commandBuffer;
17243         VkBool32 coverageModulationTableEnable;
17244     } *params = args;
17245
17246     TRACE("%p, %u\n", params->commandBuffer, params->coverageModulationTableEnable);
17247
17248     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableEnable);
17249     return STATUS_SUCCESS;
17250 }
17251
17252 #endif /* USE_STRUCT_CONVERSION */
17253
17254 #if !defined(USE_STRUCT_CONVERSION)
17255
17256 static NTSTATUS thunk64_vkCmdSetCoverageModulationTableNV(void *args)
17257 {
17258     struct vkCmdSetCoverageModulationTableNV_params *params = args;
17259
17260     TRACE("%p, %u, %p\n", params->commandBuffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
17261
17262     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
17263     return STATUS_SUCCESS;
17264 }
17265
17266 #else /* USE_STRUCT_CONVERSION */
17267
17268 static NTSTATUS thunk32_vkCmdSetCoverageModulationTableNV(void *args)
17269 {
17270     struct
17271     {
17272         VkCommandBuffer commandBuffer;
17273         uint32_t coverageModulationTableCount;
17274         const float *pCoverageModulationTable;
17275     } *params = args;
17276
17277     TRACE("%p, %u, %p\n", params->commandBuffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
17278
17279     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
17280     return STATUS_SUCCESS;
17281 }
17282
17283 #endif /* USE_STRUCT_CONVERSION */
17284
17285 #if !defined(USE_STRUCT_CONVERSION)
17286
17287 static NTSTATUS thunk64_vkCmdSetCoverageReductionModeNV(void *args)
17288 {
17289     struct vkCmdSetCoverageReductionModeNV_params *params = args;
17290
17291     TRACE("%p, %#x\n", params->commandBuffer, params->coverageReductionMode);
17292
17293     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageReductionMode);
17294     return STATUS_SUCCESS;
17295 }
17296
17297 #else /* USE_STRUCT_CONVERSION */
17298
17299 static NTSTATUS thunk32_vkCmdSetCoverageReductionModeNV(void *args)
17300 {
17301     struct
17302     {
17303         VkCommandBuffer commandBuffer;
17304         VkCoverageReductionModeNV coverageReductionMode;
17305     } *params = args;
17306
17307     TRACE("%p, %#x\n", params->commandBuffer, params->coverageReductionMode);
17308
17309     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageReductionMode);
17310     return STATUS_SUCCESS;
17311 }
17312
17313 #endif /* USE_STRUCT_CONVERSION */
17314
17315 #if !defined(USE_STRUCT_CONVERSION)
17316
17317 static NTSTATUS thunk64_vkCmdSetCoverageToColorEnableNV(void *args)
17318 {
17319     struct vkCmdSetCoverageToColorEnableNV_params *params = args;
17320
17321     TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorEnable);
17322
17323     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorEnable);
17324     return STATUS_SUCCESS;
17325 }
17326
17327 #else /* USE_STRUCT_CONVERSION */
17328
17329 static NTSTATUS thunk32_vkCmdSetCoverageToColorEnableNV(void *args)
17330 {
17331     struct
17332     {
17333         VkCommandBuffer commandBuffer;
17334         VkBool32 coverageToColorEnable;
17335     } *params = args;
17336
17337     TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorEnable);
17338
17339     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorEnable);
17340     return STATUS_SUCCESS;
17341 }
17342
17343 #endif /* USE_STRUCT_CONVERSION */
17344
17345 #if !defined(USE_STRUCT_CONVERSION)
17346
17347 static NTSTATUS thunk64_vkCmdSetCoverageToColorLocationNV(void *args)
17348 {
17349     struct vkCmdSetCoverageToColorLocationNV_params *params = args;
17350
17351     TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorLocation);
17352
17353     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorLocation);
17354     return STATUS_SUCCESS;
17355 }
17356
17357 #else /* USE_STRUCT_CONVERSION */
17358
17359 static NTSTATUS thunk32_vkCmdSetCoverageToColorLocationNV(void *args)
17360 {
17361     struct
17362     {
17363         VkCommandBuffer commandBuffer;
17364         uint32_t coverageToColorLocation;
17365     } *params = args;
17366
17367     TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorLocation);
17368
17369     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorLocation);
17370     return STATUS_SUCCESS;
17371 }
17372
17373 #endif /* USE_STRUCT_CONVERSION */
17374
17375 #if !defined(USE_STRUCT_CONVERSION)
17376
17377 static NTSTATUS thunk64_vkCmdSetCullMode(void *args)
17378 {
17379     struct vkCmdSetCullMode_params *params = args;
17380
17381     TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
17382
17383     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
17384     return STATUS_SUCCESS;
17385 }
17386
17387 #else /* USE_STRUCT_CONVERSION */
17388
17389 static NTSTATUS thunk32_vkCmdSetCullMode(void *args)
17390 {
17391     struct
17392     {
17393         VkCommandBuffer commandBuffer;
17394         VkCullModeFlags cullMode;
17395     } *params = args;
17396
17397     TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
17398
17399     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
17400     return STATUS_SUCCESS;
17401 }
17402
17403 #endif /* USE_STRUCT_CONVERSION */
17404
17405 #if !defined(USE_STRUCT_CONVERSION)
17406
17407 static NTSTATUS thunk64_vkCmdSetCullModeEXT(void *args)
17408 {
17409     struct vkCmdSetCullModeEXT_params *params = args;
17410
17411     TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
17412
17413     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
17414     return STATUS_SUCCESS;
17415 }
17416
17417 #else /* USE_STRUCT_CONVERSION */
17418
17419 static NTSTATUS thunk32_vkCmdSetCullModeEXT(void *args)
17420 {
17421     struct
17422     {
17423         VkCommandBuffer commandBuffer;
17424         VkCullModeFlags cullMode;
17425     } *params = args;
17426
17427     TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
17428
17429     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
17430     return STATUS_SUCCESS;
17431 }
17432
17433 #endif /* USE_STRUCT_CONVERSION */
17434
17435 #if !defined(USE_STRUCT_CONVERSION)
17436
17437 static NTSTATUS thunk64_vkCmdSetDepthBias(void *args)
17438 {
17439     struct vkCmdSetDepthBias_params *params = args;
17440
17441     TRACE("%p, %f, %f, %f\n", params->commandBuffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
17442
17443     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);
17444     return STATUS_SUCCESS;
17445 }
17446
17447 #else /* USE_STRUCT_CONVERSION */
17448
17449 static NTSTATUS thunk32_vkCmdSetDepthBias(void *args)
17450 {
17451     struct
17452     {
17453         VkCommandBuffer commandBuffer;
17454         float depthBiasConstantFactor;
17455         float depthBiasClamp;
17456         float depthBiasSlopeFactor;
17457     } *params = args;
17458
17459     TRACE("%p, %f, %f, %f\n", params->commandBuffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
17460
17461     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);
17462     return STATUS_SUCCESS;
17463 }
17464
17465 #endif /* USE_STRUCT_CONVERSION */
17466
17467 #if !defined(USE_STRUCT_CONVERSION)
17468
17469 static NTSTATUS thunk64_vkCmdSetDepthBiasEnable(void *args)
17470 {
17471     struct vkCmdSetDepthBiasEnable_params *params = args;
17472
17473     TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
17474
17475     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
17476     return STATUS_SUCCESS;
17477 }
17478
17479 #else /* USE_STRUCT_CONVERSION */
17480
17481 static NTSTATUS thunk32_vkCmdSetDepthBiasEnable(void *args)
17482 {
17483     struct
17484     {
17485         VkCommandBuffer commandBuffer;
17486         VkBool32 depthBiasEnable;
17487     } *params = args;
17488
17489     TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
17490
17491     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
17492     return STATUS_SUCCESS;
17493 }
17494
17495 #endif /* USE_STRUCT_CONVERSION */
17496
17497 #if !defined(USE_STRUCT_CONVERSION)
17498
17499 static NTSTATUS thunk64_vkCmdSetDepthBiasEnableEXT(void *args)
17500 {
17501     struct vkCmdSetDepthBiasEnableEXT_params *params = args;
17502
17503     TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
17504
17505     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
17506     return STATUS_SUCCESS;
17507 }
17508
17509 #else /* USE_STRUCT_CONVERSION */
17510
17511 static NTSTATUS thunk32_vkCmdSetDepthBiasEnableEXT(void *args)
17512 {
17513     struct
17514     {
17515         VkCommandBuffer commandBuffer;
17516         VkBool32 depthBiasEnable;
17517     } *params = args;
17518
17519     TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
17520
17521     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
17522     return STATUS_SUCCESS;
17523 }
17524
17525 #endif /* USE_STRUCT_CONVERSION */
17526
17527 #if !defined(USE_STRUCT_CONVERSION)
17528
17529 static NTSTATUS thunk64_vkCmdSetDepthBounds(void *args)
17530 {
17531     struct vkCmdSetDepthBounds_params *params = args;
17532
17533     TRACE("%p, %f, %f\n", params->commandBuffer, params->minDepthBounds, params->maxDepthBounds);
17534
17535     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
17536     return STATUS_SUCCESS;
17537 }
17538
17539 #else /* USE_STRUCT_CONVERSION */
17540
17541 static NTSTATUS thunk32_vkCmdSetDepthBounds(void *args)
17542 {
17543     struct
17544     {
17545         VkCommandBuffer commandBuffer;
17546         float minDepthBounds;
17547         float maxDepthBounds;
17548     } *params = args;
17549
17550     TRACE("%p, %f, %f\n", params->commandBuffer, params->minDepthBounds, params->maxDepthBounds);
17551
17552     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
17553     return STATUS_SUCCESS;
17554 }
17555
17556 #endif /* USE_STRUCT_CONVERSION */
17557
17558 #if !defined(USE_STRUCT_CONVERSION)
17559
17560 static NTSTATUS thunk64_vkCmdSetDepthBoundsTestEnable(void *args)
17561 {
17562     struct vkCmdSetDepthBoundsTestEnable_params *params = args;
17563
17564     TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
17565
17566     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
17567     return STATUS_SUCCESS;
17568 }
17569
17570 #else /* USE_STRUCT_CONVERSION */
17571
17572 static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnable(void *args)
17573 {
17574     struct
17575     {
17576         VkCommandBuffer commandBuffer;
17577         VkBool32 depthBoundsTestEnable;
17578     } *params = args;
17579
17580     TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
17581
17582     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
17583     return STATUS_SUCCESS;
17584 }
17585
17586 #endif /* USE_STRUCT_CONVERSION */
17587
17588 #if !defined(USE_STRUCT_CONVERSION)
17589
17590 static NTSTATUS thunk64_vkCmdSetDepthBoundsTestEnableEXT(void *args)
17591 {
17592     struct vkCmdSetDepthBoundsTestEnableEXT_params *params = args;
17593
17594     TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
17595
17596     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
17597     return STATUS_SUCCESS;
17598 }
17599
17600 #else /* USE_STRUCT_CONVERSION */
17601
17602 static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnableEXT(void *args)
17603 {
17604     struct
17605     {
17606         VkCommandBuffer commandBuffer;
17607         VkBool32 depthBoundsTestEnable;
17608     } *params = args;
17609
17610     TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
17611
17612     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
17613     return STATUS_SUCCESS;
17614 }
17615
17616 #endif /* USE_STRUCT_CONVERSION */
17617
17618 #if !defined(USE_STRUCT_CONVERSION)
17619
17620 static NTSTATUS thunk64_vkCmdSetDepthClampEnableEXT(void *args)
17621 {
17622     struct vkCmdSetDepthClampEnableEXT_params *params = args;
17623
17624     TRACE("%p, %u\n", params->commandBuffer, params->depthClampEnable);
17625
17626     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClampEnable);
17627     return STATUS_SUCCESS;
17628 }
17629
17630 #else /* USE_STRUCT_CONVERSION */
17631
17632 static NTSTATUS thunk32_vkCmdSetDepthClampEnableEXT(void *args)
17633 {
17634     struct
17635     {
17636         VkCommandBuffer commandBuffer;
17637         VkBool32 depthClampEnable;
17638     } *params = args;
17639
17640     TRACE("%p, %u\n", params->commandBuffer, params->depthClampEnable);
17641
17642     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClampEnable);
17643     return STATUS_SUCCESS;
17644 }
17645
17646 #endif /* USE_STRUCT_CONVERSION */
17647
17648 #if !defined(USE_STRUCT_CONVERSION)
17649
17650 static NTSTATUS thunk64_vkCmdSetDepthClipEnableEXT(void *args)
17651 {
17652     struct vkCmdSetDepthClipEnableEXT_params *params = args;
17653
17654     TRACE("%p, %u\n", params->commandBuffer, params->depthClipEnable);
17655
17656     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClipEnable);
17657     return STATUS_SUCCESS;
17658 }
17659
17660 #else /* USE_STRUCT_CONVERSION */
17661
17662 static NTSTATUS thunk32_vkCmdSetDepthClipEnableEXT(void *args)
17663 {
17664     struct
17665     {
17666         VkCommandBuffer commandBuffer;
17667         VkBool32 depthClipEnable;
17668     } *params = args;
17669
17670     TRACE("%p, %u\n", params->commandBuffer, params->depthClipEnable);
17671
17672     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClipEnable);
17673     return STATUS_SUCCESS;
17674 }
17675
17676 #endif /* USE_STRUCT_CONVERSION */
17677
17678 #if !defined(USE_STRUCT_CONVERSION)
17679
17680 static NTSTATUS thunk64_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
17681 {
17682     struct vkCmdSetDepthClipNegativeOneToOneEXT_params *params = args;
17683
17684     TRACE("%p, %u\n", params->commandBuffer, params->negativeOneToOne);
17685
17686     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->negativeOneToOne);
17687     return STATUS_SUCCESS;
17688 }
17689
17690 #else /* USE_STRUCT_CONVERSION */
17691
17692 static NTSTATUS thunk32_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
17693 {
17694     struct
17695     {
17696         VkCommandBuffer commandBuffer;
17697         VkBool32 negativeOneToOne;
17698     } *params = args;
17699
17700     TRACE("%p, %u\n", params->commandBuffer, params->negativeOneToOne);
17701
17702     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->negativeOneToOne);
17703     return STATUS_SUCCESS;
17704 }
17705
17706 #endif /* USE_STRUCT_CONVERSION */
17707
17708 #if !defined(USE_STRUCT_CONVERSION)
17709
17710 static NTSTATUS thunk64_vkCmdSetDepthCompareOp(void *args)
17711 {
17712     struct vkCmdSetDepthCompareOp_params *params = args;
17713
17714     TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
17715
17716     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
17717     return STATUS_SUCCESS;
17718 }
17719
17720 #else /* USE_STRUCT_CONVERSION */
17721
17722 static NTSTATUS thunk32_vkCmdSetDepthCompareOp(void *args)
17723 {
17724     struct
17725     {
17726         VkCommandBuffer commandBuffer;
17727         VkCompareOp depthCompareOp;
17728     } *params = args;
17729
17730     TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
17731
17732     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
17733     return STATUS_SUCCESS;
17734 }
17735
17736 #endif /* USE_STRUCT_CONVERSION */
17737
17738 #if !defined(USE_STRUCT_CONVERSION)
17739
17740 static NTSTATUS thunk64_vkCmdSetDepthCompareOpEXT(void *args)
17741 {
17742     struct vkCmdSetDepthCompareOpEXT_params *params = args;
17743
17744     TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
17745
17746     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
17747     return STATUS_SUCCESS;
17748 }
17749
17750 #else /* USE_STRUCT_CONVERSION */
17751
17752 static NTSTATUS thunk32_vkCmdSetDepthCompareOpEXT(void *args)
17753 {
17754     struct
17755     {
17756         VkCommandBuffer commandBuffer;
17757         VkCompareOp depthCompareOp;
17758     } *params = args;
17759
17760     TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
17761
17762     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
17763     return STATUS_SUCCESS;
17764 }
17765
17766 #endif /* USE_STRUCT_CONVERSION */
17767
17768 #if !defined(USE_STRUCT_CONVERSION)
17769
17770 static NTSTATUS thunk64_vkCmdSetDepthTestEnable(void *args)
17771 {
17772     struct vkCmdSetDepthTestEnable_params *params = args;
17773
17774     TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
17775
17776     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
17777     return STATUS_SUCCESS;
17778 }
17779
17780 #else /* USE_STRUCT_CONVERSION */
17781
17782 static NTSTATUS thunk32_vkCmdSetDepthTestEnable(void *args)
17783 {
17784     struct
17785     {
17786         VkCommandBuffer commandBuffer;
17787         VkBool32 depthTestEnable;
17788     } *params = args;
17789
17790     TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
17791
17792     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
17793     return STATUS_SUCCESS;
17794 }
17795
17796 #endif /* USE_STRUCT_CONVERSION */
17797
17798 #if !defined(USE_STRUCT_CONVERSION)
17799
17800 static NTSTATUS thunk64_vkCmdSetDepthTestEnableEXT(void *args)
17801 {
17802     struct vkCmdSetDepthTestEnableEXT_params *params = args;
17803
17804     TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
17805
17806     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
17807     return STATUS_SUCCESS;
17808 }
17809
17810 #else /* USE_STRUCT_CONVERSION */
17811
17812 static NTSTATUS thunk32_vkCmdSetDepthTestEnableEXT(void *args)
17813 {
17814     struct
17815     {
17816         VkCommandBuffer commandBuffer;
17817         VkBool32 depthTestEnable;
17818     } *params = args;
17819
17820     TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
17821
17822     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
17823     return STATUS_SUCCESS;
17824 }
17825
17826 #endif /* USE_STRUCT_CONVERSION */
17827
17828 #if !defined(USE_STRUCT_CONVERSION)
17829
17830 static NTSTATUS thunk64_vkCmdSetDepthWriteEnable(void *args)
17831 {
17832     struct vkCmdSetDepthWriteEnable_params *params = args;
17833
17834     TRACE("%p, %u\n", params->commandBuffer, params->depthWriteEnable);
17835
17836     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
17837     return STATUS_SUCCESS;
17838 }
17839
17840 #else /* USE_STRUCT_CONVERSION */
17841
17842 static NTSTATUS thunk32_vkCmdSetDepthWriteEnable(void *args)
17843 {
17844     struct
17845     {
17846         VkCommandBuffer commandBuffer;
17847         VkBool32 depthWriteEnable;
17848     } *params = args;
17849
17850     TRACE("%p, %u\n", params->commandBuffer, params->depthWriteEnable);
17851
17852     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
17853     return STATUS_SUCCESS;
17854 }
17855
17856 #endif /* USE_STRUCT_CONVERSION */
17857
17858 #if !defined(USE_STRUCT_CONVERSION)
17859
17860 static NTSTATUS thunk64_vkCmdSetDepthWriteEnableEXT(void *args)
17861 {
17862     struct vkCmdSetDepthWriteEnableEXT_params *params = args;
17863
17864     TRACE("%p, %u\n", params->commandBuffer, params->depthWriteEnable);
17865
17866     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
17867     return STATUS_SUCCESS;
17868 }
17869
17870 #else /* USE_STRUCT_CONVERSION */
17871
17872 static NTSTATUS thunk32_vkCmdSetDepthWriteEnableEXT(void *args)
17873 {
17874     struct
17875     {
17876         VkCommandBuffer commandBuffer;
17877         VkBool32 depthWriteEnable;
17878     } *params = args;
17879
17880     TRACE("%p, %u\n", params->commandBuffer, params->depthWriteEnable);
17881
17882     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
17883     return STATUS_SUCCESS;
17884 }
17885
17886 #endif /* USE_STRUCT_CONVERSION */
17887
17888 #if !defined(USE_STRUCT_CONVERSION)
17889
17890 static NTSTATUS thunk64_vkCmdSetDeviceMask(void *args)
17891 {
17892     struct vkCmdSetDeviceMask_params *params = args;
17893
17894     TRACE("%p, %u\n", params->commandBuffer, params->deviceMask);
17895
17896     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
17897     return STATUS_SUCCESS;
17898 }
17899
17900 #else /* USE_STRUCT_CONVERSION */
17901
17902 static NTSTATUS thunk32_vkCmdSetDeviceMask(void *args)
17903 {
17904     struct
17905     {
17906         VkCommandBuffer commandBuffer;
17907         uint32_t deviceMask;
17908     } *params = args;
17909
17910     TRACE("%p, %u\n", params->commandBuffer, params->deviceMask);
17911
17912     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
17913     return STATUS_SUCCESS;
17914 }
17915
17916 #endif /* USE_STRUCT_CONVERSION */
17917
17918 #if !defined(USE_STRUCT_CONVERSION)
17919
17920 static NTSTATUS thunk64_vkCmdSetDeviceMaskKHR(void *args)
17921 {
17922     struct vkCmdSetDeviceMaskKHR_params *params = args;
17923
17924     TRACE("%p, %u\n", params->commandBuffer, params->deviceMask);
17925
17926     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
17927     return STATUS_SUCCESS;
17928 }
17929
17930 #else /* USE_STRUCT_CONVERSION */
17931
17932 static NTSTATUS thunk32_vkCmdSetDeviceMaskKHR(void *args)
17933 {
17934     struct
17935     {
17936         VkCommandBuffer commandBuffer;
17937         uint32_t deviceMask;
17938     } *params = args;
17939
17940     TRACE("%p, %u\n", params->commandBuffer, params->deviceMask);
17941
17942     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
17943     return STATUS_SUCCESS;
17944 }
17945
17946 #endif /* USE_STRUCT_CONVERSION */
17947
17948 #if !defined(USE_STRUCT_CONVERSION)
17949
17950 static NTSTATUS thunk64_vkCmdSetDiscardRectangleEXT(void *args)
17951 {
17952     struct vkCmdSetDiscardRectangleEXT_params *params = args;
17953
17954     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);
17955
17956     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);
17957     return STATUS_SUCCESS;
17958 }
17959
17960 #else /* USE_STRUCT_CONVERSION */
17961
17962 static NTSTATUS thunk32_vkCmdSetDiscardRectangleEXT(void *args)
17963 {
17964     struct
17965     {
17966         VkCommandBuffer commandBuffer;
17967         uint32_t firstDiscardRectangle;
17968         uint32_t discardRectangleCount;
17969         const VkRect2D *pDiscardRectangles;
17970     } *params = args;
17971
17972     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);
17973
17974     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);
17975     return STATUS_SUCCESS;
17976 }
17977
17978 #endif /* USE_STRUCT_CONVERSION */
17979
17980 #if !defined(USE_STRUCT_CONVERSION)
17981
17982 static NTSTATUS thunk64_vkCmdSetEvent(void *args)
17983 {
17984     struct vkCmdSetEvent_params *params = args;
17985
17986     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
17987
17988     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
17989     return STATUS_SUCCESS;
17990 }
17991
17992 #else /* USE_STRUCT_CONVERSION */
17993
17994 static NTSTATUS thunk32_vkCmdSetEvent(void *args)
17995 {
17996     struct
17997     {
17998         VkCommandBuffer commandBuffer;
17999         VkEvent DECLSPEC_ALIGN(8) event;
18000         VkPipelineStageFlags stageMask;
18001     } *params = args;
18002
18003     TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
18004
18005     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
18006     return STATUS_SUCCESS;
18007 }
18008
18009 #endif /* USE_STRUCT_CONVERSION */
18010
18011 #if !defined(USE_STRUCT_CONVERSION)
18012
18013 static NTSTATUS thunk64_vkCmdSetEvent2(void *args)
18014 {
18015     struct vkCmdSetEvent2_params *params = args;
18016
18017     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
18018
18019     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
18020     return STATUS_SUCCESS;
18021 }
18022
18023 #else /* USE_STRUCT_CONVERSION */
18024
18025 static NTSTATUS thunk32_vkCmdSetEvent2(void *args)
18026 {
18027     struct
18028     {
18029         VkCommandBuffer commandBuffer;
18030         VkEvent DECLSPEC_ALIGN(8) event;
18031         const VkDependencyInfo32 *pDependencyInfo;
18032     } *params = args;
18033     VkDependencyInfo pDependencyInfo_host;
18034     struct conversion_context ctx;
18035
18036     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
18037
18038     init_conversion_context(&ctx);
18039     convert_VkDependencyInfo_win32_to_host(&ctx, params->pDependencyInfo, &pDependencyInfo_host);
18040     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, &pDependencyInfo_host);
18041     free_conversion_context(&ctx);
18042     return STATUS_SUCCESS;
18043 }
18044
18045 #endif /* USE_STRUCT_CONVERSION */
18046
18047 #if !defined(USE_STRUCT_CONVERSION)
18048
18049 static NTSTATUS thunk64_vkCmdSetEvent2KHR(void *args)
18050 {
18051     struct vkCmdSetEvent2KHR_params *params = args;
18052
18053     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
18054
18055     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
18056     return STATUS_SUCCESS;
18057 }
18058
18059 #else /* USE_STRUCT_CONVERSION */
18060
18061 static NTSTATUS thunk32_vkCmdSetEvent2KHR(void *args)
18062 {
18063     struct
18064     {
18065         VkCommandBuffer commandBuffer;
18066         VkEvent DECLSPEC_ALIGN(8) event;
18067         const VkDependencyInfo32 *pDependencyInfo;
18068     } *params = args;
18069     VkDependencyInfo pDependencyInfo_host;
18070     struct conversion_context ctx;
18071
18072     TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
18073
18074     init_conversion_context(&ctx);
18075     convert_VkDependencyInfo_win32_to_host(&ctx, params->pDependencyInfo, &pDependencyInfo_host);
18076     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, &pDependencyInfo_host);
18077     free_conversion_context(&ctx);
18078     return STATUS_SUCCESS;
18079 }
18080
18081 #endif /* USE_STRUCT_CONVERSION */
18082
18083 #if !defined(USE_STRUCT_CONVERSION)
18084
18085 static NTSTATUS thunk64_vkCmdSetExclusiveScissorNV(void *args)
18086 {
18087     struct vkCmdSetExclusiveScissorNV_params *params = args;
18088
18089     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);
18090
18091     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);
18092     return STATUS_SUCCESS;
18093 }
18094
18095 #else /* USE_STRUCT_CONVERSION */
18096
18097 static NTSTATUS thunk32_vkCmdSetExclusiveScissorNV(void *args)
18098 {
18099     struct
18100     {
18101         VkCommandBuffer commandBuffer;
18102         uint32_t firstExclusiveScissor;
18103         uint32_t exclusiveScissorCount;
18104         const VkRect2D *pExclusiveScissors;
18105     } *params = args;
18106
18107     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);
18108
18109     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);
18110     return STATUS_SUCCESS;
18111 }
18112
18113 #endif /* USE_STRUCT_CONVERSION */
18114
18115 #if !defined(USE_STRUCT_CONVERSION)
18116
18117 static NTSTATUS thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
18118 {
18119     struct vkCmdSetExtraPrimitiveOverestimationSizeEXT_params *params = args;
18120
18121     TRACE("%p, %f\n", params->commandBuffer, params->extraPrimitiveOverestimationSize);
18122
18123     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->extraPrimitiveOverestimationSize);
18124     return STATUS_SUCCESS;
18125 }
18126
18127 #else /* USE_STRUCT_CONVERSION */
18128
18129 static NTSTATUS thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
18130 {
18131     struct
18132     {
18133         VkCommandBuffer commandBuffer;
18134         float extraPrimitiveOverestimationSize;
18135     } *params = args;
18136
18137     TRACE("%p, %f\n", params->commandBuffer, params->extraPrimitiveOverestimationSize);
18138
18139     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->extraPrimitiveOverestimationSize);
18140     return STATUS_SUCCESS;
18141 }
18142
18143 #endif /* USE_STRUCT_CONVERSION */
18144
18145 #if !defined(USE_STRUCT_CONVERSION)
18146
18147 static NTSTATUS thunk64_vkCmdSetFragmentShadingRateEnumNV(void *args)
18148 {
18149     struct vkCmdSetFragmentShadingRateEnumNV_params *params = args;
18150
18151     TRACE("%p, %#x, %p\n", params->commandBuffer, params->shadingRate, params->combinerOps);
18152
18153     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRate, params->combinerOps);
18154     return STATUS_SUCCESS;
18155 }
18156
18157 #else /* USE_STRUCT_CONVERSION */
18158
18159 static NTSTATUS thunk32_vkCmdSetFragmentShadingRateEnumNV(void *args)
18160 {
18161     struct
18162     {
18163         VkCommandBuffer commandBuffer;
18164         VkFragmentShadingRateNV shadingRate;
18165         const VkFragmentShadingRateCombinerOpKHR *combinerOps;
18166     } *params = args;
18167
18168     TRACE("%p, %#x, %p\n", params->commandBuffer, params->shadingRate, params->combinerOps);
18169
18170     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRate, params->combinerOps);
18171     return STATUS_SUCCESS;
18172 }
18173
18174 #endif /* USE_STRUCT_CONVERSION */
18175
18176 #if !defined(USE_STRUCT_CONVERSION)
18177
18178 static NTSTATUS thunk64_vkCmdSetFragmentShadingRateKHR(void *args)
18179 {
18180     struct vkCmdSetFragmentShadingRateKHR_params *params = args;
18181
18182     TRACE("%p, %p, %p\n", params->commandBuffer, params->pFragmentSize, params->combinerOps);
18183
18184     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pFragmentSize, params->combinerOps);
18185     return STATUS_SUCCESS;
18186 }
18187
18188 #else /* USE_STRUCT_CONVERSION */
18189
18190 static NTSTATUS thunk32_vkCmdSetFragmentShadingRateKHR(void *args)
18191 {
18192     struct
18193     {
18194         VkCommandBuffer commandBuffer;
18195         const VkExtent2D *pFragmentSize;
18196         const VkFragmentShadingRateCombinerOpKHR *combinerOps;
18197     } *params = args;
18198
18199     TRACE("%p, %p, %p\n", params->commandBuffer, params->pFragmentSize, params->combinerOps);
18200
18201     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pFragmentSize, params->combinerOps);
18202     return STATUS_SUCCESS;
18203 }
18204
18205 #endif /* USE_STRUCT_CONVERSION */
18206
18207 #if !defined(USE_STRUCT_CONVERSION)
18208
18209 static NTSTATUS thunk64_vkCmdSetFrontFace(void *args)
18210 {
18211     struct vkCmdSetFrontFace_params *params = args;
18212
18213     TRACE("%p, %#x\n", params->commandBuffer, params->frontFace);
18214
18215     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
18216     return STATUS_SUCCESS;
18217 }
18218
18219 #else /* USE_STRUCT_CONVERSION */
18220
18221 static NTSTATUS thunk32_vkCmdSetFrontFace(void *args)
18222 {
18223     struct
18224     {
18225         VkCommandBuffer commandBuffer;
18226         VkFrontFace frontFace;
18227     } *params = args;
18228
18229     TRACE("%p, %#x\n", params->commandBuffer, params->frontFace);
18230
18231     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
18232     return STATUS_SUCCESS;
18233 }
18234
18235 #endif /* USE_STRUCT_CONVERSION */
18236
18237 #if !defined(USE_STRUCT_CONVERSION)
18238
18239 static NTSTATUS thunk64_vkCmdSetFrontFaceEXT(void *args)
18240 {
18241     struct vkCmdSetFrontFaceEXT_params *params = args;
18242
18243     TRACE("%p, %#x\n", params->commandBuffer, params->frontFace);
18244
18245     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
18246     return STATUS_SUCCESS;
18247 }
18248
18249 #else /* USE_STRUCT_CONVERSION */
18250
18251 static NTSTATUS thunk32_vkCmdSetFrontFaceEXT(void *args)
18252 {
18253     struct
18254     {
18255         VkCommandBuffer commandBuffer;
18256         VkFrontFace frontFace;
18257     } *params = args;
18258
18259     TRACE("%p, %#x\n", params->commandBuffer, params->frontFace);
18260
18261     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
18262     return STATUS_SUCCESS;
18263 }
18264
18265 #endif /* USE_STRUCT_CONVERSION */
18266
18267 #if !defined(USE_STRUCT_CONVERSION)
18268
18269 static NTSTATUS thunk64_vkCmdSetLineRasterizationModeEXT(void *args)
18270 {
18271     struct vkCmdSetLineRasterizationModeEXT_params *params = args;
18272
18273     TRACE("%p, %#x\n", params->commandBuffer, params->lineRasterizationMode);
18274
18275     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineRasterizationMode);
18276     return STATUS_SUCCESS;
18277 }
18278
18279 #else /* USE_STRUCT_CONVERSION */
18280
18281 static NTSTATUS thunk32_vkCmdSetLineRasterizationModeEXT(void *args)
18282 {
18283     struct
18284     {
18285         VkCommandBuffer commandBuffer;
18286         VkLineRasterizationModeEXT lineRasterizationMode;
18287     } *params = args;
18288
18289     TRACE("%p, %#x\n", params->commandBuffer, params->lineRasterizationMode);
18290
18291     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineRasterizationMode);
18292     return STATUS_SUCCESS;
18293 }
18294
18295 #endif /* USE_STRUCT_CONVERSION */
18296
18297 #if !defined(USE_STRUCT_CONVERSION)
18298
18299 static NTSTATUS thunk64_vkCmdSetLineStippleEXT(void *args)
18300 {
18301     struct vkCmdSetLineStippleEXT_params *params = args;
18302
18303     TRACE("%p, %u, %u\n", params->commandBuffer, params->lineStippleFactor, params->lineStipplePattern);
18304
18305     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
18306     return STATUS_SUCCESS;
18307 }
18308
18309 #else /* USE_STRUCT_CONVERSION */
18310
18311 static NTSTATUS thunk32_vkCmdSetLineStippleEXT(void *args)
18312 {
18313     struct
18314     {
18315         VkCommandBuffer commandBuffer;
18316         uint32_t lineStippleFactor;
18317         uint16_t lineStipplePattern;
18318     } *params = args;
18319
18320     TRACE("%p, %u, %u\n", params->commandBuffer, params->lineStippleFactor, params->lineStipplePattern);
18321
18322     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
18323     return STATUS_SUCCESS;
18324 }
18325
18326 #endif /* USE_STRUCT_CONVERSION */
18327
18328 #if !defined(USE_STRUCT_CONVERSION)
18329
18330 static NTSTATUS thunk64_vkCmdSetLineStippleEnableEXT(void *args)
18331 {
18332     struct vkCmdSetLineStippleEnableEXT_params *params = args;
18333
18334     TRACE("%p, %u\n", params->commandBuffer, params->stippledLineEnable);
18335
18336     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stippledLineEnable);
18337     return STATUS_SUCCESS;
18338 }
18339
18340 #else /* USE_STRUCT_CONVERSION */
18341
18342 static NTSTATUS thunk32_vkCmdSetLineStippleEnableEXT(void *args)
18343 {
18344     struct
18345     {
18346         VkCommandBuffer commandBuffer;
18347         VkBool32 stippledLineEnable;
18348     } *params = args;
18349
18350     TRACE("%p, %u\n", params->commandBuffer, params->stippledLineEnable);
18351
18352     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stippledLineEnable);
18353     return STATUS_SUCCESS;
18354 }
18355
18356 #endif /* USE_STRUCT_CONVERSION */
18357
18358 #if !defined(USE_STRUCT_CONVERSION)
18359
18360 static NTSTATUS thunk64_vkCmdSetLineWidth(void *args)
18361 {
18362     struct vkCmdSetLineWidth_params *params = args;
18363
18364     TRACE("%p, %f\n", params->commandBuffer, params->lineWidth);
18365
18366     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineWidth);
18367     return STATUS_SUCCESS;
18368 }
18369
18370 #else /* USE_STRUCT_CONVERSION */
18371
18372 static NTSTATUS thunk32_vkCmdSetLineWidth(void *args)
18373 {
18374     struct
18375     {
18376         VkCommandBuffer commandBuffer;
18377         float lineWidth;
18378     } *params = args;
18379
18380     TRACE("%p, %f\n", params->commandBuffer, params->lineWidth);
18381
18382     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineWidth);
18383     return STATUS_SUCCESS;
18384 }
18385
18386 #endif /* USE_STRUCT_CONVERSION */
18387
18388 #if !defined(USE_STRUCT_CONVERSION)
18389
18390 static NTSTATUS thunk64_vkCmdSetLogicOpEXT(void *args)
18391 {
18392     struct vkCmdSetLogicOpEXT_params *params = args;
18393
18394     TRACE("%p, %#x\n", params->commandBuffer, params->logicOp);
18395
18396     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOp);
18397     return STATUS_SUCCESS;
18398 }
18399
18400 #else /* USE_STRUCT_CONVERSION */
18401
18402 static NTSTATUS thunk32_vkCmdSetLogicOpEXT(void *args)
18403 {
18404     struct
18405     {
18406         VkCommandBuffer commandBuffer;
18407         VkLogicOp logicOp;
18408     } *params = args;
18409
18410     TRACE("%p, %#x\n", params->commandBuffer, params->logicOp);
18411
18412     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOp);
18413     return STATUS_SUCCESS;
18414 }
18415
18416 #endif /* USE_STRUCT_CONVERSION */
18417
18418 #if !defined(USE_STRUCT_CONVERSION)
18419
18420 static NTSTATUS thunk64_vkCmdSetLogicOpEnableEXT(void *args)
18421 {
18422     struct vkCmdSetLogicOpEnableEXT_params *params = args;
18423
18424     TRACE("%p, %u\n", params->commandBuffer, params->logicOpEnable);
18425
18426     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOpEnable);
18427     return STATUS_SUCCESS;
18428 }
18429
18430 #else /* USE_STRUCT_CONVERSION */
18431
18432 static NTSTATUS thunk32_vkCmdSetLogicOpEnableEXT(void *args)
18433 {
18434     struct
18435     {
18436         VkCommandBuffer commandBuffer;
18437         VkBool32 logicOpEnable;
18438     } *params = args;
18439
18440     TRACE("%p, %u\n", params->commandBuffer, params->logicOpEnable);
18441
18442     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOpEnable);
18443     return STATUS_SUCCESS;
18444 }
18445
18446 #endif /* USE_STRUCT_CONVERSION */
18447
18448 #if !defined(USE_STRUCT_CONVERSION)
18449
18450 static NTSTATUS thunk64_vkCmdSetPatchControlPointsEXT(void *args)
18451 {
18452     struct vkCmdSetPatchControlPointsEXT_params *params = args;
18453
18454     TRACE("%p, %u\n", params->commandBuffer, params->patchControlPoints);
18455
18456     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->patchControlPoints);
18457     return STATUS_SUCCESS;
18458 }
18459
18460 #else /* USE_STRUCT_CONVERSION */
18461
18462 static NTSTATUS thunk32_vkCmdSetPatchControlPointsEXT(void *args)
18463 {
18464     struct
18465     {
18466         VkCommandBuffer commandBuffer;
18467         uint32_t patchControlPoints;
18468     } *params = args;
18469
18470     TRACE("%p, %u\n", params->commandBuffer, params->patchControlPoints);
18471
18472     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->patchControlPoints);
18473     return STATUS_SUCCESS;
18474 }
18475
18476 #endif /* USE_STRUCT_CONVERSION */
18477
18478 #if !defined(USE_STRUCT_CONVERSION)
18479
18480 static NTSTATUS thunk64_vkCmdSetPerformanceMarkerINTEL(void *args)
18481 {
18482     struct vkCmdSetPerformanceMarkerINTEL_params *params = args;
18483
18484     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
18485
18486     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
18487     return STATUS_SUCCESS;
18488 }
18489
18490 #else /* USE_STRUCT_CONVERSION */
18491
18492 static NTSTATUS thunk32_vkCmdSetPerformanceMarkerINTEL(void *args)
18493 {
18494     struct
18495     {
18496         VkCommandBuffer commandBuffer;
18497         const VkPerformanceMarkerInfoINTEL32 *pMarkerInfo;
18498         VkResult result;
18499     } *params = args;
18500     VkPerformanceMarkerInfoINTEL pMarkerInfo_host;
18501
18502     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
18503
18504     convert_VkPerformanceMarkerInfoINTEL_win32_to_host(params->pMarkerInfo, &pMarkerInfo_host);
18505     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pMarkerInfo_host);
18506     return STATUS_SUCCESS;
18507 }
18508
18509 #endif /* USE_STRUCT_CONVERSION */
18510
18511 #if !defined(USE_STRUCT_CONVERSION)
18512
18513 static NTSTATUS thunk64_vkCmdSetPerformanceOverrideINTEL(void *args)
18514 {
18515     struct vkCmdSetPerformanceOverrideINTEL_params *params = args;
18516
18517     TRACE("%p, %p\n", params->commandBuffer, params->pOverrideInfo);
18518
18519     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pOverrideInfo);
18520     return STATUS_SUCCESS;
18521 }
18522
18523 #else /* USE_STRUCT_CONVERSION */
18524
18525 static NTSTATUS thunk32_vkCmdSetPerformanceOverrideINTEL(void *args)
18526 {
18527     struct
18528     {
18529         VkCommandBuffer commandBuffer;
18530         const VkPerformanceOverrideInfoINTEL32 *pOverrideInfo;
18531         VkResult result;
18532     } *params = args;
18533     VkPerformanceOverrideInfoINTEL pOverrideInfo_host;
18534
18535     TRACE("%p, %p\n", params->commandBuffer, params->pOverrideInfo);
18536
18537     convert_VkPerformanceOverrideInfoINTEL_win32_to_host(params->pOverrideInfo, &pOverrideInfo_host);
18538     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pOverrideInfo_host);
18539     return STATUS_SUCCESS;
18540 }
18541
18542 #endif /* USE_STRUCT_CONVERSION */
18543
18544 #if !defined(USE_STRUCT_CONVERSION)
18545
18546 static NTSTATUS thunk64_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
18547 {
18548     struct vkCmdSetPerformanceStreamMarkerINTEL_params *params = args;
18549
18550     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
18551
18552     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
18553     return STATUS_SUCCESS;
18554 }
18555
18556 #else /* USE_STRUCT_CONVERSION */
18557
18558 static NTSTATUS thunk32_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
18559 {
18560     struct
18561     {
18562         VkCommandBuffer commandBuffer;
18563         const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo;
18564         VkResult result;
18565     } *params = args;
18566
18567     TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
18568
18569     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
18570     return STATUS_SUCCESS;
18571 }
18572
18573 #endif /* USE_STRUCT_CONVERSION */
18574
18575 #if !defined(USE_STRUCT_CONVERSION)
18576
18577 static NTSTATUS thunk64_vkCmdSetPolygonModeEXT(void *args)
18578 {
18579     struct vkCmdSetPolygonModeEXT_params *params = args;
18580
18581     TRACE("%p, %#x\n", params->commandBuffer, params->polygonMode);
18582
18583     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->polygonMode);
18584     return STATUS_SUCCESS;
18585 }
18586
18587 #else /* USE_STRUCT_CONVERSION */
18588
18589 static NTSTATUS thunk32_vkCmdSetPolygonModeEXT(void *args)
18590 {
18591     struct
18592     {
18593         VkCommandBuffer commandBuffer;
18594         VkPolygonMode polygonMode;
18595     } *params = args;
18596
18597     TRACE("%p, %#x\n", params->commandBuffer, params->polygonMode);
18598
18599     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->polygonMode);
18600     return STATUS_SUCCESS;
18601 }
18602
18603 #endif /* USE_STRUCT_CONVERSION */
18604
18605 #if !defined(USE_STRUCT_CONVERSION)
18606
18607 static NTSTATUS thunk64_vkCmdSetPrimitiveRestartEnable(void *args)
18608 {
18609     struct vkCmdSetPrimitiveRestartEnable_params *params = args;
18610
18611     TRACE("%p, %u\n", params->commandBuffer, params->primitiveRestartEnable);
18612
18613     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
18614     return STATUS_SUCCESS;
18615 }
18616
18617 #else /* USE_STRUCT_CONVERSION */
18618
18619 static NTSTATUS thunk32_vkCmdSetPrimitiveRestartEnable(void *args)
18620 {
18621     struct
18622     {
18623         VkCommandBuffer commandBuffer;
18624         VkBool32 primitiveRestartEnable;
18625     } *params = args;
18626
18627     TRACE("%p, %u\n", params->commandBuffer, params->primitiveRestartEnable);
18628
18629     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
18630     return STATUS_SUCCESS;
18631 }
18632
18633 #endif /* USE_STRUCT_CONVERSION */
18634
18635 #if !defined(USE_STRUCT_CONVERSION)
18636
18637 static NTSTATUS thunk64_vkCmdSetPrimitiveRestartEnableEXT(void *args)
18638 {
18639     struct vkCmdSetPrimitiveRestartEnableEXT_params *params = args;
18640
18641     TRACE("%p, %u\n", params->commandBuffer, params->primitiveRestartEnable);
18642
18643     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
18644     return STATUS_SUCCESS;
18645 }
18646
18647 #else /* USE_STRUCT_CONVERSION */
18648
18649 static NTSTATUS thunk32_vkCmdSetPrimitiveRestartEnableEXT(void *args)
18650 {
18651     struct
18652     {
18653         VkCommandBuffer commandBuffer;
18654         VkBool32 primitiveRestartEnable;
18655     } *params = args;
18656
18657     TRACE("%p, %u\n", params->commandBuffer, params->primitiveRestartEnable);
18658
18659     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
18660     return STATUS_SUCCESS;
18661 }
18662
18663 #endif /* USE_STRUCT_CONVERSION */
18664
18665 #if !defined(USE_STRUCT_CONVERSION)
18666
18667 static NTSTATUS thunk64_vkCmdSetPrimitiveTopology(void *args)
18668 {
18669     struct vkCmdSetPrimitiveTopology_params *params = args;
18670
18671     TRACE("%p, %#x\n", params->commandBuffer, params->primitiveTopology);
18672
18673     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
18674     return STATUS_SUCCESS;
18675 }
18676
18677 #else /* USE_STRUCT_CONVERSION */
18678
18679 static NTSTATUS thunk32_vkCmdSetPrimitiveTopology(void *args)
18680 {
18681     struct
18682     {
18683         VkCommandBuffer commandBuffer;
18684         VkPrimitiveTopology primitiveTopology;
18685     } *params = args;
18686
18687     TRACE("%p, %#x\n", params->commandBuffer, params->primitiveTopology);
18688
18689     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
18690     return STATUS_SUCCESS;
18691 }
18692
18693 #endif /* USE_STRUCT_CONVERSION */
18694
18695 #if !defined(USE_STRUCT_CONVERSION)
18696
18697 static NTSTATUS thunk64_vkCmdSetPrimitiveTopologyEXT(void *args)
18698 {
18699     struct vkCmdSetPrimitiveTopologyEXT_params *params = args;
18700
18701     TRACE("%p, %#x\n", params->commandBuffer, params->primitiveTopology);
18702
18703     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
18704     return STATUS_SUCCESS;
18705 }
18706
18707 #else /* USE_STRUCT_CONVERSION */
18708
18709 static NTSTATUS thunk32_vkCmdSetPrimitiveTopologyEXT(void *args)
18710 {
18711     struct
18712     {
18713         VkCommandBuffer commandBuffer;
18714         VkPrimitiveTopology primitiveTopology;
18715     } *params = args;
18716
18717     TRACE("%p, %#x\n", params->commandBuffer, params->primitiveTopology);
18718
18719     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
18720     return STATUS_SUCCESS;
18721 }
18722
18723 #endif /* USE_STRUCT_CONVERSION */
18724
18725 #if !defined(USE_STRUCT_CONVERSION)
18726
18727 static NTSTATUS thunk64_vkCmdSetProvokingVertexModeEXT(void *args)
18728 {
18729     struct vkCmdSetProvokingVertexModeEXT_params *params = args;
18730
18731     TRACE("%p, %#x\n", params->commandBuffer, params->provokingVertexMode);
18732
18733     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->provokingVertexMode);
18734     return STATUS_SUCCESS;
18735 }
18736
18737 #else /* USE_STRUCT_CONVERSION */
18738
18739 static NTSTATUS thunk32_vkCmdSetProvokingVertexModeEXT(void *args)
18740 {
18741     struct
18742     {
18743         VkCommandBuffer commandBuffer;
18744         VkProvokingVertexModeEXT provokingVertexMode;
18745     } *params = args;
18746
18747     TRACE("%p, %#x\n", params->commandBuffer, params->provokingVertexMode);
18748
18749     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->provokingVertexMode);
18750     return STATUS_SUCCESS;
18751 }
18752
18753 #endif /* USE_STRUCT_CONVERSION */
18754
18755 #if !defined(USE_STRUCT_CONVERSION)
18756
18757 static NTSTATUS thunk64_vkCmdSetRasterizationSamplesEXT(void *args)
18758 {
18759     struct vkCmdSetRasterizationSamplesEXT_params *params = args;
18760
18761     TRACE("%p, %#x\n", params->commandBuffer, params->rasterizationSamples);
18762
18763     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationSamples);
18764     return STATUS_SUCCESS;
18765 }
18766
18767 #else /* USE_STRUCT_CONVERSION */
18768
18769 static NTSTATUS thunk32_vkCmdSetRasterizationSamplesEXT(void *args)
18770 {
18771     struct
18772     {
18773         VkCommandBuffer commandBuffer;
18774         VkSampleCountFlagBits rasterizationSamples;
18775     } *params = args;
18776
18777     TRACE("%p, %#x\n", params->commandBuffer, params->rasterizationSamples);
18778
18779     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationSamples);
18780     return STATUS_SUCCESS;
18781 }
18782
18783 #endif /* USE_STRUCT_CONVERSION */
18784
18785 #if !defined(USE_STRUCT_CONVERSION)
18786
18787 static NTSTATUS thunk64_vkCmdSetRasterizationStreamEXT(void *args)
18788 {
18789     struct vkCmdSetRasterizationStreamEXT_params *params = args;
18790
18791     TRACE("%p, %u\n", params->commandBuffer, params->rasterizationStream);
18792
18793     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationStream);
18794     return STATUS_SUCCESS;
18795 }
18796
18797 #else /* USE_STRUCT_CONVERSION */
18798
18799 static NTSTATUS thunk32_vkCmdSetRasterizationStreamEXT(void *args)
18800 {
18801     struct
18802     {
18803         VkCommandBuffer commandBuffer;
18804         uint32_t rasterizationStream;
18805     } *params = args;
18806
18807     TRACE("%p, %u\n", params->commandBuffer, params->rasterizationStream);
18808
18809     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationStream);
18810     return STATUS_SUCCESS;
18811 }
18812
18813 #endif /* USE_STRUCT_CONVERSION */
18814
18815 #if !defined(USE_STRUCT_CONVERSION)
18816
18817 static NTSTATUS thunk64_vkCmdSetRasterizerDiscardEnable(void *args)
18818 {
18819     struct vkCmdSetRasterizerDiscardEnable_params *params = args;
18820
18821     TRACE("%p, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
18822
18823     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
18824     return STATUS_SUCCESS;
18825 }
18826
18827 #else /* USE_STRUCT_CONVERSION */
18828
18829 static NTSTATUS thunk32_vkCmdSetRasterizerDiscardEnable(void *args)
18830 {
18831     struct
18832     {
18833         VkCommandBuffer commandBuffer;
18834         VkBool32 rasterizerDiscardEnable;
18835     } *params = args;
18836
18837     TRACE("%p, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
18838
18839     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
18840     return STATUS_SUCCESS;
18841 }
18842
18843 #endif /* USE_STRUCT_CONVERSION */
18844
18845 #if !defined(USE_STRUCT_CONVERSION)
18846
18847 static NTSTATUS thunk64_vkCmdSetRasterizerDiscardEnableEXT(void *args)
18848 {
18849     struct vkCmdSetRasterizerDiscardEnableEXT_params *params = args;
18850
18851     TRACE("%p, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
18852
18853     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
18854     return STATUS_SUCCESS;
18855 }
18856
18857 #else /* USE_STRUCT_CONVERSION */
18858
18859 static NTSTATUS thunk32_vkCmdSetRasterizerDiscardEnableEXT(void *args)
18860 {
18861     struct
18862     {
18863         VkCommandBuffer commandBuffer;
18864         VkBool32 rasterizerDiscardEnable;
18865     } *params = args;
18866
18867     TRACE("%p, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
18868
18869     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
18870     return STATUS_SUCCESS;
18871 }
18872
18873 #endif /* USE_STRUCT_CONVERSION */
18874
18875 #if !defined(USE_STRUCT_CONVERSION)
18876
18877 static NTSTATUS thunk64_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
18878 {
18879     struct vkCmdSetRayTracingPipelineStackSizeKHR_params *params = args;
18880
18881     TRACE("%p, %u\n", params->commandBuffer, params->pipelineStackSize);
18882
18883     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStackSize);
18884     return STATUS_SUCCESS;
18885 }
18886
18887 #else /* USE_STRUCT_CONVERSION */
18888
18889 static NTSTATUS thunk32_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
18890 {
18891     struct
18892     {
18893         VkCommandBuffer commandBuffer;
18894         uint32_t pipelineStackSize;
18895     } *params = args;
18896
18897     TRACE("%p, %u\n", params->commandBuffer, params->pipelineStackSize);
18898
18899     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStackSize);
18900     return STATUS_SUCCESS;
18901 }
18902
18903 #endif /* USE_STRUCT_CONVERSION */
18904
18905 #if !defined(USE_STRUCT_CONVERSION)
18906
18907 static NTSTATUS thunk64_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
18908 {
18909     struct vkCmdSetRepresentativeFragmentTestEnableNV_params *params = args;
18910
18911     TRACE("%p, %u\n", params->commandBuffer, params->representativeFragmentTestEnable);
18912
18913     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->representativeFragmentTestEnable);
18914     return STATUS_SUCCESS;
18915 }
18916
18917 #else /* USE_STRUCT_CONVERSION */
18918
18919 static NTSTATUS thunk32_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
18920 {
18921     struct
18922     {
18923         VkCommandBuffer commandBuffer;
18924         VkBool32 representativeFragmentTestEnable;
18925     } *params = args;
18926
18927     TRACE("%p, %u\n", params->commandBuffer, params->representativeFragmentTestEnable);
18928
18929     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->representativeFragmentTestEnable);
18930     return STATUS_SUCCESS;
18931 }
18932
18933 #endif /* USE_STRUCT_CONVERSION */
18934
18935 #if !defined(USE_STRUCT_CONVERSION)
18936
18937 static NTSTATUS thunk64_vkCmdSetSampleLocationsEXT(void *args)
18938 {
18939     struct vkCmdSetSampleLocationsEXT_params *params = args;
18940
18941     TRACE("%p, %p\n", params->commandBuffer, params->pSampleLocationsInfo);
18942
18943     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSampleLocationsInfo);
18944     return STATUS_SUCCESS;
18945 }
18946
18947 #else /* USE_STRUCT_CONVERSION */
18948
18949 static NTSTATUS thunk32_vkCmdSetSampleLocationsEXT(void *args)
18950 {
18951     struct
18952     {
18953         VkCommandBuffer commandBuffer;
18954         const VkSampleLocationsInfoEXT *pSampleLocationsInfo;
18955     } *params = args;
18956
18957     TRACE("%p, %p\n", params->commandBuffer, params->pSampleLocationsInfo);
18958
18959     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSampleLocationsInfo);
18960     return STATUS_SUCCESS;
18961 }
18962
18963 #endif /* USE_STRUCT_CONVERSION */
18964
18965 #if !defined(USE_STRUCT_CONVERSION)
18966
18967 static NTSTATUS thunk64_vkCmdSetSampleLocationsEnableEXT(void *args)
18968 {
18969     struct vkCmdSetSampleLocationsEnableEXT_params *params = args;
18970
18971     TRACE("%p, %u\n", params->commandBuffer, params->sampleLocationsEnable);
18972
18973     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleLocationsEnable);
18974     return STATUS_SUCCESS;
18975 }
18976
18977 #else /* USE_STRUCT_CONVERSION */
18978
18979 static NTSTATUS thunk32_vkCmdSetSampleLocationsEnableEXT(void *args)
18980 {
18981     struct
18982     {
18983         VkCommandBuffer commandBuffer;
18984         VkBool32 sampleLocationsEnable;
18985     } *params = args;
18986
18987     TRACE("%p, %u\n", params->commandBuffer, params->sampleLocationsEnable);
18988
18989     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleLocationsEnable);
18990     return STATUS_SUCCESS;
18991 }
18992
18993 #endif /* USE_STRUCT_CONVERSION */
18994
18995 #if !defined(USE_STRUCT_CONVERSION)
18996
18997 static NTSTATUS thunk64_vkCmdSetSampleMaskEXT(void *args)
18998 {
18999     struct vkCmdSetSampleMaskEXT_params *params = args;
19000
19001     TRACE("%p, %#x, %p\n", params->commandBuffer, params->samples, params->pSampleMask);
19002
19003     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->samples, params->pSampleMask);
19004     return STATUS_SUCCESS;
19005 }
19006
19007 #else /* USE_STRUCT_CONVERSION */
19008
19009 static NTSTATUS thunk32_vkCmdSetSampleMaskEXT(void *args)
19010 {
19011     struct
19012     {
19013         VkCommandBuffer commandBuffer;
19014         VkSampleCountFlagBits samples;
19015         const VkSampleMask *pSampleMask;
19016     } *params = args;
19017
19018     TRACE("%p, %#x, %p\n", params->commandBuffer, params->samples, params->pSampleMask);
19019
19020     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->samples, params->pSampleMask);
19021     return STATUS_SUCCESS;
19022 }
19023
19024 #endif /* USE_STRUCT_CONVERSION */
19025
19026 #if !defined(USE_STRUCT_CONVERSION)
19027
19028 static NTSTATUS thunk64_vkCmdSetScissor(void *args)
19029 {
19030     struct vkCmdSetScissor_params *params = args;
19031
19032     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstScissor, params->scissorCount, params->pScissors);
19033
19034     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);
19035     return STATUS_SUCCESS;
19036 }
19037
19038 #else /* USE_STRUCT_CONVERSION */
19039
19040 static NTSTATUS thunk32_vkCmdSetScissor(void *args)
19041 {
19042     struct
19043     {
19044         VkCommandBuffer commandBuffer;
19045         uint32_t firstScissor;
19046         uint32_t scissorCount;
19047         const VkRect2D *pScissors;
19048     } *params = args;
19049
19050     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstScissor, params->scissorCount, params->pScissors);
19051
19052     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);
19053     return STATUS_SUCCESS;
19054 }
19055
19056 #endif /* USE_STRUCT_CONVERSION */
19057
19058 #if !defined(USE_STRUCT_CONVERSION)
19059
19060 static NTSTATUS thunk64_vkCmdSetScissorWithCount(void *args)
19061 {
19062     struct vkCmdSetScissorWithCount_params *params = args;
19063
19064     TRACE("%p, %u, %p\n", params->commandBuffer, params->scissorCount, params->pScissors);
19065
19066     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
19067     return STATUS_SUCCESS;
19068 }
19069
19070 #else /* USE_STRUCT_CONVERSION */
19071
19072 static NTSTATUS thunk32_vkCmdSetScissorWithCount(void *args)
19073 {
19074     struct
19075     {
19076         VkCommandBuffer commandBuffer;
19077         uint32_t scissorCount;
19078         const VkRect2D *pScissors;
19079     } *params = args;
19080
19081     TRACE("%p, %u, %p\n", params->commandBuffer, params->scissorCount, params->pScissors);
19082
19083     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
19084     return STATUS_SUCCESS;
19085 }
19086
19087 #endif /* USE_STRUCT_CONVERSION */
19088
19089 #if !defined(USE_STRUCT_CONVERSION)
19090
19091 static NTSTATUS thunk64_vkCmdSetScissorWithCountEXT(void *args)
19092 {
19093     struct vkCmdSetScissorWithCountEXT_params *params = args;
19094
19095     TRACE("%p, %u, %p\n", params->commandBuffer, params->scissorCount, params->pScissors);
19096
19097     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
19098     return STATUS_SUCCESS;
19099 }
19100
19101 #else /* USE_STRUCT_CONVERSION */
19102
19103 static NTSTATUS thunk32_vkCmdSetScissorWithCountEXT(void *args)
19104 {
19105     struct
19106     {
19107         VkCommandBuffer commandBuffer;
19108         uint32_t scissorCount;
19109         const VkRect2D *pScissors;
19110     } *params = args;
19111
19112     TRACE("%p, %u, %p\n", params->commandBuffer, params->scissorCount, params->pScissors);
19113
19114     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
19115     return STATUS_SUCCESS;
19116 }
19117
19118 #endif /* USE_STRUCT_CONVERSION */
19119
19120 #if !defined(USE_STRUCT_CONVERSION)
19121
19122 static NTSTATUS thunk64_vkCmdSetShadingRateImageEnableNV(void *args)
19123 {
19124     struct vkCmdSetShadingRateImageEnableNV_params *params = args;
19125
19126     TRACE("%p, %u\n", params->commandBuffer, params->shadingRateImageEnable);
19127
19128     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRateImageEnable);
19129     return STATUS_SUCCESS;
19130 }
19131
19132 #else /* USE_STRUCT_CONVERSION */
19133
19134 static NTSTATUS thunk32_vkCmdSetShadingRateImageEnableNV(void *args)
19135 {
19136     struct
19137     {
19138         VkCommandBuffer commandBuffer;
19139         VkBool32 shadingRateImageEnable;
19140     } *params = args;
19141
19142     TRACE("%p, %u\n", params->commandBuffer, params->shadingRateImageEnable);
19143
19144     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRateImageEnable);
19145     return STATUS_SUCCESS;
19146 }
19147
19148 #endif /* USE_STRUCT_CONVERSION */
19149
19150 #if !defined(USE_STRUCT_CONVERSION)
19151
19152 static NTSTATUS thunk64_vkCmdSetStencilCompareMask(void *args)
19153 {
19154     struct vkCmdSetStencilCompareMask_params *params = args;
19155
19156     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->compareMask);
19157
19158     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->compareMask);
19159     return STATUS_SUCCESS;
19160 }
19161
19162 #else /* USE_STRUCT_CONVERSION */
19163
19164 static NTSTATUS thunk32_vkCmdSetStencilCompareMask(void *args)
19165 {
19166     struct
19167     {
19168         VkCommandBuffer commandBuffer;
19169         VkStencilFaceFlags faceMask;
19170         uint32_t compareMask;
19171     } *params = args;
19172
19173     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->compareMask);
19174
19175     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->compareMask);
19176     return STATUS_SUCCESS;
19177 }
19178
19179 #endif /* USE_STRUCT_CONVERSION */
19180
19181 #if !defined(USE_STRUCT_CONVERSION)
19182
19183 static NTSTATUS thunk64_vkCmdSetStencilOp(void *args)
19184 {
19185     struct vkCmdSetStencilOp_params *params = args;
19186
19187     TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
19188
19189     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);
19190     return STATUS_SUCCESS;
19191 }
19192
19193 #else /* USE_STRUCT_CONVERSION */
19194
19195 static NTSTATUS thunk32_vkCmdSetStencilOp(void *args)
19196 {
19197     struct
19198     {
19199         VkCommandBuffer commandBuffer;
19200         VkStencilFaceFlags faceMask;
19201         VkStencilOp failOp;
19202         VkStencilOp passOp;
19203         VkStencilOp depthFailOp;
19204         VkCompareOp compareOp;
19205     } *params = args;
19206
19207     TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
19208
19209     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);
19210     return STATUS_SUCCESS;
19211 }
19212
19213 #endif /* USE_STRUCT_CONVERSION */
19214
19215 #if !defined(USE_STRUCT_CONVERSION)
19216
19217 static NTSTATUS thunk64_vkCmdSetStencilOpEXT(void *args)
19218 {
19219     struct vkCmdSetStencilOpEXT_params *params = args;
19220
19221     TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
19222
19223     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);
19224     return STATUS_SUCCESS;
19225 }
19226
19227 #else /* USE_STRUCT_CONVERSION */
19228
19229 static NTSTATUS thunk32_vkCmdSetStencilOpEXT(void *args)
19230 {
19231     struct
19232     {
19233         VkCommandBuffer commandBuffer;
19234         VkStencilFaceFlags faceMask;
19235         VkStencilOp failOp;
19236         VkStencilOp passOp;
19237         VkStencilOp depthFailOp;
19238         VkCompareOp compareOp;
19239     } *params = args;
19240
19241     TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
19242
19243     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);
19244     return STATUS_SUCCESS;
19245 }
19246
19247 #endif /* USE_STRUCT_CONVERSION */
19248
19249 #if !defined(USE_STRUCT_CONVERSION)
19250
19251 static NTSTATUS thunk64_vkCmdSetStencilReference(void *args)
19252 {
19253     struct vkCmdSetStencilReference_params *params = args;
19254
19255     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->reference);
19256
19257     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->reference);
19258     return STATUS_SUCCESS;
19259 }
19260
19261 #else /* USE_STRUCT_CONVERSION */
19262
19263 static NTSTATUS thunk32_vkCmdSetStencilReference(void *args)
19264 {
19265     struct
19266     {
19267         VkCommandBuffer commandBuffer;
19268         VkStencilFaceFlags faceMask;
19269         uint32_t reference;
19270     } *params = args;
19271
19272     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->reference);
19273
19274     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->reference);
19275     return STATUS_SUCCESS;
19276 }
19277
19278 #endif /* USE_STRUCT_CONVERSION */
19279
19280 #if !defined(USE_STRUCT_CONVERSION)
19281
19282 static NTSTATUS thunk64_vkCmdSetStencilTestEnable(void *args)
19283 {
19284     struct vkCmdSetStencilTestEnable_params *params = args;
19285
19286     TRACE("%p, %u\n", params->commandBuffer, params->stencilTestEnable);
19287
19288     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
19289     return STATUS_SUCCESS;
19290 }
19291
19292 #else /* USE_STRUCT_CONVERSION */
19293
19294 static NTSTATUS thunk32_vkCmdSetStencilTestEnable(void *args)
19295 {
19296     struct
19297     {
19298         VkCommandBuffer commandBuffer;
19299         VkBool32 stencilTestEnable;
19300     } *params = args;
19301
19302     TRACE("%p, %u\n", params->commandBuffer, params->stencilTestEnable);
19303
19304     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
19305     return STATUS_SUCCESS;
19306 }
19307
19308 #endif /* USE_STRUCT_CONVERSION */
19309
19310 #if !defined(USE_STRUCT_CONVERSION)
19311
19312 static NTSTATUS thunk64_vkCmdSetStencilTestEnableEXT(void *args)
19313 {
19314     struct vkCmdSetStencilTestEnableEXT_params *params = args;
19315
19316     TRACE("%p, %u\n", params->commandBuffer, params->stencilTestEnable);
19317
19318     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
19319     return STATUS_SUCCESS;
19320 }
19321
19322 #else /* USE_STRUCT_CONVERSION */
19323
19324 static NTSTATUS thunk32_vkCmdSetStencilTestEnableEXT(void *args)
19325 {
19326     struct
19327     {
19328         VkCommandBuffer commandBuffer;
19329         VkBool32 stencilTestEnable;
19330     } *params = args;
19331
19332     TRACE("%p, %u\n", params->commandBuffer, params->stencilTestEnable);
19333
19334     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
19335     return STATUS_SUCCESS;
19336 }
19337
19338 #endif /* USE_STRUCT_CONVERSION */
19339
19340 #if !defined(USE_STRUCT_CONVERSION)
19341
19342 static NTSTATUS thunk64_vkCmdSetStencilWriteMask(void *args)
19343 {
19344     struct vkCmdSetStencilWriteMask_params *params = args;
19345
19346     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->writeMask);
19347
19348     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
19349     return STATUS_SUCCESS;
19350 }
19351
19352 #else /* USE_STRUCT_CONVERSION */
19353
19354 static NTSTATUS thunk32_vkCmdSetStencilWriteMask(void *args)
19355 {
19356     struct
19357     {
19358         VkCommandBuffer commandBuffer;
19359         VkStencilFaceFlags faceMask;
19360         uint32_t writeMask;
19361     } *params = args;
19362
19363     TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->writeMask);
19364
19365     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
19366     return STATUS_SUCCESS;
19367 }
19368
19369 #endif /* USE_STRUCT_CONVERSION */
19370
19371 #if !defined(USE_STRUCT_CONVERSION)
19372
19373 static NTSTATUS thunk64_vkCmdSetTessellationDomainOriginEXT(void *args)
19374 {
19375     struct vkCmdSetTessellationDomainOriginEXT_params *params = args;
19376
19377     TRACE("%p, %#x\n", params->commandBuffer, params->domainOrigin);
19378
19379     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->domainOrigin);
19380     return STATUS_SUCCESS;
19381 }
19382
19383 #else /* USE_STRUCT_CONVERSION */
19384
19385 static NTSTATUS thunk32_vkCmdSetTessellationDomainOriginEXT(void *args)
19386 {
19387     struct
19388     {
19389         VkCommandBuffer commandBuffer;
19390         VkTessellationDomainOrigin domainOrigin;
19391     } *params = args;
19392
19393     TRACE("%p, %#x\n", params->commandBuffer, params->domainOrigin);
19394
19395     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->domainOrigin);
19396     return STATUS_SUCCESS;
19397 }
19398
19399 #endif /* USE_STRUCT_CONVERSION */
19400
19401 #if !defined(USE_STRUCT_CONVERSION)
19402
19403 static NTSTATUS thunk64_vkCmdSetVertexInputEXT(void *args)
19404 {
19405     struct vkCmdSetVertexInputEXT_params *params = args;
19406
19407     TRACE("%p, %u, %p, %u, %p\n", params->commandBuffer, params->vertexBindingDescriptionCount, params->pVertexBindingDescriptions, params->vertexAttributeDescriptionCount, params->pVertexAttributeDescriptions);
19408
19409     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);
19410     return STATUS_SUCCESS;
19411 }
19412
19413 #else /* USE_STRUCT_CONVERSION */
19414
19415 static NTSTATUS thunk32_vkCmdSetVertexInputEXT(void *args)
19416 {
19417     struct
19418     {
19419         VkCommandBuffer commandBuffer;
19420         uint32_t vertexBindingDescriptionCount;
19421         const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions;
19422         uint32_t vertexAttributeDescriptionCount;
19423         const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions;
19424     } *params = args;
19425
19426     TRACE("%p, %u, %p, %u, %p\n", params->commandBuffer, params->vertexBindingDescriptionCount, params->pVertexBindingDescriptions, params->vertexAttributeDescriptionCount, params->pVertexAttributeDescriptions);
19427
19428     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);
19429     return STATUS_SUCCESS;
19430 }
19431
19432 #endif /* USE_STRUCT_CONVERSION */
19433
19434 #if !defined(USE_STRUCT_CONVERSION)
19435
19436 static NTSTATUS thunk64_vkCmdSetViewport(void *args)
19437 {
19438     struct vkCmdSetViewport_params *params = args;
19439
19440     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewports);
19441
19442     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);
19443     return STATUS_SUCCESS;
19444 }
19445
19446 #else /* USE_STRUCT_CONVERSION */
19447
19448 static NTSTATUS thunk32_vkCmdSetViewport(void *args)
19449 {
19450     struct
19451     {
19452         VkCommandBuffer commandBuffer;
19453         uint32_t firstViewport;
19454         uint32_t viewportCount;
19455         const VkViewport *pViewports;
19456     } *params = args;
19457
19458     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewports);
19459
19460     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);
19461     return STATUS_SUCCESS;
19462 }
19463
19464 #endif /* USE_STRUCT_CONVERSION */
19465
19466 #if !defined(USE_STRUCT_CONVERSION)
19467
19468 static NTSTATUS thunk64_vkCmdSetViewportShadingRatePaletteNV(void *args)
19469 {
19470     struct vkCmdSetViewportShadingRatePaletteNV_params *params = args;
19471
19472     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pShadingRatePalettes);
19473
19474     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);
19475     return STATUS_SUCCESS;
19476 }
19477
19478 #else /* USE_STRUCT_CONVERSION */
19479
19480 static NTSTATUS thunk32_vkCmdSetViewportShadingRatePaletteNV(void *args)
19481 {
19482     struct
19483     {
19484         VkCommandBuffer commandBuffer;
19485         uint32_t firstViewport;
19486         uint32_t viewportCount;
19487         const VkShadingRatePaletteNV *pShadingRatePalettes;
19488     } *params = args;
19489
19490     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pShadingRatePalettes);
19491
19492     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);
19493     return STATUS_SUCCESS;
19494 }
19495
19496 #endif /* USE_STRUCT_CONVERSION */
19497
19498 #if !defined(USE_STRUCT_CONVERSION)
19499
19500 static NTSTATUS thunk64_vkCmdSetViewportSwizzleNV(void *args)
19501 {
19502     struct vkCmdSetViewportSwizzleNV_params *params = args;
19503
19504     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
19505
19506     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);
19507     return STATUS_SUCCESS;
19508 }
19509
19510 #else /* USE_STRUCT_CONVERSION */
19511
19512 static NTSTATUS thunk32_vkCmdSetViewportSwizzleNV(void *args)
19513 {
19514     struct
19515     {
19516         VkCommandBuffer commandBuffer;
19517         uint32_t firstViewport;
19518         uint32_t viewportCount;
19519         const VkViewportSwizzleNV *pViewportSwizzles;
19520     } *params = args;
19521
19522     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
19523
19524     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);
19525     return STATUS_SUCCESS;
19526 }
19527
19528 #endif /* USE_STRUCT_CONVERSION */
19529
19530 #if !defined(USE_STRUCT_CONVERSION)
19531
19532 static NTSTATUS thunk64_vkCmdSetViewportWScalingEnableNV(void *args)
19533 {
19534     struct vkCmdSetViewportWScalingEnableNV_params *params = args;
19535
19536     TRACE("%p, %u\n", params->commandBuffer, params->viewportWScalingEnable);
19537
19538     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportWScalingEnable);
19539     return STATUS_SUCCESS;
19540 }
19541
19542 #else /* USE_STRUCT_CONVERSION */
19543
19544 static NTSTATUS thunk32_vkCmdSetViewportWScalingEnableNV(void *args)
19545 {
19546     struct
19547     {
19548         VkCommandBuffer commandBuffer;
19549         VkBool32 viewportWScalingEnable;
19550     } *params = args;
19551
19552     TRACE("%p, %u\n", params->commandBuffer, params->viewportWScalingEnable);
19553
19554     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportWScalingEnable);
19555     return STATUS_SUCCESS;
19556 }
19557
19558 #endif /* USE_STRUCT_CONVERSION */
19559
19560 #if !defined(USE_STRUCT_CONVERSION)
19561
19562 static NTSTATUS thunk64_vkCmdSetViewportWScalingNV(void *args)
19563 {
19564     struct vkCmdSetViewportWScalingNV_params *params = args;
19565
19566     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);
19567
19568     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);
19569     return STATUS_SUCCESS;
19570 }
19571
19572 #else /* USE_STRUCT_CONVERSION */
19573
19574 static NTSTATUS thunk32_vkCmdSetViewportWScalingNV(void *args)
19575 {
19576     struct
19577     {
19578         VkCommandBuffer commandBuffer;
19579         uint32_t firstViewport;
19580         uint32_t viewportCount;
19581         const VkViewportWScalingNV *pViewportWScalings;
19582     } *params = args;
19583
19584     TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);
19585
19586     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);
19587     return STATUS_SUCCESS;
19588 }
19589
19590 #endif /* USE_STRUCT_CONVERSION */
19591
19592 #if !defined(USE_STRUCT_CONVERSION)
19593
19594 static NTSTATUS thunk64_vkCmdSetViewportWithCount(void *args)
19595 {
19596     struct vkCmdSetViewportWithCount_params *params = args;
19597
19598     TRACE("%p, %u, %p\n", params->commandBuffer, params->viewportCount, params->pViewports);
19599
19600     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
19601     return STATUS_SUCCESS;
19602 }
19603
19604 #else /* USE_STRUCT_CONVERSION */
19605
19606 static NTSTATUS thunk32_vkCmdSetViewportWithCount(void *args)
19607 {
19608     struct
19609     {
19610         VkCommandBuffer commandBuffer;
19611         uint32_t viewportCount;
19612         const VkViewport *pViewports;
19613     } *params = args;
19614
19615     TRACE("%p, %u, %p\n", params->commandBuffer, params->viewportCount, params->pViewports);
19616
19617     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
19618     return STATUS_SUCCESS;
19619 }
19620
19621 #endif /* USE_STRUCT_CONVERSION */
19622
19623 #if !defined(USE_STRUCT_CONVERSION)
19624
19625 static NTSTATUS thunk64_vkCmdSetViewportWithCountEXT(void *args)
19626 {
19627     struct vkCmdSetViewportWithCountEXT_params *params = args;
19628
19629     TRACE("%p, %u, %p\n", params->commandBuffer, params->viewportCount, params->pViewports);
19630
19631     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
19632     return STATUS_SUCCESS;
19633 }
19634
19635 #else /* USE_STRUCT_CONVERSION */
19636
19637 static NTSTATUS thunk32_vkCmdSetViewportWithCountEXT(void *args)
19638 {
19639     struct
19640     {
19641         VkCommandBuffer commandBuffer;
19642         uint32_t viewportCount;
19643         const VkViewport *pViewports;
19644     } *params = args;
19645
19646     TRACE("%p, %u, %p\n", params->commandBuffer, params->viewportCount, params->pViewports);
19647
19648     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
19649     return STATUS_SUCCESS;
19650 }
19651
19652 #endif /* USE_STRUCT_CONVERSION */
19653
19654 #if !defined(USE_STRUCT_CONVERSION)
19655
19656 static NTSTATUS thunk64_vkCmdSubpassShadingHUAWEI(void *args)
19657 {
19658     struct vkCmdSubpassShadingHUAWEI_params *params = args;
19659
19660     TRACE("%p\n", params->commandBuffer);
19661
19662     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
19663     return STATUS_SUCCESS;
19664 }
19665
19666 #else /* USE_STRUCT_CONVERSION */
19667
19668 static NTSTATUS thunk32_vkCmdSubpassShadingHUAWEI(void *args)
19669 {
19670     struct
19671     {
19672         VkCommandBuffer commandBuffer;
19673     } *params = args;
19674
19675     TRACE("%p\n", params->commandBuffer);
19676
19677     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
19678     return STATUS_SUCCESS;
19679 }
19680
19681 #endif /* USE_STRUCT_CONVERSION */
19682
19683 #if !defined(USE_STRUCT_CONVERSION)
19684
19685 static NTSTATUS thunk64_vkCmdTraceRaysIndirect2KHR(void *args)
19686 {
19687     struct vkCmdTraceRaysIndirect2KHR_params *params = args;
19688
19689     TRACE("%p, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectDeviceAddress));
19690
19691     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectDeviceAddress);
19692     return STATUS_SUCCESS;
19693 }
19694
19695 #else /* USE_STRUCT_CONVERSION */
19696
19697 static NTSTATUS thunk32_vkCmdTraceRaysIndirect2KHR(void *args)
19698 {
19699     struct
19700     {
19701         VkCommandBuffer commandBuffer;
19702         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
19703     } *params = args;
19704
19705     TRACE("%p, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectDeviceAddress));
19706
19707     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectDeviceAddress);
19708     return STATUS_SUCCESS;
19709 }
19710
19711 #endif /* USE_STRUCT_CONVERSION */
19712
19713 #if !defined(USE_STRUCT_CONVERSION)
19714
19715 static NTSTATUS thunk64_vkCmdTraceRaysIndirectKHR(void *args)
19716 {
19717     struct vkCmdTraceRaysIndirectKHR_params *params = args;
19718
19719     TRACE("%p, %p, %p, %p, %p, 0x%s\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, wine_dbgstr_longlong(params->indirectDeviceAddress));
19720
19721     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);
19722     return STATUS_SUCCESS;
19723 }
19724
19725 #else /* USE_STRUCT_CONVERSION */
19726
19727 static NTSTATUS thunk32_vkCmdTraceRaysIndirectKHR(void *args)
19728 {
19729     struct
19730     {
19731         VkCommandBuffer commandBuffer;
19732         const VkStridedDeviceAddressRegionKHR32 *pRaygenShaderBindingTable;
19733         const VkStridedDeviceAddressRegionKHR32 *pMissShaderBindingTable;
19734         const VkStridedDeviceAddressRegionKHR32 *pHitShaderBindingTable;
19735         const VkStridedDeviceAddressRegionKHR32 *pCallableShaderBindingTable;
19736         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
19737     } *params = args;
19738     VkStridedDeviceAddressRegionKHR pRaygenShaderBindingTable_host;
19739     VkStridedDeviceAddressRegionKHR pMissShaderBindingTable_host;
19740     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
19741     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;
19742
19743     TRACE("%p, %p, %p, %p, %p, 0x%s\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, wine_dbgstr_longlong(params->indirectDeviceAddress));
19744
19745     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pRaygenShaderBindingTable, &pRaygenShaderBindingTable_host);
19746     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pMissShaderBindingTable, &pMissShaderBindingTable_host);
19747     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pHitShaderBindingTable, &pHitShaderBindingTable_host);
19748     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pCallableShaderBindingTable, &pCallableShaderBindingTable_host);
19749     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirectKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRaygenShaderBindingTable_host, &pMissShaderBindingTable_host, &pHitShaderBindingTable_host, &pCallableShaderBindingTable_host, params->indirectDeviceAddress);
19750     return STATUS_SUCCESS;
19751 }
19752
19753 #endif /* USE_STRUCT_CONVERSION */
19754
19755 #if !defined(USE_STRUCT_CONVERSION)
19756
19757 static NTSTATUS thunk64_vkCmdTraceRaysKHR(void *args)
19758 {
19759     struct vkCmdTraceRaysKHR_params *params = args;
19760
19761     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);
19762
19763     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);
19764     return STATUS_SUCCESS;
19765 }
19766
19767 #else /* USE_STRUCT_CONVERSION */
19768
19769 static NTSTATUS thunk32_vkCmdTraceRaysKHR(void *args)
19770 {
19771     struct
19772     {
19773         VkCommandBuffer commandBuffer;
19774         const VkStridedDeviceAddressRegionKHR32 *pRaygenShaderBindingTable;
19775         const VkStridedDeviceAddressRegionKHR32 *pMissShaderBindingTable;
19776         const VkStridedDeviceAddressRegionKHR32 *pHitShaderBindingTable;
19777         const VkStridedDeviceAddressRegionKHR32 *pCallableShaderBindingTable;
19778         uint32_t width;
19779         uint32_t height;
19780         uint32_t depth;
19781     } *params = args;
19782     VkStridedDeviceAddressRegionKHR pRaygenShaderBindingTable_host;
19783     VkStridedDeviceAddressRegionKHR pMissShaderBindingTable_host;
19784     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
19785     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;
19786
19787     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);
19788
19789     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pRaygenShaderBindingTable, &pRaygenShaderBindingTable_host);
19790     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pMissShaderBindingTable, &pMissShaderBindingTable_host);
19791     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pHitShaderBindingTable, &pHitShaderBindingTable_host);
19792     convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pCallableShaderBindingTable, &pCallableShaderBindingTable_host);
19793     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRaygenShaderBindingTable_host, &pMissShaderBindingTable_host, &pHitShaderBindingTable_host, &pCallableShaderBindingTable_host, params->width, params->height, params->depth);
19794     return STATUS_SUCCESS;
19795 }
19796
19797 #endif /* USE_STRUCT_CONVERSION */
19798
19799 #if !defined(USE_STRUCT_CONVERSION)
19800
19801 static NTSTATUS thunk64_vkCmdTraceRaysNV(void *args)
19802 {
19803     struct vkCmdTraceRaysNV_params *params = args;
19804
19805     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);
19806
19807     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);
19808     return STATUS_SUCCESS;
19809 }
19810
19811 #else /* USE_STRUCT_CONVERSION */
19812
19813 static NTSTATUS thunk32_vkCmdTraceRaysNV(void *args)
19814 {
19815     struct
19816     {
19817         VkCommandBuffer commandBuffer;
19818         VkBuffer DECLSPEC_ALIGN(8) raygenShaderBindingTableBuffer;
19819         VkDeviceSize DECLSPEC_ALIGN(8) raygenShaderBindingOffset;
19820         VkBuffer DECLSPEC_ALIGN(8) missShaderBindingTableBuffer;
19821         VkDeviceSize DECLSPEC_ALIGN(8) missShaderBindingOffset;
19822         VkDeviceSize DECLSPEC_ALIGN(8) missShaderBindingStride;
19823         VkBuffer DECLSPEC_ALIGN(8) hitShaderBindingTableBuffer;
19824         VkDeviceSize DECLSPEC_ALIGN(8) hitShaderBindingOffset;
19825         VkDeviceSize DECLSPEC_ALIGN(8) hitShaderBindingStride;
19826         VkBuffer DECLSPEC_ALIGN(8) callableShaderBindingTableBuffer;
19827         VkDeviceSize DECLSPEC_ALIGN(8) callableShaderBindingOffset;
19828         VkDeviceSize DECLSPEC_ALIGN(8) callableShaderBindingStride;
19829         uint32_t width;
19830         uint32_t height;
19831         uint32_t depth;
19832     } *params = args;
19833
19834     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);
19835
19836     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);
19837     return STATUS_SUCCESS;
19838 }
19839
19840 #endif /* USE_STRUCT_CONVERSION */
19841
19842 #if !defined(USE_STRUCT_CONVERSION)
19843
19844 static NTSTATUS thunk64_vkCmdUpdateBuffer(void *args)
19845 {
19846     struct vkCmdUpdateBuffer_params *params = args;
19847
19848     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);
19849
19850     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);
19851     return STATUS_SUCCESS;
19852 }
19853
19854 #else /* USE_STRUCT_CONVERSION */
19855
19856 static NTSTATUS thunk32_vkCmdUpdateBuffer(void *args)
19857 {
19858     struct
19859     {
19860         VkCommandBuffer commandBuffer;
19861         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
19862         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
19863         VkDeviceSize DECLSPEC_ALIGN(8) dataSize;
19864         const void *pData;
19865     } *params = args;
19866
19867     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);
19868
19869     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);
19870     return STATUS_SUCCESS;
19871 }
19872
19873 #endif /* USE_STRUCT_CONVERSION */
19874
19875 #if !defined(USE_STRUCT_CONVERSION)
19876
19877 static NTSTATUS thunk64_vkCmdWaitEvents(void *args)
19878 {
19879     struct vkCmdWaitEvents_params *params = args;
19880
19881     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);
19882
19883     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);
19884     return STATUS_SUCCESS;
19885 }
19886
19887 #else /* USE_STRUCT_CONVERSION */
19888
19889 static NTSTATUS thunk32_vkCmdWaitEvents(void *args)
19890 {
19891     struct
19892     {
19893         VkCommandBuffer commandBuffer;
19894         uint32_t eventCount;
19895         const VkEvent *pEvents;
19896         VkPipelineStageFlags srcStageMask;
19897         VkPipelineStageFlags dstStageMask;
19898         uint32_t memoryBarrierCount;
19899         const VkMemoryBarrier *pMemoryBarriers;
19900         uint32_t bufferMemoryBarrierCount;
19901         const VkBufferMemoryBarrier32 *pBufferMemoryBarriers;
19902         uint32_t imageMemoryBarrierCount;
19903         const VkImageMemoryBarrier32 *pImageMemoryBarriers;
19904     } *params = args;
19905     const VkBufferMemoryBarrier *pBufferMemoryBarriers_host;
19906     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
19907     struct conversion_context ctx;
19908
19909     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);
19910
19911     init_conversion_context(&ctx);
19912     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(&ctx, params->pBufferMemoryBarriers, params->bufferMemoryBarrierCount);
19913     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(&ctx, params->pImageMemoryBarriers, params->imageMemoryBarrierCount);
19914     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, pBufferMemoryBarriers_host, params->imageMemoryBarrierCount, pImageMemoryBarriers_host);
19915     free_conversion_context(&ctx);
19916     return STATUS_SUCCESS;
19917 }
19918
19919 #endif /* USE_STRUCT_CONVERSION */
19920
19921 #if !defined(USE_STRUCT_CONVERSION)
19922
19923 static NTSTATUS thunk64_vkCmdWaitEvents2(void *args)
19924 {
19925     struct vkCmdWaitEvents2_params *params = args;
19926
19927     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
19928
19929     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);
19930     return STATUS_SUCCESS;
19931 }
19932
19933 #else /* USE_STRUCT_CONVERSION */
19934
19935 static NTSTATUS thunk32_vkCmdWaitEvents2(void *args)
19936 {
19937     struct
19938     {
19939         VkCommandBuffer commandBuffer;
19940         uint32_t eventCount;
19941         const VkEvent *pEvents;
19942         const VkDependencyInfo32 *pDependencyInfos;
19943     } *params = args;
19944     const VkDependencyInfo *pDependencyInfos_host;
19945     struct conversion_context ctx;
19946
19947     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
19948
19949     init_conversion_context(&ctx);
19950     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, params->pDependencyInfos, params->eventCount);
19951     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, pDependencyInfos_host);
19952     free_conversion_context(&ctx);
19953     return STATUS_SUCCESS;
19954 }
19955
19956 #endif /* USE_STRUCT_CONVERSION */
19957
19958 #if !defined(USE_STRUCT_CONVERSION)
19959
19960 static NTSTATUS thunk64_vkCmdWaitEvents2KHR(void *args)
19961 {
19962     struct vkCmdWaitEvents2KHR_params *params = args;
19963
19964     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
19965
19966     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);
19967     return STATUS_SUCCESS;
19968 }
19969
19970 #else /* USE_STRUCT_CONVERSION */
19971
19972 static NTSTATUS thunk32_vkCmdWaitEvents2KHR(void *args)
19973 {
19974     struct
19975     {
19976         VkCommandBuffer commandBuffer;
19977         uint32_t eventCount;
19978         const VkEvent *pEvents;
19979         const VkDependencyInfo32 *pDependencyInfos;
19980     } *params = args;
19981     const VkDependencyInfo *pDependencyInfos_host;
19982     struct conversion_context ctx;
19983
19984     TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
19985
19986     init_conversion_context(&ctx);
19987     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, params->pDependencyInfos, params->eventCount);
19988     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, pDependencyInfos_host);
19989     free_conversion_context(&ctx);
19990     return STATUS_SUCCESS;
19991 }
19992
19993 #endif /* USE_STRUCT_CONVERSION */
19994
19995 #if !defined(USE_STRUCT_CONVERSION)
19996
19997 static NTSTATUS thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
19998 {
19999     struct vkCmdWriteAccelerationStructuresPropertiesKHR_params *params = args;
20000
20001     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
20002
20003     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);
20004     return STATUS_SUCCESS;
20005 }
20006
20007 #else /* USE_STRUCT_CONVERSION */
20008
20009 static NTSTATUS thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
20010 {
20011     struct
20012     {
20013         VkCommandBuffer commandBuffer;
20014         uint32_t accelerationStructureCount;
20015         const VkAccelerationStructureKHR *pAccelerationStructures;
20016         VkQueryType queryType;
20017         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
20018         uint32_t firstQuery;
20019     } *params = args;
20020
20021     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
20022
20023     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);
20024     return STATUS_SUCCESS;
20025 }
20026
20027 #endif /* USE_STRUCT_CONVERSION */
20028
20029 #if !defined(USE_STRUCT_CONVERSION)
20030
20031 static NTSTATUS thunk64_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
20032 {
20033     struct vkCmdWriteAccelerationStructuresPropertiesNV_params *params = args;
20034
20035     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
20036
20037     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);
20038     return STATUS_SUCCESS;
20039 }
20040
20041 #else /* USE_STRUCT_CONVERSION */
20042
20043 static NTSTATUS thunk32_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
20044 {
20045     struct
20046     {
20047         VkCommandBuffer commandBuffer;
20048         uint32_t accelerationStructureCount;
20049         const VkAccelerationStructureNV *pAccelerationStructures;
20050         VkQueryType queryType;
20051         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
20052         uint32_t firstQuery;
20053     } *params = args;
20054
20055     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
20056
20057     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);
20058     return STATUS_SUCCESS;
20059 }
20060
20061 #endif /* USE_STRUCT_CONVERSION */
20062
20063 #if !defined(USE_STRUCT_CONVERSION)
20064
20065 static NTSTATUS thunk64_vkCmdWriteBufferMarker2AMD(void *args)
20066 {
20067     struct vkCmdWriteBufferMarker2AMD_params *params = args;
20068
20069     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);
20070
20071     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);
20072     return STATUS_SUCCESS;
20073 }
20074
20075 #else /* USE_STRUCT_CONVERSION */
20076
20077 static NTSTATUS thunk32_vkCmdWriteBufferMarker2AMD(void *args)
20078 {
20079     struct
20080     {
20081         VkCommandBuffer commandBuffer;
20082         VkPipelineStageFlags2 stage;
20083         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
20084         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
20085         uint32_t marker;
20086     } *params = args;
20087
20088     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);
20089
20090     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);
20091     return STATUS_SUCCESS;
20092 }
20093
20094 #endif /* USE_STRUCT_CONVERSION */
20095
20096 #if !defined(USE_STRUCT_CONVERSION)
20097
20098 static NTSTATUS thunk64_vkCmdWriteBufferMarkerAMD(void *args)
20099 {
20100     struct vkCmdWriteBufferMarkerAMD_params *params = args;
20101
20102     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);
20103
20104     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);
20105     return STATUS_SUCCESS;
20106 }
20107
20108 #else /* USE_STRUCT_CONVERSION */
20109
20110 static NTSTATUS thunk32_vkCmdWriteBufferMarkerAMD(void *args)
20111 {
20112     struct
20113     {
20114         VkCommandBuffer commandBuffer;
20115         VkPipelineStageFlagBits pipelineStage;
20116         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
20117         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
20118         uint32_t marker;
20119     } *params = args;
20120
20121     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);
20122
20123     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);
20124     return STATUS_SUCCESS;
20125 }
20126
20127 #endif /* USE_STRUCT_CONVERSION */
20128
20129 #if !defined(USE_STRUCT_CONVERSION)
20130
20131 static NTSTATUS thunk64_vkCmdWriteMicromapsPropertiesEXT(void *args)
20132 {
20133     struct vkCmdWriteMicromapsPropertiesEXT_params *params = args;
20134
20135     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
20136
20137     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);
20138     return STATUS_SUCCESS;
20139 }
20140
20141 #else /* USE_STRUCT_CONVERSION */
20142
20143 static NTSTATUS thunk32_vkCmdWriteMicromapsPropertiesEXT(void *args)
20144 {
20145     struct
20146     {
20147         VkCommandBuffer commandBuffer;
20148         uint32_t micromapCount;
20149         const VkMicromapEXT *pMicromaps;
20150         VkQueryType queryType;
20151         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
20152         uint32_t firstQuery;
20153     } *params = args;
20154
20155     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
20156
20157     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);
20158     return STATUS_SUCCESS;
20159 }
20160
20161 #endif /* USE_STRUCT_CONVERSION */
20162
20163 #if !defined(USE_STRUCT_CONVERSION)
20164
20165 static NTSTATUS thunk64_vkCmdWriteTimestamp(void *args)
20166 {
20167     struct vkCmdWriteTimestamp_params *params = args;
20168
20169     TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->queryPool), params->query);
20170
20171     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);
20172     return STATUS_SUCCESS;
20173 }
20174
20175 #else /* USE_STRUCT_CONVERSION */
20176
20177 static NTSTATUS thunk32_vkCmdWriteTimestamp(void *args)
20178 {
20179     struct
20180     {
20181         VkCommandBuffer commandBuffer;
20182         VkPipelineStageFlagBits pipelineStage;
20183         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
20184         uint32_t query;
20185     } *params = args;
20186
20187     TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->queryPool), params->query);
20188
20189     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);
20190     return STATUS_SUCCESS;
20191 }
20192
20193 #endif /* USE_STRUCT_CONVERSION */
20194
20195 #if !defined(USE_STRUCT_CONVERSION)
20196
20197 static NTSTATUS thunk64_vkCmdWriteTimestamp2(void *args)
20198 {
20199     struct vkCmdWriteTimestamp2_params *params = args;
20200
20201     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
20202
20203     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);
20204     return STATUS_SUCCESS;
20205 }
20206
20207 #else /* USE_STRUCT_CONVERSION */
20208
20209 static NTSTATUS thunk32_vkCmdWriteTimestamp2(void *args)
20210 {
20211     struct
20212     {
20213         VkCommandBuffer commandBuffer;
20214         VkPipelineStageFlags2 stage;
20215         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
20216         uint32_t query;
20217     } *params = args;
20218
20219     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
20220
20221     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);
20222     return STATUS_SUCCESS;
20223 }
20224
20225 #endif /* USE_STRUCT_CONVERSION */
20226
20227 #if !defined(USE_STRUCT_CONVERSION)
20228
20229 static NTSTATUS thunk64_vkCmdWriteTimestamp2KHR(void *args)
20230 {
20231     struct vkCmdWriteTimestamp2KHR_params *params = args;
20232
20233     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
20234
20235     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);
20236     return STATUS_SUCCESS;
20237 }
20238
20239 #else /* USE_STRUCT_CONVERSION */
20240
20241 static NTSTATUS thunk32_vkCmdWriteTimestamp2KHR(void *args)
20242 {
20243     struct
20244     {
20245         VkCommandBuffer commandBuffer;
20246         VkPipelineStageFlags2 stage;
20247         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
20248         uint32_t query;
20249     } *params = args;
20250
20251     TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
20252
20253     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);
20254     return STATUS_SUCCESS;
20255 }
20256
20257 #endif /* USE_STRUCT_CONVERSION */
20258
20259 #if !defined(USE_STRUCT_CONVERSION)
20260
20261 static NTSTATUS thunk64_vkCompileDeferredNV(void *args)
20262 {
20263     struct vkCompileDeferredNV_params *params = args;
20264
20265     TRACE("%p, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);
20266
20267     params->result = wine_device_from_handle(params->device)->funcs.p_vkCompileDeferredNV(wine_device_from_handle(params->device)->device, params->pipeline, params->shader);
20268     return STATUS_SUCCESS;
20269 }
20270
20271 #else /* USE_STRUCT_CONVERSION */
20272
20273 static NTSTATUS thunk32_vkCompileDeferredNV(void *args)
20274 {
20275     struct
20276     {
20277         VkDevice device;
20278         VkPipeline DECLSPEC_ALIGN(8) pipeline;
20279         uint32_t shader;
20280         VkResult result;
20281     } *params = args;
20282
20283     TRACE("%p, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);
20284
20285     params->result = wine_device_from_handle(params->device)->funcs.p_vkCompileDeferredNV(wine_device_from_handle(params->device)->device, params->pipeline, params->shader);
20286     return STATUS_SUCCESS;
20287 }
20288
20289 #endif /* USE_STRUCT_CONVERSION */
20290
20291 #if !defined(USE_STRUCT_CONVERSION)
20292
20293 static NTSTATUS thunk64_vkCopyAccelerationStructureKHR(void *args)
20294 {
20295     struct vkCopyAccelerationStructureKHR_params *params = args;
20296
20297     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
20298
20299     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
20300     return STATUS_SUCCESS;
20301 }
20302
20303 #else /* USE_STRUCT_CONVERSION */
20304
20305 static NTSTATUS thunk32_vkCopyAccelerationStructureKHR(void *args)
20306 {
20307     struct
20308     {
20309         VkDevice device;
20310         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
20311         const VkCopyAccelerationStructureInfoKHR32 *pInfo;
20312         VkResult result;
20313     } *params = args;
20314     VkCopyAccelerationStructureInfoKHR pInfo_host;
20315
20316     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
20317
20318     convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
20319     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
20320     return STATUS_SUCCESS;
20321 }
20322
20323 #endif /* USE_STRUCT_CONVERSION */
20324
20325 #if !defined(USE_STRUCT_CONVERSION)
20326
20327 static NTSTATUS thunk64_vkCopyAccelerationStructureToMemoryKHR(void *args)
20328 {
20329     struct vkCopyAccelerationStructureToMemoryKHR_params *params = args;
20330
20331     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
20332
20333     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
20334     return STATUS_SUCCESS;
20335 }
20336
20337 #else /* USE_STRUCT_CONVERSION */
20338
20339 static NTSTATUS thunk32_vkCopyAccelerationStructureToMemoryKHR(void *args)
20340 {
20341     struct
20342     {
20343         VkDevice device;
20344         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
20345         const VkCopyAccelerationStructureToMemoryInfoKHR32 *pInfo;
20346         VkResult result;
20347     } *params = args;
20348     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;
20349
20350     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
20351
20352     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
20353     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
20354     return STATUS_SUCCESS;
20355 }
20356
20357 #endif /* USE_STRUCT_CONVERSION */
20358
20359 #if !defined(USE_STRUCT_CONVERSION)
20360
20361 static NTSTATUS thunk64_vkCopyMemoryToAccelerationStructureKHR(void *args)
20362 {
20363     struct vkCopyMemoryToAccelerationStructureKHR_params *params = args;
20364
20365     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
20366
20367     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
20368     return STATUS_SUCCESS;
20369 }
20370
20371 #else /* USE_STRUCT_CONVERSION */
20372
20373 static NTSTATUS thunk32_vkCopyMemoryToAccelerationStructureKHR(void *args)
20374 {
20375     struct
20376     {
20377         VkDevice device;
20378         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
20379         const VkCopyMemoryToAccelerationStructureInfoKHR32 *pInfo;
20380         VkResult result;
20381     } *params = args;
20382     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;
20383
20384     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
20385
20386     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
20387     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
20388     return STATUS_SUCCESS;
20389 }
20390
20391 #endif /* USE_STRUCT_CONVERSION */
20392
20393 #if !defined(USE_STRUCT_CONVERSION)
20394
20395 static NTSTATUS thunk64_vkCopyMemoryToMicromapEXT(void *args)
20396 {
20397     struct vkCopyMemoryToMicromapEXT_params *params = args;
20398
20399     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
20400
20401     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
20402     return STATUS_SUCCESS;
20403 }
20404
20405 #else /* USE_STRUCT_CONVERSION */
20406
20407 static NTSTATUS thunk32_vkCopyMemoryToMicromapEXT(void *args)
20408 {
20409     struct
20410     {
20411         VkDevice device;
20412         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
20413         const VkCopyMemoryToMicromapInfoEXT32 *pInfo;
20414         VkResult result;
20415     } *params = args;
20416     VkCopyMemoryToMicromapInfoEXT pInfo_host;
20417
20418     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
20419
20420     convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
20421     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
20422     return STATUS_SUCCESS;
20423 }
20424
20425 #endif /* USE_STRUCT_CONVERSION */
20426
20427 #if !defined(USE_STRUCT_CONVERSION)
20428
20429 static NTSTATUS thunk64_vkCopyMicromapEXT(void *args)
20430 {
20431     struct vkCopyMicromapEXT_params *params = args;
20432
20433     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
20434
20435     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
20436     return STATUS_SUCCESS;
20437 }
20438
20439 #else /* USE_STRUCT_CONVERSION */
20440
20441 static NTSTATUS thunk32_vkCopyMicromapEXT(void *args)
20442 {
20443     struct
20444     {
20445         VkDevice device;
20446         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
20447         const VkCopyMicromapInfoEXT32 *pInfo;
20448         VkResult result;
20449     } *params = args;
20450     VkCopyMicromapInfoEXT pInfo_host;
20451
20452     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
20453
20454     convert_VkCopyMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
20455     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
20456     return STATUS_SUCCESS;
20457 }
20458
20459 #endif /* USE_STRUCT_CONVERSION */
20460
20461 #if !defined(USE_STRUCT_CONVERSION)
20462
20463 static NTSTATUS thunk64_vkCopyMicromapToMemoryEXT(void *args)
20464 {
20465     struct vkCopyMicromapToMemoryEXT_params *params = args;
20466
20467     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
20468
20469     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapToMemoryEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pInfo);
20470     return STATUS_SUCCESS;
20471 }
20472
20473 #else /* USE_STRUCT_CONVERSION */
20474
20475 static NTSTATUS thunk32_vkCopyMicromapToMemoryEXT(void *args)
20476 {
20477     struct
20478     {
20479         VkDevice device;
20480         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
20481         const VkCopyMicromapToMemoryInfoEXT32 *pInfo;
20482         VkResult result;
20483     } *params = args;
20484     VkCopyMicromapToMemoryInfoEXT pInfo_host;
20485
20486     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
20487
20488     convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
20489     params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapToMemoryEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
20490     return STATUS_SUCCESS;
20491 }
20492
20493 #endif /* USE_STRUCT_CONVERSION */
20494
20495 #if !defined(USE_STRUCT_CONVERSION)
20496
20497 static NTSTATUS thunk64_vkCreateAccelerationStructureKHR(void *args)
20498 {
20499     struct vkCreateAccelerationStructureKHR_params *params = args;
20500
20501     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
20502
20503     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
20504     return STATUS_SUCCESS;
20505 }
20506
20507 #else /* USE_STRUCT_CONVERSION */
20508
20509 static NTSTATUS thunk32_vkCreateAccelerationStructureKHR(void *args)
20510 {
20511     struct
20512     {
20513         VkDevice device;
20514         const VkAccelerationStructureCreateInfoKHR32 *pCreateInfo;
20515         const VkAllocationCallbacks *pAllocator;
20516         VkAccelerationStructureKHR *pAccelerationStructure;
20517         VkResult result;
20518     } *params = args;
20519     VkAccelerationStructureCreateInfoKHR pCreateInfo_host;
20520
20521     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
20522
20523     convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
20524     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pAccelerationStructure);
20525     return STATUS_SUCCESS;
20526 }
20527
20528 #endif /* USE_STRUCT_CONVERSION */
20529
20530 #if !defined(USE_STRUCT_CONVERSION)
20531
20532 static NTSTATUS thunk64_vkCreateAccelerationStructureNV(void *args)
20533 {
20534     struct vkCreateAccelerationStructureNV_params *params = args;
20535
20536     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
20537
20538     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pAccelerationStructure);
20539     return STATUS_SUCCESS;
20540 }
20541
20542 #else /* USE_STRUCT_CONVERSION */
20543
20544 static NTSTATUS thunk32_vkCreateAccelerationStructureNV(void *args)
20545 {
20546     struct
20547     {
20548         VkDevice device;
20549         const VkAccelerationStructureCreateInfoNV32 *pCreateInfo;
20550         const VkAllocationCallbacks *pAllocator;
20551         VkAccelerationStructureNV *pAccelerationStructure;
20552         VkResult result;
20553     } *params = args;
20554     VkAccelerationStructureCreateInfoNV pCreateInfo_host;
20555     struct conversion_context ctx;
20556
20557     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
20558
20559     init_conversion_context(&ctx);
20560     convert_VkAccelerationStructureCreateInfoNV_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
20561     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pAccelerationStructure);
20562     free_conversion_context(&ctx);
20563     return STATUS_SUCCESS;
20564 }
20565
20566 #endif /* USE_STRUCT_CONVERSION */
20567
20568 #if !defined(USE_STRUCT_CONVERSION)
20569
20570 static NTSTATUS thunk64_vkCreateBuffer(void *args)
20571 {
20572     struct vkCreateBuffer_params *params = args;
20573
20574     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
20575
20576     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBuffer(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pBuffer);
20577     return STATUS_SUCCESS;
20578 }
20579
20580 #else /* USE_STRUCT_CONVERSION */
20581
20582 static NTSTATUS thunk32_vkCreateBuffer(void *args)
20583 {
20584     struct
20585     {
20586         VkDevice device;
20587         const VkBufferCreateInfo32 *pCreateInfo;
20588         const VkAllocationCallbacks *pAllocator;
20589         VkBuffer *pBuffer;
20590         VkResult result;
20591     } *params = args;
20592     VkBufferCreateInfo pCreateInfo_host;
20593     struct conversion_context ctx;
20594
20595     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
20596
20597     init_conversion_context(&ctx);
20598     convert_VkBufferCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
20599     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBuffer(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pBuffer);
20600     free_conversion_context(&ctx);
20601     return STATUS_SUCCESS;
20602 }
20603
20604 #endif /* USE_STRUCT_CONVERSION */
20605
20606 #if !defined(USE_STRUCT_CONVERSION)
20607
20608 static NTSTATUS thunk64_vkCreateBufferView(void *args)
20609 {
20610     struct vkCreateBufferView_params *params = args;
20611
20612     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
20613
20614     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBufferView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
20615     return STATUS_SUCCESS;
20616 }
20617
20618 #else /* USE_STRUCT_CONVERSION */
20619
20620 static NTSTATUS thunk32_vkCreateBufferView(void *args)
20621 {
20622     struct
20623     {
20624         VkDevice device;
20625         const VkBufferViewCreateInfo32 *pCreateInfo;
20626         const VkAllocationCallbacks *pAllocator;
20627         VkBufferView *pView;
20628         VkResult result;
20629     } *params = args;
20630     VkBufferViewCreateInfo pCreateInfo_host;
20631
20632     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
20633
20634     convert_VkBufferViewCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
20635     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBufferView(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pView);
20636     return STATUS_SUCCESS;
20637 }
20638
20639 #endif /* USE_STRUCT_CONVERSION */
20640
20641 #if !defined(USE_STRUCT_CONVERSION)
20642
20643 static NTSTATUS thunk64_vkCreateCommandPool(void *args)
20644 {
20645     struct vkCreateCommandPool_params *params = args;
20646
20647     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);
20648
20649     params->result = wine_vkCreateCommandPool(params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool, params->client_ptr);
20650     return STATUS_SUCCESS;
20651 }
20652
20653 #else /* USE_STRUCT_CONVERSION */
20654
20655 static NTSTATUS thunk32_vkCreateCommandPool(void *args)
20656 {
20657     struct
20658     {
20659         VkDevice device;
20660         const VkCommandPoolCreateInfo *pCreateInfo;
20661         const VkAllocationCallbacks *pAllocator;
20662         VkCommandPool *pCommandPool;
20663         void *client_ptr;
20664         VkResult result;
20665     } *params = args;
20666
20667     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);
20668
20669     params->result = wine_vkCreateCommandPool(params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool, params->client_ptr);
20670     return STATUS_SUCCESS;
20671 }
20672
20673 #endif /* USE_STRUCT_CONVERSION */
20674
20675 #if !defined(USE_STRUCT_CONVERSION)
20676
20677 static NTSTATUS thunk64_vkCreateComputePipelines(void *args)
20678 {
20679     struct vkCreateComputePipelines_params *params = args;
20680     const VkComputePipelineCreateInfo *pCreateInfos_host;
20681     struct conversion_context ctx;
20682
20683     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
20684
20685     init_conversion_context(&ctx);
20686     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
20687     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);
20688     free_conversion_context(&ctx);
20689     return STATUS_SUCCESS;
20690 }
20691
20692 #else /* USE_STRUCT_CONVERSION */
20693
20694 static NTSTATUS thunk32_vkCreateComputePipelines(void *args)
20695 {
20696     struct
20697     {
20698         VkDevice device;
20699         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
20700         uint32_t createInfoCount;
20701         const VkComputePipelineCreateInfo32 *pCreateInfos;
20702         const VkAllocationCallbacks *pAllocator;
20703         VkPipeline *pPipelines;
20704         VkResult result;
20705     } *params = args;
20706     const VkComputePipelineCreateInfo *pCreateInfos_host;
20707     struct conversion_context ctx;
20708
20709     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
20710
20711     init_conversion_context(&ctx);
20712     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win32_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
20713     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);
20714     convert_VkComputePipelineCreateInfo_array_host_to_win32(pCreateInfos_host, params->pCreateInfos, params->createInfoCount);
20715     free_conversion_context(&ctx);
20716     return STATUS_SUCCESS;
20717 }
20718
20719 #endif /* USE_STRUCT_CONVERSION */
20720
20721 #if !defined(USE_STRUCT_CONVERSION)
20722
20723 static NTSTATUS thunk64_vkCreateCuFunctionNVX(void *args)
20724 {
20725     struct vkCreateCuFunctionNVX_params *params = args;
20726
20727     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);
20728
20729     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFunction);
20730     return STATUS_SUCCESS;
20731 }
20732
20733 #else /* USE_STRUCT_CONVERSION */
20734
20735 static NTSTATUS thunk32_vkCreateCuFunctionNVX(void *args)
20736 {
20737     struct
20738     {
20739         VkDevice device;
20740         const VkCuFunctionCreateInfoNVX32 *pCreateInfo;
20741         const VkAllocationCallbacks *pAllocator;
20742         VkCuFunctionNVX *pFunction;
20743         VkResult result;
20744     } *params = args;
20745     VkCuFunctionCreateInfoNVX pCreateInfo_host;
20746
20747     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);
20748
20749     convert_VkCuFunctionCreateInfoNVX_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
20750     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pFunction);
20751     return STATUS_SUCCESS;
20752 }
20753
20754 #endif /* USE_STRUCT_CONVERSION */
20755
20756 #if !defined(USE_STRUCT_CONVERSION)
20757
20758 static NTSTATUS thunk64_vkCreateCuModuleNVX(void *args)
20759 {
20760     struct vkCreateCuModuleNVX_params *params = args;
20761
20762     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);
20763
20764     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pModule);
20765     return STATUS_SUCCESS;
20766 }
20767
20768 #else /* USE_STRUCT_CONVERSION */
20769
20770 static NTSTATUS thunk32_vkCreateCuModuleNVX(void *args)
20771 {
20772     struct
20773     {
20774         VkDevice device;
20775         const VkCuModuleCreateInfoNVX *pCreateInfo;
20776         const VkAllocationCallbacks *pAllocator;
20777         VkCuModuleNVX *pModule;
20778         VkResult result;
20779     } *params = args;
20780
20781     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);
20782
20783     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pModule);
20784     return STATUS_SUCCESS;
20785 }
20786
20787 #endif /* USE_STRUCT_CONVERSION */
20788
20789 #if !defined(USE_STRUCT_CONVERSION)
20790
20791 static NTSTATUS thunk64_vkCreateDebugReportCallbackEXT(void *args)
20792 {
20793     struct vkCreateDebugReportCallbackEXT_params *params = args;
20794
20795     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
20796
20797     params->result = wine_vkCreateDebugReportCallbackEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
20798     return STATUS_SUCCESS;
20799 }
20800
20801 #else /* USE_STRUCT_CONVERSION */
20802
20803 static NTSTATUS thunk32_vkCreateDebugReportCallbackEXT(void *args)
20804 {
20805     struct
20806     {
20807         VkInstance instance;
20808         const VkDebugReportCallbackCreateInfoEXT *pCreateInfo;
20809         const VkAllocationCallbacks *pAllocator;
20810         VkDebugReportCallbackEXT *pCallback;
20811         VkResult result;
20812     } *params = args;
20813
20814     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
20815
20816     params->result = wine_vkCreateDebugReportCallbackEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
20817     return STATUS_SUCCESS;
20818 }
20819
20820 #endif /* USE_STRUCT_CONVERSION */
20821
20822 #if !defined(USE_STRUCT_CONVERSION)
20823
20824 static NTSTATUS thunk64_vkCreateDebugUtilsMessengerEXT(void *args)
20825 {
20826     struct vkCreateDebugUtilsMessengerEXT_params *params = args;
20827
20828     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
20829
20830     params->result = wine_vkCreateDebugUtilsMessengerEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
20831     return STATUS_SUCCESS;
20832 }
20833
20834 #else /* USE_STRUCT_CONVERSION */
20835
20836 static NTSTATUS thunk32_vkCreateDebugUtilsMessengerEXT(void *args)
20837 {
20838     struct
20839     {
20840         VkInstance instance;
20841         const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo;
20842         const VkAllocationCallbacks *pAllocator;
20843         VkDebugUtilsMessengerEXT *pMessenger;
20844         VkResult result;
20845     } *params = args;
20846
20847     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
20848
20849     params->result = wine_vkCreateDebugUtilsMessengerEXT(params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
20850     return STATUS_SUCCESS;
20851 }
20852
20853 #endif /* USE_STRUCT_CONVERSION */
20854
20855 #if !defined(USE_STRUCT_CONVERSION)
20856
20857 static NTSTATUS thunk64_vkCreateDeferredOperationKHR(void *args)
20858 {
20859     struct vkCreateDeferredOperationKHR_params *params = args;
20860
20861     TRACE("%p, %p, %p\n", params->device, params->pAllocator, params->pDeferredOperation);
20862
20863     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDeferredOperationKHR(wine_device_from_handle(params->device)->device, NULL, params->pDeferredOperation);
20864     return STATUS_SUCCESS;
20865 }
20866
20867 #else /* USE_STRUCT_CONVERSION */
20868
20869 static NTSTATUS thunk32_vkCreateDeferredOperationKHR(void *args)
20870 {
20871     struct
20872     {
20873         VkDevice device;
20874         const VkAllocationCallbacks *pAllocator;
20875         VkDeferredOperationKHR *pDeferredOperation;
20876         VkResult result;
20877     } *params = args;
20878
20879     TRACE("%p, %p, %p\n", params->device, params->pAllocator, params->pDeferredOperation);
20880
20881     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDeferredOperationKHR(wine_device_from_handle(params->device)->device, NULL, params->pDeferredOperation);
20882     return STATUS_SUCCESS;
20883 }
20884
20885 #endif /* USE_STRUCT_CONVERSION */
20886
20887 #if !defined(USE_STRUCT_CONVERSION)
20888
20889 static NTSTATUS thunk64_vkCreateDescriptorPool(void *args)
20890 {
20891     struct vkCreateDescriptorPool_params *params = args;
20892
20893     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);
20894
20895     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorPool);
20896     return STATUS_SUCCESS;
20897 }
20898
20899 #else /* USE_STRUCT_CONVERSION */
20900
20901 static NTSTATUS thunk32_vkCreateDescriptorPool(void *args)
20902 {
20903     struct
20904     {
20905         VkDevice device;
20906         const VkDescriptorPoolCreateInfo *pCreateInfo;
20907         const VkAllocationCallbacks *pAllocator;
20908         VkDescriptorPool *pDescriptorPool;
20909         VkResult result;
20910     } *params = args;
20911
20912     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);
20913
20914     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorPool);
20915     return STATUS_SUCCESS;
20916 }
20917
20918 #endif /* USE_STRUCT_CONVERSION */
20919
20920 #if !defined(USE_STRUCT_CONVERSION)
20921
20922 static NTSTATUS thunk64_vkCreateDescriptorSetLayout(void *args)
20923 {
20924     struct vkCreateDescriptorSetLayout_params *params = args;
20925
20926     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);
20927
20928     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSetLayout);
20929     return STATUS_SUCCESS;
20930 }
20931
20932 #else /* USE_STRUCT_CONVERSION */
20933
20934 static NTSTATUS thunk32_vkCreateDescriptorSetLayout(void *args)
20935 {
20936     struct
20937     {
20938         VkDevice device;
20939         const VkDescriptorSetLayoutCreateInfo *pCreateInfo;
20940         const VkAllocationCallbacks *pAllocator;
20941         VkDescriptorSetLayout *pSetLayout;
20942         VkResult result;
20943     } *params = args;
20944
20945     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);
20946
20947     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSetLayout);
20948     return STATUS_SUCCESS;
20949 }
20950
20951 #endif /* USE_STRUCT_CONVERSION */
20952
20953 #if !defined(USE_STRUCT_CONVERSION)
20954
20955 static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplate(void *args)
20956 {
20957     struct vkCreateDescriptorUpdateTemplate_params *params = args;
20958
20959     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
20960
20961     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
20962     return STATUS_SUCCESS;
20963 }
20964
20965 #else /* USE_STRUCT_CONVERSION */
20966
20967 static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplate(void *args)
20968 {
20969     struct
20970     {
20971         VkDevice device;
20972         const VkDescriptorUpdateTemplateCreateInfo32 *pCreateInfo;
20973         const VkAllocationCallbacks *pAllocator;
20974         VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate;
20975         VkResult result;
20976     } *params = args;
20977     VkDescriptorUpdateTemplateCreateInfo pCreateInfo_host;
20978
20979     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
20980
20981     convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
20982     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pDescriptorUpdateTemplate);
20983     return STATUS_SUCCESS;
20984 }
20985
20986 #endif /* USE_STRUCT_CONVERSION */
20987
20988 #if !defined(USE_STRUCT_CONVERSION)
20989
20990 static NTSTATUS thunk64_vkCreateDescriptorUpdateTemplateKHR(void *args)
20991 {
20992     struct vkCreateDescriptorUpdateTemplateKHR_params *params = args;
20993
20994     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
20995
20996     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pDescriptorUpdateTemplate);
20997     return STATUS_SUCCESS;
20998 }
20999
21000 #else /* USE_STRUCT_CONVERSION */
21001
21002 static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplateKHR(void *args)
21003 {
21004     struct
21005     {
21006         VkDevice device;
21007         const VkDescriptorUpdateTemplateCreateInfo32 *pCreateInfo;
21008         const VkAllocationCallbacks *pAllocator;
21009         VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate;
21010         VkResult result;
21011     } *params = args;
21012     VkDescriptorUpdateTemplateCreateInfo pCreateInfo_host;
21013
21014     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
21015
21016     convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
21017     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pDescriptorUpdateTemplate);
21018     return STATUS_SUCCESS;
21019 }
21020
21021 #endif /* USE_STRUCT_CONVERSION */
21022
21023 #if !defined(USE_STRUCT_CONVERSION)
21024
21025 static NTSTATUS thunk64_vkCreateDevice(void *args)
21026 {
21027     struct vkCreateDevice_params *params = args;
21028     VkDeviceCreateInfo pCreateInfo_host;
21029     struct conversion_context ctx;
21030
21031     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);
21032
21033     init_conversion_context(&ctx);
21034     convert_VkDeviceCreateInfo_win64_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
21035     params->result = wine_vkCreateDevice(params->physicalDevice, &pCreateInfo_host, params->pAllocator, params->pDevice, params->client_ptr);
21036     free_conversion_context(&ctx);
21037     return STATUS_SUCCESS;
21038 }
21039
21040 #else /* USE_STRUCT_CONVERSION */
21041
21042 static NTSTATUS thunk32_vkCreateDevice(void *args)
21043 {
21044     struct
21045     {
21046         VkPhysicalDevice physicalDevice;
21047         const VkDeviceCreateInfo *pCreateInfo;
21048         const VkAllocationCallbacks *pAllocator;
21049         VkDevice *pDevice;
21050         void *client_ptr;
21051         VkResult result;
21052     } *params = args;
21053     VkDeviceCreateInfo pCreateInfo_host;
21054     struct conversion_context ctx;
21055
21056     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);
21057
21058     init_conversion_context(&ctx);
21059     convert_VkDeviceCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
21060     params->result = wine_vkCreateDevice(params->physicalDevice, &pCreateInfo_host, params->pAllocator, params->pDevice, params->client_ptr);
21061     free_conversion_context(&ctx);
21062     return STATUS_SUCCESS;
21063 }
21064
21065 #endif /* USE_STRUCT_CONVERSION */
21066
21067 #if !defined(USE_STRUCT_CONVERSION)
21068
21069 static NTSTATUS thunk64_vkCreateEvent(void *args)
21070 {
21071     struct vkCreateEvent_params *params = args;
21072
21073     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);
21074
21075     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateEvent(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pEvent);
21076     return STATUS_SUCCESS;
21077 }
21078
21079 #else /* USE_STRUCT_CONVERSION */
21080
21081 static NTSTATUS thunk32_vkCreateEvent(void *args)
21082 {
21083     struct
21084     {
21085         VkDevice device;
21086         const VkEventCreateInfo *pCreateInfo;
21087         const VkAllocationCallbacks *pAllocator;
21088         VkEvent *pEvent;
21089         VkResult result;
21090     } *params = args;
21091
21092     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);
21093
21094     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateEvent(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pEvent);
21095     return STATUS_SUCCESS;
21096 }
21097
21098 #endif /* USE_STRUCT_CONVERSION */
21099
21100 #if !defined(USE_STRUCT_CONVERSION)
21101
21102 static NTSTATUS thunk64_vkCreateFence(void *args)
21103 {
21104     struct vkCreateFence_params *params = args;
21105
21106     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);
21107
21108     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFence(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFence);
21109     return STATUS_SUCCESS;
21110 }
21111
21112 #else /* USE_STRUCT_CONVERSION */
21113
21114 static NTSTATUS thunk32_vkCreateFence(void *args)
21115 {
21116     struct
21117     {
21118         VkDevice device;
21119         const VkFenceCreateInfo *pCreateInfo;
21120         const VkAllocationCallbacks *pAllocator;
21121         VkFence *pFence;
21122         VkResult result;
21123     } *params = args;
21124
21125     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);
21126
21127     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFence(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFence);
21128     return STATUS_SUCCESS;
21129 }
21130
21131 #endif /* USE_STRUCT_CONVERSION */
21132
21133 #if !defined(USE_STRUCT_CONVERSION)
21134
21135 static NTSTATUS thunk64_vkCreateFramebuffer(void *args)
21136 {
21137     struct vkCreateFramebuffer_params *params = args;
21138
21139     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);
21140
21141     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFramebuffer(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pFramebuffer);
21142     return STATUS_SUCCESS;
21143 }
21144
21145 #else /* USE_STRUCT_CONVERSION */
21146
21147 static NTSTATUS thunk32_vkCreateFramebuffer(void *args)
21148 {
21149     struct
21150     {
21151         VkDevice device;
21152         const VkFramebufferCreateInfo32 *pCreateInfo;
21153         const VkAllocationCallbacks *pAllocator;
21154         VkFramebuffer *pFramebuffer;
21155         VkResult result;
21156     } *params = args;
21157     VkFramebufferCreateInfo pCreateInfo_host;
21158
21159     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);
21160
21161     convert_VkFramebufferCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
21162     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFramebuffer(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pFramebuffer);
21163     return STATUS_SUCCESS;
21164 }
21165
21166 #endif /* USE_STRUCT_CONVERSION */
21167
21168 #if !defined(USE_STRUCT_CONVERSION)
21169
21170 static NTSTATUS thunk64_vkCreateGraphicsPipelines(void *args)
21171 {
21172     struct vkCreateGraphicsPipelines_params *params = args;
21173     const VkGraphicsPipelineCreateInfo *pCreateInfos_host;
21174     struct conversion_context ctx;
21175
21176     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
21177
21178     init_conversion_context(&ctx);
21179     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
21180     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);
21181     free_conversion_context(&ctx);
21182     return STATUS_SUCCESS;
21183 }
21184
21185 #else /* USE_STRUCT_CONVERSION */
21186
21187 static NTSTATUS thunk32_vkCreateGraphicsPipelines(void *args)
21188 {
21189     struct
21190     {
21191         VkDevice device;
21192         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
21193         uint32_t createInfoCount;
21194         const VkGraphicsPipelineCreateInfo32 *pCreateInfos;
21195         const VkAllocationCallbacks *pAllocator;
21196         VkPipeline *pPipelines;
21197         VkResult result;
21198     } *params = args;
21199     const VkGraphicsPipelineCreateInfo *pCreateInfos_host;
21200     struct conversion_context ctx;
21201
21202     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
21203
21204     init_conversion_context(&ctx);
21205     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
21206     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);
21207     convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(pCreateInfos_host, params->pCreateInfos, params->createInfoCount);
21208     free_conversion_context(&ctx);
21209     return STATUS_SUCCESS;
21210 }
21211
21212 #endif /* USE_STRUCT_CONVERSION */
21213
21214 #if !defined(USE_STRUCT_CONVERSION)
21215
21216 static NTSTATUS thunk64_vkCreateImage(void *args)
21217 {
21218     struct vkCreateImage_params *params = args;
21219
21220     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);
21221
21222     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImage(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pImage);
21223     return STATUS_SUCCESS;
21224 }
21225
21226 #else /* USE_STRUCT_CONVERSION */
21227
21228 static NTSTATUS thunk32_vkCreateImage(void *args)
21229 {
21230     struct
21231     {
21232         VkDevice device;
21233         const VkImageCreateInfo *pCreateInfo;
21234         const VkAllocationCallbacks *pAllocator;
21235         VkImage *pImage;
21236         VkResult result;
21237     } *params = args;
21238     VkImageCreateInfo pCreateInfo_host;
21239     struct conversion_context ctx;
21240
21241     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);
21242
21243     init_conversion_context(&ctx);
21244     convert_VkImageCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
21245     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImage(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pImage);
21246     free_conversion_context(&ctx);
21247     return STATUS_SUCCESS;
21248 }
21249
21250 #endif /* USE_STRUCT_CONVERSION */
21251
21252 #if !defined(USE_STRUCT_CONVERSION)
21253
21254 static NTSTATUS thunk64_vkCreateImageView(void *args)
21255 {
21256     struct vkCreateImageView_params *params = args;
21257
21258     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
21259
21260     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImageView(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pView);
21261     return STATUS_SUCCESS;
21262 }
21263
21264 #else /* USE_STRUCT_CONVERSION */
21265
21266 static NTSTATUS thunk32_vkCreateImageView(void *args)
21267 {
21268     struct
21269     {
21270         VkDevice device;
21271         const VkImageViewCreateInfo32 *pCreateInfo;
21272         const VkAllocationCallbacks *pAllocator;
21273         VkImageView *pView;
21274         VkResult result;
21275     } *params = args;
21276     VkImageViewCreateInfo pCreateInfo_host;
21277     struct conversion_context ctx;
21278
21279     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
21280
21281     init_conversion_context(&ctx);
21282     convert_VkImageViewCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
21283     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImageView(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pView);
21284     free_conversion_context(&ctx);
21285     return STATUS_SUCCESS;
21286 }
21287
21288 #endif /* USE_STRUCT_CONVERSION */
21289
21290 #if !defined(USE_STRUCT_CONVERSION)
21291
21292 static NTSTATUS thunk64_vkCreateIndirectCommandsLayoutNV(void *args)
21293 {
21294     struct vkCreateIndirectCommandsLayoutNV_params *params = args;
21295
21296     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
21297
21298     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pIndirectCommandsLayout);
21299     return STATUS_SUCCESS;
21300 }
21301
21302 #else /* USE_STRUCT_CONVERSION */
21303
21304 static NTSTATUS thunk32_vkCreateIndirectCommandsLayoutNV(void *args)
21305 {
21306     struct
21307     {
21308         VkDevice device;
21309         const VkIndirectCommandsLayoutCreateInfoNV32 *pCreateInfo;
21310         const VkAllocationCallbacks *pAllocator;
21311         VkIndirectCommandsLayoutNV *pIndirectCommandsLayout;
21312         VkResult result;
21313     } *params = args;
21314     VkIndirectCommandsLayoutCreateInfoNV pCreateInfo_host;
21315     struct conversion_context ctx;
21316
21317     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
21318
21319     init_conversion_context(&ctx);
21320     convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
21321     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pIndirectCommandsLayout);
21322     free_conversion_context(&ctx);
21323     return STATUS_SUCCESS;
21324 }
21325
21326 #endif /* USE_STRUCT_CONVERSION */
21327
21328 #if !defined(USE_STRUCT_CONVERSION)
21329
21330 static NTSTATUS thunk64_vkCreateInstance(void *args)
21331 {
21332     struct vkCreateInstance_params *params = args;
21333     VkInstanceCreateInfo pCreateInfo_host;
21334     struct conversion_context ctx;
21335
21336     TRACE("%p, %p, %p\n", params->pCreateInfo, params->pAllocator, params->pInstance);
21337
21338     init_conversion_context(&ctx);
21339     convert_VkInstanceCreateInfo_win64_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
21340     params->result = wine_vkCreateInstance(&pCreateInfo_host, params->pAllocator, params->pInstance, params->client_ptr);
21341     free_conversion_context(&ctx);
21342     return STATUS_SUCCESS;
21343 }
21344
21345 #else /* USE_STRUCT_CONVERSION */
21346
21347 static NTSTATUS thunk32_vkCreateInstance(void *args)
21348 {
21349     struct
21350     {
21351         const VkInstanceCreateInfo *pCreateInfo;
21352         const VkAllocationCallbacks *pAllocator;
21353         VkInstance *pInstance;
21354         void *client_ptr;
21355         VkResult result;
21356     } *params = args;
21357     VkInstanceCreateInfo pCreateInfo_host;
21358     struct conversion_context ctx;
21359
21360     TRACE("%p, %p, %p\n", params->pCreateInfo, params->pAllocator, params->pInstance);
21361
21362     init_conversion_context(&ctx);
21363     convert_VkInstanceCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
21364     params->result = wine_vkCreateInstance(&pCreateInfo_host, params->pAllocator, params->pInstance, params->client_ptr);
21365     free_conversion_context(&ctx);
21366     return STATUS_SUCCESS;
21367 }
21368
21369 #endif /* USE_STRUCT_CONVERSION */
21370
21371 #if !defined(USE_STRUCT_CONVERSION)
21372
21373 static NTSTATUS thunk64_vkCreateMicromapEXT(void *args)
21374 {
21375     struct vkCreateMicromapEXT_params *params = args;
21376
21377     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
21378
21379     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateMicromapEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pMicromap);
21380     return STATUS_SUCCESS;
21381 }
21382
21383 #else /* USE_STRUCT_CONVERSION */
21384
21385 static NTSTATUS thunk32_vkCreateMicromapEXT(void *args)
21386 {
21387     struct
21388     {
21389         VkDevice device;
21390         const VkMicromapCreateInfoEXT32 *pCreateInfo;
21391         const VkAllocationCallbacks *pAllocator;
21392         VkMicromapEXT *pMicromap;
21393         VkResult result;
21394     } *params = args;
21395     VkMicromapCreateInfoEXT pCreateInfo_host;
21396
21397     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
21398
21399     convert_VkMicromapCreateInfoEXT_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
21400     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateMicromapEXT(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pMicromap);
21401     return STATUS_SUCCESS;
21402 }
21403
21404 #endif /* USE_STRUCT_CONVERSION */
21405
21406 #if !defined(USE_STRUCT_CONVERSION)
21407
21408 static NTSTATUS thunk64_vkCreateOpticalFlowSessionNV(void *args)
21409 {
21410     struct vkCreateOpticalFlowSessionNV_params *params = args;
21411
21412     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
21413
21414     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSession);
21415     return STATUS_SUCCESS;
21416 }
21417
21418 #else /* USE_STRUCT_CONVERSION */
21419
21420 static NTSTATUS thunk32_vkCreateOpticalFlowSessionNV(void *args)
21421 {
21422     struct
21423     {
21424         VkDevice device;
21425         const VkOpticalFlowSessionCreateInfoNV *pCreateInfo;
21426         const VkAllocationCallbacks *pAllocator;
21427         VkOpticalFlowSessionNV *pSession;
21428         VkResult result;
21429     } *params = args;
21430
21431     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
21432
21433     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSession);
21434     return STATUS_SUCCESS;
21435 }
21436
21437 #endif /* USE_STRUCT_CONVERSION */
21438
21439 #if !defined(USE_STRUCT_CONVERSION)
21440
21441 static NTSTATUS thunk64_vkCreatePipelineCache(void *args)
21442 {
21443     struct vkCreatePipelineCache_params *params = args;
21444
21445     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);
21446
21447     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineCache(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineCache);
21448     return STATUS_SUCCESS;
21449 }
21450
21451 #else /* USE_STRUCT_CONVERSION */
21452
21453 static NTSTATUS thunk32_vkCreatePipelineCache(void *args)
21454 {
21455     struct
21456     {
21457         VkDevice device;
21458         const VkPipelineCacheCreateInfo *pCreateInfo;
21459         const VkAllocationCallbacks *pAllocator;
21460         VkPipelineCache *pPipelineCache;
21461         VkResult result;
21462     } *params = args;
21463
21464     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);
21465
21466     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineCache(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineCache);
21467     return STATUS_SUCCESS;
21468 }
21469
21470 #endif /* USE_STRUCT_CONVERSION */
21471
21472 #if !defined(USE_STRUCT_CONVERSION)
21473
21474 static NTSTATUS thunk64_vkCreatePipelineLayout(void *args)
21475 {
21476     struct vkCreatePipelineLayout_params *params = args;
21477
21478     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);
21479
21480     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineLayout);
21481     return STATUS_SUCCESS;
21482 }
21483
21484 #else /* USE_STRUCT_CONVERSION */
21485
21486 static NTSTATUS thunk32_vkCreatePipelineLayout(void *args)
21487 {
21488     struct
21489     {
21490         VkDevice device;
21491         const VkPipelineLayoutCreateInfo *pCreateInfo;
21492         const VkAllocationCallbacks *pAllocator;
21493         VkPipelineLayout *pPipelineLayout;
21494         VkResult result;
21495     } *params = args;
21496
21497     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);
21498
21499     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineLayout(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPipelineLayout);
21500     return STATUS_SUCCESS;
21501 }
21502
21503 #endif /* USE_STRUCT_CONVERSION */
21504
21505 #if !defined(USE_STRUCT_CONVERSION)
21506
21507 static NTSTATUS thunk64_vkCreatePrivateDataSlot(void *args)
21508 {
21509     struct vkCreatePrivateDataSlot_params *params = args;
21510
21511     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
21512
21513     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
21514     return STATUS_SUCCESS;
21515 }
21516
21517 #else /* USE_STRUCT_CONVERSION */
21518
21519 static NTSTATUS thunk32_vkCreatePrivateDataSlot(void *args)
21520 {
21521     struct
21522     {
21523         VkDevice device;
21524         const VkPrivateDataSlotCreateInfo *pCreateInfo;
21525         const VkAllocationCallbacks *pAllocator;
21526         VkPrivateDataSlot *pPrivateDataSlot;
21527         VkResult result;
21528     } *params = args;
21529
21530     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
21531
21532     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
21533     return STATUS_SUCCESS;
21534 }
21535
21536 #endif /* USE_STRUCT_CONVERSION */
21537
21538 #if !defined(USE_STRUCT_CONVERSION)
21539
21540 static NTSTATUS thunk64_vkCreatePrivateDataSlotEXT(void *args)
21541 {
21542     struct vkCreatePrivateDataSlotEXT_params *params = args;
21543
21544     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
21545
21546     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
21547     return STATUS_SUCCESS;
21548 }
21549
21550 #else /* USE_STRUCT_CONVERSION */
21551
21552 static NTSTATUS thunk32_vkCreatePrivateDataSlotEXT(void *args)
21553 {
21554     struct
21555     {
21556         VkDevice device;
21557         const VkPrivateDataSlotCreateInfo *pCreateInfo;
21558         const VkAllocationCallbacks *pAllocator;
21559         VkPrivateDataSlot *pPrivateDataSlot;
21560         VkResult result;
21561     } *params = args;
21562
21563     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
21564
21565     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pPrivateDataSlot);
21566     return STATUS_SUCCESS;
21567 }
21568
21569 #endif /* USE_STRUCT_CONVERSION */
21570
21571 #if !defined(USE_STRUCT_CONVERSION)
21572
21573 static NTSTATUS thunk64_vkCreateQueryPool(void *args)
21574 {
21575     struct vkCreateQueryPool_params *params = args;
21576
21577     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);
21578
21579     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateQueryPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pQueryPool);
21580     return STATUS_SUCCESS;
21581 }
21582
21583 #else /* USE_STRUCT_CONVERSION */
21584
21585 static NTSTATUS thunk32_vkCreateQueryPool(void *args)
21586 {
21587     struct
21588     {
21589         VkDevice device;
21590         const VkQueryPoolCreateInfo *pCreateInfo;
21591         const VkAllocationCallbacks *pAllocator;
21592         VkQueryPool *pQueryPool;
21593         VkResult result;
21594     } *params = args;
21595
21596     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);
21597
21598     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateQueryPool(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pQueryPool);
21599     return STATUS_SUCCESS;
21600 }
21601
21602 #endif /* USE_STRUCT_CONVERSION */
21603
21604 #if !defined(USE_STRUCT_CONVERSION)
21605
21606 static NTSTATUS thunk64_vkCreateRayTracingPipelinesKHR(void *args)
21607 {
21608     struct vkCreateRayTracingPipelinesKHR_params *params = args;
21609     const VkRayTracingPipelineCreateInfoKHR *pCreateInfos_host;
21610     struct conversion_context ctx;
21611
21612     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);
21613
21614     init_conversion_context(&ctx);
21615     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
21616     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);
21617     free_conversion_context(&ctx);
21618     return STATUS_SUCCESS;
21619 }
21620
21621 #else /* USE_STRUCT_CONVERSION */
21622
21623 static NTSTATUS thunk32_vkCreateRayTracingPipelinesKHR(void *args)
21624 {
21625     struct
21626     {
21627         VkDevice device;
21628         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
21629         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
21630         uint32_t createInfoCount;
21631         const VkRayTracingPipelineCreateInfoKHR32 *pCreateInfos;
21632         const VkAllocationCallbacks *pAllocator;
21633         VkPipeline *pPipelines;
21634         VkResult result;
21635     } *params = args;
21636     const VkRayTracingPipelineCreateInfoKHR *pCreateInfos_host;
21637     struct conversion_context ctx;
21638
21639     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);
21640
21641     init_conversion_context(&ctx);
21642     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
21643     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);
21644     convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(pCreateInfos_host, params->pCreateInfos, params->createInfoCount);
21645     free_conversion_context(&ctx);
21646     return STATUS_SUCCESS;
21647 }
21648
21649 #endif /* USE_STRUCT_CONVERSION */
21650
21651 #if !defined(USE_STRUCT_CONVERSION)
21652
21653 static NTSTATUS thunk64_vkCreateRayTracingPipelinesNV(void *args)
21654 {
21655     struct vkCreateRayTracingPipelinesNV_params *params = args;
21656     const VkRayTracingPipelineCreateInfoNV *pCreateInfos_host;
21657     struct conversion_context ctx;
21658
21659     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
21660
21661     init_conversion_context(&ctx);
21662     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
21663     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);
21664     free_conversion_context(&ctx);
21665     return STATUS_SUCCESS;
21666 }
21667
21668 #else /* USE_STRUCT_CONVERSION */
21669
21670 static NTSTATUS thunk32_vkCreateRayTracingPipelinesNV(void *args)
21671 {
21672     struct
21673     {
21674         VkDevice device;
21675         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
21676         uint32_t createInfoCount;
21677         const VkRayTracingPipelineCreateInfoNV32 *pCreateInfos;
21678         const VkAllocationCallbacks *pAllocator;
21679         VkPipeline *pPipelines;
21680         VkResult result;
21681     } *params = args;
21682     const VkRayTracingPipelineCreateInfoNV *pCreateInfos_host;
21683     struct conversion_context ctx;
21684
21685     TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
21686
21687     init_conversion_context(&ctx);
21688     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
21689     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);
21690     convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(pCreateInfos_host, params->pCreateInfos, params->createInfoCount);
21691     free_conversion_context(&ctx);
21692     return STATUS_SUCCESS;
21693 }
21694
21695 #endif /* USE_STRUCT_CONVERSION */
21696
21697 #if !defined(USE_STRUCT_CONVERSION)
21698
21699 static NTSTATUS thunk64_vkCreateRenderPass(void *args)
21700 {
21701     struct vkCreateRenderPass_params *params = args;
21702
21703     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
21704
21705     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
21706     return STATUS_SUCCESS;
21707 }
21708
21709 #else /* USE_STRUCT_CONVERSION */
21710
21711 static NTSTATUS thunk32_vkCreateRenderPass(void *args)
21712 {
21713     struct
21714     {
21715         VkDevice device;
21716         const VkRenderPassCreateInfo *pCreateInfo;
21717         const VkAllocationCallbacks *pAllocator;
21718         VkRenderPass *pRenderPass;
21719         VkResult result;
21720     } *params = args;
21721
21722     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
21723
21724     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
21725     return STATUS_SUCCESS;
21726 }
21727
21728 #endif /* USE_STRUCT_CONVERSION */
21729
21730 #if !defined(USE_STRUCT_CONVERSION)
21731
21732 static NTSTATUS thunk64_vkCreateRenderPass2(void *args)
21733 {
21734     struct vkCreateRenderPass2_params *params = args;
21735
21736     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
21737
21738     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
21739     return STATUS_SUCCESS;
21740 }
21741
21742 #else /* USE_STRUCT_CONVERSION */
21743
21744 static NTSTATUS thunk32_vkCreateRenderPass2(void *args)
21745 {
21746     struct
21747     {
21748         VkDevice device;
21749         const VkRenderPassCreateInfo2 *pCreateInfo;
21750         const VkAllocationCallbacks *pAllocator;
21751         VkRenderPass *pRenderPass;
21752         VkResult result;
21753     } *params = args;
21754
21755     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
21756
21757     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
21758     return STATUS_SUCCESS;
21759 }
21760
21761 #endif /* USE_STRUCT_CONVERSION */
21762
21763 #if !defined(USE_STRUCT_CONVERSION)
21764
21765 static NTSTATUS thunk64_vkCreateRenderPass2KHR(void *args)
21766 {
21767     struct vkCreateRenderPass2KHR_params *params = args;
21768
21769     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
21770
21771     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
21772     return STATUS_SUCCESS;
21773 }
21774
21775 #else /* USE_STRUCT_CONVERSION */
21776
21777 static NTSTATUS thunk32_vkCreateRenderPass2KHR(void *args)
21778 {
21779     struct
21780     {
21781         VkDevice device;
21782         const VkRenderPassCreateInfo2 *pCreateInfo;
21783         const VkAllocationCallbacks *pAllocator;
21784         VkRenderPass *pRenderPass;
21785         VkResult result;
21786     } *params = args;
21787
21788     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
21789
21790     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pRenderPass);
21791     return STATUS_SUCCESS;
21792 }
21793
21794 #endif /* USE_STRUCT_CONVERSION */
21795
21796 #if !defined(USE_STRUCT_CONVERSION)
21797
21798 static NTSTATUS thunk64_vkCreateSampler(void *args)
21799 {
21800     struct vkCreateSampler_params *params = args;
21801
21802     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);
21803
21804     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSampler(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSampler);
21805     return STATUS_SUCCESS;
21806 }
21807
21808 #else /* USE_STRUCT_CONVERSION */
21809
21810 static NTSTATUS thunk32_vkCreateSampler(void *args)
21811 {
21812     struct
21813     {
21814         VkDevice device;
21815         const VkSamplerCreateInfo *pCreateInfo;
21816         const VkAllocationCallbacks *pAllocator;
21817         VkSampler *pSampler;
21818         VkResult result;
21819     } *params = args;
21820     VkSamplerCreateInfo pCreateInfo_host;
21821     struct conversion_context ctx;
21822
21823     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);
21824
21825     init_conversion_context(&ctx);
21826     convert_VkSamplerCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
21827     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSampler(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSampler);
21828     free_conversion_context(&ctx);
21829     return STATUS_SUCCESS;
21830 }
21831
21832 #endif /* USE_STRUCT_CONVERSION */
21833
21834 #if !defined(USE_STRUCT_CONVERSION)
21835
21836 static NTSTATUS thunk64_vkCreateSamplerYcbcrConversion(void *args)
21837 {
21838     struct vkCreateSamplerYcbcrConversion_params *params = args;
21839
21840     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
21841
21842     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
21843     return STATUS_SUCCESS;
21844 }
21845
21846 #else /* USE_STRUCT_CONVERSION */
21847
21848 static NTSTATUS thunk32_vkCreateSamplerYcbcrConversion(void *args)
21849 {
21850     struct
21851     {
21852         VkDevice device;
21853         const VkSamplerYcbcrConversionCreateInfo *pCreateInfo;
21854         const VkAllocationCallbacks *pAllocator;
21855         VkSamplerYcbcrConversion *pYcbcrConversion;
21856         VkResult result;
21857     } *params = args;
21858
21859     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
21860
21861     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
21862     return STATUS_SUCCESS;
21863 }
21864
21865 #endif /* USE_STRUCT_CONVERSION */
21866
21867 #if !defined(USE_STRUCT_CONVERSION)
21868
21869 static NTSTATUS thunk64_vkCreateSamplerYcbcrConversionKHR(void *args)
21870 {
21871     struct vkCreateSamplerYcbcrConversionKHR_params *params = args;
21872
21873     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
21874
21875     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
21876     return STATUS_SUCCESS;
21877 }
21878
21879 #else /* USE_STRUCT_CONVERSION */
21880
21881 static NTSTATUS thunk32_vkCreateSamplerYcbcrConversionKHR(void *args)
21882 {
21883     struct
21884     {
21885         VkDevice device;
21886         const VkSamplerYcbcrConversionCreateInfo *pCreateInfo;
21887         const VkAllocationCallbacks *pAllocator;
21888         VkSamplerYcbcrConversion *pYcbcrConversion;
21889         VkResult result;
21890     } *params = args;
21891
21892     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
21893
21894     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pYcbcrConversion);
21895     return STATUS_SUCCESS;
21896 }
21897
21898 #endif /* USE_STRUCT_CONVERSION */
21899
21900 #if !defined(USE_STRUCT_CONVERSION)
21901
21902 static NTSTATUS thunk64_vkCreateSemaphore(void *args)
21903 {
21904     struct vkCreateSemaphore_params *params = args;
21905
21906     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);
21907
21908     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSemaphore(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pSemaphore);
21909     return STATUS_SUCCESS;
21910 }
21911
21912 #else /* USE_STRUCT_CONVERSION */
21913
21914 static NTSTATUS thunk32_vkCreateSemaphore(void *args)
21915 {
21916     struct
21917     {
21918         VkDevice device;
21919         const VkSemaphoreCreateInfo *pCreateInfo;
21920         const VkAllocationCallbacks *pAllocator;
21921         VkSemaphore *pSemaphore;
21922         VkResult result;
21923     } *params = args;
21924     VkSemaphoreCreateInfo pCreateInfo_host;
21925     struct conversion_context ctx;
21926
21927     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);
21928
21929     init_conversion_context(&ctx);
21930     convert_VkSemaphoreCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
21931     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSemaphore(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSemaphore);
21932     free_conversion_context(&ctx);
21933     return STATUS_SUCCESS;
21934 }
21935
21936 #endif /* USE_STRUCT_CONVERSION */
21937
21938 #if !defined(USE_STRUCT_CONVERSION)
21939
21940 static NTSTATUS thunk64_vkCreateShaderModule(void *args)
21941 {
21942     struct vkCreateShaderModule_params *params = args;
21943
21944     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);
21945
21946     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateShaderModule(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pShaderModule);
21947     return STATUS_SUCCESS;
21948 }
21949
21950 #else /* USE_STRUCT_CONVERSION */
21951
21952 static NTSTATUS thunk32_vkCreateShaderModule(void *args)
21953 {
21954     struct
21955     {
21956         VkDevice device;
21957         const VkShaderModuleCreateInfo *pCreateInfo;
21958         const VkAllocationCallbacks *pAllocator;
21959         VkShaderModule *pShaderModule;
21960         VkResult result;
21961     } *params = args;
21962     VkShaderModuleCreateInfo pCreateInfo_host;
21963     struct conversion_context ctx;
21964
21965     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);
21966
21967     init_conversion_context(&ctx);
21968     convert_VkShaderModuleCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
21969     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateShaderModule(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pShaderModule);
21970     free_conversion_context(&ctx);
21971     return STATUS_SUCCESS;
21972 }
21973
21974 #endif /* USE_STRUCT_CONVERSION */
21975
21976 #if !defined(USE_STRUCT_CONVERSION)
21977
21978 static NTSTATUS thunk64_vkCreateSwapchainKHR(void *args)
21979 {
21980     struct vkCreateSwapchainKHR_params *params = args;
21981     VkSwapchainCreateInfoKHR pCreateInfo_host;
21982
21983     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);
21984
21985     convert_VkSwapchainCreateInfoKHR_win64_to_host(params->pCreateInfo, &pCreateInfo_host);
21986     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSwapchain);
21987     return STATUS_SUCCESS;
21988 }
21989
21990 #else /* USE_STRUCT_CONVERSION */
21991
21992 static NTSTATUS thunk32_vkCreateSwapchainKHR(void *args)
21993 {
21994     struct
21995     {
21996         VkDevice device;
21997         const VkSwapchainCreateInfoKHR32 *pCreateInfo;
21998         const VkAllocationCallbacks *pAllocator;
21999         VkSwapchainKHR *pSwapchain;
22000         VkResult result;
22001     } *params = args;
22002     VkSwapchainCreateInfoKHR pCreateInfo_host;
22003
22004     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);
22005
22006     convert_VkSwapchainCreateInfoKHR_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
22007     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSwapchain);
22008     return STATUS_SUCCESS;
22009 }
22010
22011 #endif /* USE_STRUCT_CONVERSION */
22012
22013 #if !defined(USE_STRUCT_CONVERSION)
22014
22015 static NTSTATUS thunk64_vkCreateValidationCacheEXT(void *args)
22016 {
22017     struct vkCreateValidationCacheEXT_params *params = args;
22018
22019     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);
22020
22021     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pValidationCache);
22022     return STATUS_SUCCESS;
22023 }
22024
22025 #else /* USE_STRUCT_CONVERSION */
22026
22027 static NTSTATUS thunk32_vkCreateValidationCacheEXT(void *args)
22028 {
22029     struct
22030     {
22031         VkDevice device;
22032         const VkValidationCacheCreateInfoEXT *pCreateInfo;
22033         const VkAllocationCallbacks *pAllocator;
22034         VkValidationCacheEXT *pValidationCache;
22035         VkResult result;
22036     } *params = args;
22037
22038     TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);
22039
22040     params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, NULL, params->pValidationCache);
22041     return STATUS_SUCCESS;
22042 }
22043
22044 #endif /* USE_STRUCT_CONVERSION */
22045
22046 #if !defined(USE_STRUCT_CONVERSION)
22047
22048 static NTSTATUS thunk64_vkCreateWin32SurfaceKHR(void *args)
22049 {
22050     struct vkCreateWin32SurfaceKHR_params *params = args;
22051
22052     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
22053
22054     params->result = wine_vkCreateWin32SurfaceKHR(params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
22055     return STATUS_SUCCESS;
22056 }
22057
22058 #else /* USE_STRUCT_CONVERSION */
22059
22060 static NTSTATUS thunk32_vkCreateWin32SurfaceKHR(void *args)
22061 {
22062     struct
22063     {
22064         VkInstance instance;
22065         const VkWin32SurfaceCreateInfoKHR *pCreateInfo;
22066         const VkAllocationCallbacks *pAllocator;
22067         VkSurfaceKHR *pSurface;
22068         VkResult result;
22069     } *params = args;
22070
22071     TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
22072
22073     params->result = wine_vkCreateWin32SurfaceKHR(params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
22074     return STATUS_SUCCESS;
22075 }
22076
22077 #endif /* USE_STRUCT_CONVERSION */
22078
22079 #if !defined(USE_STRUCT_CONVERSION)
22080
22081 static NTSTATUS thunk64_vkDebugMarkerSetObjectNameEXT(void *args)
22082 {
22083     struct vkDebugMarkerSetObjectNameEXT_params *params = args;
22084     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;
22085
22086     TRACE("%p, %p\n", params->device, params->pNameInfo);
22087
22088     convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(params->pNameInfo, &pNameInfo_host);
22089     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
22090     return STATUS_SUCCESS;
22091 }
22092
22093 #else /* USE_STRUCT_CONVERSION */
22094
22095 static NTSTATUS thunk32_vkDebugMarkerSetObjectNameEXT(void *args)
22096 {
22097     struct
22098     {
22099         VkDevice device;
22100         const VkDebugMarkerObjectNameInfoEXT32 *pNameInfo;
22101         VkResult result;
22102     } *params = args;
22103     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;
22104
22105     TRACE("%p, %p\n", params->device, params->pNameInfo);
22106
22107     convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(params->pNameInfo, &pNameInfo_host);
22108     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
22109     return STATUS_SUCCESS;
22110 }
22111
22112 #endif /* USE_STRUCT_CONVERSION */
22113
22114 #if !defined(USE_STRUCT_CONVERSION)
22115
22116 static NTSTATUS thunk64_vkDebugMarkerSetObjectTagEXT(void *args)
22117 {
22118     struct vkDebugMarkerSetObjectTagEXT_params *params = args;
22119     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;
22120
22121     TRACE("%p, %p\n", params->device, params->pTagInfo);
22122
22123     convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(params->pTagInfo, &pTagInfo_host);
22124     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
22125     return STATUS_SUCCESS;
22126 }
22127
22128 #else /* USE_STRUCT_CONVERSION */
22129
22130 static NTSTATUS thunk32_vkDebugMarkerSetObjectTagEXT(void *args)
22131 {
22132     struct
22133     {
22134         VkDevice device;
22135         const VkDebugMarkerObjectTagInfoEXT32 *pTagInfo;
22136         VkResult result;
22137     } *params = args;
22138     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;
22139
22140     TRACE("%p, %p\n", params->device, params->pTagInfo);
22141
22142     convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(params->pTagInfo, &pTagInfo_host);
22143     params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
22144     return STATUS_SUCCESS;
22145 }
22146
22147 #endif /* USE_STRUCT_CONVERSION */
22148
22149 #if !defined(USE_STRUCT_CONVERSION)
22150
22151 static NTSTATUS thunk64_vkDebugReportMessageEXT(void *args)
22152 {
22153     struct vkDebugReportMessageEXT_params *params = args;
22154
22155     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);
22156
22157     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);
22158     return STATUS_SUCCESS;
22159 }
22160
22161 #else /* USE_STRUCT_CONVERSION */
22162
22163 static NTSTATUS thunk32_vkDebugReportMessageEXT(void *args)
22164 {
22165     struct
22166     {
22167         VkInstance instance;
22168         VkDebugReportFlagsEXT flags;
22169         VkDebugReportObjectTypeEXT objectType;
22170         uint64_t DECLSPEC_ALIGN(8) object;
22171         size_t location;
22172         int32_t messageCode;
22173         const char *pLayerPrefix;
22174         const char *pMessage;
22175     } *params = args;
22176
22177     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);
22178
22179     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);
22180     return STATUS_SUCCESS;
22181 }
22182
22183 #endif /* USE_STRUCT_CONVERSION */
22184
22185 #if !defined(USE_STRUCT_CONVERSION)
22186
22187 static NTSTATUS thunk64_vkDeferredOperationJoinKHR(void *args)
22188 {
22189     struct vkDeferredOperationJoinKHR_params *params = args;
22190
22191     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
22192
22193     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle(params->device)->device, params->operation);
22194     return STATUS_SUCCESS;
22195 }
22196
22197 #else /* USE_STRUCT_CONVERSION */
22198
22199 static NTSTATUS thunk32_vkDeferredOperationJoinKHR(void *args)
22200 {
22201     struct
22202     {
22203         VkDevice device;
22204         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
22205         VkResult result;
22206     } *params = args;
22207
22208     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
22209
22210     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle(params->device)->device, params->operation);
22211     return STATUS_SUCCESS;
22212 }
22213
22214 #endif /* USE_STRUCT_CONVERSION */
22215
22216 #if !defined(USE_STRUCT_CONVERSION)
22217
22218 static NTSTATUS thunk64_vkDestroyAccelerationStructureKHR(void *args)
22219 {
22220     struct vkDestroyAccelerationStructureKHR_params *params = args;
22221
22222     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
22223
22224     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
22225     return STATUS_SUCCESS;
22226 }
22227
22228 #else /* USE_STRUCT_CONVERSION */
22229
22230 static NTSTATUS thunk32_vkDestroyAccelerationStructureKHR(void *args)
22231 {
22232     struct
22233     {
22234         VkDevice device;
22235         VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
22236         const VkAllocationCallbacks *pAllocator;
22237     } *params = args;
22238
22239     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
22240
22241     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
22242     return STATUS_SUCCESS;
22243 }
22244
22245 #endif /* USE_STRUCT_CONVERSION */
22246
22247 #if !defined(USE_STRUCT_CONVERSION)
22248
22249 static NTSTATUS thunk64_vkDestroyAccelerationStructureNV(void *args)
22250 {
22251     struct vkDestroyAccelerationStructureNV_params *params = args;
22252
22253     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
22254
22255     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
22256     return STATUS_SUCCESS;
22257 }
22258
22259 #else /* USE_STRUCT_CONVERSION */
22260
22261 static NTSTATUS thunk32_vkDestroyAccelerationStructureNV(void *args)
22262 {
22263     struct
22264     {
22265         VkDevice device;
22266         VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
22267         const VkAllocationCallbacks *pAllocator;
22268     } *params = args;
22269
22270     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
22271
22272     wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
22273     return STATUS_SUCCESS;
22274 }
22275
22276 #endif /* USE_STRUCT_CONVERSION */
22277
22278 #if !defined(USE_STRUCT_CONVERSION)
22279
22280 static NTSTATUS thunk64_vkDestroyBuffer(void *args)
22281 {
22282     struct vkDestroyBuffer_params *params = args;
22283
22284     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pAllocator);
22285
22286     wine_device_from_handle(params->device)->funcs.p_vkDestroyBuffer(wine_device_from_handle(params->device)->device, params->buffer, NULL);
22287     return STATUS_SUCCESS;
22288 }
22289
22290 #else /* USE_STRUCT_CONVERSION */
22291
22292 static NTSTATUS thunk32_vkDestroyBuffer(void *args)
22293 {
22294     struct
22295     {
22296         VkDevice device;
22297         VkBuffer DECLSPEC_ALIGN(8) buffer;
22298         const VkAllocationCallbacks *pAllocator;
22299     } *params = args;
22300
22301     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pAllocator);
22302
22303     wine_device_from_handle(params->device)->funcs.p_vkDestroyBuffer(wine_device_from_handle(params->device)->device, params->buffer, NULL);
22304     return STATUS_SUCCESS;
22305 }
22306
22307 #endif /* USE_STRUCT_CONVERSION */
22308
22309 #if !defined(USE_STRUCT_CONVERSION)
22310
22311 static NTSTATUS thunk64_vkDestroyBufferView(void *args)
22312 {
22313     struct vkDestroyBufferView_params *params = args;
22314
22315     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->bufferView), params->pAllocator);
22316
22317     wine_device_from_handle(params->device)->funcs.p_vkDestroyBufferView(wine_device_from_handle(params->device)->device, params->bufferView, NULL);
22318     return STATUS_SUCCESS;
22319 }
22320
22321 #else /* USE_STRUCT_CONVERSION */
22322
22323 static NTSTATUS thunk32_vkDestroyBufferView(void *args)
22324 {
22325     struct
22326     {
22327         VkDevice device;
22328         VkBufferView DECLSPEC_ALIGN(8) bufferView;
22329         const VkAllocationCallbacks *pAllocator;
22330     } *params = args;
22331
22332     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->bufferView), params->pAllocator);
22333
22334     wine_device_from_handle(params->device)->funcs.p_vkDestroyBufferView(wine_device_from_handle(params->device)->device, params->bufferView, NULL);
22335     return STATUS_SUCCESS;
22336 }
22337
22338 #endif /* USE_STRUCT_CONVERSION */
22339
22340 #if !defined(USE_STRUCT_CONVERSION)
22341
22342 static NTSTATUS thunk64_vkDestroyCommandPool(void *args)
22343 {
22344     struct vkDestroyCommandPool_params *params = args;
22345
22346     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->pAllocator);
22347
22348     wine_vkDestroyCommandPool(params->device, params->commandPool, params->pAllocator);
22349     return STATUS_SUCCESS;
22350 }
22351
22352 #else /* USE_STRUCT_CONVERSION */
22353
22354 static NTSTATUS thunk32_vkDestroyCommandPool(void *args)
22355 {
22356     struct
22357     {
22358         VkDevice device;
22359         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
22360         const VkAllocationCallbacks *pAllocator;
22361     } *params = args;
22362
22363     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->pAllocator);
22364
22365     wine_vkDestroyCommandPool(params->device, params->commandPool, params->pAllocator);
22366     return STATUS_SUCCESS;
22367 }
22368
22369 #endif /* USE_STRUCT_CONVERSION */
22370
22371 #if !defined(USE_STRUCT_CONVERSION)
22372
22373 static NTSTATUS thunk64_vkDestroyCuFunctionNVX(void *args)
22374 {
22375     struct vkDestroyCuFunctionNVX_params *params = args;
22376
22377     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator);
22378
22379     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuFunctionNVX(wine_device_from_handle(params->device)->device, params->function, NULL);
22380     return STATUS_SUCCESS;
22381 }
22382
22383 #else /* USE_STRUCT_CONVERSION */
22384
22385 static NTSTATUS thunk32_vkDestroyCuFunctionNVX(void *args)
22386 {
22387     struct
22388     {
22389         VkDevice device;
22390         VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
22391         const VkAllocationCallbacks *pAllocator;
22392     } *params = args;
22393
22394     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator);
22395
22396     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuFunctionNVX(wine_device_from_handle(params->device)->device, params->function, NULL);
22397     return STATUS_SUCCESS;
22398 }
22399
22400 #endif /* USE_STRUCT_CONVERSION */
22401
22402 #if !defined(USE_STRUCT_CONVERSION)
22403
22404 static NTSTATUS thunk64_vkDestroyCuModuleNVX(void *args)
22405 {
22406     struct vkDestroyCuModuleNVX_params *params = args;
22407
22408     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator);
22409
22410     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuModuleNVX(wine_device_from_handle(params->device)->device, params->module, NULL);
22411     return STATUS_SUCCESS;
22412 }
22413
22414 #else /* USE_STRUCT_CONVERSION */
22415
22416 static NTSTATUS thunk32_vkDestroyCuModuleNVX(void *args)
22417 {
22418     struct
22419     {
22420         VkDevice device;
22421         VkCuModuleNVX DECLSPEC_ALIGN(8) module;
22422         const VkAllocationCallbacks *pAllocator;
22423     } *params = args;
22424
22425     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator);
22426
22427     wine_device_from_handle(params->device)->funcs.p_vkDestroyCuModuleNVX(wine_device_from_handle(params->device)->device, params->module, NULL);
22428     return STATUS_SUCCESS;
22429 }
22430
22431 #endif /* USE_STRUCT_CONVERSION */
22432
22433 #if !defined(USE_STRUCT_CONVERSION)
22434
22435 static NTSTATUS thunk64_vkDestroyDebugReportCallbackEXT(void *args)
22436 {
22437     struct vkDestroyDebugReportCallbackEXT_params *params = args;
22438
22439     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->callback), params->pAllocator);
22440
22441     wine_vkDestroyDebugReportCallbackEXT(params->instance, params->callback, params->pAllocator);
22442     return STATUS_SUCCESS;
22443 }
22444
22445 #else /* USE_STRUCT_CONVERSION */
22446
22447 static NTSTATUS thunk32_vkDestroyDebugReportCallbackEXT(void *args)
22448 {
22449     struct
22450     {
22451         VkInstance instance;
22452         VkDebugReportCallbackEXT DECLSPEC_ALIGN(8) callback;
22453         const VkAllocationCallbacks *pAllocator;
22454     } *params = args;
22455
22456     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->callback), params->pAllocator);
22457
22458     wine_vkDestroyDebugReportCallbackEXT(params->instance, params->callback, params->pAllocator);
22459     return STATUS_SUCCESS;
22460 }
22461
22462 #endif /* USE_STRUCT_CONVERSION */
22463
22464 #if !defined(USE_STRUCT_CONVERSION)
22465
22466 static NTSTATUS thunk64_vkDestroyDebugUtilsMessengerEXT(void *args)
22467 {
22468     struct vkDestroyDebugUtilsMessengerEXT_params *params = args;
22469
22470     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->messenger), params->pAllocator);
22471
22472     wine_vkDestroyDebugUtilsMessengerEXT(params->instance, params->messenger, params->pAllocator);
22473     return STATUS_SUCCESS;
22474 }
22475
22476 #else /* USE_STRUCT_CONVERSION */
22477
22478 static NTSTATUS thunk32_vkDestroyDebugUtilsMessengerEXT(void *args)
22479 {
22480     struct
22481     {
22482         VkInstance instance;
22483         VkDebugUtilsMessengerEXT DECLSPEC_ALIGN(8) messenger;
22484         const VkAllocationCallbacks *pAllocator;
22485     } *params = args;
22486
22487     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->messenger), params->pAllocator);
22488
22489     wine_vkDestroyDebugUtilsMessengerEXT(params->instance, params->messenger, params->pAllocator);
22490     return STATUS_SUCCESS;
22491 }
22492
22493 #endif /* USE_STRUCT_CONVERSION */
22494
22495 #if !defined(USE_STRUCT_CONVERSION)
22496
22497 static NTSTATUS thunk64_vkDestroyDeferredOperationKHR(void *args)
22498 {
22499     struct vkDestroyDeferredOperationKHR_params *params = args;
22500
22501     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->operation), params->pAllocator);
22502
22503     wine_device_from_handle(params->device)->funcs.p_vkDestroyDeferredOperationKHR(wine_device_from_handle(params->device)->device, params->operation, NULL);
22504     return STATUS_SUCCESS;
22505 }
22506
22507 #else /* USE_STRUCT_CONVERSION */
22508
22509 static NTSTATUS thunk32_vkDestroyDeferredOperationKHR(void *args)
22510 {
22511     struct
22512     {
22513         VkDevice device;
22514         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
22515         const VkAllocationCallbacks *pAllocator;
22516     } *params = args;
22517
22518     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->operation), params->pAllocator);
22519
22520     wine_device_from_handle(params->device)->funcs.p_vkDestroyDeferredOperationKHR(wine_device_from_handle(params->device)->device, params->operation, NULL);
22521     return STATUS_SUCCESS;
22522 }
22523
22524 #endif /* USE_STRUCT_CONVERSION */
22525
22526 #if !defined(USE_STRUCT_CONVERSION)
22527
22528 static NTSTATUS thunk64_vkDestroyDescriptorPool(void *args)
22529 {
22530     struct vkDestroyDescriptorPool_params *params = args;
22531
22532     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->pAllocator);
22533
22534     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, NULL);
22535     return STATUS_SUCCESS;
22536 }
22537
22538 #else /* USE_STRUCT_CONVERSION */
22539
22540 static NTSTATUS thunk32_vkDestroyDescriptorPool(void *args)
22541 {
22542     struct
22543     {
22544         VkDevice device;
22545         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
22546         const VkAllocationCallbacks *pAllocator;
22547     } *params = args;
22548
22549     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->pAllocator);
22550
22551     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, NULL);
22552     return STATUS_SUCCESS;
22553 }
22554
22555 #endif /* USE_STRUCT_CONVERSION */
22556
22557 #if !defined(USE_STRUCT_CONVERSION)
22558
22559 static NTSTATUS thunk64_vkDestroyDescriptorSetLayout(void *args)
22560 {
22561     struct vkDestroyDescriptorSetLayout_params *params = args;
22562
22563     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSetLayout), params->pAllocator);
22564
22565     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->descriptorSetLayout, NULL);
22566     return STATUS_SUCCESS;
22567 }
22568
22569 #else /* USE_STRUCT_CONVERSION */
22570
22571 static NTSTATUS thunk32_vkDestroyDescriptorSetLayout(void *args)
22572 {
22573     struct
22574     {
22575         VkDevice device;
22576         VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
22577         const VkAllocationCallbacks *pAllocator;
22578     } *params = args;
22579
22580     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSetLayout), params->pAllocator);
22581
22582     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->descriptorSetLayout, NULL);
22583     return STATUS_SUCCESS;
22584 }
22585
22586 #endif /* USE_STRUCT_CONVERSION */
22587
22588 #if !defined(USE_STRUCT_CONVERSION)
22589
22590 static NTSTATUS thunk64_vkDestroyDescriptorUpdateTemplate(void *args)
22591 {
22592     struct vkDestroyDescriptorUpdateTemplate_params *params = args;
22593
22594     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
22595
22596     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
22597     return STATUS_SUCCESS;
22598 }
22599
22600 #else /* USE_STRUCT_CONVERSION */
22601
22602 static NTSTATUS thunk32_vkDestroyDescriptorUpdateTemplate(void *args)
22603 {
22604     struct
22605     {
22606         VkDevice device;
22607         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
22608         const VkAllocationCallbacks *pAllocator;
22609     } *params = args;
22610
22611     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
22612
22613     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
22614     return STATUS_SUCCESS;
22615 }
22616
22617 #endif /* USE_STRUCT_CONVERSION */
22618
22619 #if !defined(USE_STRUCT_CONVERSION)
22620
22621 static NTSTATUS thunk64_vkDestroyDescriptorUpdateTemplateKHR(void *args)
22622 {
22623     struct vkDestroyDescriptorUpdateTemplateKHR_params *params = args;
22624
22625     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
22626
22627     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
22628     return STATUS_SUCCESS;
22629 }
22630
22631 #else /* USE_STRUCT_CONVERSION */
22632
22633 static NTSTATUS thunk32_vkDestroyDescriptorUpdateTemplateKHR(void *args)
22634 {
22635     struct
22636     {
22637         VkDevice device;
22638         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
22639         const VkAllocationCallbacks *pAllocator;
22640     } *params = args;
22641
22642     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
22643
22644     wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
22645     return STATUS_SUCCESS;
22646 }
22647
22648 #endif /* USE_STRUCT_CONVERSION */
22649
22650 #if !defined(USE_STRUCT_CONVERSION)
22651
22652 static NTSTATUS thunk64_vkDestroyDevice(void *args)
22653 {
22654     struct vkDestroyDevice_params *params = args;
22655
22656     TRACE("%p, %p\n", params->device, params->pAllocator);
22657
22658     if (!params->device)
22659         return STATUS_SUCCESS;
22660
22661     wine_vkDestroyDevice(params->device, params->pAllocator);
22662     return STATUS_SUCCESS;
22663 }
22664
22665 #else /* USE_STRUCT_CONVERSION */
22666
22667 static NTSTATUS thunk32_vkDestroyDevice(void *args)
22668 {
22669     struct
22670     {
22671         VkDevice device;
22672         const VkAllocationCallbacks *pAllocator;
22673     } *params = args;
22674
22675     TRACE("%p, %p\n", params->device, params->pAllocator);
22676
22677     if (!params->device)
22678         return STATUS_SUCCESS;
22679
22680     wine_vkDestroyDevice(params->device, params->pAllocator);
22681     return STATUS_SUCCESS;
22682 }
22683
22684 #endif /* USE_STRUCT_CONVERSION */
22685
22686 #if !defined(USE_STRUCT_CONVERSION)
22687
22688 static NTSTATUS thunk64_vkDestroyEvent(void *args)
22689 {
22690     struct vkDestroyEvent_params *params = args;
22691
22692     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->event), params->pAllocator);
22693
22694     wine_device_from_handle(params->device)->funcs.p_vkDestroyEvent(wine_device_from_handle(params->device)->device, params->event, NULL);
22695     return STATUS_SUCCESS;
22696 }
22697
22698 #else /* USE_STRUCT_CONVERSION */
22699
22700 static NTSTATUS thunk32_vkDestroyEvent(void *args)
22701 {
22702     struct
22703     {
22704         VkDevice device;
22705         VkEvent DECLSPEC_ALIGN(8) event;
22706         const VkAllocationCallbacks *pAllocator;
22707     } *params = args;
22708
22709     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->event), params->pAllocator);
22710
22711     wine_device_from_handle(params->device)->funcs.p_vkDestroyEvent(wine_device_from_handle(params->device)->device, params->event, NULL);
22712     return STATUS_SUCCESS;
22713 }
22714
22715 #endif /* USE_STRUCT_CONVERSION */
22716
22717 #if !defined(USE_STRUCT_CONVERSION)
22718
22719 static NTSTATUS thunk64_vkDestroyFence(void *args)
22720 {
22721     struct vkDestroyFence_params *params = args;
22722
22723     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
22724
22725     wine_device_from_handle(params->device)->funcs.p_vkDestroyFence(wine_device_from_handle(params->device)->device, params->fence, NULL);
22726     return STATUS_SUCCESS;
22727 }
22728
22729 #else /* USE_STRUCT_CONVERSION */
22730
22731 static NTSTATUS thunk32_vkDestroyFence(void *args)
22732 {
22733     struct
22734     {
22735         VkDevice device;
22736         VkFence DECLSPEC_ALIGN(8) fence;
22737         const VkAllocationCallbacks *pAllocator;
22738     } *params = args;
22739
22740     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
22741
22742     wine_device_from_handle(params->device)->funcs.p_vkDestroyFence(wine_device_from_handle(params->device)->device, params->fence, NULL);
22743     return STATUS_SUCCESS;
22744 }
22745
22746 #endif /* USE_STRUCT_CONVERSION */
22747
22748 #if !defined(USE_STRUCT_CONVERSION)
22749
22750 static NTSTATUS thunk64_vkDestroyFramebuffer(void *args)
22751 {
22752     struct vkDestroyFramebuffer_params *params = args;
22753
22754     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pAllocator);
22755
22756     wine_device_from_handle(params->device)->funcs.p_vkDestroyFramebuffer(wine_device_from_handle(params->device)->device, params->framebuffer, NULL);
22757     return STATUS_SUCCESS;
22758 }
22759
22760 #else /* USE_STRUCT_CONVERSION */
22761
22762 static NTSTATUS thunk32_vkDestroyFramebuffer(void *args)
22763 {
22764     struct
22765     {
22766         VkDevice device;
22767         VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
22768         const VkAllocationCallbacks *pAllocator;
22769     } *params = args;
22770
22771     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pAllocator);
22772
22773     wine_device_from_handle(params->device)->funcs.p_vkDestroyFramebuffer(wine_device_from_handle(params->device)->device, params->framebuffer, NULL);
22774     return STATUS_SUCCESS;
22775 }
22776
22777 #endif /* USE_STRUCT_CONVERSION */
22778
22779 #if !defined(USE_STRUCT_CONVERSION)
22780
22781 static NTSTATUS thunk64_vkDestroyImage(void *args)
22782 {
22783     struct vkDestroyImage_params *params = args;
22784
22785     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pAllocator);
22786
22787     wine_device_from_handle(params->device)->funcs.p_vkDestroyImage(wine_device_from_handle(params->device)->device, params->image, NULL);
22788     return STATUS_SUCCESS;
22789 }
22790
22791 #else /* USE_STRUCT_CONVERSION */
22792
22793 static NTSTATUS thunk32_vkDestroyImage(void *args)
22794 {
22795     struct
22796     {
22797         VkDevice device;
22798         VkImage DECLSPEC_ALIGN(8) image;
22799         const VkAllocationCallbacks *pAllocator;
22800     } *params = args;
22801
22802     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pAllocator);
22803
22804     wine_device_from_handle(params->device)->funcs.p_vkDestroyImage(wine_device_from_handle(params->device)->device, params->image, NULL);
22805     return STATUS_SUCCESS;
22806 }
22807
22808 #endif /* USE_STRUCT_CONVERSION */
22809
22810 #if !defined(USE_STRUCT_CONVERSION)
22811
22812 static NTSTATUS thunk64_vkDestroyImageView(void *args)
22813 {
22814     struct vkDestroyImageView_params *params = args;
22815
22816     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pAllocator);
22817
22818     wine_device_from_handle(params->device)->funcs.p_vkDestroyImageView(wine_device_from_handle(params->device)->device, params->imageView, NULL);
22819     return STATUS_SUCCESS;
22820 }
22821
22822 #else /* USE_STRUCT_CONVERSION */
22823
22824 static NTSTATUS thunk32_vkDestroyImageView(void *args)
22825 {
22826     struct
22827     {
22828         VkDevice device;
22829         VkImageView DECLSPEC_ALIGN(8) imageView;
22830         const VkAllocationCallbacks *pAllocator;
22831     } *params = args;
22832
22833     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pAllocator);
22834
22835     wine_device_from_handle(params->device)->funcs.p_vkDestroyImageView(wine_device_from_handle(params->device)->device, params->imageView, NULL);
22836     return STATUS_SUCCESS;
22837 }
22838
22839 #endif /* USE_STRUCT_CONVERSION */
22840
22841 #if !defined(USE_STRUCT_CONVERSION)
22842
22843 static NTSTATUS thunk64_vkDestroyIndirectCommandsLayoutNV(void *args)
22844 {
22845     struct vkDestroyIndirectCommandsLayoutNV_params *params = args;
22846
22847     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
22848
22849     wine_device_from_handle(params->device)->funcs.p_vkDestroyIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->indirectCommandsLayout, NULL);
22850     return STATUS_SUCCESS;
22851 }
22852
22853 #else /* USE_STRUCT_CONVERSION */
22854
22855 static NTSTATUS thunk32_vkDestroyIndirectCommandsLayoutNV(void *args)
22856 {
22857     struct
22858     {
22859         VkDevice device;
22860         VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
22861         const VkAllocationCallbacks *pAllocator;
22862     } *params = args;
22863
22864     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
22865
22866     wine_device_from_handle(params->device)->funcs.p_vkDestroyIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->indirectCommandsLayout, NULL);
22867     return STATUS_SUCCESS;
22868 }
22869
22870 #endif /* USE_STRUCT_CONVERSION */
22871
22872 #if !defined(USE_STRUCT_CONVERSION)
22873
22874 static NTSTATUS thunk64_vkDestroyInstance(void *args)
22875 {
22876     struct vkDestroyInstance_params *params = args;
22877
22878     TRACE("%p, %p\n", params->instance, params->pAllocator);
22879
22880     if (!params->instance)
22881         return STATUS_SUCCESS;
22882
22883     wine_vkDestroyInstance(params->instance, params->pAllocator);
22884     return STATUS_SUCCESS;
22885 }
22886
22887 #else /* USE_STRUCT_CONVERSION */
22888
22889 static NTSTATUS thunk32_vkDestroyInstance(void *args)
22890 {
22891     struct
22892     {
22893         VkInstance instance;
22894         const VkAllocationCallbacks *pAllocator;
22895     } *params = args;
22896
22897     TRACE("%p, %p\n", params->instance, params->pAllocator);
22898
22899     if (!params->instance)
22900         return STATUS_SUCCESS;
22901
22902     wine_vkDestroyInstance(params->instance, params->pAllocator);
22903     return STATUS_SUCCESS;
22904 }
22905
22906 #endif /* USE_STRUCT_CONVERSION */
22907
22908 #if !defined(USE_STRUCT_CONVERSION)
22909
22910 static NTSTATUS thunk64_vkDestroyMicromapEXT(void *args)
22911 {
22912     struct vkDestroyMicromapEXT_params *params = args;
22913
22914     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
22915
22916     wine_device_from_handle(params->device)->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle(params->device)->device, params->micromap, NULL);
22917     return STATUS_SUCCESS;
22918 }
22919
22920 #else /* USE_STRUCT_CONVERSION */
22921
22922 static NTSTATUS thunk32_vkDestroyMicromapEXT(void *args)
22923 {
22924     struct
22925     {
22926         VkDevice device;
22927         VkMicromapEXT DECLSPEC_ALIGN(8) micromap;
22928         const VkAllocationCallbacks *pAllocator;
22929     } *params = args;
22930
22931     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
22932
22933     wine_device_from_handle(params->device)->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle(params->device)->device, params->micromap, NULL);
22934     return STATUS_SUCCESS;
22935 }
22936
22937 #endif /* USE_STRUCT_CONVERSION */
22938
22939 #if !defined(USE_STRUCT_CONVERSION)
22940
22941 static NTSTATUS thunk64_vkDestroyOpticalFlowSessionNV(void *args)
22942 {
22943     struct vkDestroyOpticalFlowSessionNV_params *params = args;
22944
22945     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
22946
22947     wine_device_from_handle(params->device)->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->session, NULL);
22948     return STATUS_SUCCESS;
22949 }
22950
22951 #else /* USE_STRUCT_CONVERSION */
22952
22953 static NTSTATUS thunk32_vkDestroyOpticalFlowSessionNV(void *args)
22954 {
22955     struct
22956     {
22957         VkDevice device;
22958         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
22959         const VkAllocationCallbacks *pAllocator;
22960     } *params = args;
22961
22962     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
22963
22964     wine_device_from_handle(params->device)->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->session, NULL);
22965     return STATUS_SUCCESS;
22966 }
22967
22968 #endif /* USE_STRUCT_CONVERSION */
22969
22970 #if !defined(USE_STRUCT_CONVERSION)
22971
22972 static NTSTATUS thunk64_vkDestroyPipeline(void *args)
22973 {
22974     struct vkDestroyPipeline_params *params = args;
22975
22976     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->pAllocator);
22977
22978     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipeline(wine_device_from_handle(params->device)->device, params->pipeline, NULL);
22979     return STATUS_SUCCESS;
22980 }
22981
22982 #else /* USE_STRUCT_CONVERSION */
22983
22984 static NTSTATUS thunk32_vkDestroyPipeline(void *args)
22985 {
22986     struct
22987     {
22988         VkDevice device;
22989         VkPipeline DECLSPEC_ALIGN(8) pipeline;
22990         const VkAllocationCallbacks *pAllocator;
22991     } *params = args;
22992
22993     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->pAllocator);
22994
22995     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipeline(wine_device_from_handle(params->device)->device, params->pipeline, NULL);
22996     return STATUS_SUCCESS;
22997 }
22998
22999 #endif /* USE_STRUCT_CONVERSION */
23000
23001 #if !defined(USE_STRUCT_CONVERSION)
23002
23003 static NTSTATUS thunk64_vkDestroyPipelineCache(void *args)
23004 {
23005     struct vkDestroyPipelineCache_params *params = args;
23006
23007     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pAllocator);
23008
23009     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineCache(wine_device_from_handle(params->device)->device, params->pipelineCache, NULL);
23010     return STATUS_SUCCESS;
23011 }
23012
23013 #else /* USE_STRUCT_CONVERSION */
23014
23015 static NTSTATUS thunk32_vkDestroyPipelineCache(void *args)
23016 {
23017     struct
23018     {
23019         VkDevice device;
23020         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
23021         const VkAllocationCallbacks *pAllocator;
23022     } *params = args;
23023
23024     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pAllocator);
23025
23026     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineCache(wine_device_from_handle(params->device)->device, params->pipelineCache, NULL);
23027     return STATUS_SUCCESS;
23028 }
23029
23030 #endif /* USE_STRUCT_CONVERSION */
23031
23032 #if !defined(USE_STRUCT_CONVERSION)
23033
23034 static NTSTATUS thunk64_vkDestroyPipelineLayout(void *args)
23035 {
23036     struct vkDestroyPipelineLayout_params *params = args;
23037
23038     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineLayout), params->pAllocator);
23039
23040     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineLayout(wine_device_from_handle(params->device)->device, params->pipelineLayout, NULL);
23041     return STATUS_SUCCESS;
23042 }
23043
23044 #else /* USE_STRUCT_CONVERSION */
23045
23046 static NTSTATUS thunk32_vkDestroyPipelineLayout(void *args)
23047 {
23048     struct
23049     {
23050         VkDevice device;
23051         VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
23052         const VkAllocationCallbacks *pAllocator;
23053     } *params = args;
23054
23055     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineLayout), params->pAllocator);
23056
23057     wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineLayout(wine_device_from_handle(params->device)->device, params->pipelineLayout, NULL);
23058     return STATUS_SUCCESS;
23059 }
23060
23061 #endif /* USE_STRUCT_CONVERSION */
23062
23063 #if !defined(USE_STRUCT_CONVERSION)
23064
23065 static NTSTATUS thunk64_vkDestroyPrivateDataSlot(void *args)
23066 {
23067     struct vkDestroyPrivateDataSlot_params *params = args;
23068
23069     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
23070
23071     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlot(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
23072     return STATUS_SUCCESS;
23073 }
23074
23075 #else /* USE_STRUCT_CONVERSION */
23076
23077 static NTSTATUS thunk32_vkDestroyPrivateDataSlot(void *args)
23078 {
23079     struct
23080     {
23081         VkDevice device;
23082         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
23083         const VkAllocationCallbacks *pAllocator;
23084     } *params = args;
23085
23086     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
23087
23088     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlot(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
23089     return STATUS_SUCCESS;
23090 }
23091
23092 #endif /* USE_STRUCT_CONVERSION */
23093
23094 #if !defined(USE_STRUCT_CONVERSION)
23095
23096 static NTSTATUS thunk64_vkDestroyPrivateDataSlotEXT(void *args)
23097 {
23098     struct vkDestroyPrivateDataSlotEXT_params *params = args;
23099
23100     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
23101
23102     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
23103     return STATUS_SUCCESS;
23104 }
23105
23106 #else /* USE_STRUCT_CONVERSION */
23107
23108 static NTSTATUS thunk32_vkDestroyPrivateDataSlotEXT(void *args)
23109 {
23110     struct
23111     {
23112         VkDevice device;
23113         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
23114         const VkAllocationCallbacks *pAllocator;
23115     } *params = args;
23116
23117     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
23118
23119     wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
23120     return STATUS_SUCCESS;
23121 }
23122
23123 #endif /* USE_STRUCT_CONVERSION */
23124
23125 #if !defined(USE_STRUCT_CONVERSION)
23126
23127 static NTSTATUS thunk64_vkDestroyQueryPool(void *args)
23128 {
23129     struct vkDestroyQueryPool_params *params = args;
23130
23131     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->queryPool), params->pAllocator);
23132
23133     wine_device_from_handle(params->device)->funcs.p_vkDestroyQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, NULL);
23134     return STATUS_SUCCESS;
23135 }
23136
23137 #else /* USE_STRUCT_CONVERSION */
23138
23139 static NTSTATUS thunk32_vkDestroyQueryPool(void *args)
23140 {
23141     struct
23142     {
23143         VkDevice device;
23144         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
23145         const VkAllocationCallbacks *pAllocator;
23146     } *params = args;
23147
23148     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->queryPool), params->pAllocator);
23149
23150     wine_device_from_handle(params->device)->funcs.p_vkDestroyQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, NULL);
23151     return STATUS_SUCCESS;
23152 }
23153
23154 #endif /* USE_STRUCT_CONVERSION */
23155
23156 #if !defined(USE_STRUCT_CONVERSION)
23157
23158 static NTSTATUS thunk64_vkDestroyRenderPass(void *args)
23159 {
23160     struct vkDestroyRenderPass_params *params = args;
23161
23162     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pAllocator);
23163
23164     wine_device_from_handle(params->device)->funcs.p_vkDestroyRenderPass(wine_device_from_handle(params->device)->device, params->renderPass, NULL);
23165     return STATUS_SUCCESS;
23166 }
23167
23168 #else /* USE_STRUCT_CONVERSION */
23169
23170 static NTSTATUS thunk32_vkDestroyRenderPass(void *args)
23171 {
23172     struct
23173     {
23174         VkDevice device;
23175         VkRenderPass DECLSPEC_ALIGN(8) renderPass;
23176         const VkAllocationCallbacks *pAllocator;
23177     } *params = args;
23178
23179     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pAllocator);
23180
23181     wine_device_from_handle(params->device)->funcs.p_vkDestroyRenderPass(wine_device_from_handle(params->device)->device, params->renderPass, NULL);
23182     return STATUS_SUCCESS;
23183 }
23184
23185 #endif /* USE_STRUCT_CONVERSION */
23186
23187 #if !defined(USE_STRUCT_CONVERSION)
23188
23189 static NTSTATUS thunk64_vkDestroySampler(void *args)
23190 {
23191     struct vkDestroySampler_params *params = args;
23192
23193     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->sampler), params->pAllocator);
23194
23195     wine_device_from_handle(params->device)->funcs.p_vkDestroySampler(wine_device_from_handle(params->device)->device, params->sampler, NULL);
23196     return STATUS_SUCCESS;
23197 }
23198
23199 #else /* USE_STRUCT_CONVERSION */
23200
23201 static NTSTATUS thunk32_vkDestroySampler(void *args)
23202 {
23203     struct
23204     {
23205         VkDevice device;
23206         VkSampler DECLSPEC_ALIGN(8) sampler;
23207         const VkAllocationCallbacks *pAllocator;
23208     } *params = args;
23209
23210     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->sampler), params->pAllocator);
23211
23212     wine_device_from_handle(params->device)->funcs.p_vkDestroySampler(wine_device_from_handle(params->device)->device, params->sampler, NULL);
23213     return STATUS_SUCCESS;
23214 }
23215
23216 #endif /* USE_STRUCT_CONVERSION */
23217
23218 #if !defined(USE_STRUCT_CONVERSION)
23219
23220 static NTSTATUS thunk64_vkDestroySamplerYcbcrConversion(void *args)
23221 {
23222     struct vkDestroySamplerYcbcrConversion_params *params = args;
23223
23224     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
23225
23226     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
23227     return STATUS_SUCCESS;
23228 }
23229
23230 #else /* USE_STRUCT_CONVERSION */
23231
23232 static NTSTATUS thunk32_vkDestroySamplerYcbcrConversion(void *args)
23233 {
23234     struct
23235     {
23236         VkDevice device;
23237         VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) ycbcrConversion;
23238         const VkAllocationCallbacks *pAllocator;
23239     } *params = args;
23240
23241     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
23242
23243     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
23244     return STATUS_SUCCESS;
23245 }
23246
23247 #endif /* USE_STRUCT_CONVERSION */
23248
23249 #if !defined(USE_STRUCT_CONVERSION)
23250
23251 static NTSTATUS thunk64_vkDestroySamplerYcbcrConversionKHR(void *args)
23252 {
23253     struct vkDestroySamplerYcbcrConversionKHR_params *params = args;
23254
23255     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
23256
23257     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
23258     return STATUS_SUCCESS;
23259 }
23260
23261 #else /* USE_STRUCT_CONVERSION */
23262
23263 static NTSTATUS thunk32_vkDestroySamplerYcbcrConversionKHR(void *args)
23264 {
23265     struct
23266     {
23267         VkDevice device;
23268         VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) ycbcrConversion;
23269         const VkAllocationCallbacks *pAllocator;
23270     } *params = args;
23271
23272     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
23273
23274     wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
23275     return STATUS_SUCCESS;
23276 }
23277
23278 #endif /* USE_STRUCT_CONVERSION */
23279
23280 #if !defined(USE_STRUCT_CONVERSION)
23281
23282 static NTSTATUS thunk64_vkDestroySemaphore(void *args)
23283 {
23284     struct vkDestroySemaphore_params *params = args;
23285
23286     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pAllocator);
23287
23288     wine_device_from_handle(params->device)->funcs.p_vkDestroySemaphore(wine_device_from_handle(params->device)->device, params->semaphore, NULL);
23289     return STATUS_SUCCESS;
23290 }
23291
23292 #else /* USE_STRUCT_CONVERSION */
23293
23294 static NTSTATUS thunk32_vkDestroySemaphore(void *args)
23295 {
23296     struct
23297     {
23298         VkDevice device;
23299         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
23300         const VkAllocationCallbacks *pAllocator;
23301     } *params = args;
23302
23303     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pAllocator);
23304
23305     wine_device_from_handle(params->device)->funcs.p_vkDestroySemaphore(wine_device_from_handle(params->device)->device, params->semaphore, NULL);
23306     return STATUS_SUCCESS;
23307 }
23308
23309 #endif /* USE_STRUCT_CONVERSION */
23310
23311 #if !defined(USE_STRUCT_CONVERSION)
23312
23313 static NTSTATUS thunk64_vkDestroyShaderModule(void *args)
23314 {
23315     struct vkDestroyShaderModule_params *params = args;
23316
23317     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pAllocator);
23318
23319     wine_device_from_handle(params->device)->funcs.p_vkDestroyShaderModule(wine_device_from_handle(params->device)->device, params->shaderModule, NULL);
23320     return STATUS_SUCCESS;
23321 }
23322
23323 #else /* USE_STRUCT_CONVERSION */
23324
23325 static NTSTATUS thunk32_vkDestroyShaderModule(void *args)
23326 {
23327     struct
23328     {
23329         VkDevice device;
23330         VkShaderModule DECLSPEC_ALIGN(8) shaderModule;
23331         const VkAllocationCallbacks *pAllocator;
23332     } *params = args;
23333
23334     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pAllocator);
23335
23336     wine_device_from_handle(params->device)->funcs.p_vkDestroyShaderModule(wine_device_from_handle(params->device)->device, params->shaderModule, NULL);
23337     return STATUS_SUCCESS;
23338 }
23339
23340 #endif /* USE_STRUCT_CONVERSION */
23341
23342 #if !defined(USE_STRUCT_CONVERSION)
23343
23344 static NTSTATUS thunk64_vkDestroySurfaceKHR(void *args)
23345 {
23346     struct vkDestroySurfaceKHR_params *params = args;
23347
23348     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->surface), params->pAllocator);
23349
23350     wine_vkDestroySurfaceKHR(params->instance, params->surface, params->pAllocator);
23351     return STATUS_SUCCESS;
23352 }
23353
23354 #else /* USE_STRUCT_CONVERSION */
23355
23356 static NTSTATUS thunk32_vkDestroySurfaceKHR(void *args)
23357 {
23358     struct
23359     {
23360         VkInstance instance;
23361         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
23362         const VkAllocationCallbacks *pAllocator;
23363     } *params = args;
23364
23365     TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->surface), params->pAllocator);
23366
23367     wine_vkDestroySurfaceKHR(params->instance, params->surface, params->pAllocator);
23368     return STATUS_SUCCESS;
23369 }
23370
23371 #endif /* USE_STRUCT_CONVERSION */
23372
23373 #if !defined(USE_STRUCT_CONVERSION)
23374
23375 static NTSTATUS thunk64_vkDestroySwapchainKHR(void *args)
23376 {
23377     struct vkDestroySwapchainKHR_params *params = args;
23378
23379     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pAllocator);
23380
23381     wine_device_from_handle(params->device)->funcs.p_vkDestroySwapchainKHR(wine_device_from_handle(params->device)->device, params->swapchain, NULL);
23382     return STATUS_SUCCESS;
23383 }
23384
23385 #else /* USE_STRUCT_CONVERSION */
23386
23387 static NTSTATUS thunk32_vkDestroySwapchainKHR(void *args)
23388 {
23389     struct
23390     {
23391         VkDevice device;
23392         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
23393         const VkAllocationCallbacks *pAllocator;
23394     } *params = args;
23395
23396     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pAllocator);
23397
23398     wine_device_from_handle(params->device)->funcs.p_vkDestroySwapchainKHR(wine_device_from_handle(params->device)->device, params->swapchain, NULL);
23399     return STATUS_SUCCESS;
23400 }
23401
23402 #endif /* USE_STRUCT_CONVERSION */
23403
23404 #if !defined(USE_STRUCT_CONVERSION)
23405
23406 static NTSTATUS thunk64_vkDestroyValidationCacheEXT(void *args)
23407 {
23408     struct vkDestroyValidationCacheEXT_params *params = args;
23409
23410     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pAllocator);
23411
23412     wine_device_from_handle(params->device)->funcs.p_vkDestroyValidationCacheEXT(wine_device_from_handle(params->device)->device, params->validationCache, NULL);
23413     return STATUS_SUCCESS;
23414 }
23415
23416 #else /* USE_STRUCT_CONVERSION */
23417
23418 static NTSTATUS thunk32_vkDestroyValidationCacheEXT(void *args)
23419 {
23420     struct
23421     {
23422         VkDevice device;
23423         VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
23424         const VkAllocationCallbacks *pAllocator;
23425     } *params = args;
23426
23427     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pAllocator);
23428
23429     wine_device_from_handle(params->device)->funcs.p_vkDestroyValidationCacheEXT(wine_device_from_handle(params->device)->device, params->validationCache, NULL);
23430     return STATUS_SUCCESS;
23431 }
23432
23433 #endif /* USE_STRUCT_CONVERSION */
23434
23435 #if !defined(USE_STRUCT_CONVERSION)
23436
23437 static NTSTATUS thunk64_vkDeviceWaitIdle(void *args)
23438 {
23439     struct vkDeviceWaitIdle_params *params = args;
23440
23441     TRACE("%p\n", params->device);
23442
23443     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeviceWaitIdle(wine_device_from_handle(params->device)->device);
23444     return STATUS_SUCCESS;
23445 }
23446
23447 #else /* USE_STRUCT_CONVERSION */
23448
23449 static NTSTATUS thunk32_vkDeviceWaitIdle(void *args)
23450 {
23451     struct
23452     {
23453         VkDevice device;
23454         VkResult result;
23455     } *params = args;
23456
23457     TRACE("%p\n", params->device);
23458
23459     params->result = wine_device_from_handle(params->device)->funcs.p_vkDeviceWaitIdle(wine_device_from_handle(params->device)->device);
23460     return STATUS_SUCCESS;
23461 }
23462
23463 #endif /* USE_STRUCT_CONVERSION */
23464
23465 #if !defined(USE_STRUCT_CONVERSION)
23466
23467 static NTSTATUS thunk64_vkEndCommandBuffer(void *args)
23468 {
23469     struct vkEndCommandBuffer_params *params = args;
23470
23471     TRACE("%p\n", params->commandBuffer);
23472
23473     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
23474     return STATUS_SUCCESS;
23475 }
23476
23477 #else /* USE_STRUCT_CONVERSION */
23478
23479 static NTSTATUS thunk32_vkEndCommandBuffer(void *args)
23480 {
23481     struct
23482     {
23483         VkCommandBuffer commandBuffer;
23484         VkResult result;
23485     } *params = args;
23486
23487     TRACE("%p\n", params->commandBuffer);
23488
23489     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
23490     return STATUS_SUCCESS;
23491 }
23492
23493 #endif /* USE_STRUCT_CONVERSION */
23494
23495 #if !defined(USE_STRUCT_CONVERSION)
23496
23497 static NTSTATUS thunk64_vkEnumerateDeviceExtensionProperties(void *args)
23498 {
23499     struct vkEnumerateDeviceExtensionProperties_params *params = args;
23500
23501     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
23502
23503     params->result = wine_vkEnumerateDeviceExtensionProperties(params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
23504     return STATUS_SUCCESS;
23505 }
23506
23507 #else /* USE_STRUCT_CONVERSION */
23508
23509 static NTSTATUS thunk32_vkEnumerateDeviceExtensionProperties(void *args)
23510 {
23511     struct
23512     {
23513         VkPhysicalDevice physicalDevice;
23514         const char *pLayerName;
23515         uint32_t *pPropertyCount;
23516         VkExtensionProperties *pProperties;
23517         VkResult result;
23518     } *params = args;
23519
23520     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
23521
23522     params->result = wine_vkEnumerateDeviceExtensionProperties(params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
23523     return STATUS_SUCCESS;
23524 }
23525
23526 #endif /* USE_STRUCT_CONVERSION */
23527
23528 #if !defined(USE_STRUCT_CONVERSION)
23529
23530 static NTSTATUS thunk64_vkEnumerateDeviceLayerProperties(void *args)
23531 {
23532     struct vkEnumerateDeviceLayerProperties_params *params = args;
23533
23534     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
23535
23536     params->result = wine_vkEnumerateDeviceLayerProperties(params->physicalDevice, params->pPropertyCount, params->pProperties);
23537     return STATUS_SUCCESS;
23538 }
23539
23540 #else /* USE_STRUCT_CONVERSION */
23541
23542 static NTSTATUS thunk32_vkEnumerateDeviceLayerProperties(void *args)
23543 {
23544     struct
23545     {
23546         VkPhysicalDevice physicalDevice;
23547         uint32_t *pPropertyCount;
23548         VkLayerProperties *pProperties;
23549         VkResult result;
23550     } *params = args;
23551
23552     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
23553
23554     params->result = wine_vkEnumerateDeviceLayerProperties(params->physicalDevice, params->pPropertyCount, params->pProperties);
23555     return STATUS_SUCCESS;
23556 }
23557
23558 #endif /* USE_STRUCT_CONVERSION */
23559
23560 #if !defined(USE_STRUCT_CONVERSION)
23561
23562 static NTSTATUS thunk64_vkEnumerateInstanceExtensionProperties(void *args)
23563 {
23564     struct vkEnumerateInstanceExtensionProperties_params *params = args;
23565
23566     TRACE("%p, %p, %p\n", params->pLayerName, params->pPropertyCount, params->pProperties);
23567
23568     params->result = wine_vkEnumerateInstanceExtensionProperties(params->pLayerName, params->pPropertyCount, params->pProperties);
23569     return STATUS_SUCCESS;
23570 }
23571
23572 #else /* USE_STRUCT_CONVERSION */
23573
23574 static NTSTATUS thunk32_vkEnumerateInstanceExtensionProperties(void *args)
23575 {
23576     struct
23577     {
23578         const char *pLayerName;
23579         uint32_t *pPropertyCount;
23580         VkExtensionProperties *pProperties;
23581         VkResult result;
23582     } *params = args;
23583
23584     TRACE("%p, %p, %p\n", params->pLayerName, params->pPropertyCount, params->pProperties);
23585
23586     params->result = wine_vkEnumerateInstanceExtensionProperties(params->pLayerName, params->pPropertyCount, params->pProperties);
23587     return STATUS_SUCCESS;
23588 }
23589
23590 #endif /* USE_STRUCT_CONVERSION */
23591
23592 #if !defined(USE_STRUCT_CONVERSION)
23593
23594 static NTSTATUS thunk64_vkEnumerateInstanceVersion(void *args)
23595 {
23596     struct vkEnumerateInstanceVersion_params *params = args;
23597
23598     TRACE("%p\n", params->pApiVersion);
23599
23600     params->result = wine_vkEnumerateInstanceVersion(params->pApiVersion);
23601     return STATUS_SUCCESS;
23602 }
23603
23604 #else /* USE_STRUCT_CONVERSION */
23605
23606 static NTSTATUS thunk32_vkEnumerateInstanceVersion(void *args)
23607 {
23608     struct
23609     {
23610         uint32_t *pApiVersion;
23611         VkResult result;
23612     } *params = args;
23613
23614     TRACE("%p\n", params->pApiVersion);
23615
23616     params->result = wine_vkEnumerateInstanceVersion(params->pApiVersion);
23617     return STATUS_SUCCESS;
23618 }
23619
23620 #endif /* USE_STRUCT_CONVERSION */
23621
23622 #if !defined(USE_STRUCT_CONVERSION)
23623
23624 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroups(void *args)
23625 {
23626     struct vkEnumeratePhysicalDeviceGroups_params *params = args;
23627
23628     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
23629
23630     params->result = wine_vkEnumeratePhysicalDeviceGroups(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
23631     return STATUS_SUCCESS;
23632 }
23633
23634 #else /* USE_STRUCT_CONVERSION */
23635
23636 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroups(void *args)
23637 {
23638     struct
23639     {
23640         VkInstance instance;
23641         uint32_t *pPhysicalDeviceGroupCount;
23642         VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties;
23643         VkResult result;
23644     } *params = args;
23645
23646     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
23647
23648     params->result = wine_vkEnumeratePhysicalDeviceGroups(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
23649     return STATUS_SUCCESS;
23650 }
23651
23652 #endif /* USE_STRUCT_CONVERSION */
23653
23654 #if !defined(USE_STRUCT_CONVERSION)
23655
23656 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
23657 {
23658     struct vkEnumeratePhysicalDeviceGroupsKHR_params *params = args;
23659
23660     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
23661
23662     params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
23663     return STATUS_SUCCESS;
23664 }
23665
23666 #else /* USE_STRUCT_CONVERSION */
23667
23668 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
23669 {
23670     struct
23671     {
23672         VkInstance instance;
23673         uint32_t *pPhysicalDeviceGroupCount;
23674         VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties;
23675         VkResult result;
23676     } *params = args;
23677
23678     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
23679
23680     params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR(params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
23681     return STATUS_SUCCESS;
23682 }
23683
23684 #endif /* USE_STRUCT_CONVERSION */
23685
23686 #if !defined(USE_STRUCT_CONVERSION)
23687
23688 static NTSTATUS thunk64_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(void *args)
23689 {
23690     struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_params *params = args;
23691
23692     TRACE("%p, %u, %p, %p, %p\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
23693
23694     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);
23695     return STATUS_SUCCESS;
23696 }
23697
23698 #else /* USE_STRUCT_CONVERSION */
23699
23700 static NTSTATUS thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(void *args)
23701 {
23702     struct
23703     {
23704         VkPhysicalDevice physicalDevice;
23705         uint32_t queueFamilyIndex;
23706         uint32_t *pCounterCount;
23707         VkPerformanceCounterKHR *pCounters;
23708         VkPerformanceCounterDescriptionKHR *pCounterDescriptions;
23709         VkResult result;
23710     } *params = args;
23711
23712     TRACE("%p, %u, %p, %p, %p\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
23713
23714     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);
23715     return STATUS_SUCCESS;
23716 }
23717
23718 #endif /* USE_STRUCT_CONVERSION */
23719
23720 #if !defined(USE_STRUCT_CONVERSION)
23721
23722 static NTSTATUS thunk64_vkEnumeratePhysicalDevices(void *args)
23723 {
23724     struct vkEnumeratePhysicalDevices_params *params = args;
23725
23726     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
23727
23728     params->result = wine_vkEnumeratePhysicalDevices(params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
23729     return STATUS_SUCCESS;
23730 }
23731
23732 #else /* USE_STRUCT_CONVERSION */
23733
23734 static NTSTATUS thunk32_vkEnumeratePhysicalDevices(void *args)
23735 {
23736     struct
23737     {
23738         VkInstance instance;
23739         uint32_t *pPhysicalDeviceCount;
23740         VkPhysicalDevice *pPhysicalDevices;
23741         VkResult result;
23742     } *params = args;
23743
23744     TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
23745
23746     params->result = wine_vkEnumeratePhysicalDevices(params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
23747     return STATUS_SUCCESS;
23748 }
23749
23750 #endif /* USE_STRUCT_CONVERSION */
23751
23752 #if !defined(USE_STRUCT_CONVERSION)
23753
23754 static NTSTATUS thunk64_vkFlushMappedMemoryRanges(void *args)
23755 {
23756     struct vkFlushMappedMemoryRanges_params *params = args;
23757
23758     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
23759
23760     params->result = wine_device_from_handle(params->device)->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, params->pMemoryRanges);
23761     return STATUS_SUCCESS;
23762 }
23763
23764 #else /* USE_STRUCT_CONVERSION */
23765
23766 static NTSTATUS thunk32_vkFlushMappedMemoryRanges(void *args)
23767 {
23768     struct
23769     {
23770         VkDevice device;
23771         uint32_t memoryRangeCount;
23772         const VkMappedMemoryRange32 *pMemoryRanges;
23773         VkResult result;
23774     } *params = args;
23775     const VkMappedMemoryRange *pMemoryRanges_host;
23776     struct conversion_context ctx;
23777
23778     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
23779
23780     init_conversion_context(&ctx);
23781     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(&ctx, params->pMemoryRanges, params->memoryRangeCount);
23782     params->result = wine_device_from_handle(params->device)->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
23783     free_conversion_context(&ctx);
23784     return STATUS_SUCCESS;
23785 }
23786
23787 #endif /* USE_STRUCT_CONVERSION */
23788
23789 #if !defined(USE_STRUCT_CONVERSION)
23790
23791 static NTSTATUS thunk64_vkFreeCommandBuffers(void *args)
23792 {
23793     struct vkFreeCommandBuffers_params *params = args;
23794
23795     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->commandBufferCount, params->pCommandBuffers);
23796
23797     wine_vkFreeCommandBuffers(params->device, params->commandPool, params->commandBufferCount, params->pCommandBuffers);
23798     return STATUS_SUCCESS;
23799 }
23800
23801 #else /* USE_STRUCT_CONVERSION */
23802
23803 static NTSTATUS thunk32_vkFreeCommandBuffers(void *args)
23804 {
23805     struct
23806     {
23807         VkDevice device;
23808         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
23809         uint32_t commandBufferCount;
23810         const VkCommandBuffer *pCommandBuffers;
23811     } *params = args;
23812
23813     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->commandBufferCount, params->pCommandBuffers);
23814
23815     wine_vkFreeCommandBuffers(params->device, params->commandPool, params->commandBufferCount, params->pCommandBuffers);
23816     return STATUS_SUCCESS;
23817 }
23818
23819 #endif /* USE_STRUCT_CONVERSION */
23820
23821 #if !defined(USE_STRUCT_CONVERSION)
23822
23823 static NTSTATUS thunk64_vkFreeDescriptorSets(void *args)
23824 {
23825     struct vkFreeDescriptorSets_params *params = args;
23826
23827     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);
23828
23829     params->result = wine_device_from_handle(params->device)->funcs.p_vkFreeDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorPool, params->descriptorSetCount, params->pDescriptorSets);
23830     return STATUS_SUCCESS;
23831 }
23832
23833 #else /* USE_STRUCT_CONVERSION */
23834
23835 static NTSTATUS thunk32_vkFreeDescriptorSets(void *args)
23836 {
23837     struct
23838     {
23839         VkDevice device;
23840         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
23841         uint32_t descriptorSetCount;
23842         const VkDescriptorSet *pDescriptorSets;
23843         VkResult result;
23844     } *params = args;
23845
23846     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);
23847
23848     params->result = wine_device_from_handle(params->device)->funcs.p_vkFreeDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorPool, params->descriptorSetCount, params->pDescriptorSets);
23849     return STATUS_SUCCESS;
23850 }
23851
23852 #endif /* USE_STRUCT_CONVERSION */
23853
23854 #if !defined(USE_STRUCT_CONVERSION)
23855
23856 static NTSTATUS thunk64_vkFreeMemory(void *args)
23857 {
23858     struct vkFreeMemory_params *params = args;
23859
23860     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pAllocator);
23861
23862     wine_device_from_handle(params->device)->funcs.p_vkFreeMemory(wine_device_from_handle(params->device)->device, params->memory, NULL);
23863     return STATUS_SUCCESS;
23864 }
23865
23866 #else /* USE_STRUCT_CONVERSION */
23867
23868 static NTSTATUS thunk32_vkFreeMemory(void *args)
23869 {
23870     struct
23871     {
23872         VkDevice device;
23873         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
23874         const VkAllocationCallbacks *pAllocator;
23875     } *params = args;
23876
23877     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pAllocator);
23878
23879     wine_device_from_handle(params->device)->funcs.p_vkFreeMemory(wine_device_from_handle(params->device)->device, params->memory, NULL);
23880     return STATUS_SUCCESS;
23881 }
23882
23883 #endif /* USE_STRUCT_CONVERSION */
23884
23885 #if !defined(USE_STRUCT_CONVERSION)
23886
23887 static NTSTATUS thunk64_vkGetAccelerationStructureBuildSizesKHR(void *args)
23888 {
23889     struct vkGetAccelerationStructureBuildSizesKHR_params *params = args;
23890
23891     TRACE("%p, %#x, %p, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
23892
23893     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureBuildSizesKHR(wine_device_from_handle(params->device)->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
23894     return STATUS_SUCCESS;
23895 }
23896
23897 #else /* USE_STRUCT_CONVERSION */
23898
23899 static NTSTATUS thunk32_vkGetAccelerationStructureBuildSizesKHR(void *args)
23900 {
23901     struct
23902     {
23903         VkDevice device;
23904         VkAccelerationStructureBuildTypeKHR buildType;
23905         const VkAccelerationStructureBuildGeometryInfoKHR32 *pBuildInfo;
23906         const uint32_t *pMaxPrimitiveCounts;
23907         VkAccelerationStructureBuildSizesInfoKHR32 *pSizeInfo;
23908     } *params = args;
23909     VkAccelerationStructureBuildGeometryInfoKHR pBuildInfo_host;
23910     VkAccelerationStructureBuildSizesInfoKHR pSizeInfo_host;
23911     struct conversion_context ctx;
23912
23913     TRACE("%p, %#x, %p, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
23914
23915     init_conversion_context(&ctx);
23916     convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(&ctx, params->pBuildInfo, &pBuildInfo_host);
23917     convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host(params->pSizeInfo, &pSizeInfo_host);
23918     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureBuildSizesKHR(wine_device_from_handle(params->device)->device, params->buildType, &pBuildInfo_host, params->pMaxPrimitiveCounts, &pSizeInfo_host);
23919     convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(&pSizeInfo_host, params->pSizeInfo);
23920     free_conversion_context(&ctx);
23921     return STATUS_SUCCESS;
23922 }
23923
23924 #endif /* USE_STRUCT_CONVERSION */
23925
23926 #if !defined(USE_STRUCT_CONVERSION)
23927
23928 static NTSTATUS thunk64_vkGetAccelerationStructureDeviceAddressKHR(void *args)
23929 {
23930     struct vkGetAccelerationStructureDeviceAddressKHR_params *params = args;
23931
23932     TRACE("%p, %p\n", params->device, params->pInfo);
23933
23934     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
23935     return STATUS_SUCCESS;
23936 }
23937
23938 #else /* USE_STRUCT_CONVERSION */
23939
23940 static NTSTATUS thunk32_vkGetAccelerationStructureDeviceAddressKHR(void *args)
23941 {
23942     struct
23943     {
23944         VkDevice device;
23945         const VkAccelerationStructureDeviceAddressInfoKHR32 *pInfo;
23946         VkDeviceAddress result;
23947     } *params = args;
23948     VkAccelerationStructureDeviceAddressInfoKHR pInfo_host;
23949
23950     TRACE("%p, %p\n", params->device, params->pInfo);
23951
23952     convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
23953     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
23954     return STATUS_SUCCESS;
23955 }
23956
23957 #endif /* USE_STRUCT_CONVERSION */
23958
23959 #if !defined(USE_STRUCT_CONVERSION)
23960
23961 static NTSTATUS thunk64_vkGetAccelerationStructureHandleNV(void *args)
23962 {
23963     struct vkGetAccelerationStructureHandleNV_params *params = args;
23964
23965     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);
23966
23967     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, params->dataSize, params->pData);
23968     return STATUS_SUCCESS;
23969 }
23970
23971 #else /* USE_STRUCT_CONVERSION */
23972
23973 static NTSTATUS thunk32_vkGetAccelerationStructureHandleNV(void *args)
23974 {
23975     struct
23976     {
23977         VkDevice device;
23978         VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
23979         size_t dataSize;
23980         void *pData;
23981         VkResult result;
23982     } *params = args;
23983
23984     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);
23985
23986     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, params->dataSize, params->pData);
23987     return STATUS_SUCCESS;
23988 }
23989
23990 #endif /* USE_STRUCT_CONVERSION */
23991
23992 #if !defined(USE_STRUCT_CONVERSION)
23993
23994 static NTSTATUS thunk64_vkGetAccelerationStructureMemoryRequirementsNV(void *args)
23995 {
23996     struct vkGetAccelerationStructureMemoryRequirementsNV_params *params = args;
23997
23998     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
23999
24000     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
24001     return STATUS_SUCCESS;
24002 }
24003
24004 #else /* USE_STRUCT_CONVERSION */
24005
24006 static NTSTATUS thunk32_vkGetAccelerationStructureMemoryRequirementsNV(void *args)
24007 {
24008     struct
24009     {
24010         VkDevice device;
24011         const VkAccelerationStructureMemoryRequirementsInfoNV32 *pInfo;
24012         VkMemoryRequirements2KHR32 *pMemoryRequirements;
24013     } *params = args;
24014     VkAccelerationStructureMemoryRequirementsInfoNV pInfo_host;
24015     VkMemoryRequirements2KHR pMemoryRequirements_host;
24016
24017     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
24018
24019     convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host(params->pInfo, &pInfo_host);
24020     convert_VkMemoryRequirements2KHR_win32_to_host(params->pMemoryRequirements, &pMemoryRequirements_host);
24021     wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
24022     convert_VkMemoryRequirements2KHR_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
24023     return STATUS_SUCCESS;
24024 }
24025
24026 #endif /* USE_STRUCT_CONVERSION */
24027
24028 #if !defined(USE_STRUCT_CONVERSION)
24029
24030 static NTSTATUS thunk64_vkGetBufferDeviceAddress(void *args)
24031 {
24032     struct vkGetBufferDeviceAddress_params *params = args;
24033
24034     TRACE("%p, %p\n", params->device, params->pInfo);
24035
24036     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddress(wine_device_from_handle(params->device)->device, params->pInfo);
24037     return STATUS_SUCCESS;
24038 }
24039
24040 #else /* USE_STRUCT_CONVERSION */
24041
24042 static NTSTATUS thunk32_vkGetBufferDeviceAddress(void *args)
24043 {
24044     struct
24045     {
24046         VkDevice device;
24047         const VkBufferDeviceAddressInfo32 *pInfo;
24048         VkDeviceAddress result;
24049     } *params = args;
24050     VkBufferDeviceAddressInfo pInfo_host;
24051
24052     TRACE("%p, %p\n", params->device, params->pInfo);
24053
24054     convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
24055     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddress(wine_device_from_handle(params->device)->device, &pInfo_host);
24056     return STATUS_SUCCESS;
24057 }
24058
24059 #endif /* USE_STRUCT_CONVERSION */
24060
24061 #if !defined(USE_STRUCT_CONVERSION)
24062
24063 static NTSTATUS thunk64_vkGetBufferDeviceAddressEXT(void *args)
24064 {
24065     struct vkGetBufferDeviceAddressEXT_params *params = args;
24066
24067     TRACE("%p, %p\n", params->device, params->pInfo);
24068
24069     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressEXT(wine_device_from_handle(params->device)->device, params->pInfo);
24070     return STATUS_SUCCESS;
24071 }
24072
24073 #else /* USE_STRUCT_CONVERSION */
24074
24075 static NTSTATUS thunk32_vkGetBufferDeviceAddressEXT(void *args)
24076 {
24077     struct
24078     {
24079         VkDevice device;
24080         const VkBufferDeviceAddressInfo32 *pInfo;
24081         VkDeviceAddress result;
24082     } *params = args;
24083     VkBufferDeviceAddressInfo pInfo_host;
24084
24085     TRACE("%p, %p\n", params->device, params->pInfo);
24086
24087     convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
24088     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressEXT(wine_device_from_handle(params->device)->device, &pInfo_host);
24089     return STATUS_SUCCESS;
24090 }
24091
24092 #endif /* USE_STRUCT_CONVERSION */
24093
24094 #if !defined(USE_STRUCT_CONVERSION)
24095
24096 static NTSTATUS thunk64_vkGetBufferDeviceAddressKHR(void *args)
24097 {
24098     struct vkGetBufferDeviceAddressKHR_params *params = args;
24099
24100     TRACE("%p, %p\n", params->device, params->pInfo);
24101
24102     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
24103     return STATUS_SUCCESS;
24104 }
24105
24106 #else /* USE_STRUCT_CONVERSION */
24107
24108 static NTSTATUS thunk32_vkGetBufferDeviceAddressKHR(void *args)
24109 {
24110     struct
24111     {
24112         VkDevice device;
24113         const VkBufferDeviceAddressInfo32 *pInfo;
24114         VkDeviceAddress result;
24115     } *params = args;
24116     VkBufferDeviceAddressInfo pInfo_host;
24117
24118     TRACE("%p, %p\n", params->device, params->pInfo);
24119
24120     convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
24121     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
24122     return STATUS_SUCCESS;
24123 }
24124
24125 #endif /* USE_STRUCT_CONVERSION */
24126
24127 #if !defined(USE_STRUCT_CONVERSION)
24128
24129 static NTSTATUS thunk64_vkGetBufferMemoryRequirements(void *args)
24130 {
24131     struct vkGetBufferMemoryRequirements_params *params = args;
24132
24133     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pMemoryRequirements);
24134
24135     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->buffer, params->pMemoryRequirements);
24136     return STATUS_SUCCESS;
24137 }
24138
24139 #else /* USE_STRUCT_CONVERSION */
24140
24141 static NTSTATUS thunk32_vkGetBufferMemoryRequirements(void *args)
24142 {
24143     struct
24144     {
24145         VkDevice device;
24146         VkBuffer DECLSPEC_ALIGN(8) buffer;
24147         VkMemoryRequirements32 *pMemoryRequirements;
24148     } *params = args;
24149     VkMemoryRequirements pMemoryRequirements_host;
24150
24151     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pMemoryRequirements);
24152
24153     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->buffer, &pMemoryRequirements_host);
24154     convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
24155     return STATUS_SUCCESS;
24156 }
24157
24158 #endif /* USE_STRUCT_CONVERSION */
24159
24160 #if !defined(USE_STRUCT_CONVERSION)
24161
24162 static NTSTATUS thunk64_vkGetBufferMemoryRequirements2(void *args)
24163 {
24164     struct vkGetBufferMemoryRequirements2_params *params = args;
24165
24166     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
24167
24168     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
24169     return STATUS_SUCCESS;
24170 }
24171
24172 #else /* USE_STRUCT_CONVERSION */
24173
24174 static NTSTATUS thunk32_vkGetBufferMemoryRequirements2(void *args)
24175 {
24176     struct
24177     {
24178         VkDevice device;
24179         const VkBufferMemoryRequirementsInfo232 *pInfo;
24180         VkMemoryRequirements232 *pMemoryRequirements;
24181     } *params = args;
24182     VkBufferMemoryRequirementsInfo2 pInfo_host;
24183     VkMemoryRequirements2 pMemoryRequirements_host;
24184
24185     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
24186
24187     convert_VkBufferMemoryRequirementsInfo2_win32_to_host(params->pInfo, &pInfo_host);
24188     convert_VkMemoryRequirements2_win32_to_host(params->pMemoryRequirements, &pMemoryRequirements_host);
24189     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
24190     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
24191     return STATUS_SUCCESS;
24192 }
24193
24194 #endif /* USE_STRUCT_CONVERSION */
24195
24196 #if !defined(USE_STRUCT_CONVERSION)
24197
24198 static NTSTATUS thunk64_vkGetBufferMemoryRequirements2KHR(void *args)
24199 {
24200     struct vkGetBufferMemoryRequirements2KHR_params *params = args;
24201
24202     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
24203
24204     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
24205     return STATUS_SUCCESS;
24206 }
24207
24208 #else /* USE_STRUCT_CONVERSION */
24209
24210 static NTSTATUS thunk32_vkGetBufferMemoryRequirements2KHR(void *args)
24211 {
24212     struct
24213     {
24214         VkDevice device;
24215         const VkBufferMemoryRequirementsInfo232 *pInfo;
24216         VkMemoryRequirements232 *pMemoryRequirements;
24217     } *params = args;
24218     VkBufferMemoryRequirementsInfo2 pInfo_host;
24219     VkMemoryRequirements2 pMemoryRequirements_host;
24220
24221     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
24222
24223     convert_VkBufferMemoryRequirementsInfo2_win32_to_host(params->pInfo, &pInfo_host);
24224     convert_VkMemoryRequirements2_win32_to_host(params->pMemoryRequirements, &pMemoryRequirements_host);
24225     wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
24226     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
24227     return STATUS_SUCCESS;
24228 }
24229
24230 #endif /* USE_STRUCT_CONVERSION */
24231
24232 #if !defined(USE_STRUCT_CONVERSION)
24233
24234 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureAddress(void *args)
24235 {
24236     struct vkGetBufferOpaqueCaptureAddress_params *params = args;
24237
24238     TRACE("%p, %p\n", params->device, params->pInfo);
24239
24240     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, params->pInfo);
24241     return STATUS_SUCCESS;
24242 }
24243
24244 #else /* USE_STRUCT_CONVERSION */
24245
24246 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddress(void *args)
24247 {
24248     struct
24249     {
24250         VkDevice device;
24251         const VkBufferDeviceAddressInfo32 *pInfo;
24252         uint64_t result;
24253     } *params = args;
24254     VkBufferDeviceAddressInfo pInfo_host;
24255
24256     TRACE("%p, %p\n", params->device, params->pInfo);
24257
24258     convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
24259     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, &pInfo_host);
24260     return STATUS_SUCCESS;
24261 }
24262
24263 #endif /* USE_STRUCT_CONVERSION */
24264
24265 #if !defined(USE_STRUCT_CONVERSION)
24266
24267 static NTSTATUS thunk64_vkGetBufferOpaqueCaptureAddressKHR(void *args)
24268 {
24269     struct vkGetBufferOpaqueCaptureAddressKHR_params *params = args;
24270
24271     TRACE("%p, %p\n", params->device, params->pInfo);
24272
24273     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
24274     return STATUS_SUCCESS;
24275 }
24276
24277 #else /* USE_STRUCT_CONVERSION */
24278
24279 static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddressKHR(void *args)
24280 {
24281     struct
24282     {
24283         VkDevice device;
24284         const VkBufferDeviceAddressInfo32 *pInfo;
24285         uint64_t result;
24286     } *params = args;
24287     VkBufferDeviceAddressInfo pInfo_host;
24288
24289     TRACE("%p, %p\n", params->device, params->pInfo);
24290
24291     convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
24292     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
24293     return STATUS_SUCCESS;
24294 }
24295
24296 #endif /* USE_STRUCT_CONVERSION */
24297
24298 #if !defined(USE_STRUCT_CONVERSION)
24299
24300 static NTSTATUS thunk64_vkGetCalibratedTimestampsEXT(void *args)
24301 {
24302     struct vkGetCalibratedTimestampsEXT_params *params = args;
24303
24304     TRACE("%p, %u, %p, %p, %p\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
24305
24306     params->result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
24307     return STATUS_SUCCESS;
24308 }
24309
24310 #else /* USE_STRUCT_CONVERSION */
24311
24312 static NTSTATUS thunk32_vkGetCalibratedTimestampsEXT(void *args)
24313 {
24314     struct
24315     {
24316         VkDevice device;
24317         uint32_t timestampCount;
24318         const VkCalibratedTimestampInfoEXT *pTimestampInfos;
24319         uint64_t *pTimestamps;
24320         uint64_t *pMaxDeviation;
24321         VkResult result;
24322     } *params = args;
24323
24324     TRACE("%p, %u, %p, %p, %p\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
24325
24326     params->result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
24327     return STATUS_SUCCESS;
24328 }
24329
24330 #endif /* USE_STRUCT_CONVERSION */
24331
24332 #if !defined(USE_STRUCT_CONVERSION)
24333
24334 static NTSTATUS thunk64_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
24335 {
24336     struct vkGetDeferredOperationMaxConcurrencyKHR_params *params = args;
24337
24338     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
24339
24340     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle(params->device)->device, params->operation);
24341     return STATUS_SUCCESS;
24342 }
24343
24344 #else /* USE_STRUCT_CONVERSION */
24345
24346 static NTSTATUS thunk32_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
24347 {
24348     struct
24349     {
24350         VkDevice device;
24351         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
24352         uint32_t result;
24353     } *params = args;
24354
24355     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
24356
24357     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle(params->device)->device, params->operation);
24358     return STATUS_SUCCESS;
24359 }
24360
24361 #endif /* USE_STRUCT_CONVERSION */
24362
24363 #if !defined(USE_STRUCT_CONVERSION)
24364
24365 static NTSTATUS thunk64_vkGetDeferredOperationResultKHR(void *args)
24366 {
24367     struct vkGetDeferredOperationResultKHR_params *params = args;
24368
24369     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
24370
24371     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle(params->device)->device, params->operation);
24372     return STATUS_SUCCESS;
24373 }
24374
24375 #else /* USE_STRUCT_CONVERSION */
24376
24377 static NTSTATUS thunk32_vkGetDeferredOperationResultKHR(void *args)
24378 {
24379     struct
24380     {
24381         VkDevice device;
24382         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
24383         VkResult result;
24384     } *params = args;
24385
24386     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
24387
24388     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle(params->device)->device, params->operation);
24389     return STATUS_SUCCESS;
24390 }
24391
24392 #endif /* USE_STRUCT_CONVERSION */
24393
24394 #if !defined(USE_STRUCT_CONVERSION)
24395
24396 static NTSTATUS thunk64_vkGetDescriptorSetHostMappingVALVE(void *args)
24397 {
24398     struct vkGetDescriptorSetHostMappingVALVE_params *params = args;
24399
24400     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), params->ppData);
24401
24402     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetHostMappingVALVE(wine_device_from_handle(params->device)->device, params->descriptorSet, params->ppData);
24403     return STATUS_SUCCESS;
24404 }
24405
24406 #else /* USE_STRUCT_CONVERSION */
24407
24408 static NTSTATUS thunk32_vkGetDescriptorSetHostMappingVALVE(void *args)
24409 {
24410     struct
24411     {
24412         VkDevice device;
24413         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
24414         void **ppData;
24415     } *params = args;
24416
24417     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), params->ppData);
24418
24419     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetHostMappingVALVE(wine_device_from_handle(params->device)->device, params->descriptorSet, params->ppData);
24420     return STATUS_SUCCESS;
24421 }
24422
24423 #endif /* USE_STRUCT_CONVERSION */
24424
24425 #if !defined(USE_STRUCT_CONVERSION)
24426
24427 static NTSTATUS thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args)
24428 {
24429     struct vkGetDescriptorSetLayoutHostMappingInfoVALVE_params *params = args;
24430
24431     TRACE("%p, %p, %p\n", params->device, params->pBindingReference, params->pHostMapping);
24432
24433     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutHostMappingInfoVALVE(wine_device_from_handle(params->device)->device, params->pBindingReference, params->pHostMapping);
24434     return STATUS_SUCCESS;
24435 }
24436
24437 #else /* USE_STRUCT_CONVERSION */
24438
24439 static NTSTATUS thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args)
24440 {
24441     struct
24442     {
24443         VkDevice device;
24444         const VkDescriptorSetBindingReferenceVALVE32 *pBindingReference;
24445         VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping;
24446     } *params = args;
24447     VkDescriptorSetBindingReferenceVALVE pBindingReference_host;
24448
24449     TRACE("%p, %p, %p\n", params->device, params->pBindingReference, params->pHostMapping);
24450
24451     convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(params->pBindingReference, &pBindingReference_host);
24452     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutHostMappingInfoVALVE(wine_device_from_handle(params->device)->device, &pBindingReference_host, params->pHostMapping);
24453     return STATUS_SUCCESS;
24454 }
24455
24456 #endif /* USE_STRUCT_CONVERSION */
24457
24458 #if !defined(USE_STRUCT_CONVERSION)
24459
24460 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSupport(void *args)
24461 {
24462     struct vkGetDescriptorSetLayoutSupport_params *params = args;
24463
24464     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
24465
24466     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupport(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pSupport);
24467     return STATUS_SUCCESS;
24468 }
24469
24470 #else /* USE_STRUCT_CONVERSION */
24471
24472 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSupport(void *args)
24473 {
24474     struct
24475     {
24476         VkDevice device;
24477         const VkDescriptorSetLayoutCreateInfo *pCreateInfo;
24478         VkDescriptorSetLayoutSupport *pSupport;
24479     } *params = args;
24480
24481     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
24482
24483     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupport(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pSupport);
24484     return STATUS_SUCCESS;
24485 }
24486
24487 #endif /* USE_STRUCT_CONVERSION */
24488
24489 #if !defined(USE_STRUCT_CONVERSION)
24490
24491 static NTSTATUS thunk64_vkGetDescriptorSetLayoutSupportKHR(void *args)
24492 {
24493     struct vkGetDescriptorSetLayoutSupportKHR_params *params = args;
24494
24495     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
24496
24497     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupportKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pSupport);
24498     return STATUS_SUCCESS;
24499 }
24500
24501 #else /* USE_STRUCT_CONVERSION */
24502
24503 static NTSTATUS thunk32_vkGetDescriptorSetLayoutSupportKHR(void *args)
24504 {
24505     struct
24506     {
24507         VkDevice device;
24508         const VkDescriptorSetLayoutCreateInfo *pCreateInfo;
24509         VkDescriptorSetLayoutSupport *pSupport;
24510     } *params = args;
24511
24512     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
24513
24514     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupportKHR(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pSupport);
24515     return STATUS_SUCCESS;
24516 }
24517
24518 #endif /* USE_STRUCT_CONVERSION */
24519
24520 #if !defined(USE_STRUCT_CONVERSION)
24521
24522 static NTSTATUS thunk64_vkGetDeviceAccelerationStructureCompatibilityKHR(void *args)
24523 {
24524     struct vkGetDeviceAccelerationStructureCompatibilityKHR_params *params = args;
24525
24526     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
24527
24528     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceAccelerationStructureCompatibilityKHR(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
24529     return STATUS_SUCCESS;
24530 }
24531
24532 #else /* USE_STRUCT_CONVERSION */
24533
24534 static NTSTATUS thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR(void *args)
24535 {
24536     struct
24537     {
24538         VkDevice device;
24539         const VkAccelerationStructureVersionInfoKHR *pVersionInfo;
24540         VkAccelerationStructureCompatibilityKHR *pCompatibility;
24541     } *params = args;
24542
24543     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
24544
24545     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceAccelerationStructureCompatibilityKHR(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
24546     return STATUS_SUCCESS;
24547 }
24548
24549 #endif /* USE_STRUCT_CONVERSION */
24550
24551 #if !defined(USE_STRUCT_CONVERSION)
24552
24553 static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirements(void *args)
24554 {
24555     struct vkGetDeviceBufferMemoryRequirements_params *params = args;
24556
24557     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
24558
24559     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
24560     return STATUS_SUCCESS;
24561 }
24562
24563 #else /* USE_STRUCT_CONVERSION */
24564
24565 static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirements(void *args)
24566 {
24567     struct
24568     {
24569         VkDevice device;
24570         const VkDeviceBufferMemoryRequirements32 *pInfo;
24571         VkMemoryRequirements232 *pMemoryRequirements;
24572     } *params = args;
24573     VkDeviceBufferMemoryRequirements pInfo_host;
24574     VkMemoryRequirements2 pMemoryRequirements_host;
24575     struct conversion_context ctx;
24576
24577     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
24578
24579     init_conversion_context(&ctx);
24580     convert_VkDeviceBufferMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
24581     convert_VkMemoryRequirements2_win32_to_host(params->pMemoryRequirements, &pMemoryRequirements_host);
24582     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirements(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
24583     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
24584     free_conversion_context(&ctx);
24585     return STATUS_SUCCESS;
24586 }
24587
24588 #endif /* USE_STRUCT_CONVERSION */
24589
24590 #if !defined(USE_STRUCT_CONVERSION)
24591
24592 static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirementsKHR(void *args)
24593 {
24594     struct vkGetDeviceBufferMemoryRequirementsKHR_params *params = args;
24595
24596     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
24597
24598     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
24599     return STATUS_SUCCESS;
24600 }
24601
24602 #else /* USE_STRUCT_CONVERSION */
24603
24604 static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirementsKHR(void *args)
24605 {
24606     struct
24607     {
24608         VkDevice device;
24609         const VkDeviceBufferMemoryRequirements32 *pInfo;
24610         VkMemoryRequirements232 *pMemoryRequirements;
24611     } *params = args;
24612     VkDeviceBufferMemoryRequirements pInfo_host;
24613     VkMemoryRequirements2 pMemoryRequirements_host;
24614     struct conversion_context ctx;
24615
24616     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
24617
24618     init_conversion_context(&ctx);
24619     convert_VkDeviceBufferMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
24620     convert_VkMemoryRequirements2_win32_to_host(params->pMemoryRequirements, &pMemoryRequirements_host);
24621     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
24622     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
24623     free_conversion_context(&ctx);
24624     return STATUS_SUCCESS;
24625 }
24626
24627 #endif /* USE_STRUCT_CONVERSION */
24628
24629 #if !defined(USE_STRUCT_CONVERSION)
24630
24631 static NTSTATUS thunk64_vkGetDeviceFaultInfoEXT(void *args)
24632 {
24633     struct vkGetDeviceFaultInfoEXT_params *params = args;
24634
24635     TRACE("%p, %p, %p\n", params->device, params->pFaultCounts, params->pFaultInfo);
24636
24637     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceFaultInfoEXT(wine_device_from_handle(params->device)->device, params->pFaultCounts, params->pFaultInfo);
24638     return STATUS_SUCCESS;
24639 }
24640
24641 #else /* USE_STRUCT_CONVERSION */
24642
24643 static NTSTATUS thunk32_vkGetDeviceFaultInfoEXT(void *args)
24644 {
24645     struct
24646     {
24647         VkDevice device;
24648         VkDeviceFaultCountsEXT32 *pFaultCounts;
24649         VkDeviceFaultInfoEXT32 *pFaultInfo;
24650         VkResult result;
24651     } *params = args;
24652     VkDeviceFaultCountsEXT pFaultCounts_host;
24653     VkDeviceFaultInfoEXT *pFaultInfo_host = NULL;
24654     struct conversion_context ctx;
24655
24656     TRACE("%p, %p, %p\n", params->device, params->pFaultCounts, params->pFaultInfo);
24657
24658     init_conversion_context(&ctx);
24659     convert_VkDeviceFaultCountsEXT_win32_to_host(params->pFaultCounts, &pFaultCounts_host);
24660     if (params->pFaultInfo)
24661     {
24662         pFaultInfo_host = conversion_context_alloc(&ctx, sizeof(*pFaultInfo_host));
24663         convert_VkDeviceFaultInfoEXT_win32_to_host(&ctx, params->pFaultInfo, pFaultInfo_host);
24664     }
24665     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceFaultInfoEXT(wine_device_from_handle(params->device)->device, &pFaultCounts_host, pFaultInfo_host);
24666     convert_VkDeviceFaultCountsEXT_host_to_win32(&pFaultCounts_host, params->pFaultCounts);
24667     convert_VkDeviceFaultInfoEXT_host_to_win32(pFaultInfo_host, params->pFaultInfo);
24668     free_conversion_context(&ctx);
24669     return STATUS_SUCCESS;
24670 }
24671
24672 #endif /* USE_STRUCT_CONVERSION */
24673
24674 #if !defined(USE_STRUCT_CONVERSION)
24675
24676 static NTSTATUS thunk64_vkGetDeviceGroupPeerMemoryFeatures(void *args)
24677 {
24678     struct vkGetDeviceGroupPeerMemoryFeatures_params *params = args;
24679
24680     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
24681
24682     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
24683     return STATUS_SUCCESS;
24684 }
24685
24686 #else /* USE_STRUCT_CONVERSION */
24687
24688 static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeatures(void *args)
24689 {
24690     struct
24691     {
24692         VkDevice device;
24693         uint32_t heapIndex;
24694         uint32_t localDeviceIndex;
24695         uint32_t remoteDeviceIndex;
24696         VkPeerMemoryFeatureFlags *pPeerMemoryFeatures;
24697     } *params = args;
24698
24699     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
24700
24701     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
24702     return STATUS_SUCCESS;
24703 }
24704
24705 #endif /* USE_STRUCT_CONVERSION */
24706
24707 #if !defined(USE_STRUCT_CONVERSION)
24708
24709 static NTSTATUS thunk64_vkGetDeviceGroupPeerMemoryFeaturesKHR(void *args)
24710 {
24711     struct vkGetDeviceGroupPeerMemoryFeaturesKHR_params *params = args;
24712
24713     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
24714
24715     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
24716     return STATUS_SUCCESS;
24717 }
24718
24719 #else /* USE_STRUCT_CONVERSION */
24720
24721 static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR(void *args)
24722 {
24723     struct
24724     {
24725         VkDevice device;
24726         uint32_t heapIndex;
24727         uint32_t localDeviceIndex;
24728         uint32_t remoteDeviceIndex;
24729         VkPeerMemoryFeatureFlags *pPeerMemoryFeatures;
24730     } *params = args;
24731
24732     TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
24733
24734     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
24735     return STATUS_SUCCESS;
24736 }
24737
24738 #endif /* USE_STRUCT_CONVERSION */
24739
24740 #if !defined(USE_STRUCT_CONVERSION)
24741
24742 static NTSTATUS thunk64_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
24743 {
24744     struct vkGetDeviceGroupPresentCapabilitiesKHR_params *params = args;
24745
24746     TRACE("%p, %p\n", params->device, params->pDeviceGroupPresentCapabilities);
24747
24748     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle(params->device)->device, params->pDeviceGroupPresentCapabilities);
24749     return STATUS_SUCCESS;
24750 }
24751
24752 #else /* USE_STRUCT_CONVERSION */
24753
24754 static NTSTATUS thunk32_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
24755 {
24756     struct
24757     {
24758         VkDevice device;
24759         VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities;
24760         VkResult result;
24761     } *params = args;
24762
24763     TRACE("%p, %p\n", params->device, params->pDeviceGroupPresentCapabilities);
24764
24765     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle(params->device)->device, params->pDeviceGroupPresentCapabilities);
24766     return STATUS_SUCCESS;
24767 }
24768
24769 #endif /* USE_STRUCT_CONVERSION */
24770
24771 #if !defined(USE_STRUCT_CONVERSION)
24772
24773 static NTSTATUS thunk64_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
24774 {
24775     struct vkGetDeviceGroupSurfacePresentModesKHR_params *params = args;
24776
24777     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);
24778
24779     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);
24780     return STATUS_SUCCESS;
24781 }
24782
24783 #else /* USE_STRUCT_CONVERSION */
24784
24785 static NTSTATUS thunk32_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
24786 {
24787     struct
24788     {
24789         VkDevice device;
24790         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
24791         VkDeviceGroupPresentModeFlagsKHR *pModes;
24792         VkResult result;
24793     } *params = args;
24794
24795     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);
24796
24797     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);
24798     return STATUS_SUCCESS;
24799 }
24800
24801 #endif /* USE_STRUCT_CONVERSION */
24802
24803 #if !defined(USE_STRUCT_CONVERSION)
24804
24805 static NTSTATUS thunk64_vkGetDeviceImageMemoryRequirements(void *args)
24806 {
24807     struct vkGetDeviceImageMemoryRequirements_params *params = args;
24808
24809     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
24810
24811     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
24812     return STATUS_SUCCESS;
24813 }
24814
24815 #else /* USE_STRUCT_CONVERSION */
24816
24817 static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirements(void *args)
24818 {
24819     struct
24820     {
24821         VkDevice device;
24822         const VkDeviceImageMemoryRequirements *pInfo;
24823         VkMemoryRequirements232 *pMemoryRequirements;
24824     } *params = args;
24825     VkDeviceImageMemoryRequirements pInfo_host;
24826     VkMemoryRequirements2 pMemoryRequirements_host;
24827     struct conversion_context ctx;
24828
24829     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
24830
24831     init_conversion_context(&ctx);
24832     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
24833     convert_VkMemoryRequirements2_win32_to_host(params->pMemoryRequirements, &pMemoryRequirements_host);
24834     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirements(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
24835     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
24836     free_conversion_context(&ctx);
24837     return STATUS_SUCCESS;
24838 }
24839
24840 #endif /* USE_STRUCT_CONVERSION */
24841
24842 #if !defined(USE_STRUCT_CONVERSION)
24843
24844 static NTSTATUS thunk64_vkGetDeviceImageMemoryRequirementsKHR(void *args)
24845 {
24846     struct vkGetDeviceImageMemoryRequirementsKHR_params *params = args;
24847
24848     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
24849
24850     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
24851     return STATUS_SUCCESS;
24852 }
24853
24854 #else /* USE_STRUCT_CONVERSION */
24855
24856 static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirementsKHR(void *args)
24857 {
24858     struct
24859     {
24860         VkDevice device;
24861         const VkDeviceImageMemoryRequirements *pInfo;
24862         VkMemoryRequirements232 *pMemoryRequirements;
24863     } *params = args;
24864     VkDeviceImageMemoryRequirements pInfo_host;
24865     VkMemoryRequirements2 pMemoryRequirements_host;
24866     struct conversion_context ctx;
24867
24868     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
24869
24870     init_conversion_context(&ctx);
24871     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
24872     convert_VkMemoryRequirements2_win32_to_host(params->pMemoryRequirements, &pMemoryRequirements_host);
24873     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
24874     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
24875     free_conversion_context(&ctx);
24876     return STATUS_SUCCESS;
24877 }
24878
24879 #endif /* USE_STRUCT_CONVERSION */
24880
24881 #if !defined(USE_STRUCT_CONVERSION)
24882
24883 static NTSTATUS thunk64_vkGetDeviceImageSparseMemoryRequirements(void *args)
24884 {
24885     struct vkGetDeviceImageSparseMemoryRequirements_params *params = args;
24886
24887     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
24888
24889     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
24890     return STATUS_SUCCESS;
24891 }
24892
24893 #else /* USE_STRUCT_CONVERSION */
24894
24895 static NTSTATUS thunk32_vkGetDeviceImageSparseMemoryRequirements(void *args)
24896 {
24897     struct
24898     {
24899         VkDevice device;
24900         const VkDeviceImageMemoryRequirements *pInfo;
24901         uint32_t *pSparseMemoryRequirementCount;
24902         VkSparseImageMemoryRequirements232 *pSparseMemoryRequirements;
24903     } *params = args;
24904     VkDeviceImageMemoryRequirements pInfo_host;
24905     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
24906     struct conversion_context ctx;
24907
24908     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
24909
24910     init_conversion_context(&ctx);
24911     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
24912     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
24913     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, &pInfo_host, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
24914     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
24915     free_conversion_context(&ctx);
24916     return STATUS_SUCCESS;
24917 }
24918
24919 #endif /* USE_STRUCT_CONVERSION */
24920
24921 #if !defined(USE_STRUCT_CONVERSION)
24922
24923 static NTSTATUS thunk64_vkGetDeviceImageSparseMemoryRequirementsKHR(void *args)
24924 {
24925     struct vkGetDeviceImageSparseMemoryRequirementsKHR_params *params = args;
24926
24927     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
24928
24929     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
24930     return STATUS_SUCCESS;
24931 }
24932
24933 #else /* USE_STRUCT_CONVERSION */
24934
24935 static NTSTATUS thunk32_vkGetDeviceImageSparseMemoryRequirementsKHR(void *args)
24936 {
24937     struct
24938     {
24939         VkDevice device;
24940         const VkDeviceImageMemoryRequirements *pInfo;
24941         uint32_t *pSparseMemoryRequirementCount;
24942         VkSparseImageMemoryRequirements232 *pSparseMemoryRequirements;
24943     } *params = args;
24944     VkDeviceImageMemoryRequirements pInfo_host;
24945     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
24946     struct conversion_context ctx;
24947
24948     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
24949
24950     init_conversion_context(&ctx);
24951     convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
24952     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
24953     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, &pInfo_host, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
24954     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
24955     free_conversion_context(&ctx);
24956     return STATUS_SUCCESS;
24957 }
24958
24959 #endif /* USE_STRUCT_CONVERSION */
24960
24961 #if !defined(USE_STRUCT_CONVERSION)
24962
24963 static NTSTATUS thunk64_vkGetDeviceMemoryCommitment(void *args)
24964 {
24965     struct vkGetDeviceMemoryCommitment_params *params = args;
24966
24967     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pCommittedMemoryInBytes);
24968
24969     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryCommitment(wine_device_from_handle(params->device)->device, params->memory, params->pCommittedMemoryInBytes);
24970     return STATUS_SUCCESS;
24971 }
24972
24973 #else /* USE_STRUCT_CONVERSION */
24974
24975 static NTSTATUS thunk32_vkGetDeviceMemoryCommitment(void *args)
24976 {
24977     struct
24978     {
24979         VkDevice device;
24980         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
24981         VkDeviceSize *pCommittedMemoryInBytes;
24982     } *params = args;
24983
24984     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pCommittedMemoryInBytes);
24985
24986     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryCommitment(wine_device_from_handle(params->device)->device, params->memory, params->pCommittedMemoryInBytes);
24987     return STATUS_SUCCESS;
24988 }
24989
24990 #endif /* USE_STRUCT_CONVERSION */
24991
24992 #if !defined(USE_STRUCT_CONVERSION)
24993
24994 static NTSTATUS thunk64_vkGetDeviceMemoryOpaqueCaptureAddress(void *args)
24995 {
24996     struct vkGetDeviceMemoryOpaqueCaptureAddress_params *params = args;
24997
24998     TRACE("%p, %p\n", params->device, params->pInfo);
24999
25000     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, params->pInfo);
25001     return STATUS_SUCCESS;
25002 }
25003
25004 #else /* USE_STRUCT_CONVERSION */
25005
25006 static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddress(void *args)
25007 {
25008     struct
25009     {
25010         VkDevice device;
25011         const VkDeviceMemoryOpaqueCaptureAddressInfo32 *pInfo;
25012         uint64_t result;
25013     } *params = args;
25014     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
25015
25016     TRACE("%p, %p\n", params->device, params->pInfo);
25017
25018     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
25019     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, &pInfo_host);
25020     return STATUS_SUCCESS;
25021 }
25022
25023 #endif /* USE_STRUCT_CONVERSION */
25024
25025 #if !defined(USE_STRUCT_CONVERSION)
25026
25027 static NTSTATUS thunk64_vkGetDeviceMemoryOpaqueCaptureAddressKHR(void *args)
25028 {
25029     struct vkGetDeviceMemoryOpaqueCaptureAddressKHR_params *params = args;
25030
25031     TRACE("%p, %p\n", params->device, params->pInfo);
25032
25033     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, params->pInfo);
25034     return STATUS_SUCCESS;
25035 }
25036
25037 #else /* USE_STRUCT_CONVERSION */
25038
25039 static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR(void *args)
25040 {
25041     struct
25042     {
25043         VkDevice device;
25044         const VkDeviceMemoryOpaqueCaptureAddressInfo32 *pInfo;
25045         uint64_t result;
25046     } *params = args;
25047     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;
25048
25049     TRACE("%p, %p\n", params->device, params->pInfo);
25050
25051     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
25052     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
25053     return STATUS_SUCCESS;
25054 }
25055
25056 #endif /* USE_STRUCT_CONVERSION */
25057
25058 #if !defined(USE_STRUCT_CONVERSION)
25059
25060 static NTSTATUS thunk64_vkGetDeviceMicromapCompatibilityEXT(void *args)
25061 {
25062     struct vkGetDeviceMicromapCompatibilityEXT_params *params = args;
25063
25064     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
25065
25066     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMicromapCompatibilityEXT(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
25067     return STATUS_SUCCESS;
25068 }
25069
25070 #else /* USE_STRUCT_CONVERSION */
25071
25072 static NTSTATUS thunk32_vkGetDeviceMicromapCompatibilityEXT(void *args)
25073 {
25074     struct
25075     {
25076         VkDevice device;
25077         const VkMicromapVersionInfoEXT *pVersionInfo;
25078         VkAccelerationStructureCompatibilityKHR *pCompatibility;
25079     } *params = args;
25080
25081     TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
25082
25083     wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMicromapCompatibilityEXT(wine_device_from_handle(params->device)->device, params->pVersionInfo, params->pCompatibility);
25084     return STATUS_SUCCESS;
25085 }
25086
25087 #endif /* USE_STRUCT_CONVERSION */
25088
25089 #if !defined(USE_STRUCT_CONVERSION)
25090
25091 static NTSTATUS thunk64_vkGetDeviceQueue(void *args)
25092 {
25093     struct vkGetDeviceQueue_params *params = args;
25094
25095     TRACE("%p, %u, %u, %p\n", params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
25096
25097     wine_vkGetDeviceQueue(params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
25098     return STATUS_SUCCESS;
25099 }
25100
25101 #else /* USE_STRUCT_CONVERSION */
25102
25103 static NTSTATUS thunk32_vkGetDeviceQueue(void *args)
25104 {
25105     struct
25106     {
25107         VkDevice device;
25108         uint32_t queueFamilyIndex;
25109         uint32_t queueIndex;
25110         VkQueue *pQueue;
25111     } *params = args;
25112
25113     TRACE("%p, %u, %u, %p\n", params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
25114
25115     wine_vkGetDeviceQueue(params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
25116     return STATUS_SUCCESS;
25117 }
25118
25119 #endif /* USE_STRUCT_CONVERSION */
25120
25121 #if !defined(USE_STRUCT_CONVERSION)
25122
25123 static NTSTATUS thunk64_vkGetDeviceQueue2(void *args)
25124 {
25125     struct vkGetDeviceQueue2_params *params = args;
25126
25127     TRACE("%p, %p, %p\n", params->device, params->pQueueInfo, params->pQueue);
25128
25129     wine_vkGetDeviceQueue2(params->device, params->pQueueInfo, params->pQueue);
25130     return STATUS_SUCCESS;
25131 }
25132
25133 #else /* USE_STRUCT_CONVERSION */
25134
25135 static NTSTATUS thunk32_vkGetDeviceQueue2(void *args)
25136 {
25137     struct
25138     {
25139         VkDevice device;
25140         const VkDeviceQueueInfo2 *pQueueInfo;
25141         VkQueue *pQueue;
25142     } *params = args;
25143
25144     TRACE("%p, %p, %p\n", params->device, params->pQueueInfo, params->pQueue);
25145
25146     wine_vkGetDeviceQueue2(params->device, params->pQueueInfo, params->pQueue);
25147     return STATUS_SUCCESS;
25148 }
25149
25150 #endif /* USE_STRUCT_CONVERSION */
25151
25152 #if !defined(USE_STRUCT_CONVERSION)
25153
25154 static NTSTATUS thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *args)
25155 {
25156     struct vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_params *params = args;
25157
25158     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);
25159
25160     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle(params->device)->device, params->renderpass, params->pMaxWorkgroupSize);
25161     return STATUS_SUCCESS;
25162 }
25163
25164 #else /* USE_STRUCT_CONVERSION */
25165
25166 static NTSTATUS thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *args)
25167 {
25168     struct
25169     {
25170         VkDevice device;
25171         VkRenderPass DECLSPEC_ALIGN(8) renderpass;
25172         VkExtent2D *pMaxWorkgroupSize;
25173         VkResult result;
25174     } *params = args;
25175
25176     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);
25177
25178     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle(params->device)->device, params->renderpass, params->pMaxWorkgroupSize);
25179     return STATUS_SUCCESS;
25180 }
25181
25182 #endif /* USE_STRUCT_CONVERSION */
25183
25184 #if !defined(USE_STRUCT_CONVERSION)
25185
25186 static NTSTATUS thunk64_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
25187 {
25188     struct vkGetDynamicRenderingTilePropertiesQCOM_params *params = args;
25189
25190     TRACE("%p, %p, %p\n", params->device, params->pRenderingInfo, params->pProperties);
25191
25192     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->pRenderingInfo, params->pProperties);
25193     return STATUS_SUCCESS;
25194 }
25195
25196 #else /* USE_STRUCT_CONVERSION */
25197
25198 static NTSTATUS thunk32_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
25199 {
25200     struct
25201     {
25202         VkDevice device;
25203         const VkRenderingInfo32 *pRenderingInfo;
25204         VkTilePropertiesQCOM *pProperties;
25205         VkResult result;
25206     } *params = args;
25207     VkRenderingInfo pRenderingInfo_host;
25208     struct conversion_context ctx;
25209
25210     TRACE("%p, %p, %p\n", params->device, params->pRenderingInfo, params->pProperties);
25211
25212     init_conversion_context(&ctx);
25213     convert_VkRenderingInfo_win32_to_host(&ctx, params->pRenderingInfo, &pRenderingInfo_host);
25214     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle(params->device)->device, &pRenderingInfo_host, params->pProperties);
25215     free_conversion_context(&ctx);
25216     return STATUS_SUCCESS;
25217 }
25218
25219 #endif /* USE_STRUCT_CONVERSION */
25220
25221 #if !defined(USE_STRUCT_CONVERSION)
25222
25223 static NTSTATUS thunk64_vkGetEventStatus(void *args)
25224 {
25225     struct vkGetEventStatus_params *params = args;
25226
25227     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
25228
25229     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetEventStatus(wine_device_from_handle(params->device)->device, params->event);
25230     return STATUS_SUCCESS;
25231 }
25232
25233 #else /* USE_STRUCT_CONVERSION */
25234
25235 static NTSTATUS thunk32_vkGetEventStatus(void *args)
25236 {
25237     struct
25238     {
25239         VkDevice device;
25240         VkEvent DECLSPEC_ALIGN(8) event;
25241         VkResult result;
25242     } *params = args;
25243
25244     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
25245
25246     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetEventStatus(wine_device_from_handle(params->device)->device, params->event);
25247     return STATUS_SUCCESS;
25248 }
25249
25250 #endif /* USE_STRUCT_CONVERSION */
25251
25252 #if !defined(USE_STRUCT_CONVERSION)
25253
25254 static NTSTATUS thunk64_vkGetFenceStatus(void *args)
25255 {
25256     struct vkGetFenceStatus_params *params = args;
25257
25258     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));
25259
25260     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFenceStatus(wine_device_from_handle(params->device)->device, params->fence);
25261     return STATUS_SUCCESS;
25262 }
25263
25264 #else /* USE_STRUCT_CONVERSION */
25265
25266 static NTSTATUS thunk32_vkGetFenceStatus(void *args)
25267 {
25268     struct
25269     {
25270         VkDevice device;
25271         VkFence DECLSPEC_ALIGN(8) fence;
25272         VkResult result;
25273     } *params = args;
25274
25275     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));
25276
25277     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFenceStatus(wine_device_from_handle(params->device)->device, params->fence);
25278     return STATUS_SUCCESS;
25279 }
25280
25281 #endif /* USE_STRUCT_CONVERSION */
25282
25283 #if !defined(USE_STRUCT_CONVERSION)
25284
25285 static NTSTATUS thunk64_vkGetFramebufferTilePropertiesQCOM(void *args)
25286 {
25287     struct vkGetFramebufferTilePropertiesQCOM_params *params = args;
25288
25289     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);
25290
25291     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->framebuffer, params->pPropertiesCount, params->pProperties);
25292     return STATUS_SUCCESS;
25293 }
25294
25295 #else /* USE_STRUCT_CONVERSION */
25296
25297 static NTSTATUS thunk32_vkGetFramebufferTilePropertiesQCOM(void *args)
25298 {
25299     struct
25300     {
25301         VkDevice device;
25302         VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
25303         uint32_t *pPropertiesCount;
25304         VkTilePropertiesQCOM *pProperties;
25305         VkResult result;
25306     } *params = args;
25307
25308     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);
25309
25310     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->framebuffer, params->pPropertiesCount, params->pProperties);
25311     return STATUS_SUCCESS;
25312 }
25313
25314 #endif /* USE_STRUCT_CONVERSION */
25315
25316 #if !defined(USE_STRUCT_CONVERSION)
25317
25318 static NTSTATUS thunk64_vkGetGeneratedCommandsMemoryRequirementsNV(void *args)
25319 {
25320     struct vkGetGeneratedCommandsMemoryRequirementsNV_params *params = args;
25321
25322     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
25323
25324     wine_device_from_handle(params->device)->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
25325     return STATUS_SUCCESS;
25326 }
25327
25328 #else /* USE_STRUCT_CONVERSION */
25329
25330 static NTSTATUS thunk32_vkGetGeneratedCommandsMemoryRequirementsNV(void *args)
25331 {
25332     struct
25333     {
25334         VkDevice device;
25335         const VkGeneratedCommandsMemoryRequirementsInfoNV32 *pInfo;
25336         VkMemoryRequirements232 *pMemoryRequirements;
25337     } *params = args;
25338     VkGeneratedCommandsMemoryRequirementsInfoNV pInfo_host;
25339     VkMemoryRequirements2 pMemoryRequirements_host;
25340
25341     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
25342
25343     convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(params->pInfo, &pInfo_host);
25344     convert_VkMemoryRequirements2_win32_to_host(params->pMemoryRequirements, &pMemoryRequirements_host);
25345     wine_device_from_handle(params->device)->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
25346     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
25347     return STATUS_SUCCESS;
25348 }
25349
25350 #endif /* USE_STRUCT_CONVERSION */
25351
25352 #if !defined(USE_STRUCT_CONVERSION)
25353
25354 static NTSTATUS thunk64_vkGetImageMemoryRequirements(void *args)
25355 {
25356     struct vkGetImageMemoryRequirements_params *params = args;
25357
25358     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pMemoryRequirements);
25359
25360     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pMemoryRequirements);
25361     return STATUS_SUCCESS;
25362 }
25363
25364 #else /* USE_STRUCT_CONVERSION */
25365
25366 static NTSTATUS thunk32_vkGetImageMemoryRequirements(void *args)
25367 {
25368     struct
25369     {
25370         VkDevice device;
25371         VkImage DECLSPEC_ALIGN(8) image;
25372         VkMemoryRequirements32 *pMemoryRequirements;
25373     } *params = args;
25374     VkMemoryRequirements pMemoryRequirements_host;
25375
25376     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pMemoryRequirements);
25377
25378     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, &pMemoryRequirements_host);
25379     convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
25380     return STATUS_SUCCESS;
25381 }
25382
25383 #endif /* USE_STRUCT_CONVERSION */
25384
25385 #if !defined(USE_STRUCT_CONVERSION)
25386
25387 static NTSTATUS thunk64_vkGetImageMemoryRequirements2(void *args)
25388 {
25389     struct vkGetImageMemoryRequirements2_params *params = args;
25390
25391     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
25392
25393     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
25394     return STATUS_SUCCESS;
25395 }
25396
25397 #else /* USE_STRUCT_CONVERSION */
25398
25399 static NTSTATUS thunk32_vkGetImageMemoryRequirements2(void *args)
25400 {
25401     struct
25402     {
25403         VkDevice device;
25404         const VkImageMemoryRequirementsInfo232 *pInfo;
25405         VkMemoryRequirements232 *pMemoryRequirements;
25406     } *params = args;
25407     VkImageMemoryRequirementsInfo2 pInfo_host;
25408     VkMemoryRequirements2 pMemoryRequirements_host;
25409
25410     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
25411
25412     convert_VkImageMemoryRequirementsInfo2_win32_to_host(params->pInfo, &pInfo_host);
25413     convert_VkMemoryRequirements2_win32_to_host(params->pMemoryRequirements, &pMemoryRequirements_host);
25414     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
25415     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
25416     return STATUS_SUCCESS;
25417 }
25418
25419 #endif /* USE_STRUCT_CONVERSION */
25420
25421 #if !defined(USE_STRUCT_CONVERSION)
25422
25423 static NTSTATUS thunk64_vkGetImageMemoryRequirements2KHR(void *args)
25424 {
25425     struct vkGetImageMemoryRequirements2KHR_params *params = args;
25426
25427     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
25428
25429     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pMemoryRequirements);
25430     return STATUS_SUCCESS;
25431 }
25432
25433 #else /* USE_STRUCT_CONVERSION */
25434
25435 static NTSTATUS thunk32_vkGetImageMemoryRequirements2KHR(void *args)
25436 {
25437     struct
25438     {
25439         VkDevice device;
25440         const VkImageMemoryRequirementsInfo232 *pInfo;
25441         VkMemoryRequirements232 *pMemoryRequirements;
25442     } *params = args;
25443     VkImageMemoryRequirementsInfo2 pInfo_host;
25444     VkMemoryRequirements2 pMemoryRequirements_host;
25445
25446     TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
25447
25448     convert_VkImageMemoryRequirementsInfo2_win32_to_host(params->pInfo, &pInfo_host);
25449     convert_VkMemoryRequirements2_win32_to_host(params->pMemoryRequirements, &pMemoryRequirements_host);
25450     wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
25451     convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
25452     return STATUS_SUCCESS;
25453 }
25454
25455 #endif /* USE_STRUCT_CONVERSION */
25456
25457 #if !defined(USE_STRUCT_CONVERSION)
25458
25459 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements(void *args)
25460 {
25461     struct vkGetImageSparseMemoryRequirements_params *params = args;
25462
25463     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
25464
25465     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
25466     return STATUS_SUCCESS;
25467 }
25468
25469 #else /* USE_STRUCT_CONVERSION */
25470
25471 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements(void *args)
25472 {
25473     struct
25474     {
25475         VkDevice device;
25476         VkImage DECLSPEC_ALIGN(8) image;
25477         uint32_t *pSparseMemoryRequirementCount;
25478         VkSparseImageMemoryRequirements32 *pSparseMemoryRequirements;
25479     } *params = args;
25480     VkSparseImageMemoryRequirements *pSparseMemoryRequirements_host;
25481     struct conversion_context ctx;
25482
25483     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
25484
25485     init_conversion_context(&ctx);
25486     pSparseMemoryRequirements_host = (params->pSparseMemoryRequirements && *params->pSparseMemoryRequirementCount) ? conversion_context_alloc(&ctx, sizeof(*pSparseMemoryRequirements_host) * *params->pSparseMemoryRequirementCount) : NULL;
25487     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
25488     convert_VkSparseImageMemoryRequirements_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
25489     free_conversion_context(&ctx);
25490     return STATUS_SUCCESS;
25491 }
25492
25493 #endif /* USE_STRUCT_CONVERSION */
25494
25495 #if !defined(USE_STRUCT_CONVERSION)
25496
25497 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements2(void *args)
25498 {
25499     struct vkGetImageSparseMemoryRequirements2_params *params = args;
25500
25501     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
25502
25503     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
25504     return STATUS_SUCCESS;
25505 }
25506
25507 #else /* USE_STRUCT_CONVERSION */
25508
25509 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements2(void *args)
25510 {
25511     struct
25512     {
25513         VkDevice device;
25514         const VkImageSparseMemoryRequirementsInfo232 *pInfo;
25515         uint32_t *pSparseMemoryRequirementCount;
25516         VkSparseImageMemoryRequirements232 *pSparseMemoryRequirements;
25517     } *params = args;
25518     VkImageSparseMemoryRequirementsInfo2 pInfo_host;
25519     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
25520     struct conversion_context ctx;
25521
25522     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
25523
25524     init_conversion_context(&ctx);
25525     convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(params->pInfo, &pInfo_host);
25526     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
25527     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2(wine_device_from_handle(params->device)->device, &pInfo_host, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
25528     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
25529     free_conversion_context(&ctx);
25530     return STATUS_SUCCESS;
25531 }
25532
25533 #endif /* USE_STRUCT_CONVERSION */
25534
25535 #if !defined(USE_STRUCT_CONVERSION)
25536
25537 static NTSTATUS thunk64_vkGetImageSparseMemoryRequirements2KHR(void *args)
25538 {
25539     struct vkGetImageSparseMemoryRequirements2KHR_params *params = args;
25540
25541     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
25542
25543     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
25544     return STATUS_SUCCESS;
25545 }
25546
25547 #else /* USE_STRUCT_CONVERSION */
25548
25549 static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements2KHR(void *args)
25550 {
25551     struct
25552     {
25553         VkDevice device;
25554         const VkImageSparseMemoryRequirementsInfo232 *pInfo;
25555         uint32_t *pSparseMemoryRequirementCount;
25556         VkSparseImageMemoryRequirements232 *pSparseMemoryRequirements;
25557     } *params = args;
25558     VkImageSparseMemoryRequirementsInfo2 pInfo_host;
25559     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
25560     struct conversion_context ctx;
25561
25562     TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
25563
25564     init_conversion_context(&ctx);
25565     convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(params->pInfo, &pInfo_host);
25566     pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
25567     wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, &pInfo_host, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
25568     convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
25569     free_conversion_context(&ctx);
25570     return STATUS_SUCCESS;
25571 }
25572
25573 #endif /* USE_STRUCT_CONVERSION */
25574
25575 #if !defined(USE_STRUCT_CONVERSION)
25576
25577 static NTSTATUS thunk64_vkGetImageSubresourceLayout(void *args)
25578 {
25579     struct vkGetImageSubresourceLayout_params *params = args;
25580
25581     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
25582
25583     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, params->pLayout);
25584     return STATUS_SUCCESS;
25585 }
25586
25587 #else /* USE_STRUCT_CONVERSION */
25588
25589 static NTSTATUS thunk32_vkGetImageSubresourceLayout(void *args)
25590 {
25591     struct
25592     {
25593         VkDevice device;
25594         VkImage DECLSPEC_ALIGN(8) image;
25595         const VkImageSubresource *pSubresource;
25596         VkSubresourceLayout32 *pLayout;
25597     } *params = args;
25598     VkSubresourceLayout pLayout_host;
25599
25600     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
25601
25602     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, &pLayout_host);
25603     convert_VkSubresourceLayout_host_to_win32(&pLayout_host, params->pLayout);
25604     return STATUS_SUCCESS;
25605 }
25606
25607 #endif /* USE_STRUCT_CONVERSION */
25608
25609 #if !defined(USE_STRUCT_CONVERSION)
25610
25611 static NTSTATUS thunk64_vkGetImageSubresourceLayout2EXT(void *args)
25612 {
25613     struct vkGetImageSubresourceLayout2EXT_params *params = args;
25614
25615     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
25616
25617     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout2EXT(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, params->pLayout);
25618     return STATUS_SUCCESS;
25619 }
25620
25621 #else /* USE_STRUCT_CONVERSION */
25622
25623 static NTSTATUS thunk32_vkGetImageSubresourceLayout2EXT(void *args)
25624 {
25625     struct
25626     {
25627         VkDevice device;
25628         VkImage DECLSPEC_ALIGN(8) image;
25629         const VkImageSubresource2EXT *pSubresource;
25630         VkSubresourceLayout2EXT32 *pLayout;
25631     } *params = args;
25632     VkSubresourceLayout2EXT pLayout_host;
25633
25634     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
25635
25636     convert_VkSubresourceLayout2EXT_win32_to_host(params->pLayout, &pLayout_host);
25637     wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout2EXT(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, &pLayout_host);
25638     convert_VkSubresourceLayout2EXT_host_to_win32(&pLayout_host, params->pLayout);
25639     return STATUS_SUCCESS;
25640 }
25641
25642 #endif /* USE_STRUCT_CONVERSION */
25643
25644 #if !defined(USE_STRUCT_CONVERSION)
25645
25646 static NTSTATUS thunk64_vkGetImageViewAddressNVX(void *args)
25647 {
25648     struct vkGetImageViewAddressNVX_params *params = args;
25649
25650     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);
25651
25652     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle(params->device)->device, params->imageView, params->pProperties);
25653     return STATUS_SUCCESS;
25654 }
25655
25656 #else /* USE_STRUCT_CONVERSION */
25657
25658 static NTSTATUS thunk32_vkGetImageViewAddressNVX(void *args)
25659 {
25660     struct
25661     {
25662         VkDevice device;
25663         VkImageView DECLSPEC_ALIGN(8) imageView;
25664         VkImageViewAddressPropertiesNVX32 *pProperties;
25665         VkResult result;
25666     } *params = args;
25667     VkImageViewAddressPropertiesNVX pProperties_host;
25668
25669     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);
25670
25671     convert_VkImageViewAddressPropertiesNVX_win32_to_host(params->pProperties, &pProperties_host);
25672     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle(params->device)->device, params->imageView, &pProperties_host);
25673     convert_VkImageViewAddressPropertiesNVX_host_to_win32(&pProperties_host, params->pProperties);
25674     return STATUS_SUCCESS;
25675 }
25676
25677 #endif /* USE_STRUCT_CONVERSION */
25678
25679 #if !defined(USE_STRUCT_CONVERSION)
25680
25681 static NTSTATUS thunk64_vkGetImageViewHandleNVX(void *args)
25682 {
25683     struct vkGetImageViewHandleNVX_params *params = args;
25684
25685     TRACE("%p, %p\n", params->device, params->pInfo);
25686
25687     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle(params->device)->device, params->pInfo);
25688     return STATUS_SUCCESS;
25689 }
25690
25691 #else /* USE_STRUCT_CONVERSION */
25692
25693 static NTSTATUS thunk32_vkGetImageViewHandleNVX(void *args)
25694 {
25695     struct
25696     {
25697         VkDevice device;
25698         const VkImageViewHandleInfoNVX32 *pInfo;
25699         uint32_t result;
25700     } *params = args;
25701     VkImageViewHandleInfoNVX pInfo_host;
25702
25703     TRACE("%p, %p\n", params->device, params->pInfo);
25704
25705     convert_VkImageViewHandleInfoNVX_win32_to_host(params->pInfo, &pInfo_host);
25706     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle(params->device)->device, &pInfo_host);
25707     return STATUS_SUCCESS;
25708 }
25709
25710 #endif /* USE_STRUCT_CONVERSION */
25711
25712 #if !defined(USE_STRUCT_CONVERSION)
25713
25714 static NTSTATUS thunk64_vkGetMemoryHostPointerPropertiesEXT(void *args)
25715 {
25716     struct vkGetMemoryHostPointerPropertiesEXT_params *params = args;
25717
25718     TRACE("%p, %#x, %p, %p\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
25719
25720     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle(params->device)->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
25721     return STATUS_SUCCESS;
25722 }
25723
25724 #else /* USE_STRUCT_CONVERSION */
25725
25726 static NTSTATUS thunk32_vkGetMemoryHostPointerPropertiesEXT(void *args)
25727 {
25728     struct
25729     {
25730         VkDevice device;
25731         VkExternalMemoryHandleTypeFlagBits handleType;
25732         const void *pHostPointer;
25733         VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties;
25734         VkResult result;
25735     } *params = args;
25736
25737     TRACE("%p, %#x, %p, %p\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
25738
25739     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle(params->device)->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
25740     return STATUS_SUCCESS;
25741 }
25742
25743 #endif /* USE_STRUCT_CONVERSION */
25744
25745 #if !defined(USE_STRUCT_CONVERSION)
25746
25747 static NTSTATUS thunk64_vkGetMicromapBuildSizesEXT(void *args)
25748 {
25749     struct vkGetMicromapBuildSizesEXT_params *params = args;
25750
25751     TRACE("%p, %#x, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
25752
25753     wine_device_from_handle(params->device)->funcs.p_vkGetMicromapBuildSizesEXT(wine_device_from_handle(params->device)->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
25754     return STATUS_SUCCESS;
25755 }
25756
25757 #else /* USE_STRUCT_CONVERSION */
25758
25759 static NTSTATUS thunk32_vkGetMicromapBuildSizesEXT(void *args)
25760 {
25761     struct
25762     {
25763         VkDevice device;
25764         VkAccelerationStructureBuildTypeKHR buildType;
25765         const VkMicromapBuildInfoEXT32 *pBuildInfo;
25766         VkMicromapBuildSizesInfoEXT32 *pSizeInfo;
25767     } *params = args;
25768     VkMicromapBuildInfoEXT pBuildInfo_host;
25769     VkMicromapBuildSizesInfoEXT pSizeInfo_host;
25770
25771     TRACE("%p, %#x, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
25772
25773     convert_VkMicromapBuildInfoEXT_win32_to_host(params->pBuildInfo, &pBuildInfo_host);
25774     convert_VkMicromapBuildSizesInfoEXT_win32_to_host(params->pSizeInfo, &pSizeInfo_host);
25775     wine_device_from_handle(params->device)->funcs.p_vkGetMicromapBuildSizesEXT(wine_device_from_handle(params->device)->device, params->buildType, &pBuildInfo_host, &pSizeInfo_host);
25776     convert_VkMicromapBuildSizesInfoEXT_host_to_win32(&pSizeInfo_host, params->pSizeInfo);
25777     return STATUS_SUCCESS;
25778 }
25779
25780 #endif /* USE_STRUCT_CONVERSION */
25781
25782 #if !defined(USE_STRUCT_CONVERSION)
25783
25784 static NTSTATUS thunk64_vkGetPerformanceParameterINTEL(void *args)
25785 {
25786     struct vkGetPerformanceParameterINTEL_params *params = args;
25787
25788     TRACE("%p, %#x, %p\n", params->device, params->parameter, params->pValue);
25789
25790     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle(params->device)->device, params->parameter, params->pValue);
25791     return STATUS_SUCCESS;
25792 }
25793
25794 #else /* USE_STRUCT_CONVERSION */
25795
25796 static NTSTATUS thunk32_vkGetPerformanceParameterINTEL(void *args)
25797 {
25798     struct
25799     {
25800         VkDevice device;
25801         VkPerformanceParameterTypeINTEL parameter;
25802         VkPerformanceValueINTEL32 *pValue;
25803         VkResult result;
25804     } *params = args;
25805     VkPerformanceValueINTEL pValue_host;
25806
25807     TRACE("%p, %#x, %p\n", params->device, params->parameter, params->pValue);
25808
25809     convert_VkPerformanceValueINTEL_win32_to_host(params->pValue, &pValue_host);
25810     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle(params->device)->device, params->parameter, &pValue_host);
25811     convert_VkPerformanceValueINTEL_host_to_win32(&pValue_host, params->pValue);
25812     return STATUS_SUCCESS;
25813 }
25814
25815 #endif /* USE_STRUCT_CONVERSION */
25816
25817 #if !defined(USE_STRUCT_CONVERSION)
25818
25819 static NTSTATUS thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
25820 {
25821     struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params *params = args;
25822
25823     TRACE("%p, %p, %p\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
25824
25825     params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
25826     return STATUS_SUCCESS;
25827 }
25828
25829 #else /* USE_STRUCT_CONVERSION */
25830
25831 static NTSTATUS thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
25832 {
25833     struct
25834     {
25835         VkPhysicalDevice physicalDevice;
25836         uint32_t *pTimeDomainCount;
25837         VkTimeDomainEXT *pTimeDomains;
25838         VkResult result;
25839     } *params = args;
25840
25841     TRACE("%p, %p, %p\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
25842
25843     params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
25844     return STATUS_SUCCESS;
25845 }
25846
25847 #endif /* USE_STRUCT_CONVERSION */
25848
25849 #if !defined(USE_STRUCT_CONVERSION)
25850
25851 static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
25852 {
25853     struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params *params = args;
25854
25855     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
25856
25857     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);
25858     return STATUS_SUCCESS;
25859 }
25860
25861 #else /* USE_STRUCT_CONVERSION */
25862
25863 static NTSTATUS thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args)
25864 {
25865     struct
25866     {
25867         VkPhysicalDevice physicalDevice;
25868         uint32_t *pPropertyCount;
25869         VkCooperativeMatrixPropertiesNV *pProperties;
25870         VkResult result;
25871     } *params = args;
25872
25873     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
25874
25875     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);
25876     return STATUS_SUCCESS;
25877 }
25878
25879 #endif /* USE_STRUCT_CONVERSION */
25880
25881 #if !defined(USE_STRUCT_CONVERSION)
25882
25883 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalBufferProperties(void *args)
25884 {
25885     struct vkGetPhysicalDeviceExternalBufferProperties_params *params = args;
25886
25887     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
25888
25889     wine_vkGetPhysicalDeviceExternalBufferProperties(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
25890     return STATUS_SUCCESS;
25891 }
25892
25893 #else /* USE_STRUCT_CONVERSION */
25894
25895 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferProperties(void *args)
25896 {
25897     struct
25898     {
25899         VkPhysicalDevice physicalDevice;
25900         const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo;
25901         VkExternalBufferProperties *pExternalBufferProperties;
25902     } *params = args;
25903
25904     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
25905
25906     wine_vkGetPhysicalDeviceExternalBufferProperties(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
25907     return STATUS_SUCCESS;
25908 }
25909
25910 #endif /* USE_STRUCT_CONVERSION */
25911
25912 #if !defined(USE_STRUCT_CONVERSION)
25913
25914 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args)
25915 {
25916     struct vkGetPhysicalDeviceExternalBufferPropertiesKHR_params *params = args;
25917
25918     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
25919
25920     wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
25921     return STATUS_SUCCESS;
25922 }
25923
25924 #else /* USE_STRUCT_CONVERSION */
25925
25926 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args)
25927 {
25928     struct
25929     {
25930         VkPhysicalDevice physicalDevice;
25931         const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo;
25932         VkExternalBufferProperties *pExternalBufferProperties;
25933     } *params = args;
25934
25935     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
25936
25937     wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
25938     return STATUS_SUCCESS;
25939 }
25940
25941 #endif /* USE_STRUCT_CONVERSION */
25942
25943 #if !defined(USE_STRUCT_CONVERSION)
25944
25945 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalFenceProperties(void *args)
25946 {
25947     struct vkGetPhysicalDeviceExternalFenceProperties_params *params = args;
25948
25949     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
25950
25951     wine_vkGetPhysicalDeviceExternalFenceProperties(params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
25952     return STATUS_SUCCESS;
25953 }
25954
25955 #else /* USE_STRUCT_CONVERSION */
25956
25957 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalFenceProperties(void *args)
25958 {
25959     struct
25960     {
25961         VkPhysicalDevice physicalDevice;
25962         const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo;
25963         VkExternalFenceProperties *pExternalFenceProperties;
25964     } *params = args;
25965
25966     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
25967
25968     wine_vkGetPhysicalDeviceExternalFenceProperties(params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
25969     return STATUS_SUCCESS;
25970 }
25971
25972 #endif /* USE_STRUCT_CONVERSION */
25973
25974 #if !defined(USE_STRUCT_CONVERSION)
25975
25976 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args)
25977 {
25978     struct vkGetPhysicalDeviceExternalFencePropertiesKHR_params *params = args;
25979
25980     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
25981
25982     wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
25983     return STATUS_SUCCESS;
25984 }
25985
25986 #else /* USE_STRUCT_CONVERSION */
25987
25988 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args)
25989 {
25990     struct
25991     {
25992         VkPhysicalDevice physicalDevice;
25993         const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo;
25994         VkExternalFenceProperties *pExternalFenceProperties;
25995     } *params = args;
25996
25997     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
25998
25999     wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
26000     return STATUS_SUCCESS;
26001 }
26002
26003 #endif /* USE_STRUCT_CONVERSION */
26004
26005 #if !defined(USE_STRUCT_CONVERSION)
26006
26007 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalSemaphoreProperties(void *args)
26008 {
26009     struct vkGetPhysicalDeviceExternalSemaphoreProperties_params *params = args;
26010
26011     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
26012
26013     wine_vkGetPhysicalDeviceExternalSemaphoreProperties(params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
26014     return STATUS_SUCCESS;
26015 }
26016
26017 #else /* USE_STRUCT_CONVERSION */
26018
26019 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphoreProperties(void *args)
26020 {
26021     struct
26022     {
26023         VkPhysicalDevice physicalDevice;
26024         const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo;
26025         VkExternalSemaphoreProperties *pExternalSemaphoreProperties;
26026     } *params = args;
26027     VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo_host;
26028     struct conversion_context ctx;
26029
26030     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
26031
26032     init_conversion_context(&ctx);
26033     convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(&ctx, params->pExternalSemaphoreInfo, &pExternalSemaphoreInfo_host);
26034     wine_vkGetPhysicalDeviceExternalSemaphoreProperties(params->physicalDevice, &pExternalSemaphoreInfo_host, params->pExternalSemaphoreProperties);
26035     free_conversion_context(&ctx);
26036     return STATUS_SUCCESS;
26037 }
26038
26039 #endif /* USE_STRUCT_CONVERSION */
26040
26041 #if !defined(USE_STRUCT_CONVERSION)
26042
26043 static NTSTATUS thunk64_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *args)
26044 {
26045     struct vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_params *params = args;
26046
26047     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
26048
26049     wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
26050     return STATUS_SUCCESS;
26051 }
26052
26053 #else /* USE_STRUCT_CONVERSION */
26054
26055 static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *args)
26056 {
26057     struct
26058     {
26059         VkPhysicalDevice physicalDevice;
26060         const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo;
26061         VkExternalSemaphoreProperties *pExternalSemaphoreProperties;
26062     } *params = args;
26063     VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo_host;
26064     struct conversion_context ctx;
26065
26066     TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
26067
26068     init_conversion_context(&ctx);
26069     convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(&ctx, params->pExternalSemaphoreInfo, &pExternalSemaphoreInfo_host);
26070     wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(params->physicalDevice, &pExternalSemaphoreInfo_host, params->pExternalSemaphoreProperties);
26071     free_conversion_context(&ctx);
26072     return STATUS_SUCCESS;
26073 }
26074
26075 #endif /* USE_STRUCT_CONVERSION */
26076
26077 #if !defined(USE_STRUCT_CONVERSION)
26078
26079 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures(void *args)
26080 {
26081     struct vkGetPhysicalDeviceFeatures_params *params = args;
26082
26083     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
26084
26085     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
26086     return STATUS_SUCCESS;
26087 }
26088
26089 #else /* USE_STRUCT_CONVERSION */
26090
26091 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures(void *args)
26092 {
26093     struct
26094     {
26095         VkPhysicalDevice physicalDevice;
26096         VkPhysicalDeviceFeatures *pFeatures;
26097     } *params = args;
26098
26099     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
26100
26101     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
26102     return STATUS_SUCCESS;
26103 }
26104
26105 #endif /* USE_STRUCT_CONVERSION */
26106
26107 #if !defined(USE_STRUCT_CONVERSION)
26108
26109 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures2(void *args)
26110 {
26111     struct vkGetPhysicalDeviceFeatures2_params *params = args;
26112
26113     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
26114
26115     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
26116     return STATUS_SUCCESS;
26117 }
26118
26119 #else /* USE_STRUCT_CONVERSION */
26120
26121 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures2(void *args)
26122 {
26123     struct
26124     {
26125         VkPhysicalDevice physicalDevice;
26126         VkPhysicalDeviceFeatures2 *pFeatures;
26127     } *params = args;
26128
26129     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
26130
26131     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
26132     return STATUS_SUCCESS;
26133 }
26134
26135 #endif /* USE_STRUCT_CONVERSION */
26136
26137 #if !defined(USE_STRUCT_CONVERSION)
26138
26139 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures2KHR(void *args)
26140 {
26141     struct vkGetPhysicalDeviceFeatures2KHR_params *params = args;
26142
26143     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
26144
26145     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
26146     return STATUS_SUCCESS;
26147 }
26148
26149 #else /* USE_STRUCT_CONVERSION */
26150
26151 static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures2KHR(void *args)
26152 {
26153     struct
26154     {
26155         VkPhysicalDevice physicalDevice;
26156         VkPhysicalDeviceFeatures2 *pFeatures;
26157     } *params = args;
26158
26159     TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
26160
26161     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
26162     return STATUS_SUCCESS;
26163 }
26164
26165 #endif /* USE_STRUCT_CONVERSION */
26166
26167 #if !defined(USE_STRUCT_CONVERSION)
26168
26169 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties(void *args)
26170 {
26171     struct vkGetPhysicalDeviceFormatProperties_params *params = args;
26172
26173     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
26174
26175     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
26176     return STATUS_SUCCESS;
26177 }
26178
26179 #else /* USE_STRUCT_CONVERSION */
26180
26181 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties(void *args)
26182 {
26183     struct
26184     {
26185         VkPhysicalDevice physicalDevice;
26186         VkFormat format;
26187         VkFormatProperties *pFormatProperties;
26188     } *params = args;
26189
26190     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
26191
26192     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
26193     return STATUS_SUCCESS;
26194 }
26195
26196 #endif /* USE_STRUCT_CONVERSION */
26197
26198 #if !defined(USE_STRUCT_CONVERSION)
26199
26200 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties2(void *args)
26201 {
26202     struct vkGetPhysicalDeviceFormatProperties2_params *params = args;
26203
26204     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
26205
26206     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
26207     return STATUS_SUCCESS;
26208 }
26209
26210 #else /* USE_STRUCT_CONVERSION */
26211
26212 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2(void *args)
26213 {
26214     struct
26215     {
26216         VkPhysicalDevice physicalDevice;
26217         VkFormat format;
26218         VkFormatProperties2 *pFormatProperties;
26219     } *params = args;
26220
26221     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
26222
26223     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
26224     return STATUS_SUCCESS;
26225 }
26226
26227 #endif /* USE_STRUCT_CONVERSION */
26228
26229 #if !defined(USE_STRUCT_CONVERSION)
26230
26231 static NTSTATUS thunk64_vkGetPhysicalDeviceFormatProperties2KHR(void *args)
26232 {
26233     struct vkGetPhysicalDeviceFormatProperties2KHR_params *params = args;
26234
26235     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
26236
26237     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
26238     return STATUS_SUCCESS;
26239 }
26240
26241 #else /* USE_STRUCT_CONVERSION */
26242
26243 static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2KHR(void *args)
26244 {
26245     struct
26246     {
26247         VkPhysicalDevice physicalDevice;
26248         VkFormat format;
26249         VkFormatProperties2 *pFormatProperties;
26250     } *params = args;
26251
26252     TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
26253
26254     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
26255     return STATUS_SUCCESS;
26256 }
26257
26258 #endif /* USE_STRUCT_CONVERSION */
26259
26260 #if !defined(USE_STRUCT_CONVERSION)
26261
26262 static NTSTATUS thunk64_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
26263 {
26264     struct vkGetPhysicalDeviceFragmentShadingRatesKHR_params *params = args;
26265
26266     TRACE("%p, %p, %p\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
26267
26268     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);
26269     return STATUS_SUCCESS;
26270 }
26271
26272 #else /* USE_STRUCT_CONVERSION */
26273
26274 static NTSTATUS thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
26275 {
26276     struct
26277     {
26278         VkPhysicalDevice physicalDevice;
26279         uint32_t *pFragmentShadingRateCount;
26280         VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates;
26281         VkResult result;
26282     } *params = args;
26283
26284     TRACE("%p, %p, %p\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
26285
26286     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);
26287     return STATUS_SUCCESS;
26288 }
26289
26290 #endif /* USE_STRUCT_CONVERSION */
26291
26292 #if !defined(USE_STRUCT_CONVERSION)
26293
26294 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties(void *args)
26295 {
26296     struct vkGetPhysicalDeviceImageFormatProperties_params *params = args;
26297
26298     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
26299
26300     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);
26301     return STATUS_SUCCESS;
26302 }
26303
26304 #else /* USE_STRUCT_CONVERSION */
26305
26306 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties(void *args)
26307 {
26308     struct
26309     {
26310         VkPhysicalDevice physicalDevice;
26311         VkFormat format;
26312         VkImageType type;
26313         VkImageTiling tiling;
26314         VkImageUsageFlags usage;
26315         VkImageCreateFlags flags;
26316         VkImageFormatProperties32 *pImageFormatProperties;
26317         VkResult result;
26318     } *params = args;
26319     VkImageFormatProperties pImageFormatProperties_host;
26320
26321     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
26322
26323     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->type, params->tiling, params->usage, params->flags, &pImageFormatProperties_host);
26324     convert_VkImageFormatProperties_host_to_win32(&pImageFormatProperties_host, params->pImageFormatProperties);
26325     return STATUS_SUCCESS;
26326 }
26327
26328 #endif /* USE_STRUCT_CONVERSION */
26329
26330 #if !defined(USE_STRUCT_CONVERSION)
26331
26332 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2(void *args)
26333 {
26334     struct vkGetPhysicalDeviceImageFormatProperties2_params *params = args;
26335
26336     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
26337
26338     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
26339     return STATUS_SUCCESS;
26340 }
26341
26342 #else /* USE_STRUCT_CONVERSION */
26343
26344 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2(void *args)
26345 {
26346     struct
26347     {
26348         VkPhysicalDevice physicalDevice;
26349         const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo;
26350         VkImageFormatProperties232 *pImageFormatProperties;
26351         VkResult result;
26352     } *params = args;
26353     VkImageFormatProperties2 pImageFormatProperties_host;
26354
26355     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
26356
26357     convert_VkImageFormatProperties2_win32_to_host(params->pImageFormatProperties, &pImageFormatProperties_host);
26358     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, params->pImageFormatInfo, &pImageFormatProperties_host);
26359     convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, params->pImageFormatProperties);
26360     return STATUS_SUCCESS;
26361 }
26362
26363 #endif /* USE_STRUCT_CONVERSION */
26364
26365 #if !defined(USE_STRUCT_CONVERSION)
26366
26367 static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
26368 {
26369     struct vkGetPhysicalDeviceImageFormatProperties2KHR_params *params = args;
26370
26371     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
26372
26373     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
26374     return STATUS_SUCCESS;
26375 }
26376
26377 #else /* USE_STRUCT_CONVERSION */
26378
26379 static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
26380 {
26381     struct
26382     {
26383         VkPhysicalDevice physicalDevice;
26384         const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo;
26385         VkImageFormatProperties232 *pImageFormatProperties;
26386         VkResult result;
26387     } *params = args;
26388     VkImageFormatProperties2 pImageFormatProperties_host;
26389
26390     TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
26391
26392     convert_VkImageFormatProperties2_win32_to_host(params->pImageFormatProperties, &pImageFormatProperties_host);
26393     params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, params->pImageFormatInfo, &pImageFormatProperties_host);
26394     convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, params->pImageFormatProperties);
26395     return STATUS_SUCCESS;
26396 }
26397
26398 #endif /* USE_STRUCT_CONVERSION */
26399
26400 #if !defined(USE_STRUCT_CONVERSION)
26401
26402 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties(void *args)
26403 {
26404     struct vkGetPhysicalDeviceMemoryProperties_params *params = args;
26405
26406     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
26407
26408     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
26409     return STATUS_SUCCESS;
26410 }
26411
26412 #else /* USE_STRUCT_CONVERSION */
26413
26414 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties(void *args)
26415 {
26416     struct
26417     {
26418         VkPhysicalDevice physicalDevice;
26419         VkPhysicalDeviceMemoryProperties32 *pMemoryProperties;
26420     } *params = args;
26421     VkPhysicalDeviceMemoryProperties pMemoryProperties_host;
26422
26423     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
26424
26425     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pMemoryProperties_host);
26426     convert_VkPhysicalDeviceMemoryProperties_host_to_win32(&pMemoryProperties_host, params->pMemoryProperties);
26427     return STATUS_SUCCESS;
26428 }
26429
26430 #endif /* USE_STRUCT_CONVERSION */
26431
26432 #if !defined(USE_STRUCT_CONVERSION)
26433
26434 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties2(void *args)
26435 {
26436     struct vkGetPhysicalDeviceMemoryProperties2_params *params = args;
26437
26438     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
26439
26440     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
26441     return STATUS_SUCCESS;
26442 }
26443
26444 #else /* USE_STRUCT_CONVERSION */
26445
26446 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties2(void *args)
26447 {
26448     struct
26449     {
26450         VkPhysicalDevice physicalDevice;
26451         VkPhysicalDeviceMemoryProperties232 *pMemoryProperties;
26452     } *params = args;
26453     VkPhysicalDeviceMemoryProperties2 pMemoryProperties_host;
26454     struct conversion_context ctx;
26455
26456     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
26457
26458     init_conversion_context(&ctx);
26459     convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(&ctx, params->pMemoryProperties, &pMemoryProperties_host);
26460     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pMemoryProperties_host);
26461     convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, params->pMemoryProperties);
26462     free_conversion_context(&ctx);
26463     return STATUS_SUCCESS;
26464 }
26465
26466 #endif /* USE_STRUCT_CONVERSION */
26467
26468 #if !defined(USE_STRUCT_CONVERSION)
26469
26470 static NTSTATUS thunk64_vkGetPhysicalDeviceMemoryProperties2KHR(void *args)
26471 {
26472     struct vkGetPhysicalDeviceMemoryProperties2KHR_params *params = args;
26473
26474     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
26475
26476     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pMemoryProperties);
26477     return STATUS_SUCCESS;
26478 }
26479
26480 #else /* USE_STRUCT_CONVERSION */
26481
26482 static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties2KHR(void *args)
26483 {
26484     struct
26485     {
26486         VkPhysicalDevice physicalDevice;
26487         VkPhysicalDeviceMemoryProperties232 *pMemoryProperties;
26488     } *params = args;
26489     VkPhysicalDeviceMemoryProperties2 pMemoryProperties_host;
26490     struct conversion_context ctx;
26491
26492     TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
26493
26494     init_conversion_context(&ctx);
26495     convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(&ctx, params->pMemoryProperties, &pMemoryProperties_host);
26496     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pMemoryProperties_host);
26497     convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, params->pMemoryProperties);
26498     free_conversion_context(&ctx);
26499     return STATUS_SUCCESS;
26500 }
26501
26502 #endif /* USE_STRUCT_CONVERSION */
26503
26504 #if !defined(USE_STRUCT_CONVERSION)
26505
26506 static NTSTATUS thunk64_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)
26507 {
26508     struct vkGetPhysicalDeviceMultisamplePropertiesEXT_params *params = args;
26509
26510     TRACE("%p, %#x, %p\n", params->physicalDevice, params->samples, params->pMultisampleProperties);
26511
26512     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->samples, params->pMultisampleProperties);
26513     return STATUS_SUCCESS;
26514 }
26515
26516 #else /* USE_STRUCT_CONVERSION */
26517
26518 static NTSTATUS thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)
26519 {
26520     struct
26521     {
26522         VkPhysicalDevice physicalDevice;
26523         VkSampleCountFlagBits samples;
26524         VkMultisamplePropertiesEXT *pMultisampleProperties;
26525     } *params = args;
26526
26527     TRACE("%p, %#x, %p\n", params->physicalDevice, params->samples, params->pMultisampleProperties);
26528
26529     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->samples, params->pMultisampleProperties);
26530     return STATUS_SUCCESS;
26531 }
26532
26533 #endif /* USE_STRUCT_CONVERSION */
26534
26535 #if !defined(USE_STRUCT_CONVERSION)
26536
26537 static NTSTATUS thunk64_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
26538 {
26539     struct vkGetPhysicalDeviceOpticalFlowImageFormatsNV_params *params = args;
26540
26541     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
26542
26543     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);
26544     return STATUS_SUCCESS;
26545 }
26546
26547 #else /* USE_STRUCT_CONVERSION */
26548
26549 static NTSTATUS thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
26550 {
26551     struct
26552     {
26553         VkPhysicalDevice physicalDevice;
26554         const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo;
26555         uint32_t *pFormatCount;
26556         VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties;
26557         VkResult result;
26558     } *params = args;
26559
26560     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
26561
26562     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);
26563     return STATUS_SUCCESS;
26564 }
26565
26566 #endif /* USE_STRUCT_CONVERSION */
26567
26568 #if !defined(USE_STRUCT_CONVERSION)
26569
26570 static NTSTATUS thunk64_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
26571 {
26572     struct vkGetPhysicalDevicePresentRectanglesKHR_params *params = args;
26573
26574     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);
26575
26576     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);
26577     return STATUS_SUCCESS;
26578 }
26579
26580 #else /* USE_STRUCT_CONVERSION */
26581
26582 static NTSTATUS thunk32_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
26583 {
26584     struct
26585     {
26586         VkPhysicalDevice physicalDevice;
26587         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
26588         uint32_t *pRectCount;
26589         VkRect2D *pRects;
26590         VkResult result;
26591     } *params = args;
26592
26593     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);
26594
26595     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);
26596     return STATUS_SUCCESS;
26597 }
26598
26599 #endif /* USE_STRUCT_CONVERSION */
26600
26601 #if !defined(USE_STRUCT_CONVERSION)
26602
26603 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties(void *args)
26604 {
26605     struct vkGetPhysicalDeviceProperties_params *params = args;
26606
26607     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
26608
26609     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
26610     return STATUS_SUCCESS;
26611 }
26612
26613 #else /* USE_STRUCT_CONVERSION */
26614
26615 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties(void *args)
26616 {
26617     struct
26618     {
26619         VkPhysicalDevice physicalDevice;
26620         VkPhysicalDeviceProperties32 *pProperties;
26621     } *params = args;
26622     VkPhysicalDeviceProperties pProperties_host;
26623
26624     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
26625
26626     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pProperties_host);
26627     convert_VkPhysicalDeviceProperties_host_to_win32(&pProperties_host, params->pProperties);
26628     return STATUS_SUCCESS;
26629 }
26630
26631 #endif /* USE_STRUCT_CONVERSION */
26632
26633 #if !defined(USE_STRUCT_CONVERSION)
26634
26635 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties2(void *args)
26636 {
26637     struct vkGetPhysicalDeviceProperties2_params *params = args;
26638
26639     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
26640
26641     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
26642     return STATUS_SUCCESS;
26643 }
26644
26645 #else /* USE_STRUCT_CONVERSION */
26646
26647 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2(void *args)
26648 {
26649     struct
26650     {
26651         VkPhysicalDevice physicalDevice;
26652         VkPhysicalDeviceProperties232 *pProperties;
26653     } *params = args;
26654     VkPhysicalDeviceProperties2 pProperties_host;
26655     struct conversion_context ctx;
26656
26657     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
26658
26659     init_conversion_context(&ctx);
26660     convert_VkPhysicalDeviceProperties2_win32_to_host(&ctx, params->pProperties, &pProperties_host);
26661     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pProperties_host);
26662     convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, params->pProperties);
26663     free_conversion_context(&ctx);
26664     return STATUS_SUCCESS;
26665 }
26666
26667 #endif /* USE_STRUCT_CONVERSION */
26668
26669 #if !defined(USE_STRUCT_CONVERSION)
26670
26671 static NTSTATUS thunk64_vkGetPhysicalDeviceProperties2KHR(void *args)
26672 {
26673     struct vkGetPhysicalDeviceProperties2KHR_params *params = args;
26674
26675     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
26676
26677     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pProperties);
26678     return STATUS_SUCCESS;
26679 }
26680
26681 #else /* USE_STRUCT_CONVERSION */
26682
26683 static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2KHR(void *args)
26684 {
26685     struct
26686     {
26687         VkPhysicalDevice physicalDevice;
26688         VkPhysicalDeviceProperties232 *pProperties;
26689     } *params = args;
26690     VkPhysicalDeviceProperties2 pProperties_host;
26691     struct conversion_context ctx;
26692
26693     TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
26694
26695     init_conversion_context(&ctx);
26696     convert_VkPhysicalDeviceProperties2_win32_to_host(&ctx, params->pProperties, &pProperties_host);
26697     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pProperties_host);
26698     convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, params->pProperties);
26699     free_conversion_context(&ctx);
26700     return STATUS_SUCCESS;
26701 }
26702
26703 #endif /* USE_STRUCT_CONVERSION */
26704
26705 #if !defined(USE_STRUCT_CONVERSION)
26706
26707 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(void *args)
26708 {
26709     struct vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_params *params = args;
26710
26711     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPerformanceQueryCreateInfo, params->pNumPasses);
26712
26713     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPerformanceQueryCreateInfo, params->pNumPasses);
26714     return STATUS_SUCCESS;
26715 }
26716
26717 #else /* USE_STRUCT_CONVERSION */
26718
26719 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(void *args)
26720 {
26721     struct
26722     {
26723         VkPhysicalDevice physicalDevice;
26724         const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo;
26725         uint32_t *pNumPasses;
26726     } *params = args;
26727
26728     TRACE("%p, %p, %p\n", params->physicalDevice, params->pPerformanceQueryCreateInfo, params->pNumPasses);
26729
26730     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPerformanceQueryCreateInfo, params->pNumPasses);
26731     return STATUS_SUCCESS;
26732 }
26733
26734 #endif /* USE_STRUCT_CONVERSION */
26735
26736 #if !defined(USE_STRUCT_CONVERSION)
26737
26738 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties(void *args)
26739 {
26740     struct vkGetPhysicalDeviceQueueFamilyProperties_params *params = args;
26741
26742     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
26743
26744     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
26745     return STATUS_SUCCESS;
26746 }
26747
26748 #else /* USE_STRUCT_CONVERSION */
26749
26750 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties(void *args)
26751 {
26752     struct
26753     {
26754         VkPhysicalDevice physicalDevice;
26755         uint32_t *pQueueFamilyPropertyCount;
26756         VkQueueFamilyProperties *pQueueFamilyProperties;
26757     } *params = args;
26758
26759     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
26760
26761     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
26762     return STATUS_SUCCESS;
26763 }
26764
26765 #endif /* USE_STRUCT_CONVERSION */
26766
26767 #if !defined(USE_STRUCT_CONVERSION)
26768
26769 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties2(void *args)
26770 {
26771     struct vkGetPhysicalDeviceQueueFamilyProperties2_params *params = args;
26772
26773     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
26774
26775     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
26776     return STATUS_SUCCESS;
26777 }
26778
26779 #else /* USE_STRUCT_CONVERSION */
26780
26781 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties2(void *args)
26782 {
26783     struct
26784     {
26785         VkPhysicalDevice physicalDevice;
26786         uint32_t *pQueueFamilyPropertyCount;
26787         VkQueueFamilyProperties2 *pQueueFamilyProperties;
26788     } *params = args;
26789
26790     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
26791
26792     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
26793     return STATUS_SUCCESS;
26794 }
26795
26796 #endif /* USE_STRUCT_CONVERSION */
26797
26798 #if !defined(USE_STRUCT_CONVERSION)
26799
26800 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyProperties2KHR(void *args)
26801 {
26802     struct vkGetPhysicalDeviceQueueFamilyProperties2KHR_params *params = args;
26803
26804     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
26805
26806     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
26807     return STATUS_SUCCESS;
26808 }
26809
26810 #else /* USE_STRUCT_CONVERSION */
26811
26812 static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties2KHR(void *args)
26813 {
26814     struct
26815     {
26816         VkPhysicalDevice physicalDevice;
26817         uint32_t *pQueueFamilyPropertyCount;
26818         VkQueueFamilyProperties2 *pQueueFamilyProperties;
26819     } *params = args;
26820
26821     TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
26822
26823     wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
26824     return STATUS_SUCCESS;
26825 }
26826
26827 #endif /* USE_STRUCT_CONVERSION */
26828
26829 #if !defined(USE_STRUCT_CONVERSION)
26830
26831 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties(void *args)
26832 {
26833     struct vkGetPhysicalDeviceSparseImageFormatProperties_params *params = args;
26834
26835     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);
26836
26837     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);
26838     return STATUS_SUCCESS;
26839 }
26840
26841 #else /* USE_STRUCT_CONVERSION */
26842
26843 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties(void *args)
26844 {
26845     struct
26846     {
26847         VkPhysicalDevice physicalDevice;
26848         VkFormat format;
26849         VkImageType type;
26850         VkSampleCountFlagBits samples;
26851         VkImageUsageFlags usage;
26852         VkImageTiling tiling;
26853         uint32_t *pPropertyCount;
26854         VkSparseImageFormatProperties *pProperties;
26855     } *params = args;
26856
26857     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);
26858
26859     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);
26860     return STATUS_SUCCESS;
26861 }
26862
26863 #endif /* USE_STRUCT_CONVERSION */
26864
26865 #if !defined(USE_STRUCT_CONVERSION)
26866
26867 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2(void *args)
26868 {
26869     struct vkGetPhysicalDeviceSparseImageFormatProperties2_params *params = args;
26870
26871     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
26872
26873     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);
26874     return STATUS_SUCCESS;
26875 }
26876
26877 #else /* USE_STRUCT_CONVERSION */
26878
26879 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2(void *args)
26880 {
26881     struct
26882     {
26883         VkPhysicalDevice physicalDevice;
26884         const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo;
26885         uint32_t *pPropertyCount;
26886         VkSparseImageFormatProperties2 *pProperties;
26887     } *params = args;
26888
26889     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
26890
26891     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);
26892     return STATUS_SUCCESS;
26893 }
26894
26895 #endif /* USE_STRUCT_CONVERSION */
26896
26897 #if !defined(USE_STRUCT_CONVERSION)
26898
26899 static NTSTATUS thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void *args)
26900 {
26901     struct vkGetPhysicalDeviceSparseImageFormatProperties2KHR_params *params = args;
26902
26903     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
26904
26905     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);
26906     return STATUS_SUCCESS;
26907 }
26908
26909 #else /* USE_STRUCT_CONVERSION */
26910
26911 static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void *args)
26912 {
26913     struct
26914     {
26915         VkPhysicalDevice physicalDevice;
26916         const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo;
26917         uint32_t *pPropertyCount;
26918         VkSparseImageFormatProperties2 *pProperties;
26919     } *params = args;
26920
26921     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
26922
26923     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);
26924     return STATUS_SUCCESS;
26925 }
26926
26927 #endif /* USE_STRUCT_CONVERSION */
26928
26929 #if !defined(USE_STRUCT_CONVERSION)
26930
26931 static NTSTATUS thunk64_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(void *args)
26932 {
26933     struct vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_params *params = args;
26934
26935     TRACE("%p, %p, %p\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);
26936
26937     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);
26938     return STATUS_SUCCESS;
26939 }
26940
26941 #else /* USE_STRUCT_CONVERSION */
26942
26943 static NTSTATUS thunk32_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(void *args)
26944 {
26945     struct
26946     {
26947         VkPhysicalDevice physicalDevice;
26948         uint32_t *pCombinationCount;
26949         VkFramebufferMixedSamplesCombinationNV *pCombinations;
26950         VkResult result;
26951     } *params = args;
26952
26953     TRACE("%p, %p, %p\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);
26954
26955     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);
26956     return STATUS_SUCCESS;
26957 }
26958
26959 #endif /* USE_STRUCT_CONVERSION */
26960
26961 #if !defined(USE_STRUCT_CONVERSION)
26962
26963 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
26964 {
26965     struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params *params = args;
26966
26967     TRACE("%p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
26968
26969     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
26970     return STATUS_SUCCESS;
26971 }
26972
26973 #else /* USE_STRUCT_CONVERSION */
26974
26975 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
26976 {
26977     struct
26978     {
26979         VkPhysicalDevice physicalDevice;
26980         const VkPhysicalDeviceSurfaceInfo2KHR32 *pSurfaceInfo;
26981         VkSurfaceCapabilities2KHR *pSurfaceCapabilities;
26982         VkResult result;
26983     } *params = args;
26984     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
26985
26986     TRACE("%p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
26987
26988     convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(params->pSurfaceInfo, &pSurfaceInfo_host);
26989     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(params->physicalDevice, &pSurfaceInfo_host, params->pSurfaceCapabilities);
26990     return STATUS_SUCCESS;
26991 }
26992
26993 #endif /* USE_STRUCT_CONVERSION */
26994
26995 #if !defined(USE_STRUCT_CONVERSION)
26996
26997 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
26998 {
26999     struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params *params = args;
27000
27001     TRACE("%p, 0x%s, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);
27002
27003     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(params->physicalDevice, params->surface, params->pSurfaceCapabilities);
27004     return STATUS_SUCCESS;
27005 }
27006
27007 #else /* USE_STRUCT_CONVERSION */
27008
27009 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
27010 {
27011     struct
27012     {
27013         VkPhysicalDevice physicalDevice;
27014         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
27015         VkSurfaceCapabilitiesKHR *pSurfaceCapabilities;
27016         VkResult result;
27017     } *params = args;
27018
27019     TRACE("%p, 0x%s, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);
27020
27021     params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(params->physicalDevice, params->surface, params->pSurfaceCapabilities);
27022     return STATUS_SUCCESS;
27023 }
27024
27025 #endif /* USE_STRUCT_CONVERSION */
27026
27027 #if !defined(USE_STRUCT_CONVERSION)
27028
27029 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
27030 {
27031     struct vkGetPhysicalDeviceSurfaceFormats2KHR_params *params = args;
27032     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
27033
27034     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);
27035
27036     convert_VkPhysicalDeviceSurfaceInfo2KHR_win64_to_host(params->pSurfaceInfo, &pSurfaceInfo_host);
27037     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);
27038     return STATUS_SUCCESS;
27039 }
27040
27041 #else /* USE_STRUCT_CONVERSION */
27042
27043 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
27044 {
27045     struct
27046     {
27047         VkPhysicalDevice physicalDevice;
27048         const VkPhysicalDeviceSurfaceInfo2KHR32 *pSurfaceInfo;
27049         uint32_t *pSurfaceFormatCount;
27050         VkSurfaceFormat2KHR *pSurfaceFormats;
27051         VkResult result;
27052     } *params = args;
27053     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
27054
27055     TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);
27056
27057     convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host(params->pSurfaceInfo, &pSurfaceInfo_host);
27058     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);
27059     return STATUS_SUCCESS;
27060 }
27061
27062 #endif /* USE_STRUCT_CONVERSION */
27063
27064 #if !defined(USE_STRUCT_CONVERSION)
27065
27066 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
27067 {
27068     struct vkGetPhysicalDeviceSurfaceFormatsKHR_params *params = args;
27069
27070     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);
27071
27072     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);
27073     return STATUS_SUCCESS;
27074 }
27075
27076 #else /* USE_STRUCT_CONVERSION */
27077
27078 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
27079 {
27080     struct
27081     {
27082         VkPhysicalDevice physicalDevice;
27083         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
27084         uint32_t *pSurfaceFormatCount;
27085         VkSurfaceFormatKHR *pSurfaceFormats;
27086         VkResult result;
27087     } *params = args;
27088
27089     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);
27090
27091     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);
27092     return STATUS_SUCCESS;
27093 }
27094
27095 #endif /* USE_STRUCT_CONVERSION */
27096
27097 #if !defined(USE_STRUCT_CONVERSION)
27098
27099 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
27100 {
27101     struct vkGetPhysicalDeviceSurfacePresentModesKHR_params *params = args;
27102
27103     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);
27104
27105     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);
27106     return STATUS_SUCCESS;
27107 }
27108
27109 #else /* USE_STRUCT_CONVERSION */
27110
27111 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
27112 {
27113     struct
27114     {
27115         VkPhysicalDevice physicalDevice;
27116         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
27117         uint32_t *pPresentModeCount;
27118         VkPresentModeKHR *pPresentModes;
27119         VkResult result;
27120     } *params = args;
27121
27122     TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);
27123
27124     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);
27125     return STATUS_SUCCESS;
27126 }
27127
27128 #endif /* USE_STRUCT_CONVERSION */
27129
27130 #if !defined(USE_STRUCT_CONVERSION)
27131
27132 static NTSTATUS thunk64_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
27133 {
27134     struct vkGetPhysicalDeviceSurfaceSupportKHR_params *params = args;
27135
27136     TRACE("%p, %u, 0x%s, %p\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);
27137
27138     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);
27139     return STATUS_SUCCESS;
27140 }
27141
27142 #else /* USE_STRUCT_CONVERSION */
27143
27144 static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
27145 {
27146     struct
27147     {
27148         VkPhysicalDevice physicalDevice;
27149         uint32_t queueFamilyIndex;
27150         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
27151         VkBool32 *pSupported;
27152         VkResult result;
27153     } *params = args;
27154
27155     TRACE("%p, %u, 0x%s, %p\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);
27156
27157     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);
27158     return STATUS_SUCCESS;
27159 }
27160
27161 #endif /* USE_STRUCT_CONVERSION */
27162
27163 #if !defined(USE_STRUCT_CONVERSION)
27164
27165 static NTSTATUS thunk64_vkGetPhysicalDeviceToolProperties(void *args)
27166 {
27167     struct vkGetPhysicalDeviceToolProperties_params *params = args;
27168
27169     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
27170
27171     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);
27172     return STATUS_SUCCESS;
27173 }
27174
27175 #else /* USE_STRUCT_CONVERSION */
27176
27177 static NTSTATUS thunk32_vkGetPhysicalDeviceToolProperties(void *args)
27178 {
27179     struct
27180     {
27181         VkPhysicalDevice physicalDevice;
27182         uint32_t *pToolCount;
27183         VkPhysicalDeviceToolProperties *pToolProperties;
27184         VkResult result;
27185     } *params = args;
27186
27187     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
27188
27189     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);
27190     return STATUS_SUCCESS;
27191 }
27192
27193 #endif /* USE_STRUCT_CONVERSION */
27194
27195 #if !defined(USE_STRUCT_CONVERSION)
27196
27197 static NTSTATUS thunk64_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
27198 {
27199     struct vkGetPhysicalDeviceToolPropertiesEXT_params *params = args;
27200
27201     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
27202
27203     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);
27204     return STATUS_SUCCESS;
27205 }
27206
27207 #else /* USE_STRUCT_CONVERSION */
27208
27209 static NTSTATUS thunk32_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
27210 {
27211     struct
27212     {
27213         VkPhysicalDevice physicalDevice;
27214         uint32_t *pToolCount;
27215         VkPhysicalDeviceToolProperties *pToolProperties;
27216         VkResult result;
27217     } *params = args;
27218
27219     TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
27220
27221     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);
27222     return STATUS_SUCCESS;
27223 }
27224
27225 #endif /* USE_STRUCT_CONVERSION */
27226
27227 #if !defined(USE_STRUCT_CONVERSION)
27228
27229 static NTSTATUS thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *args)
27230 {
27231     struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params *params = args;
27232
27233     TRACE("%p, %u\n", params->physicalDevice, params->queueFamilyIndex);
27234
27235     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex);
27236     return STATUS_SUCCESS;
27237 }
27238
27239 #else /* USE_STRUCT_CONVERSION */
27240
27241 static NTSTATUS thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *args)
27242 {
27243     struct
27244     {
27245         VkPhysicalDevice physicalDevice;
27246         uint32_t queueFamilyIndex;
27247         VkBool32 result;
27248     } *params = args;
27249
27250     TRACE("%p, %u\n", params->physicalDevice, params->queueFamilyIndex);
27251
27252     params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex);
27253     return STATUS_SUCCESS;
27254 }
27255
27256 #endif /* USE_STRUCT_CONVERSION */
27257
27258 #if !defined(USE_STRUCT_CONVERSION)
27259
27260 static NTSTATUS thunk64_vkGetPipelineCacheData(void *args)
27261 {
27262     struct vkGetPipelineCacheData_params *params = args;
27263
27264     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);
27265
27266     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineCacheData(wine_device_from_handle(params->device)->device, params->pipelineCache, params->pDataSize, params->pData);
27267     return STATUS_SUCCESS;
27268 }
27269
27270 #else /* USE_STRUCT_CONVERSION */
27271
27272 static NTSTATUS thunk32_vkGetPipelineCacheData(void *args)
27273 {
27274     struct
27275     {
27276         VkDevice device;
27277         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
27278         size_t *pDataSize;
27279         void *pData;
27280         VkResult result;
27281     } *params = args;
27282
27283     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);
27284
27285     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineCacheData(wine_device_from_handle(params->device)->device, params->pipelineCache, params->pDataSize, params->pData);
27286     return STATUS_SUCCESS;
27287 }
27288
27289 #endif /* USE_STRUCT_CONVERSION */
27290
27291 #if !defined(USE_STRUCT_CONVERSION)
27292
27293 static NTSTATUS thunk64_vkGetPipelineExecutableInternalRepresentationsKHR(void *args)
27294 {
27295     struct vkGetPipelineExecutableInternalRepresentationsKHR_params *params = args;
27296
27297     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
27298
27299     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
27300     return STATUS_SUCCESS;
27301 }
27302
27303 #else /* USE_STRUCT_CONVERSION */
27304
27305 static NTSTATUS thunk32_vkGetPipelineExecutableInternalRepresentationsKHR(void *args)
27306 {
27307     struct
27308     {
27309         VkDevice device;
27310         const VkPipelineExecutableInfoKHR32 *pExecutableInfo;
27311         uint32_t *pInternalRepresentationCount;
27312         VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations;
27313         VkResult result;
27314     } *params = args;
27315     VkPipelineExecutableInfoKHR pExecutableInfo_host;
27316
27317     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
27318
27319     convert_VkPipelineExecutableInfoKHR_win32_to_host(params->pExecutableInfo, &pExecutableInfo_host);
27320     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle(params->device)->device, &pExecutableInfo_host, params->pInternalRepresentationCount, params->pInternalRepresentations);
27321     return STATUS_SUCCESS;
27322 }
27323
27324 #endif /* USE_STRUCT_CONVERSION */
27325
27326 #if !defined(USE_STRUCT_CONVERSION)
27327
27328 static NTSTATUS thunk64_vkGetPipelineExecutablePropertiesKHR(void *args)
27329 {
27330     struct vkGetPipelineExecutablePropertiesKHR_params *params = args;
27331
27332     TRACE("%p, %p, %p, %p\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
27333
27334     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
27335     return STATUS_SUCCESS;
27336 }
27337
27338 #else /* USE_STRUCT_CONVERSION */
27339
27340 static NTSTATUS thunk32_vkGetPipelineExecutablePropertiesKHR(void *args)
27341 {
27342     struct
27343     {
27344         VkDevice device;
27345         const VkPipelineInfoKHR32 *pPipelineInfo;
27346         uint32_t *pExecutableCount;
27347         VkPipelineExecutablePropertiesKHR *pProperties;
27348         VkResult result;
27349     } *params = args;
27350     VkPipelineInfoKHR pPipelineInfo_host;
27351
27352     TRACE("%p, %p, %p, %p\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
27353
27354     convert_VkPipelineInfoKHR_win32_to_host(params->pPipelineInfo, &pPipelineInfo_host);
27355     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle(params->device)->device, &pPipelineInfo_host, params->pExecutableCount, params->pProperties);
27356     return STATUS_SUCCESS;
27357 }
27358
27359 #endif /* USE_STRUCT_CONVERSION */
27360
27361 #if !defined(USE_STRUCT_CONVERSION)
27362
27363 static NTSTATUS thunk64_vkGetPipelineExecutableStatisticsKHR(void *args)
27364 {
27365     struct vkGetPipelineExecutableStatisticsKHR_params *params = args;
27366
27367     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
27368
27369     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle(params->device)->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
27370     return STATUS_SUCCESS;
27371 }
27372
27373 #else /* USE_STRUCT_CONVERSION */
27374
27375 static NTSTATUS thunk32_vkGetPipelineExecutableStatisticsKHR(void *args)
27376 {
27377     struct
27378     {
27379         VkDevice device;
27380         const VkPipelineExecutableInfoKHR32 *pExecutableInfo;
27381         uint32_t *pStatisticCount;
27382         VkPipelineExecutableStatisticKHR32 *pStatistics;
27383         VkResult result;
27384     } *params = args;
27385     VkPipelineExecutableInfoKHR pExecutableInfo_host;
27386     VkPipelineExecutableStatisticKHR *pStatistics_host;
27387     struct conversion_context ctx;
27388
27389     TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
27390
27391     init_conversion_context(&ctx);
27392     convert_VkPipelineExecutableInfoKHR_win32_to_host(params->pExecutableInfo, &pExecutableInfo_host);
27393     pStatistics_host = convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(&ctx, params->pStatistics, *params->pStatisticCount);
27394     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle(params->device)->device, &pExecutableInfo_host, params->pStatisticCount, pStatistics_host);
27395     convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(pStatistics_host, params->pStatistics, *params->pStatisticCount);
27396     free_conversion_context(&ctx);
27397     return STATUS_SUCCESS;
27398 }
27399
27400 #endif /* USE_STRUCT_CONVERSION */
27401
27402 #if !defined(USE_STRUCT_CONVERSION)
27403
27404 static NTSTATUS thunk64_vkGetPipelinePropertiesEXT(void *args)
27405 {
27406     struct vkGetPipelinePropertiesEXT_params *params = args;
27407
27408     TRACE("%p, %p, %p\n", params->device, params->pPipelineInfo, params->pPipelineProperties);
27409
27410     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle(params->device)->device, params->pPipelineInfo, params->pPipelineProperties);
27411     return STATUS_SUCCESS;
27412 }
27413
27414 #else /* USE_STRUCT_CONVERSION */
27415
27416 static NTSTATUS thunk32_vkGetPipelinePropertiesEXT(void *args)
27417 {
27418     struct
27419     {
27420         VkDevice device;
27421         const VkPipelineInfoEXT32 *pPipelineInfo;
27422         VkBaseOutStructure *pPipelineProperties;
27423         VkResult result;
27424     } *params = args;
27425     VkPipelineInfoEXT pPipelineInfo_host;
27426
27427     TRACE("%p, %p, %p\n", params->device, params->pPipelineInfo, params->pPipelineProperties);
27428
27429     convert_VkPipelineInfoEXT_win32_to_host(params->pPipelineInfo, &pPipelineInfo_host);
27430     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle(params->device)->device, &pPipelineInfo_host, params->pPipelineProperties);
27431     return STATUS_SUCCESS;
27432 }
27433
27434 #endif /* USE_STRUCT_CONVERSION */
27435
27436 #if !defined(USE_STRUCT_CONVERSION)
27437
27438 static NTSTATUS thunk64_vkGetPrivateData(void *args)
27439 {
27440     struct vkGetPrivateData_params *params = args;
27441
27442     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);
27443
27444     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);
27445     return STATUS_SUCCESS;
27446 }
27447
27448 #else /* USE_STRUCT_CONVERSION */
27449
27450 static NTSTATUS thunk32_vkGetPrivateData(void *args)
27451 {
27452     struct
27453     {
27454         VkDevice device;
27455         VkObjectType objectType;
27456         uint64_t DECLSPEC_ALIGN(8) objectHandle;
27457         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
27458         uint64_t *pData;
27459     } *params = args;
27460
27461     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);
27462
27463     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);
27464     return STATUS_SUCCESS;
27465 }
27466
27467 #endif /* USE_STRUCT_CONVERSION */
27468
27469 #if !defined(USE_STRUCT_CONVERSION)
27470
27471 static NTSTATUS thunk64_vkGetPrivateDataEXT(void *args)
27472 {
27473     struct vkGetPrivateDataEXT_params *params = args;
27474
27475     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);
27476
27477     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);
27478     return STATUS_SUCCESS;
27479 }
27480
27481 #else /* USE_STRUCT_CONVERSION */
27482
27483 static NTSTATUS thunk32_vkGetPrivateDataEXT(void *args)
27484 {
27485     struct
27486     {
27487         VkDevice device;
27488         VkObjectType objectType;
27489         uint64_t DECLSPEC_ALIGN(8) objectHandle;
27490         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
27491         uint64_t *pData;
27492     } *params = args;
27493
27494     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);
27495
27496     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);
27497     return STATUS_SUCCESS;
27498 }
27499
27500 #endif /* USE_STRUCT_CONVERSION */
27501
27502 #if !defined(USE_STRUCT_CONVERSION)
27503
27504 static NTSTATUS thunk64_vkGetQueryPoolResults(void *args)
27505 {
27506     struct vkGetQueryPoolResults_params *params = args;
27507
27508     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);
27509
27510     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);
27511     return STATUS_SUCCESS;
27512 }
27513
27514 #else /* USE_STRUCT_CONVERSION */
27515
27516 static NTSTATUS thunk32_vkGetQueryPoolResults(void *args)
27517 {
27518     struct
27519     {
27520         VkDevice device;
27521         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
27522         uint32_t firstQuery;
27523         uint32_t queryCount;
27524         size_t dataSize;
27525         void *pData;
27526         VkDeviceSize DECLSPEC_ALIGN(8) stride;
27527         VkQueryResultFlags flags;
27528         VkResult result;
27529     } *params = args;
27530
27531     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);
27532
27533     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);
27534     return STATUS_SUCCESS;
27535 }
27536
27537 #endif /* USE_STRUCT_CONVERSION */
27538
27539 #if !defined(USE_STRUCT_CONVERSION)
27540
27541 static NTSTATUS thunk64_vkGetQueueCheckpointData2NV(void *args)
27542 {
27543     struct vkGetQueueCheckpointData2NV_params *params = args;
27544
27545     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
27546
27547     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointData2NV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, params->pCheckpointData);
27548     return STATUS_SUCCESS;
27549 }
27550
27551 #else /* USE_STRUCT_CONVERSION */
27552
27553 static NTSTATUS thunk32_vkGetQueueCheckpointData2NV(void *args)
27554 {
27555     struct
27556     {
27557         VkQueue queue;
27558         uint32_t *pCheckpointDataCount;
27559         VkCheckpointData2NV *pCheckpointData;
27560     } *params = args;
27561
27562     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
27563
27564     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointData2NV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, params->pCheckpointData);
27565     return STATUS_SUCCESS;
27566 }
27567
27568 #endif /* USE_STRUCT_CONVERSION */
27569
27570 #if !defined(USE_STRUCT_CONVERSION)
27571
27572 static NTSTATUS thunk64_vkGetQueueCheckpointDataNV(void *args)
27573 {
27574     struct vkGetQueueCheckpointDataNV_params *params = args;
27575
27576     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
27577
27578     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointDataNV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, params->pCheckpointData);
27579     return STATUS_SUCCESS;
27580 }
27581
27582 #else /* USE_STRUCT_CONVERSION */
27583
27584 static NTSTATUS thunk32_vkGetQueueCheckpointDataNV(void *args)
27585 {
27586     struct
27587     {
27588         VkQueue queue;
27589         uint32_t *pCheckpointDataCount;
27590         VkCheckpointDataNV *pCheckpointData;
27591     } *params = args;
27592
27593     TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
27594
27595     wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointDataNV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, params->pCheckpointData);
27596     return STATUS_SUCCESS;
27597 }
27598
27599 #endif /* USE_STRUCT_CONVERSION */
27600
27601 #if !defined(USE_STRUCT_CONVERSION)
27602
27603 static NTSTATUS thunk64_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *args)
27604 {
27605     struct vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_params *params = args;
27606
27607     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);
27608
27609     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);
27610     return STATUS_SUCCESS;
27611 }
27612
27613 #else /* USE_STRUCT_CONVERSION */
27614
27615 static NTSTATUS thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *args)
27616 {
27617     struct
27618     {
27619         VkDevice device;
27620         VkPipeline DECLSPEC_ALIGN(8) pipeline;
27621         uint32_t firstGroup;
27622         uint32_t groupCount;
27623         size_t dataSize;
27624         void *pData;
27625         VkResult result;
27626     } *params = args;
27627
27628     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);
27629
27630     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);
27631     return STATUS_SUCCESS;
27632 }
27633
27634 #endif /* USE_STRUCT_CONVERSION */
27635
27636 #if !defined(USE_STRUCT_CONVERSION)
27637
27638 static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesKHR(void *args)
27639 {
27640     struct vkGetRayTracingShaderGroupHandlesKHR_params *params = args;
27641
27642     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);
27643
27644     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);
27645     return STATUS_SUCCESS;
27646 }
27647
27648 #else /* USE_STRUCT_CONVERSION */
27649
27650 static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesKHR(void *args)
27651 {
27652     struct
27653     {
27654         VkDevice device;
27655         VkPipeline DECLSPEC_ALIGN(8) pipeline;
27656         uint32_t firstGroup;
27657         uint32_t groupCount;
27658         size_t dataSize;
27659         void *pData;
27660         VkResult result;
27661     } *params = args;
27662
27663     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);
27664
27665     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);
27666     return STATUS_SUCCESS;
27667 }
27668
27669 #endif /* USE_STRUCT_CONVERSION */
27670
27671 #if !defined(USE_STRUCT_CONVERSION)
27672
27673 static NTSTATUS thunk64_vkGetRayTracingShaderGroupHandlesNV(void *args)
27674 {
27675     struct vkGetRayTracingShaderGroupHandlesNV_params *params = args;
27676
27677     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);
27678
27679     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);
27680     return STATUS_SUCCESS;
27681 }
27682
27683 #else /* USE_STRUCT_CONVERSION */
27684
27685 static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesNV(void *args)
27686 {
27687     struct
27688     {
27689         VkDevice device;
27690         VkPipeline DECLSPEC_ALIGN(8) pipeline;
27691         uint32_t firstGroup;
27692         uint32_t groupCount;
27693         size_t dataSize;
27694         void *pData;
27695         VkResult result;
27696     } *params = args;
27697
27698     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);
27699
27700     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);
27701     return STATUS_SUCCESS;
27702 }
27703
27704 #endif /* USE_STRUCT_CONVERSION */
27705
27706 #if !defined(USE_STRUCT_CONVERSION)
27707
27708 static NTSTATUS thunk64_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
27709 {
27710     struct vkGetRayTracingShaderGroupStackSizeKHR_params *params = args;
27711
27712     TRACE("%p, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);
27713
27714     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->group, params->groupShader);
27715     return STATUS_SUCCESS;
27716 }
27717
27718 #else /* USE_STRUCT_CONVERSION */
27719
27720 static NTSTATUS thunk32_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
27721 {
27722     struct
27723     {
27724         VkDevice device;
27725         VkPipeline DECLSPEC_ALIGN(8) pipeline;
27726         uint32_t group;
27727         VkShaderGroupShaderKHR groupShader;
27728         VkDeviceSize result;
27729     } *params = args;
27730
27731     TRACE("%p, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);
27732
27733     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->group, params->groupShader);
27734     return STATUS_SUCCESS;
27735 }
27736
27737 #endif /* USE_STRUCT_CONVERSION */
27738
27739 #if !defined(USE_STRUCT_CONVERSION)
27740
27741 static NTSTATUS thunk64_vkGetRenderAreaGranularity(void *args)
27742 {
27743     struct vkGetRenderAreaGranularity_params *params = args;
27744
27745     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pGranularity);
27746
27747     wine_device_from_handle(params->device)->funcs.p_vkGetRenderAreaGranularity(wine_device_from_handle(params->device)->device, params->renderPass, params->pGranularity);
27748     return STATUS_SUCCESS;
27749 }
27750
27751 #else /* USE_STRUCT_CONVERSION */
27752
27753 static NTSTATUS thunk32_vkGetRenderAreaGranularity(void *args)
27754 {
27755     struct
27756     {
27757         VkDevice device;
27758         VkRenderPass DECLSPEC_ALIGN(8) renderPass;
27759         VkExtent2D *pGranularity;
27760     } *params = args;
27761
27762     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pGranularity);
27763
27764     wine_device_from_handle(params->device)->funcs.p_vkGetRenderAreaGranularity(wine_device_from_handle(params->device)->device, params->renderPass, params->pGranularity);
27765     return STATUS_SUCCESS;
27766 }
27767
27768 #endif /* USE_STRUCT_CONVERSION */
27769
27770 #if !defined(USE_STRUCT_CONVERSION)
27771
27772 static NTSTATUS thunk64_vkGetSemaphoreCounterValue(void *args)
27773 {
27774     struct vkGetSemaphoreCounterValue_params *params = args;
27775
27776     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
27777
27778     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
27779     return STATUS_SUCCESS;
27780 }
27781
27782 #else /* USE_STRUCT_CONVERSION */
27783
27784 static NTSTATUS thunk32_vkGetSemaphoreCounterValue(void *args)
27785 {
27786     struct
27787     {
27788         VkDevice device;
27789         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
27790         uint64_t *pValue;
27791         VkResult result;
27792     } *params = args;
27793
27794     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
27795
27796     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
27797     return STATUS_SUCCESS;
27798 }
27799
27800 #endif /* USE_STRUCT_CONVERSION */
27801
27802 #if !defined(USE_STRUCT_CONVERSION)
27803
27804 static NTSTATUS thunk64_vkGetSemaphoreCounterValueKHR(void *args)
27805 {
27806     struct vkGetSemaphoreCounterValueKHR_params *params = args;
27807
27808     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
27809
27810     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
27811     return STATUS_SUCCESS;
27812 }
27813
27814 #else /* USE_STRUCT_CONVERSION */
27815
27816 static NTSTATUS thunk32_vkGetSemaphoreCounterValueKHR(void *args)
27817 {
27818     struct
27819     {
27820         VkDevice device;
27821         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
27822         uint64_t *pValue;
27823         VkResult result;
27824     } *params = args;
27825
27826     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
27827
27828     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
27829     return STATUS_SUCCESS;
27830 }
27831
27832 #endif /* USE_STRUCT_CONVERSION */
27833
27834 #if !defined(USE_STRUCT_CONVERSION)
27835
27836 static NTSTATUS thunk64_vkGetShaderInfoAMD(void *args)
27837 {
27838     struct vkGetShaderInfoAMD_params *params = args;
27839
27840     TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
27841
27842     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);
27843     return STATUS_SUCCESS;
27844 }
27845
27846 #else /* USE_STRUCT_CONVERSION */
27847
27848 static NTSTATUS thunk32_vkGetShaderInfoAMD(void *args)
27849 {
27850     struct
27851     {
27852         VkDevice device;
27853         VkPipeline DECLSPEC_ALIGN(8) pipeline;
27854         VkShaderStageFlagBits shaderStage;
27855         VkShaderInfoTypeAMD infoType;
27856         size_t *pInfoSize;
27857         void *pInfo;
27858         VkResult result;
27859     } *params = args;
27860
27861     TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
27862
27863     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);
27864     return STATUS_SUCCESS;
27865 }
27866
27867 #endif /* USE_STRUCT_CONVERSION */
27868
27869 #if !defined(USE_STRUCT_CONVERSION)
27870
27871 static NTSTATUS thunk64_vkGetShaderModuleCreateInfoIdentifierEXT(void *args)
27872 {
27873     struct vkGetShaderModuleCreateInfoIdentifierEXT_params *params = args;
27874
27875     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pIdentifier);
27876
27877     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleCreateInfoIdentifierEXT(wine_device_from_handle(params->device)->device, params->pCreateInfo, params->pIdentifier);
27878     return STATUS_SUCCESS;
27879 }
27880
27881 #else /* USE_STRUCT_CONVERSION */
27882
27883 static NTSTATUS thunk32_vkGetShaderModuleCreateInfoIdentifierEXT(void *args)
27884 {
27885     struct
27886     {
27887         VkDevice device;
27888         const VkShaderModuleCreateInfo *pCreateInfo;
27889         VkShaderModuleIdentifierEXT *pIdentifier;
27890     } *params = args;
27891     VkShaderModuleCreateInfo pCreateInfo_host;
27892     struct conversion_context ctx;
27893
27894     TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pIdentifier);
27895
27896     init_conversion_context(&ctx);
27897     convert_VkShaderModuleCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
27898     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleCreateInfoIdentifierEXT(wine_device_from_handle(params->device)->device, &pCreateInfo_host, params->pIdentifier);
27899     free_conversion_context(&ctx);
27900     return STATUS_SUCCESS;
27901 }
27902
27903 #endif /* USE_STRUCT_CONVERSION */
27904
27905 #if !defined(USE_STRUCT_CONVERSION)
27906
27907 static NTSTATUS thunk64_vkGetShaderModuleIdentifierEXT(void *args)
27908 {
27909     struct vkGetShaderModuleIdentifierEXT_params *params = args;
27910
27911     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pIdentifier);
27912
27913     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleIdentifierEXT(wine_device_from_handle(params->device)->device, params->shaderModule, params->pIdentifier);
27914     return STATUS_SUCCESS;
27915 }
27916
27917 #else /* USE_STRUCT_CONVERSION */
27918
27919 static NTSTATUS thunk32_vkGetShaderModuleIdentifierEXT(void *args)
27920 {
27921     struct
27922     {
27923         VkDevice device;
27924         VkShaderModule DECLSPEC_ALIGN(8) shaderModule;
27925         VkShaderModuleIdentifierEXT *pIdentifier;
27926     } *params = args;
27927
27928     TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pIdentifier);
27929
27930     wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleIdentifierEXT(wine_device_from_handle(params->device)->device, params->shaderModule, params->pIdentifier);
27931     return STATUS_SUCCESS;
27932 }
27933
27934 #endif /* USE_STRUCT_CONVERSION */
27935
27936 #if !defined(USE_STRUCT_CONVERSION)
27937
27938 static NTSTATUS thunk64_vkGetSwapchainImagesKHR(void *args)
27939 {
27940     struct vkGetSwapchainImagesKHR_params *params = args;
27941
27942     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);
27943
27944     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->pSwapchainImageCount, params->pSwapchainImages);
27945     return STATUS_SUCCESS;
27946 }
27947
27948 #else /* USE_STRUCT_CONVERSION */
27949
27950 static NTSTATUS thunk32_vkGetSwapchainImagesKHR(void *args)
27951 {
27952     struct
27953     {
27954         VkDevice device;
27955         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
27956         uint32_t *pSwapchainImageCount;
27957         VkImage *pSwapchainImages;
27958         VkResult result;
27959     } *params = args;
27960
27961     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);
27962
27963     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->pSwapchainImageCount, params->pSwapchainImages);
27964     return STATUS_SUCCESS;
27965 }
27966
27967 #endif /* USE_STRUCT_CONVERSION */
27968
27969 #if !defined(USE_STRUCT_CONVERSION)
27970
27971 static NTSTATUS thunk64_vkGetValidationCacheDataEXT(void *args)
27972 {
27973     struct vkGetValidationCacheDataEXT_params *params = args;
27974
27975     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);
27976
27977     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle(params->device)->device, params->validationCache, params->pDataSize, params->pData);
27978     return STATUS_SUCCESS;
27979 }
27980
27981 #else /* USE_STRUCT_CONVERSION */
27982
27983 static NTSTATUS thunk32_vkGetValidationCacheDataEXT(void *args)
27984 {
27985     struct
27986     {
27987         VkDevice device;
27988         VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
27989         size_t *pDataSize;
27990         void *pData;
27991         VkResult result;
27992     } *params = args;
27993
27994     TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);
27995
27996     params->result = wine_device_from_handle(params->device)->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle(params->device)->device, params->validationCache, params->pDataSize, params->pData);
27997     return STATUS_SUCCESS;
27998 }
27999
28000 #endif /* USE_STRUCT_CONVERSION */
28001
28002 #if !defined(USE_STRUCT_CONVERSION)
28003
28004 static NTSTATUS thunk64_vkInitializePerformanceApiINTEL(void *args)
28005 {
28006     struct vkInitializePerformanceApiINTEL_params *params = args;
28007
28008     TRACE("%p, %p\n", params->device, params->pInitializeInfo);
28009
28010     params->result = wine_device_from_handle(params->device)->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device, params->pInitializeInfo);
28011     return STATUS_SUCCESS;
28012 }
28013
28014 #else /* USE_STRUCT_CONVERSION */
28015
28016 static NTSTATUS thunk32_vkInitializePerformanceApiINTEL(void *args)
28017 {
28018     struct
28019     {
28020         VkDevice device;
28021         const VkInitializePerformanceApiInfoINTEL *pInitializeInfo;
28022         VkResult result;
28023     } *params = args;
28024
28025     TRACE("%p, %p\n", params->device, params->pInitializeInfo);
28026
28027     params->result = wine_device_from_handle(params->device)->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device, params->pInitializeInfo);
28028     return STATUS_SUCCESS;
28029 }
28030
28031 #endif /* USE_STRUCT_CONVERSION */
28032
28033 #if !defined(USE_STRUCT_CONVERSION)
28034
28035 static NTSTATUS thunk64_vkInvalidateMappedMemoryRanges(void *args)
28036 {
28037     struct vkInvalidateMappedMemoryRanges_params *params = args;
28038
28039     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
28040
28041     params->result = wine_device_from_handle(params->device)->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, params->pMemoryRanges);
28042     return STATUS_SUCCESS;
28043 }
28044
28045 #else /* USE_STRUCT_CONVERSION */
28046
28047 static NTSTATUS thunk32_vkInvalidateMappedMemoryRanges(void *args)
28048 {
28049     struct
28050     {
28051         VkDevice device;
28052         uint32_t memoryRangeCount;
28053         const VkMappedMemoryRange32 *pMemoryRanges;
28054         VkResult result;
28055     } *params = args;
28056     const VkMappedMemoryRange *pMemoryRanges_host;
28057     struct conversion_context ctx;
28058
28059     TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
28060
28061     init_conversion_context(&ctx);
28062     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(&ctx, params->pMemoryRanges, params->memoryRangeCount);
28063     params->result = wine_device_from_handle(params->device)->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
28064     free_conversion_context(&ctx);
28065     return STATUS_SUCCESS;
28066 }
28067
28068 #endif /* USE_STRUCT_CONVERSION */
28069
28070 #if !defined(USE_STRUCT_CONVERSION)
28071
28072 static NTSTATUS thunk64_vkMapMemory(void *args)
28073 {
28074     struct vkMapMemory_params *params = args;
28075
28076     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);
28077
28078     params->result = wine_device_from_handle(params->device)->funcs.p_vkMapMemory(wine_device_from_handle(params->device)->device, params->memory, params->offset, params->size, params->flags, params->ppData);
28079     return STATUS_SUCCESS;
28080 }
28081
28082 #else /* USE_STRUCT_CONVERSION */
28083
28084 static NTSTATUS thunk32_vkMapMemory(void *args)
28085 {
28086     struct
28087     {
28088         VkDevice device;
28089         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
28090         VkDeviceSize DECLSPEC_ALIGN(8) offset;
28091         VkDeviceSize DECLSPEC_ALIGN(8) size;
28092         VkMemoryMapFlags flags;
28093         void **ppData;
28094         VkResult result;
28095     } *params = args;
28096
28097     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);
28098
28099     params->result = wine_device_from_handle(params->device)->funcs.p_vkMapMemory(wine_device_from_handle(params->device)->device, params->memory, params->offset, params->size, params->flags, params->ppData);
28100     return STATUS_SUCCESS;
28101 }
28102
28103 #endif /* USE_STRUCT_CONVERSION */
28104
28105 #if !defined(USE_STRUCT_CONVERSION)
28106
28107 static NTSTATUS thunk64_vkMergePipelineCaches(void *args)
28108 {
28109     struct vkMergePipelineCaches_params *params = args;
28110
28111     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
28112
28113     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergePipelineCaches(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
28114     return STATUS_SUCCESS;
28115 }
28116
28117 #else /* USE_STRUCT_CONVERSION */
28118
28119 static NTSTATUS thunk32_vkMergePipelineCaches(void *args)
28120 {
28121     struct
28122     {
28123         VkDevice device;
28124         VkPipelineCache DECLSPEC_ALIGN(8) dstCache;
28125         uint32_t srcCacheCount;
28126         const VkPipelineCache *pSrcCaches;
28127         VkResult result;
28128     } *params = args;
28129
28130     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
28131
28132     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergePipelineCaches(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
28133     return STATUS_SUCCESS;
28134 }
28135
28136 #endif /* USE_STRUCT_CONVERSION */
28137
28138 #if !defined(USE_STRUCT_CONVERSION)
28139
28140 static NTSTATUS thunk64_vkMergeValidationCachesEXT(void *args)
28141 {
28142     struct vkMergeValidationCachesEXT_params *params = args;
28143
28144     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
28145
28146     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
28147     return STATUS_SUCCESS;
28148 }
28149
28150 #else /* USE_STRUCT_CONVERSION */
28151
28152 static NTSTATUS thunk32_vkMergeValidationCachesEXT(void *args)
28153 {
28154     struct
28155     {
28156         VkDevice device;
28157         VkValidationCacheEXT DECLSPEC_ALIGN(8) dstCache;
28158         uint32_t srcCacheCount;
28159         const VkValidationCacheEXT *pSrcCaches;
28160         VkResult result;
28161     } *params = args;
28162
28163     TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
28164
28165     params->result = wine_device_from_handle(params->device)->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
28166     return STATUS_SUCCESS;
28167 }
28168
28169 #endif /* USE_STRUCT_CONVERSION */
28170
28171 #if !defined(USE_STRUCT_CONVERSION)
28172
28173 static NTSTATUS thunk64_vkQueueBeginDebugUtilsLabelEXT(void *args)
28174 {
28175     struct vkQueueBeginDebugUtilsLabelEXT_params *params = args;
28176
28177     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
28178
28179     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, params->pLabelInfo);
28180     return STATUS_SUCCESS;
28181 }
28182
28183 #else /* USE_STRUCT_CONVERSION */
28184
28185 static NTSTATUS thunk32_vkQueueBeginDebugUtilsLabelEXT(void *args)
28186 {
28187     struct
28188     {
28189         VkQueue queue;
28190         const VkDebugUtilsLabelEXT *pLabelInfo;
28191     } *params = args;
28192
28193     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
28194
28195     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, params->pLabelInfo);
28196     return STATUS_SUCCESS;
28197 }
28198
28199 #endif /* USE_STRUCT_CONVERSION */
28200
28201 #if !defined(USE_STRUCT_CONVERSION)
28202
28203 static NTSTATUS thunk64_vkQueueBindSparse(void *args)
28204 {
28205     struct vkQueueBindSparse_params *params = args;
28206
28207     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));
28208
28209     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);
28210     return STATUS_SUCCESS;
28211 }
28212
28213 #else /* USE_STRUCT_CONVERSION */
28214
28215 static NTSTATUS thunk32_vkQueueBindSparse(void *args)
28216 {
28217     struct
28218     {
28219         VkQueue queue;
28220         uint32_t bindInfoCount;
28221         const VkBindSparseInfo32 *pBindInfo;
28222         VkFence DECLSPEC_ALIGN(8) fence;
28223         VkResult result;
28224     } *params = args;
28225     const VkBindSparseInfo *pBindInfo_host;
28226     struct conversion_context ctx;
28227
28228     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));
28229
28230     init_conversion_context(&ctx);
28231     pBindInfo_host = convert_VkBindSparseInfo_array_win32_to_host(&ctx, params->pBindInfo, params->bindInfoCount);
28232     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBindSparse(wine_queue_from_handle(params->queue)->queue, params->bindInfoCount, pBindInfo_host, params->fence);
28233     free_conversion_context(&ctx);
28234     return STATUS_SUCCESS;
28235 }
28236
28237 #endif /* USE_STRUCT_CONVERSION */
28238
28239 #if !defined(USE_STRUCT_CONVERSION)
28240
28241 static NTSTATUS thunk64_vkQueueEndDebugUtilsLabelEXT(void *args)
28242 {
28243     struct vkQueueEndDebugUtilsLabelEXT_params *params = args;
28244
28245     TRACE("%p\n", params->queue);
28246
28247     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue);
28248     return STATUS_SUCCESS;
28249 }
28250
28251 #else /* USE_STRUCT_CONVERSION */
28252
28253 static NTSTATUS thunk32_vkQueueEndDebugUtilsLabelEXT(void *args)
28254 {
28255     struct
28256     {
28257         VkQueue queue;
28258     } *params = args;
28259
28260     TRACE("%p\n", params->queue);
28261
28262     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue);
28263     return STATUS_SUCCESS;
28264 }
28265
28266 #endif /* USE_STRUCT_CONVERSION */
28267
28268 #if !defined(USE_STRUCT_CONVERSION)
28269
28270 static NTSTATUS thunk64_vkQueueInsertDebugUtilsLabelEXT(void *args)
28271 {
28272     struct vkQueueInsertDebugUtilsLabelEXT_params *params = args;
28273
28274     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
28275
28276     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, params->pLabelInfo);
28277     return STATUS_SUCCESS;
28278 }
28279
28280 #else /* USE_STRUCT_CONVERSION */
28281
28282 static NTSTATUS thunk32_vkQueueInsertDebugUtilsLabelEXT(void *args)
28283 {
28284     struct
28285     {
28286         VkQueue queue;
28287         const VkDebugUtilsLabelEXT *pLabelInfo;
28288     } *params = args;
28289
28290     TRACE("%p, %p\n", params->queue, params->pLabelInfo);
28291
28292     wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, params->pLabelInfo);
28293     return STATUS_SUCCESS;
28294 }
28295
28296 #endif /* USE_STRUCT_CONVERSION */
28297
28298 #if !defined(USE_STRUCT_CONVERSION)
28299
28300 static NTSTATUS thunk64_vkQueuePresentKHR(void *args)
28301 {
28302     struct vkQueuePresentKHR_params *params = args;
28303
28304     TRACE("%p, %p\n", params->queue, params->pPresentInfo);
28305
28306     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle(params->queue)->queue, params->pPresentInfo);
28307     return STATUS_SUCCESS;
28308 }
28309
28310 #else /* USE_STRUCT_CONVERSION */
28311
28312 static NTSTATUS thunk32_vkQueuePresentKHR(void *args)
28313 {
28314     struct
28315     {
28316         VkQueue queue;
28317         const VkPresentInfoKHR *pPresentInfo;
28318         VkResult result;
28319     } *params = args;
28320
28321     TRACE("%p, %p\n", params->queue, params->pPresentInfo);
28322
28323     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle(params->queue)->queue, params->pPresentInfo);
28324     return STATUS_SUCCESS;
28325 }
28326
28327 #endif /* USE_STRUCT_CONVERSION */
28328
28329 #if !defined(USE_STRUCT_CONVERSION)
28330
28331 static NTSTATUS thunk64_vkQueueSetPerformanceConfigurationINTEL(void *args)
28332 {
28333     struct vkQueueSetPerformanceConfigurationINTEL_params *params = args;
28334
28335     TRACE("%p, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));
28336
28337     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle(params->queue)->queue, params->configuration);
28338     return STATUS_SUCCESS;
28339 }
28340
28341 #else /* USE_STRUCT_CONVERSION */
28342
28343 static NTSTATUS thunk32_vkQueueSetPerformanceConfigurationINTEL(void *args)
28344 {
28345     struct
28346     {
28347         VkQueue queue;
28348         VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
28349         VkResult result;
28350     } *params = args;
28351
28352     TRACE("%p, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));
28353
28354     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle(params->queue)->queue, params->configuration);
28355     return STATUS_SUCCESS;
28356 }
28357
28358 #endif /* USE_STRUCT_CONVERSION */
28359
28360 #if !defined(USE_STRUCT_CONVERSION)
28361
28362 static NTSTATUS thunk64_vkQueueSubmit(void *args)
28363 {
28364     struct vkQueueSubmit_params *params = args;
28365     const VkSubmitInfo *pSubmits_host;
28366     struct conversion_context ctx;
28367
28368     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
28369
28370     init_conversion_context(&ctx);
28371     pSubmits_host = convert_VkSubmitInfo_array_win64_to_host(&ctx, params->pSubmits, params->submitCount);
28372     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);
28373     free_conversion_context(&ctx);
28374     return STATUS_SUCCESS;
28375 }
28376
28377 #else /* USE_STRUCT_CONVERSION */
28378
28379 static NTSTATUS thunk32_vkQueueSubmit(void *args)
28380 {
28381     struct
28382     {
28383         VkQueue queue;
28384         uint32_t submitCount;
28385         const VkSubmitInfo *pSubmits;
28386         VkFence DECLSPEC_ALIGN(8) fence;
28387         VkResult result;
28388     } *params = args;
28389     const VkSubmitInfo *pSubmits_host;
28390     struct conversion_context ctx;
28391
28392     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
28393
28394     init_conversion_context(&ctx);
28395     pSubmits_host = convert_VkSubmitInfo_array_win32_to_host(&ctx, params->pSubmits, params->submitCount);
28396     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);
28397     free_conversion_context(&ctx);
28398     return STATUS_SUCCESS;
28399 }
28400
28401 #endif /* USE_STRUCT_CONVERSION */
28402
28403 #if !defined(USE_STRUCT_CONVERSION)
28404
28405 static NTSTATUS thunk64_vkQueueSubmit2(void *args)
28406 {
28407     struct vkQueueSubmit2_params *params = args;
28408     const VkSubmitInfo2 *pSubmits_host;
28409     struct conversion_context ctx;
28410
28411     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
28412
28413     init_conversion_context(&ctx);
28414     pSubmits_host = convert_VkSubmitInfo2_array_win64_to_host(&ctx, params->pSubmits, params->submitCount);
28415     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);
28416     free_conversion_context(&ctx);
28417     return STATUS_SUCCESS;
28418 }
28419
28420 #else /* USE_STRUCT_CONVERSION */
28421
28422 static NTSTATUS thunk32_vkQueueSubmit2(void *args)
28423 {
28424     struct
28425     {
28426         VkQueue queue;
28427         uint32_t submitCount;
28428         const VkSubmitInfo232 *pSubmits;
28429         VkFence DECLSPEC_ALIGN(8) fence;
28430         VkResult result;
28431     } *params = args;
28432     const VkSubmitInfo2 *pSubmits_host;
28433     struct conversion_context ctx;
28434
28435     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
28436
28437     init_conversion_context(&ctx);
28438     pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(&ctx, params->pSubmits, params->submitCount);
28439     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);
28440     free_conversion_context(&ctx);
28441     return STATUS_SUCCESS;
28442 }
28443
28444 #endif /* USE_STRUCT_CONVERSION */
28445
28446 #if !defined(USE_STRUCT_CONVERSION)
28447
28448 static NTSTATUS thunk64_vkQueueSubmit2KHR(void *args)
28449 {
28450     struct vkQueueSubmit2KHR_params *params = args;
28451     const VkSubmitInfo2 *pSubmits_host;
28452     struct conversion_context ctx;
28453
28454     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
28455
28456     init_conversion_context(&ctx);
28457     pSubmits_host = convert_VkSubmitInfo2_array_win64_to_host(&ctx, params->pSubmits, params->submitCount);
28458     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);
28459     free_conversion_context(&ctx);
28460     return STATUS_SUCCESS;
28461 }
28462
28463 #else /* USE_STRUCT_CONVERSION */
28464
28465 static NTSTATUS thunk32_vkQueueSubmit2KHR(void *args)
28466 {
28467     struct
28468     {
28469         VkQueue queue;
28470         uint32_t submitCount;
28471         const VkSubmitInfo232 *pSubmits;
28472         VkFence DECLSPEC_ALIGN(8) fence;
28473         VkResult result;
28474     } *params = args;
28475     const VkSubmitInfo2 *pSubmits_host;
28476     struct conversion_context ctx;
28477
28478     TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
28479
28480     init_conversion_context(&ctx);
28481     pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(&ctx, params->pSubmits, params->submitCount);
28482     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);
28483     free_conversion_context(&ctx);
28484     return STATUS_SUCCESS;
28485 }
28486
28487 #endif /* USE_STRUCT_CONVERSION */
28488
28489 #if !defined(USE_STRUCT_CONVERSION)
28490
28491 static NTSTATUS thunk64_vkQueueWaitIdle(void *args)
28492 {
28493     struct vkQueueWaitIdle_params *params = args;
28494
28495     TRACE("%p\n", params->queue);
28496
28497     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle(params->queue)->queue);
28498     return STATUS_SUCCESS;
28499 }
28500
28501 #else /* USE_STRUCT_CONVERSION */
28502
28503 static NTSTATUS thunk32_vkQueueWaitIdle(void *args)
28504 {
28505     struct
28506     {
28507         VkQueue queue;
28508         VkResult result;
28509     } *params = args;
28510
28511     TRACE("%p\n", params->queue);
28512
28513     params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle(params->queue)->queue);
28514     return STATUS_SUCCESS;
28515 }
28516
28517 #endif /* USE_STRUCT_CONVERSION */
28518
28519 #if !defined(USE_STRUCT_CONVERSION)
28520
28521 static NTSTATUS thunk64_vkReleasePerformanceConfigurationINTEL(void *args)
28522 {
28523     struct vkReleasePerformanceConfigurationINTEL_params *params = args;
28524
28525     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));
28526
28527     params->result = wine_device_from_handle(params->device)->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->configuration);
28528     return STATUS_SUCCESS;
28529 }
28530
28531 #else /* USE_STRUCT_CONVERSION */
28532
28533 static NTSTATUS thunk32_vkReleasePerformanceConfigurationINTEL(void *args)
28534 {
28535     struct
28536     {
28537         VkDevice device;
28538         VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
28539         VkResult result;
28540     } *params = args;
28541
28542     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));
28543
28544     params->result = wine_device_from_handle(params->device)->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->configuration);
28545     return STATUS_SUCCESS;
28546 }
28547
28548 #endif /* USE_STRUCT_CONVERSION */
28549
28550 #if !defined(USE_STRUCT_CONVERSION)
28551
28552 static NTSTATUS thunk64_vkReleaseProfilingLockKHR(void *args)
28553 {
28554     struct vkReleaseProfilingLockKHR_params *params = args;
28555
28556     TRACE("%p\n", params->device);
28557
28558     wine_device_from_handle(params->device)->funcs.p_vkReleaseProfilingLockKHR(wine_device_from_handle(params->device)->device);
28559     return STATUS_SUCCESS;
28560 }
28561
28562 #else /* USE_STRUCT_CONVERSION */
28563
28564 static NTSTATUS thunk32_vkReleaseProfilingLockKHR(void *args)
28565 {
28566     struct
28567     {
28568         VkDevice device;
28569     } *params = args;
28570
28571     TRACE("%p\n", params->device);
28572
28573     wine_device_from_handle(params->device)->funcs.p_vkReleaseProfilingLockKHR(wine_device_from_handle(params->device)->device);
28574     return STATUS_SUCCESS;
28575 }
28576
28577 #endif /* USE_STRUCT_CONVERSION */
28578
28579 #if !defined(USE_STRUCT_CONVERSION)
28580
28581 static NTSTATUS thunk64_vkResetCommandBuffer(void *args)
28582 {
28583     struct vkResetCommandBuffer_params *params = args;
28584
28585     TRACE("%p, %#x\n", params->commandBuffer, params->flags);
28586
28587     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->flags);
28588     return STATUS_SUCCESS;
28589 }
28590
28591 #else /* USE_STRUCT_CONVERSION */
28592
28593 static NTSTATUS thunk32_vkResetCommandBuffer(void *args)
28594 {
28595     struct
28596     {
28597         VkCommandBuffer commandBuffer;
28598         VkCommandBufferResetFlags flags;
28599         VkResult result;
28600     } *params = args;
28601
28602     TRACE("%p, %#x\n", params->commandBuffer, params->flags);
28603
28604     params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->flags);
28605     return STATUS_SUCCESS;
28606 }
28607
28608 #endif /* USE_STRUCT_CONVERSION */
28609
28610 #if !defined(USE_STRUCT_CONVERSION)
28611
28612 static NTSTATUS thunk64_vkResetCommandPool(void *args)
28613 {
28614     struct vkResetCommandPool_params *params = args;
28615
28616     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
28617
28618     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);
28619     return STATUS_SUCCESS;
28620 }
28621
28622 #else /* USE_STRUCT_CONVERSION */
28623
28624 static NTSTATUS thunk32_vkResetCommandPool(void *args)
28625 {
28626     struct
28627     {
28628         VkDevice device;
28629         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
28630         VkCommandPoolResetFlags flags;
28631         VkResult result;
28632     } *params = args;
28633
28634     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
28635
28636     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);
28637     return STATUS_SUCCESS;
28638 }
28639
28640 #endif /* USE_STRUCT_CONVERSION */
28641
28642 #if !defined(USE_STRUCT_CONVERSION)
28643
28644 static NTSTATUS thunk64_vkResetDescriptorPool(void *args)
28645 {
28646     struct vkResetDescriptorPool_params *params = args;
28647
28648     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);
28649
28650     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, params->flags);
28651     return STATUS_SUCCESS;
28652 }
28653
28654 #else /* USE_STRUCT_CONVERSION */
28655
28656 static NTSTATUS thunk32_vkResetDescriptorPool(void *args)
28657 {
28658     struct
28659     {
28660         VkDevice device;
28661         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
28662         VkDescriptorPoolResetFlags flags;
28663         VkResult result;
28664     } *params = args;
28665
28666     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);
28667
28668     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, params->flags);
28669     return STATUS_SUCCESS;
28670 }
28671
28672 #endif /* USE_STRUCT_CONVERSION */
28673
28674 #if !defined(USE_STRUCT_CONVERSION)
28675
28676 static NTSTATUS thunk64_vkResetEvent(void *args)
28677 {
28678     struct vkResetEvent_params *params = args;
28679
28680     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
28681
28682     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetEvent(wine_device_from_handle(params->device)->device, params->event);
28683     return STATUS_SUCCESS;
28684 }
28685
28686 #else /* USE_STRUCT_CONVERSION */
28687
28688 static NTSTATUS thunk32_vkResetEvent(void *args)
28689 {
28690     struct
28691     {
28692         VkDevice device;
28693         VkEvent DECLSPEC_ALIGN(8) event;
28694         VkResult result;
28695     } *params = args;
28696
28697     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
28698
28699     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetEvent(wine_device_from_handle(params->device)->device, params->event);
28700     return STATUS_SUCCESS;
28701 }
28702
28703 #endif /* USE_STRUCT_CONVERSION */
28704
28705 #if !defined(USE_STRUCT_CONVERSION)
28706
28707 static NTSTATUS thunk64_vkResetFences(void *args)
28708 {
28709     struct vkResetFences_params *params = args;
28710
28711     TRACE("%p, %u, %p\n", params->device, params->fenceCount, params->pFences);
28712
28713     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences);
28714     return STATUS_SUCCESS;
28715 }
28716
28717 #else /* USE_STRUCT_CONVERSION */
28718
28719 static NTSTATUS thunk32_vkResetFences(void *args)
28720 {
28721     struct
28722     {
28723         VkDevice device;
28724         uint32_t fenceCount;
28725         const VkFence *pFences;
28726         VkResult result;
28727     } *params = args;
28728
28729     TRACE("%p, %u, %p\n", params->device, params->fenceCount, params->pFences);
28730
28731     params->result = wine_device_from_handle(params->device)->funcs.p_vkResetFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences);
28732     return STATUS_SUCCESS;
28733 }
28734
28735 #endif /* USE_STRUCT_CONVERSION */
28736
28737 #if !defined(USE_STRUCT_CONVERSION)
28738
28739 static NTSTATUS thunk64_vkResetQueryPool(void *args)
28740 {
28741     struct vkResetQueryPool_params *params = args;
28742
28743     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
28744
28745     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
28746     return STATUS_SUCCESS;
28747 }
28748
28749 #else /* USE_STRUCT_CONVERSION */
28750
28751 static NTSTATUS thunk32_vkResetQueryPool(void *args)
28752 {
28753     struct
28754     {
28755         VkDevice device;
28756         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
28757         uint32_t firstQuery;
28758         uint32_t queryCount;
28759     } *params = args;
28760
28761     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
28762
28763     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
28764     return STATUS_SUCCESS;
28765 }
28766
28767 #endif /* USE_STRUCT_CONVERSION */
28768
28769 #if !defined(USE_STRUCT_CONVERSION)
28770
28771 static NTSTATUS thunk64_vkResetQueryPoolEXT(void *args)
28772 {
28773     struct vkResetQueryPoolEXT_params *params = args;
28774
28775     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
28776
28777     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPoolEXT(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
28778     return STATUS_SUCCESS;
28779 }
28780
28781 #else /* USE_STRUCT_CONVERSION */
28782
28783 static NTSTATUS thunk32_vkResetQueryPoolEXT(void *args)
28784 {
28785     struct
28786     {
28787         VkDevice device;
28788         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
28789         uint32_t firstQuery;
28790         uint32_t queryCount;
28791     } *params = args;
28792
28793     TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
28794
28795     wine_device_from_handle(params->device)->funcs.p_vkResetQueryPoolEXT(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
28796     return STATUS_SUCCESS;
28797 }
28798
28799 #endif /* USE_STRUCT_CONVERSION */
28800
28801 #if !defined(USE_STRUCT_CONVERSION)
28802
28803 static NTSTATUS thunk64_vkSetDebugUtilsObjectNameEXT(void *args)
28804 {
28805     struct vkSetDebugUtilsObjectNameEXT_params *params = args;
28806     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;
28807
28808     TRACE("%p, %p\n", params->device, params->pNameInfo);
28809
28810     convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(params->pNameInfo, &pNameInfo_host);
28811     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
28812     return STATUS_SUCCESS;
28813 }
28814
28815 #else /* USE_STRUCT_CONVERSION */
28816
28817 static NTSTATUS thunk32_vkSetDebugUtilsObjectNameEXT(void *args)
28818 {
28819     struct
28820     {
28821         VkDevice device;
28822         const VkDebugUtilsObjectNameInfoEXT32 *pNameInfo;
28823         VkResult result;
28824     } *params = args;
28825     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;
28826
28827     TRACE("%p, %p\n", params->device, params->pNameInfo);
28828
28829     convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(params->pNameInfo, &pNameInfo_host);
28830     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
28831     return STATUS_SUCCESS;
28832 }
28833
28834 #endif /* USE_STRUCT_CONVERSION */
28835
28836 #if !defined(USE_STRUCT_CONVERSION)
28837
28838 static NTSTATUS thunk64_vkSetDebugUtilsObjectTagEXT(void *args)
28839 {
28840     struct vkSetDebugUtilsObjectTagEXT_params *params = args;
28841     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;
28842
28843     TRACE("%p, %p\n", params->device, params->pTagInfo);
28844
28845     convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(params->pTagInfo, &pTagInfo_host);
28846     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
28847     return STATUS_SUCCESS;
28848 }
28849
28850 #else /* USE_STRUCT_CONVERSION */
28851
28852 static NTSTATUS thunk32_vkSetDebugUtilsObjectTagEXT(void *args)
28853 {
28854     struct
28855     {
28856         VkDevice device;
28857         const VkDebugUtilsObjectTagInfoEXT32 *pTagInfo;
28858         VkResult result;
28859     } *params = args;
28860     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;
28861
28862     TRACE("%p, %p\n", params->device, params->pTagInfo);
28863
28864     convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(params->pTagInfo, &pTagInfo_host);
28865     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
28866     return STATUS_SUCCESS;
28867 }
28868
28869 #endif /* USE_STRUCT_CONVERSION */
28870
28871 #if !defined(USE_STRUCT_CONVERSION)
28872
28873 static NTSTATUS thunk64_vkSetDeviceMemoryPriorityEXT(void *args)
28874 {
28875     struct vkSetDeviceMemoryPriorityEXT_params *params = args;
28876
28877     TRACE("%p, 0x%s, %f\n", params->device, wine_dbgstr_longlong(params->memory), params->priority);
28878
28879     wine_device_from_handle(params->device)->funcs.p_vkSetDeviceMemoryPriorityEXT(wine_device_from_handle(params->device)->device, params->memory, params->priority);
28880     return STATUS_SUCCESS;
28881 }
28882
28883 #else /* USE_STRUCT_CONVERSION */
28884
28885 static NTSTATUS thunk32_vkSetDeviceMemoryPriorityEXT(void *args)
28886 {
28887     struct
28888     {
28889         VkDevice device;
28890         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
28891         float priority;
28892     } *params = args;
28893
28894     TRACE("%p, 0x%s, %f\n", params->device, wine_dbgstr_longlong(params->memory), params->priority);
28895
28896     wine_device_from_handle(params->device)->funcs.p_vkSetDeviceMemoryPriorityEXT(wine_device_from_handle(params->device)->device, params->memory, params->priority);
28897     return STATUS_SUCCESS;
28898 }
28899
28900 #endif /* USE_STRUCT_CONVERSION */
28901
28902 #if !defined(USE_STRUCT_CONVERSION)
28903
28904 static NTSTATUS thunk64_vkSetEvent(void *args)
28905 {
28906     struct vkSetEvent_params *params = args;
28907
28908     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
28909
28910     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetEvent(wine_device_from_handle(params->device)->device, params->event);
28911     return STATUS_SUCCESS;
28912 }
28913
28914 #else /* USE_STRUCT_CONVERSION */
28915
28916 static NTSTATUS thunk32_vkSetEvent(void *args)
28917 {
28918     struct
28919     {
28920         VkDevice device;
28921         VkEvent DECLSPEC_ALIGN(8) event;
28922         VkResult result;
28923     } *params = args;
28924
28925     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
28926
28927     params->result = wine_device_from_handle(params->device)->funcs.p_vkSetEvent(wine_device_from_handle(params->device)->device, params->event);
28928     return STATUS_SUCCESS;
28929 }
28930
28931 #endif /* USE_STRUCT_CONVERSION */
28932
28933 #if !defined(USE_STRUCT_CONVERSION)
28934
28935 static NTSTATUS thunk64_vkSetPrivateData(void *args)
28936 {
28937     struct vkSetPrivateData_params *params = args;
28938
28939     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));
28940
28941     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);
28942     return STATUS_SUCCESS;
28943 }
28944
28945 #else /* USE_STRUCT_CONVERSION */
28946
28947 static NTSTATUS thunk32_vkSetPrivateData(void *args)
28948 {
28949     struct
28950     {
28951         VkDevice device;
28952         VkObjectType objectType;
28953         uint64_t DECLSPEC_ALIGN(8) objectHandle;
28954         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
28955         uint64_t DECLSPEC_ALIGN(8) data;
28956         VkResult result;
28957     } *params = args;
28958
28959     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));
28960
28961     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);
28962     return STATUS_SUCCESS;
28963 }
28964
28965 #endif /* USE_STRUCT_CONVERSION */
28966
28967 #if !defined(USE_STRUCT_CONVERSION)
28968
28969 static NTSTATUS thunk64_vkSetPrivateDataEXT(void *args)
28970 {
28971     struct vkSetPrivateDataEXT_params *params = args;
28972
28973     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));
28974
28975     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);
28976     return STATUS_SUCCESS;
28977 }
28978
28979 #else /* USE_STRUCT_CONVERSION */
28980
28981 static NTSTATUS thunk32_vkSetPrivateDataEXT(void *args)
28982 {
28983     struct
28984     {
28985         VkDevice device;
28986         VkObjectType objectType;
28987         uint64_t DECLSPEC_ALIGN(8) objectHandle;
28988         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
28989         uint64_t DECLSPEC_ALIGN(8) data;
28990         VkResult result;
28991     } *params = args;
28992
28993     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));
28994
28995     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);
28996     return STATUS_SUCCESS;
28997 }
28998
28999 #endif /* USE_STRUCT_CONVERSION */
29000
29001 #if !defined(USE_STRUCT_CONVERSION)
29002
29003 static NTSTATUS thunk64_vkSignalSemaphore(void *args)
29004 {
29005     struct vkSignalSemaphore_params *params = args;
29006
29007     TRACE("%p, %p\n", params->device, params->pSignalInfo);
29008
29009     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphore(wine_device_from_handle(params->device)->device, params->pSignalInfo);
29010     return STATUS_SUCCESS;
29011 }
29012
29013 #else /* USE_STRUCT_CONVERSION */
29014
29015 static NTSTATUS thunk32_vkSignalSemaphore(void *args)
29016 {
29017     struct
29018     {
29019         VkDevice device;
29020         const VkSemaphoreSignalInfo32 *pSignalInfo;
29021         VkResult result;
29022     } *params = args;
29023     VkSemaphoreSignalInfo pSignalInfo_host;
29024
29025     TRACE("%p, %p\n", params->device, params->pSignalInfo);
29026
29027     convert_VkSemaphoreSignalInfo_win32_to_host(params->pSignalInfo, &pSignalInfo_host);
29028     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphore(wine_device_from_handle(params->device)->device, &pSignalInfo_host);
29029     return STATUS_SUCCESS;
29030 }
29031
29032 #endif /* USE_STRUCT_CONVERSION */
29033
29034 #if !defined(USE_STRUCT_CONVERSION)
29035
29036 static NTSTATUS thunk64_vkSignalSemaphoreKHR(void *args)
29037 {
29038     struct vkSignalSemaphoreKHR_params *params = args;
29039
29040     TRACE("%p, %p\n", params->device, params->pSignalInfo);
29041
29042     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle(params->device)->device, params->pSignalInfo);
29043     return STATUS_SUCCESS;
29044 }
29045
29046 #else /* USE_STRUCT_CONVERSION */
29047
29048 static NTSTATUS thunk32_vkSignalSemaphoreKHR(void *args)
29049 {
29050     struct
29051     {
29052         VkDevice device;
29053         const VkSemaphoreSignalInfo32 *pSignalInfo;
29054         VkResult result;
29055     } *params = args;
29056     VkSemaphoreSignalInfo pSignalInfo_host;
29057
29058     TRACE("%p, %p\n", params->device, params->pSignalInfo);
29059
29060     convert_VkSemaphoreSignalInfo_win32_to_host(params->pSignalInfo, &pSignalInfo_host);
29061     params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle(params->device)->device, &pSignalInfo_host);
29062     return STATUS_SUCCESS;
29063 }
29064
29065 #endif /* USE_STRUCT_CONVERSION */
29066
29067 #if !defined(USE_STRUCT_CONVERSION)
29068
29069 static NTSTATUS thunk64_vkSubmitDebugUtilsMessageEXT(void *args)
29070 {
29071     struct vkSubmitDebugUtilsMessageEXT_params *params = args;
29072     VkDebugUtilsMessengerCallbackDataEXT pCallbackData_host;
29073     struct conversion_context ctx;
29074
29075     TRACE("%p, %#x, %#x, %p\n", params->instance, params->messageSeverity, params->messageTypes, params->pCallbackData);
29076
29077     init_conversion_context(&ctx);
29078     convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(&ctx, params->pCallbackData, &pCallbackData_host);
29079     wine_instance_from_handle(params->instance)->funcs.p_vkSubmitDebugUtilsMessageEXT(wine_instance_from_handle(params->instance)->instance, params->messageSeverity, params->messageTypes, &pCallbackData_host);
29080     free_conversion_context(&ctx);
29081     return STATUS_SUCCESS;
29082 }
29083
29084 #else /* USE_STRUCT_CONVERSION */
29085
29086 static NTSTATUS thunk32_vkSubmitDebugUtilsMessageEXT(void *args)
29087 {
29088     struct
29089     {
29090         VkInstance instance;
29091         VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity;
29092         VkDebugUtilsMessageTypeFlagsEXT messageTypes;
29093         const VkDebugUtilsMessengerCallbackDataEXT32 *pCallbackData;
29094     } *params = args;
29095     VkDebugUtilsMessengerCallbackDataEXT pCallbackData_host;
29096     struct conversion_context ctx;
29097
29098     TRACE("%p, %#x, %#x, %p\n", params->instance, params->messageSeverity, params->messageTypes, params->pCallbackData);
29099
29100     init_conversion_context(&ctx);
29101     convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(&ctx, params->pCallbackData, &pCallbackData_host);
29102     wine_instance_from_handle(params->instance)->funcs.p_vkSubmitDebugUtilsMessageEXT(wine_instance_from_handle(params->instance)->instance, params->messageSeverity, params->messageTypes, &pCallbackData_host);
29103     free_conversion_context(&ctx);
29104     return STATUS_SUCCESS;
29105 }
29106
29107 #endif /* USE_STRUCT_CONVERSION */
29108
29109 #if !defined(USE_STRUCT_CONVERSION)
29110
29111 static NTSTATUS thunk64_vkTrimCommandPool(void *args)
29112 {
29113     struct vkTrimCommandPool_params *params = args;
29114
29115     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
29116
29117     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);
29118     return STATUS_SUCCESS;
29119 }
29120
29121 #else /* USE_STRUCT_CONVERSION */
29122
29123 static NTSTATUS thunk32_vkTrimCommandPool(void *args)
29124 {
29125     struct
29126     {
29127         VkDevice device;
29128         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
29129         VkCommandPoolTrimFlags flags;
29130     } *params = args;
29131
29132     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
29133
29134     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);
29135     return STATUS_SUCCESS;
29136 }
29137
29138 #endif /* USE_STRUCT_CONVERSION */
29139
29140 #if !defined(USE_STRUCT_CONVERSION)
29141
29142 static NTSTATUS thunk64_vkTrimCommandPoolKHR(void *args)
29143 {
29144     struct vkTrimCommandPoolKHR_params *params = args;
29145
29146     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
29147
29148     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);
29149     return STATUS_SUCCESS;
29150 }
29151
29152 #else /* USE_STRUCT_CONVERSION */
29153
29154 static NTSTATUS thunk32_vkTrimCommandPoolKHR(void *args)
29155 {
29156     struct
29157     {
29158         VkDevice device;
29159         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
29160         VkCommandPoolTrimFlags flags;
29161     } *params = args;
29162
29163     TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
29164
29165     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);
29166     return STATUS_SUCCESS;
29167 }
29168
29169 #endif /* USE_STRUCT_CONVERSION */
29170
29171 #if !defined(USE_STRUCT_CONVERSION)
29172
29173 static NTSTATUS thunk64_vkUninitializePerformanceApiINTEL(void *args)
29174 {
29175     struct vkUninitializePerformanceApiINTEL_params *params = args;
29176
29177     TRACE("%p\n", params->device);
29178
29179     wine_device_from_handle(params->device)->funcs.p_vkUninitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device);
29180     return STATUS_SUCCESS;
29181 }
29182
29183 #else /* USE_STRUCT_CONVERSION */
29184
29185 static NTSTATUS thunk32_vkUninitializePerformanceApiINTEL(void *args)
29186 {
29187     struct
29188     {
29189         VkDevice device;
29190     } *params = args;
29191
29192     TRACE("%p\n", params->device);
29193
29194     wine_device_from_handle(params->device)->funcs.p_vkUninitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device);
29195     return STATUS_SUCCESS;
29196 }
29197
29198 #endif /* USE_STRUCT_CONVERSION */
29199
29200 #if !defined(USE_STRUCT_CONVERSION)
29201
29202 static NTSTATUS thunk64_vkUnmapMemory(void *args)
29203 {
29204     struct vkUnmapMemory_params *params = args;
29205
29206     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->memory));
29207
29208     wine_device_from_handle(params->device)->funcs.p_vkUnmapMemory(wine_device_from_handle(params->device)->device, params->memory);
29209     return STATUS_SUCCESS;
29210 }
29211
29212 #else /* USE_STRUCT_CONVERSION */
29213
29214 static NTSTATUS thunk32_vkUnmapMemory(void *args)
29215 {
29216     struct
29217     {
29218         VkDevice device;
29219         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
29220     } *params = args;
29221
29222     TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->memory));
29223
29224     wine_device_from_handle(params->device)->funcs.p_vkUnmapMemory(wine_device_from_handle(params->device)->device, params->memory);
29225     return STATUS_SUCCESS;
29226 }
29227
29228 #endif /* USE_STRUCT_CONVERSION */
29229
29230 #if !defined(USE_STRUCT_CONVERSION)
29231
29232 static NTSTATUS thunk64_vkUpdateDescriptorSetWithTemplate(void *args)
29233 {
29234     struct vkUpdateDescriptorSetWithTemplate_params *params = args;
29235
29236     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
29237
29238     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
29239     return STATUS_SUCCESS;
29240 }
29241
29242 #else /* USE_STRUCT_CONVERSION */
29243
29244 static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplate(void *args)
29245 {
29246     struct
29247     {
29248         VkDevice device;
29249         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
29250         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
29251         const void *pData;
29252     } *params = args;
29253
29254     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
29255
29256     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
29257     return STATUS_SUCCESS;
29258 }
29259
29260 #endif /* USE_STRUCT_CONVERSION */
29261
29262 #if !defined(USE_STRUCT_CONVERSION)
29263
29264 static NTSTATUS thunk64_vkUpdateDescriptorSetWithTemplateKHR(void *args)
29265 {
29266     struct vkUpdateDescriptorSetWithTemplateKHR_params *params = args;
29267
29268     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
29269
29270     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
29271     return STATUS_SUCCESS;
29272 }
29273
29274 #else /* USE_STRUCT_CONVERSION */
29275
29276 static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplateKHR(void *args)
29277 {
29278     struct
29279     {
29280         VkDevice device;
29281         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
29282         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
29283         const void *pData;
29284     } *params = args;
29285
29286     TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
29287
29288     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
29289     return STATUS_SUCCESS;
29290 }
29291
29292 #endif /* USE_STRUCT_CONVERSION */
29293
29294 #if !defined(USE_STRUCT_CONVERSION)
29295
29296 static NTSTATUS thunk64_vkUpdateDescriptorSets(void *args)
29297 {
29298     struct vkUpdateDescriptorSets_params *params = args;
29299
29300     TRACE("%p, %u, %p, %u, %p\n", params->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
29301
29302     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
29303     return STATUS_SUCCESS;
29304 }
29305
29306 #else /* USE_STRUCT_CONVERSION */
29307
29308 static NTSTATUS thunk32_vkUpdateDescriptorSets(void *args)
29309 {
29310     struct
29311     {
29312         VkDevice device;
29313         uint32_t descriptorWriteCount;
29314         const VkWriteDescriptorSet32 *pDescriptorWrites;
29315         uint32_t descriptorCopyCount;
29316         const VkCopyDescriptorSet32 *pDescriptorCopies;
29317     } *params = args;
29318     const VkWriteDescriptorSet *pDescriptorWrites_host;
29319     const VkCopyDescriptorSet *pDescriptorCopies_host;
29320     struct conversion_context ctx;
29321
29322     TRACE("%p, %u, %p, %u, %p\n", params->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
29323
29324     init_conversion_context(&ctx);
29325     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, params->pDescriptorWrites, params->descriptorWriteCount);
29326     pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win32_to_host(&ctx, params->pDescriptorCopies, params->descriptorCopyCount);
29327     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorWriteCount, pDescriptorWrites_host, params->descriptorCopyCount, pDescriptorCopies_host);
29328     free_conversion_context(&ctx);
29329     return STATUS_SUCCESS;
29330 }
29331
29332 #endif /* USE_STRUCT_CONVERSION */
29333
29334 #if !defined(USE_STRUCT_CONVERSION)
29335
29336 static NTSTATUS thunk64_vkWaitForFences(void *args)
29337 {
29338     struct vkWaitForFences_params *params = args;
29339
29340     TRACE("%p, %u, %p, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));
29341
29342     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);
29343     return STATUS_SUCCESS;
29344 }
29345
29346 #else /* USE_STRUCT_CONVERSION */
29347
29348 static NTSTATUS thunk32_vkWaitForFences(void *args)
29349 {
29350     struct
29351     {
29352         VkDevice device;
29353         uint32_t fenceCount;
29354         const VkFence *pFences;
29355         VkBool32 waitAll;
29356         uint64_t DECLSPEC_ALIGN(8) timeout;
29357         VkResult result;
29358     } *params = args;
29359
29360     TRACE("%p, %u, %p, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));
29361
29362     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);
29363     return STATUS_SUCCESS;
29364 }
29365
29366 #endif /* USE_STRUCT_CONVERSION */
29367
29368 #if !defined(USE_STRUCT_CONVERSION)
29369
29370 static NTSTATUS thunk64_vkWaitForPresentKHR(void *args)
29371 {
29372     struct vkWaitForPresentKHR_params *params = args;
29373
29374     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));
29375
29376     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForPresentKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->presentId, params->timeout);
29377     return STATUS_SUCCESS;
29378 }
29379
29380 #else /* USE_STRUCT_CONVERSION */
29381
29382 static NTSTATUS thunk32_vkWaitForPresentKHR(void *args)
29383 {
29384     struct
29385     {
29386         VkDevice device;
29387         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
29388         uint64_t DECLSPEC_ALIGN(8) presentId;
29389         uint64_t DECLSPEC_ALIGN(8) timeout;
29390         VkResult result;
29391     } *params = args;
29392
29393     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));
29394
29395     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForPresentKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->presentId, params->timeout);
29396     return STATUS_SUCCESS;
29397 }
29398
29399 #endif /* USE_STRUCT_CONVERSION */
29400
29401 #if !defined(USE_STRUCT_CONVERSION)
29402
29403 static NTSTATUS thunk64_vkWaitSemaphores(void *args)
29404 {
29405     struct vkWaitSemaphores_params *params = args;
29406
29407     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
29408
29409     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphores(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
29410     return STATUS_SUCCESS;
29411 }
29412
29413 #else /* USE_STRUCT_CONVERSION */
29414
29415 static NTSTATUS thunk32_vkWaitSemaphores(void *args)
29416 {
29417     struct
29418     {
29419         VkDevice device;
29420         const VkSemaphoreWaitInfo *pWaitInfo;
29421         uint64_t DECLSPEC_ALIGN(8) timeout;
29422         VkResult result;
29423     } *params = args;
29424
29425     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
29426
29427     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphores(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
29428     return STATUS_SUCCESS;
29429 }
29430
29431 #endif /* USE_STRUCT_CONVERSION */
29432
29433 #if !defined(USE_STRUCT_CONVERSION)
29434
29435 static NTSTATUS thunk64_vkWaitSemaphoresKHR(void *args)
29436 {
29437     struct vkWaitSemaphoresKHR_params *params = args;
29438
29439     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
29440
29441     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
29442     return STATUS_SUCCESS;
29443 }
29444
29445 #else /* USE_STRUCT_CONVERSION */
29446
29447 static NTSTATUS thunk32_vkWaitSemaphoresKHR(void *args)
29448 {
29449     struct
29450     {
29451         VkDevice device;
29452         const VkSemaphoreWaitInfo *pWaitInfo;
29453         uint64_t DECLSPEC_ALIGN(8) timeout;
29454         VkResult result;
29455     } *params = args;
29456
29457     TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
29458
29459     params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle(params->device)->device, params->pWaitInfo, params->timeout);
29460     return STATUS_SUCCESS;
29461 }
29462
29463 #endif /* USE_STRUCT_CONVERSION */
29464
29465 #if !defined(USE_STRUCT_CONVERSION)
29466
29467 static NTSTATUS thunk64_vkWriteAccelerationStructuresPropertiesKHR(void *args)
29468 {
29469     struct vkWriteAccelerationStructuresPropertiesKHR_params *params = args;
29470
29471     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));
29472
29473     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);
29474     return STATUS_SUCCESS;
29475 }
29476
29477 #else /* USE_STRUCT_CONVERSION */
29478
29479 static NTSTATUS thunk32_vkWriteAccelerationStructuresPropertiesKHR(void *args)
29480 {
29481     struct
29482     {
29483         VkDevice device;
29484         uint32_t accelerationStructureCount;
29485         const VkAccelerationStructureKHR *pAccelerationStructures;
29486         VkQueryType queryType;
29487         size_t dataSize;
29488         void *pData;
29489         size_t stride;
29490         VkResult result;
29491     } *params = args;
29492
29493     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));
29494
29495     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);
29496     return STATUS_SUCCESS;
29497 }
29498
29499 #endif /* USE_STRUCT_CONVERSION */
29500
29501 #if !defined(USE_STRUCT_CONVERSION)
29502
29503 static NTSTATUS thunk64_vkWriteMicromapsPropertiesEXT(void *args)
29504 {
29505     struct vkWriteMicromapsPropertiesEXT_params *params = args;
29506
29507     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));
29508
29509     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);
29510     return STATUS_SUCCESS;
29511 }
29512
29513 #else /* USE_STRUCT_CONVERSION */
29514
29515 static NTSTATUS thunk32_vkWriteMicromapsPropertiesEXT(void *args)
29516 {
29517     struct
29518     {
29519         VkDevice device;
29520         uint32_t micromapCount;
29521         const VkMicromapEXT *pMicromaps;
29522         VkQueryType queryType;
29523         size_t dataSize;
29524         void *pData;
29525         size_t stride;
29526         VkResult result;
29527     } *params = args;
29528
29529     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));
29530
29531     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);
29532     return STATUS_SUCCESS;
29533 }
29534
29535 #endif /* USE_STRUCT_CONVERSION */
29536
29537 static const char * const vk_device_extensions[] =
29538 {
29539     "VK_AMD_buffer_marker",
29540     "VK_AMD_device_coherent_memory",
29541     "VK_AMD_draw_indirect_count",
29542     "VK_AMD_gcn_shader",
29543     "VK_AMD_gpu_shader_half_float",
29544     "VK_AMD_gpu_shader_int16",
29545     "VK_AMD_memory_overallocation_behavior",
29546     "VK_AMD_mixed_attachment_samples",
29547     "VK_AMD_negative_viewport_height",
29548     "VK_AMD_pipeline_compiler_control",
29549     "VK_AMD_rasterization_order",
29550     "VK_AMD_shader_ballot",
29551     "VK_AMD_shader_core_properties",
29552     "VK_AMD_shader_core_properties2",
29553     "VK_AMD_shader_early_and_late_fragment_tests",
29554     "VK_AMD_shader_explicit_vertex_parameter",
29555     "VK_AMD_shader_fragment_mask",
29556     "VK_AMD_shader_image_load_store_lod",
29557     "VK_AMD_shader_info",
29558     "VK_AMD_shader_trinary_minmax",
29559     "VK_AMD_texture_gather_bias_lod",
29560     "VK_ARM_rasterization_order_attachment_access",
29561     "VK_ARM_shader_core_builtins",
29562     "VK_EXT_4444_formats",
29563     "VK_EXT_astc_decode_mode",
29564     "VK_EXT_attachment_feedback_loop_layout",
29565     "VK_EXT_blend_operation_advanced",
29566     "VK_EXT_border_color_swizzle",
29567     "VK_EXT_buffer_device_address",
29568     "VK_EXT_calibrated_timestamps",
29569     "VK_EXT_color_write_enable",
29570     "VK_EXT_conditional_rendering",
29571     "VK_EXT_conservative_rasterization",
29572     "VK_EXT_custom_border_color",
29573     "VK_EXT_debug_marker",
29574     "VK_EXT_depth_clamp_zero_one",
29575     "VK_EXT_depth_clip_control",
29576     "VK_EXT_depth_clip_enable",
29577     "VK_EXT_depth_range_unrestricted",
29578     "VK_EXT_descriptor_indexing",
29579     "VK_EXT_device_address_binding_report",
29580     "VK_EXT_device_fault",
29581     "VK_EXT_discard_rectangles",
29582     "VK_EXT_extended_dynamic_state",
29583     "VK_EXT_extended_dynamic_state2",
29584     "VK_EXT_extended_dynamic_state3",
29585     "VK_EXT_external_memory_host",
29586     "VK_EXT_filter_cubic",
29587     "VK_EXT_fragment_density_map",
29588     "VK_EXT_fragment_density_map2",
29589     "VK_EXT_fragment_shader_interlock",
29590     "VK_EXT_global_priority",
29591     "VK_EXT_global_priority_query",
29592     "VK_EXT_graphics_pipeline_library",
29593     "VK_EXT_host_query_reset",
29594     "VK_EXT_image_2d_view_of_3d",
29595     "VK_EXT_image_compression_control",
29596     "VK_EXT_image_compression_control_swapchain",
29597     "VK_EXT_image_robustness",
29598     "VK_EXT_image_view_min_lod",
29599     "VK_EXT_index_type_uint8",
29600     "VK_EXT_inline_uniform_block",
29601     "VK_EXT_legacy_dithering",
29602     "VK_EXT_line_rasterization",
29603     "VK_EXT_load_store_op_none",
29604     "VK_EXT_memory_budget",
29605     "VK_EXT_memory_priority",
29606     "VK_EXT_mesh_shader",
29607     "VK_EXT_multi_draw",
29608     "VK_EXT_multisampled_render_to_single_sampled",
29609     "VK_EXT_mutable_descriptor_type",
29610     "VK_EXT_non_seamless_cube_map",
29611     "VK_EXT_opacity_micromap",
29612     "VK_EXT_pageable_device_local_memory",
29613     "VK_EXT_pci_bus_info",
29614     "VK_EXT_pipeline_creation_cache_control",
29615     "VK_EXT_pipeline_creation_feedback",
29616     "VK_EXT_pipeline_properties",
29617     "VK_EXT_pipeline_protected_access",
29618     "VK_EXT_pipeline_robustness",
29619     "VK_EXT_post_depth_coverage",
29620     "VK_EXT_primitive_topology_list_restart",
29621     "VK_EXT_primitives_generated_query",
29622     "VK_EXT_private_data",
29623     "VK_EXT_provoking_vertex",
29624     "VK_EXT_queue_family_foreign",
29625     "VK_EXT_rasterization_order_attachment_access",
29626     "VK_EXT_rgba10x6_formats",
29627     "VK_EXT_robustness2",
29628     "VK_EXT_sample_locations",
29629     "VK_EXT_sampler_filter_minmax",
29630     "VK_EXT_scalar_block_layout",
29631     "VK_EXT_separate_stencil_usage",
29632     "VK_EXT_shader_atomic_float",
29633     "VK_EXT_shader_atomic_float2",
29634     "VK_EXT_shader_demote_to_helper_invocation",
29635     "VK_EXT_shader_image_atomic_int64",
29636     "VK_EXT_shader_module_identifier",
29637     "VK_EXT_shader_stencil_export",
29638     "VK_EXT_shader_subgroup_ballot",
29639     "VK_EXT_shader_subgroup_vote",
29640     "VK_EXT_shader_viewport_index_layer",
29641     "VK_EXT_subgroup_size_control",
29642     "VK_EXT_subpass_merge_feedback",
29643     "VK_EXT_texel_buffer_alignment",
29644     "VK_EXT_texture_compression_astc_hdr",
29645     "VK_EXT_tooling_info",
29646     "VK_EXT_transform_feedback",
29647     "VK_EXT_validation_cache",
29648     "VK_EXT_vertex_attribute_divisor",
29649     "VK_EXT_vertex_input_dynamic_state",
29650     "VK_EXT_ycbcr_2plane_444_formats",
29651     "VK_EXT_ycbcr_image_arrays",
29652     "VK_GOOGLE_decorate_string",
29653     "VK_GOOGLE_hlsl_functionality1",
29654     "VK_GOOGLE_user_type",
29655     "VK_HUAWEI_invocation_mask",
29656     "VK_HUAWEI_subpass_shading",
29657     "VK_IMG_filter_cubic",
29658     "VK_IMG_format_pvrtc",
29659     "VK_INTEL_performance_query",
29660     "VK_INTEL_shader_integer_functions2",
29661     "VK_KHR_16bit_storage",
29662     "VK_KHR_8bit_storage",
29663     "VK_KHR_acceleration_structure",
29664     "VK_KHR_bind_memory2",
29665     "VK_KHR_buffer_device_address",
29666     "VK_KHR_copy_commands2",
29667     "VK_KHR_create_renderpass2",
29668     "VK_KHR_dedicated_allocation",
29669     "VK_KHR_deferred_host_operations",
29670     "VK_KHR_depth_stencil_resolve",
29671     "VK_KHR_descriptor_update_template",
29672     "VK_KHR_device_group",
29673     "VK_KHR_draw_indirect_count",
29674     "VK_KHR_driver_properties",
29675     "VK_KHR_dynamic_rendering",
29676     "VK_KHR_external_fence",
29677     "VK_KHR_external_memory",
29678     "VK_KHR_external_semaphore",
29679     "VK_KHR_format_feature_flags2",
29680     "VK_KHR_fragment_shader_barycentric",
29681     "VK_KHR_fragment_shading_rate",
29682     "VK_KHR_get_memory_requirements2",
29683     "VK_KHR_global_priority",
29684     "VK_KHR_image_format_list",
29685     "VK_KHR_imageless_framebuffer",
29686     "VK_KHR_incremental_present",
29687     "VK_KHR_maintenance1",
29688     "VK_KHR_maintenance2",
29689     "VK_KHR_maintenance3",
29690     "VK_KHR_maintenance4",
29691     "VK_KHR_multiview",
29692     "VK_KHR_performance_query",
29693     "VK_KHR_pipeline_executable_properties",
29694     "VK_KHR_pipeline_library",
29695     "VK_KHR_present_id",
29696     "VK_KHR_present_wait",
29697     "VK_KHR_push_descriptor",
29698     "VK_KHR_ray_query",
29699     "VK_KHR_ray_tracing_maintenance1",
29700     "VK_KHR_ray_tracing_pipeline",
29701     "VK_KHR_relaxed_block_layout",
29702     "VK_KHR_sampler_mirror_clamp_to_edge",
29703     "VK_KHR_sampler_ycbcr_conversion",
29704     "VK_KHR_separate_depth_stencil_layouts",
29705     "VK_KHR_shader_atomic_int64",
29706     "VK_KHR_shader_clock",
29707     "VK_KHR_shader_draw_parameters",
29708     "VK_KHR_shader_float16_int8",
29709     "VK_KHR_shader_float_controls",
29710     "VK_KHR_shader_integer_dot_product",
29711     "VK_KHR_shader_non_semantic_info",
29712     "VK_KHR_shader_subgroup_extended_types",
29713     "VK_KHR_shader_subgroup_uniform_control_flow",
29714     "VK_KHR_shader_terminate_invocation",
29715     "VK_KHR_spirv_1_4",
29716     "VK_KHR_storage_buffer_storage_class",
29717     "VK_KHR_swapchain",
29718     "VK_KHR_swapchain_mutable_format",
29719     "VK_KHR_synchronization2",
29720     "VK_KHR_timeline_semaphore",
29721     "VK_KHR_uniform_buffer_standard_layout",
29722     "VK_KHR_variable_pointers",
29723     "VK_KHR_vulkan_memory_model",
29724     "VK_KHR_workgroup_memory_explicit_layout",
29725     "VK_KHR_zero_initialize_workgroup_memory",
29726     "VK_NVX_binary_import",
29727     "VK_NVX_image_view_handle",
29728     "VK_NV_clip_space_w_scaling",
29729     "VK_NV_compute_shader_derivatives",
29730     "VK_NV_cooperative_matrix",
29731     "VK_NV_copy_memory_indirect",
29732     "VK_NV_corner_sampled_image",
29733     "VK_NV_coverage_reduction_mode",
29734     "VK_NV_dedicated_allocation",
29735     "VK_NV_dedicated_allocation_image_aliasing",
29736     "VK_NV_device_diagnostic_checkpoints",
29737     "VK_NV_device_diagnostics_config",
29738     "VK_NV_device_generated_commands",
29739     "VK_NV_fill_rectangle",
29740     "VK_NV_fragment_coverage_to_color",
29741     "VK_NV_fragment_shader_barycentric",
29742     "VK_NV_fragment_shading_rate_enums",
29743     "VK_NV_framebuffer_mixed_samples",
29744     "VK_NV_geometry_shader_passthrough",
29745     "VK_NV_glsl_shader",
29746     "VK_NV_inherited_viewport_scissor",
29747     "VK_NV_linear_color_attachment",
29748     "VK_NV_memory_decompression",
29749     "VK_NV_mesh_shader",
29750     "VK_NV_optical_flow",
29751     "VK_NV_present_barrier",
29752     "VK_NV_ray_tracing",
29753     "VK_NV_ray_tracing_invocation_reorder",
29754     "VK_NV_ray_tracing_motion_blur",
29755     "VK_NV_representative_fragment_test",
29756     "VK_NV_sample_mask_override_coverage",
29757     "VK_NV_scissor_exclusive",
29758     "VK_NV_shader_image_footprint",
29759     "VK_NV_shader_sm_builtins",
29760     "VK_NV_shader_subgroup_partitioned",
29761     "VK_NV_shading_rate_image",
29762     "VK_NV_viewport_array2",
29763     "VK_NV_viewport_swizzle",
29764     "VK_QCOM_fragment_density_map_offset",
29765     "VK_QCOM_image_processing",
29766     "VK_QCOM_render_pass_shader_resolve",
29767     "VK_QCOM_render_pass_store_ops",
29768     "VK_QCOM_render_pass_transform",
29769     "VK_QCOM_rotated_copy_commands",
29770     "VK_QCOM_tile_properties",
29771     "VK_VALVE_descriptor_set_host_mapping",
29772     "VK_VALVE_mutable_descriptor_type",
29773 };
29774
29775 static const char * const vk_instance_extensions[] =
29776 {
29777     "VK_EXT_debug_report",
29778     "VK_EXT_debug_utils",
29779     "VK_EXT_swapchain_colorspace",
29780     "VK_EXT_validation_features",
29781     "VK_EXT_validation_flags",
29782     "VK_KHR_device_group_creation",
29783     "VK_KHR_external_fence_capabilities",
29784     "VK_KHR_external_memory_capabilities",
29785     "VK_KHR_external_semaphore_capabilities",
29786     "VK_KHR_get_physical_device_properties2",
29787     "VK_KHR_get_surface_capabilities2",
29788     "VK_KHR_portability_enumeration",
29789     "VK_KHR_surface",
29790     "VK_KHR_win32_surface",
29791 };
29792
29793 BOOL wine_vk_device_extension_supported(const char *name)
29794 {
29795     unsigned int i;
29796     for (i = 0; i < ARRAY_SIZE(vk_device_extensions); i++)
29797     {
29798         if (strcmp(vk_device_extensions[i], name) == 0)
29799             return TRUE;
29800     }
29801     return FALSE;
29802 }
29803
29804 BOOL wine_vk_instance_extension_supported(const char *name)
29805 {
29806     unsigned int i;
29807     for (i = 0; i < ARRAY_SIZE(vk_instance_extensions); i++)
29808     {
29809         if (strcmp(vk_instance_extensions[i], name) == 0)
29810             return TRUE;
29811     }
29812     return FALSE;
29813 }
29814
29815 BOOL wine_vk_is_type_wrapped(VkObjectType type)
29816 {
29817     return FALSE ||
29818         type == VK_OBJECT_TYPE_COMMAND_BUFFER ||
29819         type == VK_OBJECT_TYPE_COMMAND_POOL ||
29820         type == VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT ||
29821         type == VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT ||
29822         type == VK_OBJECT_TYPE_DEVICE ||
29823         type == VK_OBJECT_TYPE_INSTANCE ||
29824         type == VK_OBJECT_TYPE_PHYSICAL_DEVICE ||
29825         type == VK_OBJECT_TYPE_QUEUE ||
29826         type == VK_OBJECT_TYPE_SURFACE_KHR;
29827 }
29828
29829 #if !defined(USE_STRUCT_CONVERSION)
29830
29831 const unixlib_entry_t __wine_unix_call_funcs[] =
29832 {
29833     init_vulkan,
29834     vk_is_available_instance_function,
29835     vk_is_available_device_function,
29836     thunk64_vkAcquireNextImage2KHR,
29837     thunk64_vkAcquireNextImageKHR,
29838     thunk64_vkAcquirePerformanceConfigurationINTEL,
29839     thunk64_vkAcquireProfilingLockKHR,
29840     thunk64_vkAllocateCommandBuffers,
29841     thunk64_vkAllocateDescriptorSets,
29842     thunk64_vkAllocateMemory,
29843     thunk64_vkBeginCommandBuffer,
29844     thunk64_vkBindAccelerationStructureMemoryNV,
29845     thunk64_vkBindBufferMemory,
29846     thunk64_vkBindBufferMemory2,
29847     thunk64_vkBindBufferMemory2KHR,
29848     thunk64_vkBindImageMemory,
29849     thunk64_vkBindImageMemory2,
29850     thunk64_vkBindImageMemory2KHR,
29851     thunk64_vkBindOpticalFlowSessionImageNV,
29852     thunk64_vkBuildAccelerationStructuresKHR,
29853     thunk64_vkBuildMicromapsEXT,
29854     thunk64_vkCmdBeginConditionalRenderingEXT,
29855     thunk64_vkCmdBeginDebugUtilsLabelEXT,
29856     thunk64_vkCmdBeginQuery,
29857     thunk64_vkCmdBeginQueryIndexedEXT,
29858     thunk64_vkCmdBeginRenderPass,
29859     thunk64_vkCmdBeginRenderPass2,
29860     thunk64_vkCmdBeginRenderPass2KHR,
29861     thunk64_vkCmdBeginRendering,
29862     thunk64_vkCmdBeginRenderingKHR,
29863     thunk64_vkCmdBeginTransformFeedbackEXT,
29864     thunk64_vkCmdBindDescriptorSets,
29865     thunk64_vkCmdBindIndexBuffer,
29866     thunk64_vkCmdBindInvocationMaskHUAWEI,
29867     thunk64_vkCmdBindPipeline,
29868     thunk64_vkCmdBindPipelineShaderGroupNV,
29869     thunk64_vkCmdBindShadingRateImageNV,
29870     thunk64_vkCmdBindTransformFeedbackBuffersEXT,
29871     thunk64_vkCmdBindVertexBuffers,
29872     thunk64_vkCmdBindVertexBuffers2,
29873     thunk64_vkCmdBindVertexBuffers2EXT,
29874     thunk64_vkCmdBlitImage,
29875     thunk64_vkCmdBlitImage2,
29876     thunk64_vkCmdBlitImage2KHR,
29877     thunk64_vkCmdBuildAccelerationStructureNV,
29878     thunk64_vkCmdBuildAccelerationStructuresIndirectKHR,
29879     thunk64_vkCmdBuildAccelerationStructuresKHR,
29880     thunk64_vkCmdBuildMicromapsEXT,
29881     thunk64_vkCmdClearAttachments,
29882     thunk64_vkCmdClearColorImage,
29883     thunk64_vkCmdClearDepthStencilImage,
29884     thunk64_vkCmdCopyAccelerationStructureKHR,
29885     thunk64_vkCmdCopyAccelerationStructureNV,
29886     thunk64_vkCmdCopyAccelerationStructureToMemoryKHR,
29887     thunk64_vkCmdCopyBuffer,
29888     thunk64_vkCmdCopyBuffer2,
29889     thunk64_vkCmdCopyBuffer2KHR,
29890     thunk64_vkCmdCopyBufferToImage,
29891     thunk64_vkCmdCopyBufferToImage2,
29892     thunk64_vkCmdCopyBufferToImage2KHR,
29893     thunk64_vkCmdCopyImage,
29894     thunk64_vkCmdCopyImage2,
29895     thunk64_vkCmdCopyImage2KHR,
29896     thunk64_vkCmdCopyImageToBuffer,
29897     thunk64_vkCmdCopyImageToBuffer2,
29898     thunk64_vkCmdCopyImageToBuffer2KHR,
29899     thunk64_vkCmdCopyMemoryIndirectNV,
29900     thunk64_vkCmdCopyMemoryToAccelerationStructureKHR,
29901     thunk64_vkCmdCopyMemoryToImageIndirectNV,
29902     thunk64_vkCmdCopyMemoryToMicromapEXT,
29903     thunk64_vkCmdCopyMicromapEXT,
29904     thunk64_vkCmdCopyMicromapToMemoryEXT,
29905     thunk64_vkCmdCopyQueryPoolResults,
29906     thunk64_vkCmdCuLaunchKernelNVX,
29907     thunk64_vkCmdDebugMarkerBeginEXT,
29908     thunk64_vkCmdDebugMarkerEndEXT,
29909     thunk64_vkCmdDebugMarkerInsertEXT,
29910     thunk64_vkCmdDecompressMemoryIndirectCountNV,
29911     thunk64_vkCmdDecompressMemoryNV,
29912     thunk64_vkCmdDispatch,
29913     thunk64_vkCmdDispatchBase,
29914     thunk64_vkCmdDispatchBaseKHR,
29915     thunk64_vkCmdDispatchIndirect,
29916     thunk64_vkCmdDraw,
29917     thunk64_vkCmdDrawIndexed,
29918     thunk64_vkCmdDrawIndexedIndirect,
29919     thunk64_vkCmdDrawIndexedIndirectCount,
29920     thunk64_vkCmdDrawIndexedIndirectCountAMD,
29921     thunk64_vkCmdDrawIndexedIndirectCountKHR,
29922     thunk64_vkCmdDrawIndirect,
29923     thunk64_vkCmdDrawIndirectByteCountEXT,
29924     thunk64_vkCmdDrawIndirectCount,
29925     thunk64_vkCmdDrawIndirectCountAMD,
29926     thunk64_vkCmdDrawIndirectCountKHR,
29927     thunk64_vkCmdDrawMeshTasksEXT,
29928     thunk64_vkCmdDrawMeshTasksIndirectCountEXT,
29929     thunk64_vkCmdDrawMeshTasksIndirectCountNV,
29930     thunk64_vkCmdDrawMeshTasksIndirectEXT,
29931     thunk64_vkCmdDrawMeshTasksIndirectNV,
29932     thunk64_vkCmdDrawMeshTasksNV,
29933     thunk64_vkCmdDrawMultiEXT,
29934     thunk64_vkCmdDrawMultiIndexedEXT,
29935     thunk64_vkCmdEndConditionalRenderingEXT,
29936     thunk64_vkCmdEndDebugUtilsLabelEXT,
29937     thunk64_vkCmdEndQuery,
29938     thunk64_vkCmdEndQueryIndexedEXT,
29939     thunk64_vkCmdEndRenderPass,
29940     thunk64_vkCmdEndRenderPass2,
29941     thunk64_vkCmdEndRenderPass2KHR,
29942     thunk64_vkCmdEndRendering,
29943     thunk64_vkCmdEndRenderingKHR,
29944     thunk64_vkCmdEndTransformFeedbackEXT,
29945     thunk64_vkCmdExecuteCommands,
29946     thunk64_vkCmdExecuteGeneratedCommandsNV,
29947     thunk64_vkCmdFillBuffer,
29948     thunk64_vkCmdInsertDebugUtilsLabelEXT,
29949     thunk64_vkCmdNextSubpass,
29950     thunk64_vkCmdNextSubpass2,
29951     thunk64_vkCmdNextSubpass2KHR,
29952     thunk64_vkCmdOpticalFlowExecuteNV,
29953     thunk64_vkCmdPipelineBarrier,
29954     thunk64_vkCmdPipelineBarrier2,
29955     thunk64_vkCmdPipelineBarrier2KHR,
29956     thunk64_vkCmdPreprocessGeneratedCommandsNV,
29957     thunk64_vkCmdPushConstants,
29958     thunk64_vkCmdPushDescriptorSetKHR,
29959     thunk64_vkCmdPushDescriptorSetWithTemplateKHR,
29960     thunk64_vkCmdResetEvent,
29961     thunk64_vkCmdResetEvent2,
29962     thunk64_vkCmdResetEvent2KHR,
29963     thunk64_vkCmdResetQueryPool,
29964     thunk64_vkCmdResolveImage,
29965     thunk64_vkCmdResolveImage2,
29966     thunk64_vkCmdResolveImage2KHR,
29967     thunk64_vkCmdSetAlphaToCoverageEnableEXT,
29968     thunk64_vkCmdSetAlphaToOneEnableEXT,
29969     thunk64_vkCmdSetBlendConstants,
29970     thunk64_vkCmdSetCheckpointNV,
29971     thunk64_vkCmdSetCoarseSampleOrderNV,
29972     thunk64_vkCmdSetColorBlendAdvancedEXT,
29973     thunk64_vkCmdSetColorBlendEnableEXT,
29974     thunk64_vkCmdSetColorBlendEquationEXT,
29975     thunk64_vkCmdSetColorWriteEnableEXT,
29976     thunk64_vkCmdSetColorWriteMaskEXT,
29977     thunk64_vkCmdSetConservativeRasterizationModeEXT,
29978     thunk64_vkCmdSetCoverageModulationModeNV,
29979     thunk64_vkCmdSetCoverageModulationTableEnableNV,
29980     thunk64_vkCmdSetCoverageModulationTableNV,
29981     thunk64_vkCmdSetCoverageReductionModeNV,
29982     thunk64_vkCmdSetCoverageToColorEnableNV,
29983     thunk64_vkCmdSetCoverageToColorLocationNV,
29984     thunk64_vkCmdSetCullMode,
29985     thunk64_vkCmdSetCullModeEXT,
29986     thunk64_vkCmdSetDepthBias,
29987     thunk64_vkCmdSetDepthBiasEnable,
29988     thunk64_vkCmdSetDepthBiasEnableEXT,
29989     thunk64_vkCmdSetDepthBounds,
29990     thunk64_vkCmdSetDepthBoundsTestEnable,
29991     thunk64_vkCmdSetDepthBoundsTestEnableEXT,
29992     thunk64_vkCmdSetDepthClampEnableEXT,
29993     thunk64_vkCmdSetDepthClipEnableEXT,
29994     thunk64_vkCmdSetDepthClipNegativeOneToOneEXT,
29995     thunk64_vkCmdSetDepthCompareOp,
29996     thunk64_vkCmdSetDepthCompareOpEXT,
29997     thunk64_vkCmdSetDepthTestEnable,
29998     thunk64_vkCmdSetDepthTestEnableEXT,
29999     thunk64_vkCmdSetDepthWriteEnable,
30000     thunk64_vkCmdSetDepthWriteEnableEXT,
30001     thunk64_vkCmdSetDeviceMask,
30002     thunk64_vkCmdSetDeviceMaskKHR,
30003     thunk64_vkCmdSetDiscardRectangleEXT,
30004     thunk64_vkCmdSetEvent,
30005     thunk64_vkCmdSetEvent2,
30006     thunk64_vkCmdSetEvent2KHR,
30007     thunk64_vkCmdSetExclusiveScissorNV,
30008     thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
30009     thunk64_vkCmdSetFragmentShadingRateEnumNV,
30010     thunk64_vkCmdSetFragmentShadingRateKHR,
30011     thunk64_vkCmdSetFrontFace,
30012     thunk64_vkCmdSetFrontFaceEXT,
30013     thunk64_vkCmdSetLineRasterizationModeEXT,
30014     thunk64_vkCmdSetLineStippleEXT,
30015     thunk64_vkCmdSetLineStippleEnableEXT,
30016     thunk64_vkCmdSetLineWidth,
30017     thunk64_vkCmdSetLogicOpEXT,
30018     thunk64_vkCmdSetLogicOpEnableEXT,
30019     thunk64_vkCmdSetPatchControlPointsEXT,
30020     thunk64_vkCmdSetPerformanceMarkerINTEL,
30021     thunk64_vkCmdSetPerformanceOverrideINTEL,
30022     thunk64_vkCmdSetPerformanceStreamMarkerINTEL,
30023     thunk64_vkCmdSetPolygonModeEXT,
30024     thunk64_vkCmdSetPrimitiveRestartEnable,
30025     thunk64_vkCmdSetPrimitiveRestartEnableEXT,
30026     thunk64_vkCmdSetPrimitiveTopology,
30027     thunk64_vkCmdSetPrimitiveTopologyEXT,
30028     thunk64_vkCmdSetProvokingVertexModeEXT,
30029     thunk64_vkCmdSetRasterizationSamplesEXT,
30030     thunk64_vkCmdSetRasterizationStreamEXT,
30031     thunk64_vkCmdSetRasterizerDiscardEnable,
30032     thunk64_vkCmdSetRasterizerDiscardEnableEXT,
30033     thunk64_vkCmdSetRayTracingPipelineStackSizeKHR,
30034     thunk64_vkCmdSetRepresentativeFragmentTestEnableNV,
30035     thunk64_vkCmdSetSampleLocationsEXT,
30036     thunk64_vkCmdSetSampleLocationsEnableEXT,
30037     thunk64_vkCmdSetSampleMaskEXT,
30038     thunk64_vkCmdSetScissor,
30039     thunk64_vkCmdSetScissorWithCount,
30040     thunk64_vkCmdSetScissorWithCountEXT,
30041     thunk64_vkCmdSetShadingRateImageEnableNV,
30042     thunk64_vkCmdSetStencilCompareMask,
30043     thunk64_vkCmdSetStencilOp,
30044     thunk64_vkCmdSetStencilOpEXT,
30045     thunk64_vkCmdSetStencilReference,
30046     thunk64_vkCmdSetStencilTestEnable,
30047     thunk64_vkCmdSetStencilTestEnableEXT,
30048     thunk64_vkCmdSetStencilWriteMask,
30049     thunk64_vkCmdSetTessellationDomainOriginEXT,
30050     thunk64_vkCmdSetVertexInputEXT,
30051     thunk64_vkCmdSetViewport,
30052     thunk64_vkCmdSetViewportShadingRatePaletteNV,
30053     thunk64_vkCmdSetViewportSwizzleNV,
30054     thunk64_vkCmdSetViewportWScalingEnableNV,
30055     thunk64_vkCmdSetViewportWScalingNV,
30056     thunk64_vkCmdSetViewportWithCount,
30057     thunk64_vkCmdSetViewportWithCountEXT,
30058     thunk64_vkCmdSubpassShadingHUAWEI,
30059     thunk64_vkCmdTraceRaysIndirect2KHR,
30060     thunk64_vkCmdTraceRaysIndirectKHR,
30061     thunk64_vkCmdTraceRaysKHR,
30062     thunk64_vkCmdTraceRaysNV,
30063     thunk64_vkCmdUpdateBuffer,
30064     thunk64_vkCmdWaitEvents,
30065     thunk64_vkCmdWaitEvents2,
30066     thunk64_vkCmdWaitEvents2KHR,
30067     thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR,
30068     thunk64_vkCmdWriteAccelerationStructuresPropertiesNV,
30069     thunk64_vkCmdWriteBufferMarker2AMD,
30070     thunk64_vkCmdWriteBufferMarkerAMD,
30071     thunk64_vkCmdWriteMicromapsPropertiesEXT,
30072     thunk64_vkCmdWriteTimestamp,
30073     thunk64_vkCmdWriteTimestamp2,
30074     thunk64_vkCmdWriteTimestamp2KHR,
30075     thunk64_vkCompileDeferredNV,
30076     thunk64_vkCopyAccelerationStructureKHR,
30077     thunk64_vkCopyAccelerationStructureToMemoryKHR,
30078     thunk64_vkCopyMemoryToAccelerationStructureKHR,
30079     thunk64_vkCopyMemoryToMicromapEXT,
30080     thunk64_vkCopyMicromapEXT,
30081     thunk64_vkCopyMicromapToMemoryEXT,
30082     thunk64_vkCreateAccelerationStructureKHR,
30083     thunk64_vkCreateAccelerationStructureNV,
30084     thunk64_vkCreateBuffer,
30085     thunk64_vkCreateBufferView,
30086     thunk64_vkCreateCommandPool,
30087     thunk64_vkCreateComputePipelines,
30088     thunk64_vkCreateCuFunctionNVX,
30089     thunk64_vkCreateCuModuleNVX,
30090     thunk64_vkCreateDebugReportCallbackEXT,
30091     thunk64_vkCreateDebugUtilsMessengerEXT,
30092     thunk64_vkCreateDeferredOperationKHR,
30093     thunk64_vkCreateDescriptorPool,
30094     thunk64_vkCreateDescriptorSetLayout,
30095     thunk64_vkCreateDescriptorUpdateTemplate,
30096     thunk64_vkCreateDescriptorUpdateTemplateKHR,
30097     thunk64_vkCreateDevice,
30098     thunk64_vkCreateEvent,
30099     thunk64_vkCreateFence,
30100     thunk64_vkCreateFramebuffer,
30101     thunk64_vkCreateGraphicsPipelines,
30102     thunk64_vkCreateImage,
30103     thunk64_vkCreateImageView,
30104     thunk64_vkCreateIndirectCommandsLayoutNV,
30105     thunk64_vkCreateInstance,
30106     thunk64_vkCreateMicromapEXT,
30107     thunk64_vkCreateOpticalFlowSessionNV,
30108     thunk64_vkCreatePipelineCache,
30109     thunk64_vkCreatePipelineLayout,
30110     thunk64_vkCreatePrivateDataSlot,
30111     thunk64_vkCreatePrivateDataSlotEXT,
30112     thunk64_vkCreateQueryPool,
30113     thunk64_vkCreateRayTracingPipelinesKHR,
30114     thunk64_vkCreateRayTracingPipelinesNV,
30115     thunk64_vkCreateRenderPass,
30116     thunk64_vkCreateRenderPass2,
30117     thunk64_vkCreateRenderPass2KHR,
30118     thunk64_vkCreateSampler,
30119     thunk64_vkCreateSamplerYcbcrConversion,
30120     thunk64_vkCreateSamplerYcbcrConversionKHR,
30121     thunk64_vkCreateSemaphore,
30122     thunk64_vkCreateShaderModule,
30123     thunk64_vkCreateSwapchainKHR,
30124     thunk64_vkCreateValidationCacheEXT,
30125     thunk64_vkCreateWin32SurfaceKHR,
30126     thunk64_vkDebugMarkerSetObjectNameEXT,
30127     thunk64_vkDebugMarkerSetObjectTagEXT,
30128     thunk64_vkDebugReportMessageEXT,
30129     thunk64_vkDeferredOperationJoinKHR,
30130     thunk64_vkDestroyAccelerationStructureKHR,
30131     thunk64_vkDestroyAccelerationStructureNV,
30132     thunk64_vkDestroyBuffer,
30133     thunk64_vkDestroyBufferView,
30134     thunk64_vkDestroyCommandPool,
30135     thunk64_vkDestroyCuFunctionNVX,
30136     thunk64_vkDestroyCuModuleNVX,
30137     thunk64_vkDestroyDebugReportCallbackEXT,
30138     thunk64_vkDestroyDebugUtilsMessengerEXT,
30139     thunk64_vkDestroyDeferredOperationKHR,
30140     thunk64_vkDestroyDescriptorPool,
30141     thunk64_vkDestroyDescriptorSetLayout,
30142     thunk64_vkDestroyDescriptorUpdateTemplate,
30143     thunk64_vkDestroyDescriptorUpdateTemplateKHR,
30144     thunk64_vkDestroyDevice,
30145     thunk64_vkDestroyEvent,
30146     thunk64_vkDestroyFence,
30147     thunk64_vkDestroyFramebuffer,
30148     thunk64_vkDestroyImage,
30149     thunk64_vkDestroyImageView,
30150     thunk64_vkDestroyIndirectCommandsLayoutNV,
30151     thunk64_vkDestroyInstance,
30152     thunk64_vkDestroyMicromapEXT,
30153     thunk64_vkDestroyOpticalFlowSessionNV,
30154     thunk64_vkDestroyPipeline,
30155     thunk64_vkDestroyPipelineCache,
30156     thunk64_vkDestroyPipelineLayout,
30157     thunk64_vkDestroyPrivateDataSlot,
30158     thunk64_vkDestroyPrivateDataSlotEXT,
30159     thunk64_vkDestroyQueryPool,
30160     thunk64_vkDestroyRenderPass,
30161     thunk64_vkDestroySampler,
30162     thunk64_vkDestroySamplerYcbcrConversion,
30163     thunk64_vkDestroySamplerYcbcrConversionKHR,
30164     thunk64_vkDestroySemaphore,
30165     thunk64_vkDestroyShaderModule,
30166     thunk64_vkDestroySurfaceKHR,
30167     thunk64_vkDestroySwapchainKHR,
30168     thunk64_vkDestroyValidationCacheEXT,
30169     thunk64_vkDeviceWaitIdle,
30170     thunk64_vkEndCommandBuffer,
30171     thunk64_vkEnumerateDeviceExtensionProperties,
30172     thunk64_vkEnumerateDeviceLayerProperties,
30173     thunk64_vkEnumerateInstanceExtensionProperties,
30174     thunk64_vkEnumerateInstanceVersion,
30175     thunk64_vkEnumeratePhysicalDeviceGroups,
30176     thunk64_vkEnumeratePhysicalDeviceGroupsKHR,
30177     thunk64_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
30178     thunk64_vkEnumeratePhysicalDevices,
30179     thunk64_vkFlushMappedMemoryRanges,
30180     thunk64_vkFreeCommandBuffers,
30181     thunk64_vkFreeDescriptorSets,
30182     thunk64_vkFreeMemory,
30183     thunk64_vkGetAccelerationStructureBuildSizesKHR,
30184     thunk64_vkGetAccelerationStructureDeviceAddressKHR,
30185     thunk64_vkGetAccelerationStructureHandleNV,
30186     thunk64_vkGetAccelerationStructureMemoryRequirementsNV,
30187     thunk64_vkGetBufferDeviceAddress,
30188     thunk64_vkGetBufferDeviceAddressEXT,
30189     thunk64_vkGetBufferDeviceAddressKHR,
30190     thunk64_vkGetBufferMemoryRequirements,
30191     thunk64_vkGetBufferMemoryRequirements2,
30192     thunk64_vkGetBufferMemoryRequirements2KHR,
30193     thunk64_vkGetBufferOpaqueCaptureAddress,
30194     thunk64_vkGetBufferOpaqueCaptureAddressKHR,
30195     thunk64_vkGetCalibratedTimestampsEXT,
30196     thunk64_vkGetDeferredOperationMaxConcurrencyKHR,
30197     thunk64_vkGetDeferredOperationResultKHR,
30198     thunk64_vkGetDescriptorSetHostMappingVALVE,
30199     thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
30200     thunk64_vkGetDescriptorSetLayoutSupport,
30201     thunk64_vkGetDescriptorSetLayoutSupportKHR,
30202     thunk64_vkGetDeviceAccelerationStructureCompatibilityKHR,
30203     thunk64_vkGetDeviceBufferMemoryRequirements,
30204     thunk64_vkGetDeviceBufferMemoryRequirementsKHR,
30205     thunk64_vkGetDeviceFaultInfoEXT,
30206     thunk64_vkGetDeviceGroupPeerMemoryFeatures,
30207     thunk64_vkGetDeviceGroupPeerMemoryFeaturesKHR,
30208     thunk64_vkGetDeviceGroupPresentCapabilitiesKHR,
30209     thunk64_vkGetDeviceGroupSurfacePresentModesKHR,
30210     thunk64_vkGetDeviceImageMemoryRequirements,
30211     thunk64_vkGetDeviceImageMemoryRequirementsKHR,
30212     thunk64_vkGetDeviceImageSparseMemoryRequirements,
30213     thunk64_vkGetDeviceImageSparseMemoryRequirementsKHR,
30214     thunk64_vkGetDeviceMemoryCommitment,
30215     thunk64_vkGetDeviceMemoryOpaqueCaptureAddress,
30216     thunk64_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
30217     thunk64_vkGetDeviceMicromapCompatibilityEXT,
30218     thunk64_vkGetDeviceQueue,
30219     thunk64_vkGetDeviceQueue2,
30220     thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
30221     thunk64_vkGetDynamicRenderingTilePropertiesQCOM,
30222     thunk64_vkGetEventStatus,
30223     thunk64_vkGetFenceStatus,
30224     thunk64_vkGetFramebufferTilePropertiesQCOM,
30225     thunk64_vkGetGeneratedCommandsMemoryRequirementsNV,
30226     thunk64_vkGetImageMemoryRequirements,
30227     thunk64_vkGetImageMemoryRequirements2,
30228     thunk64_vkGetImageMemoryRequirements2KHR,
30229     thunk64_vkGetImageSparseMemoryRequirements,
30230     thunk64_vkGetImageSparseMemoryRequirements2,
30231     thunk64_vkGetImageSparseMemoryRequirements2KHR,
30232     thunk64_vkGetImageSubresourceLayout,
30233     thunk64_vkGetImageSubresourceLayout2EXT,
30234     thunk64_vkGetImageViewAddressNVX,
30235     thunk64_vkGetImageViewHandleNVX,
30236     thunk64_vkGetMemoryHostPointerPropertiesEXT,
30237     thunk64_vkGetMicromapBuildSizesEXT,
30238     thunk64_vkGetPerformanceParameterINTEL,
30239     thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
30240     thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
30241     thunk64_vkGetPhysicalDeviceExternalBufferProperties,
30242     thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
30243     thunk64_vkGetPhysicalDeviceExternalFenceProperties,
30244     thunk64_vkGetPhysicalDeviceExternalFencePropertiesKHR,
30245     thunk64_vkGetPhysicalDeviceExternalSemaphoreProperties,
30246     thunk64_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
30247     thunk64_vkGetPhysicalDeviceFeatures,
30248     thunk64_vkGetPhysicalDeviceFeatures2,
30249     thunk64_vkGetPhysicalDeviceFeatures2KHR,
30250     thunk64_vkGetPhysicalDeviceFormatProperties,
30251     thunk64_vkGetPhysicalDeviceFormatProperties2,
30252     thunk64_vkGetPhysicalDeviceFormatProperties2KHR,
30253     thunk64_vkGetPhysicalDeviceFragmentShadingRatesKHR,
30254     thunk64_vkGetPhysicalDeviceImageFormatProperties,
30255     thunk64_vkGetPhysicalDeviceImageFormatProperties2,
30256     thunk64_vkGetPhysicalDeviceImageFormatProperties2KHR,
30257     thunk64_vkGetPhysicalDeviceMemoryProperties,
30258     thunk64_vkGetPhysicalDeviceMemoryProperties2,
30259     thunk64_vkGetPhysicalDeviceMemoryProperties2KHR,
30260     thunk64_vkGetPhysicalDeviceMultisamplePropertiesEXT,
30261     thunk64_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
30262     thunk64_vkGetPhysicalDevicePresentRectanglesKHR,
30263     thunk64_vkGetPhysicalDeviceProperties,
30264     thunk64_vkGetPhysicalDeviceProperties2,
30265     thunk64_vkGetPhysicalDeviceProperties2KHR,
30266     thunk64_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
30267     thunk64_vkGetPhysicalDeviceQueueFamilyProperties,
30268     thunk64_vkGetPhysicalDeviceQueueFamilyProperties2,
30269     thunk64_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
30270     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties,
30271     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2,
30272     thunk64_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
30273     thunk64_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
30274     thunk64_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
30275     thunk64_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
30276     thunk64_vkGetPhysicalDeviceSurfaceFormats2KHR,
30277     thunk64_vkGetPhysicalDeviceSurfaceFormatsKHR,
30278     thunk64_vkGetPhysicalDeviceSurfacePresentModesKHR,
30279     thunk64_vkGetPhysicalDeviceSurfaceSupportKHR,
30280     thunk64_vkGetPhysicalDeviceToolProperties,
30281     thunk64_vkGetPhysicalDeviceToolPropertiesEXT,
30282     thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR,
30283     thunk64_vkGetPipelineCacheData,
30284     thunk64_vkGetPipelineExecutableInternalRepresentationsKHR,
30285     thunk64_vkGetPipelineExecutablePropertiesKHR,
30286     thunk64_vkGetPipelineExecutableStatisticsKHR,
30287     thunk64_vkGetPipelinePropertiesEXT,
30288     thunk64_vkGetPrivateData,
30289     thunk64_vkGetPrivateDataEXT,
30290     thunk64_vkGetQueryPoolResults,
30291     thunk64_vkGetQueueCheckpointData2NV,
30292     thunk64_vkGetQueueCheckpointDataNV,
30293     thunk64_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
30294     thunk64_vkGetRayTracingShaderGroupHandlesKHR,
30295     thunk64_vkGetRayTracingShaderGroupHandlesNV,
30296     thunk64_vkGetRayTracingShaderGroupStackSizeKHR,
30297     thunk64_vkGetRenderAreaGranularity,
30298     thunk64_vkGetSemaphoreCounterValue,
30299     thunk64_vkGetSemaphoreCounterValueKHR,
30300     thunk64_vkGetShaderInfoAMD,
30301     thunk64_vkGetShaderModuleCreateInfoIdentifierEXT,
30302     thunk64_vkGetShaderModuleIdentifierEXT,
30303     thunk64_vkGetSwapchainImagesKHR,
30304     thunk64_vkGetValidationCacheDataEXT,
30305     thunk64_vkInitializePerformanceApiINTEL,
30306     thunk64_vkInvalidateMappedMemoryRanges,
30307     thunk64_vkMapMemory,
30308     thunk64_vkMergePipelineCaches,
30309     thunk64_vkMergeValidationCachesEXT,
30310     thunk64_vkQueueBeginDebugUtilsLabelEXT,
30311     thunk64_vkQueueBindSparse,
30312     thunk64_vkQueueEndDebugUtilsLabelEXT,
30313     thunk64_vkQueueInsertDebugUtilsLabelEXT,
30314     thunk64_vkQueuePresentKHR,
30315     thunk64_vkQueueSetPerformanceConfigurationINTEL,
30316     thunk64_vkQueueSubmit,
30317     thunk64_vkQueueSubmit2,
30318     thunk64_vkQueueSubmit2KHR,
30319     thunk64_vkQueueWaitIdle,
30320     thunk64_vkReleasePerformanceConfigurationINTEL,
30321     thunk64_vkReleaseProfilingLockKHR,
30322     thunk64_vkResetCommandBuffer,
30323     thunk64_vkResetCommandPool,
30324     thunk64_vkResetDescriptorPool,
30325     thunk64_vkResetEvent,
30326     thunk64_vkResetFences,
30327     thunk64_vkResetQueryPool,
30328     thunk64_vkResetQueryPoolEXT,
30329     thunk64_vkSetDebugUtilsObjectNameEXT,
30330     thunk64_vkSetDebugUtilsObjectTagEXT,
30331     thunk64_vkSetDeviceMemoryPriorityEXT,
30332     thunk64_vkSetEvent,
30333     thunk64_vkSetPrivateData,
30334     thunk64_vkSetPrivateDataEXT,
30335     thunk64_vkSignalSemaphore,
30336     thunk64_vkSignalSemaphoreKHR,
30337     thunk64_vkSubmitDebugUtilsMessageEXT,
30338     thunk64_vkTrimCommandPool,
30339     thunk64_vkTrimCommandPoolKHR,
30340     thunk64_vkUninitializePerformanceApiINTEL,
30341     thunk64_vkUnmapMemory,
30342     thunk64_vkUpdateDescriptorSetWithTemplate,
30343     thunk64_vkUpdateDescriptorSetWithTemplateKHR,
30344     thunk64_vkUpdateDescriptorSets,
30345     thunk64_vkWaitForFences,
30346     thunk64_vkWaitForPresentKHR,
30347     thunk64_vkWaitSemaphores,
30348     thunk64_vkWaitSemaphoresKHR,
30349     thunk64_vkWriteAccelerationStructuresPropertiesKHR,
30350     thunk64_vkWriteMicromapsPropertiesEXT,
30351 };
30352 C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);
30353
30354 #else /* USE_STRUCT_CONVERSION) */
30355
30356 const unixlib_entry_t __wine_unix_call_funcs[] =
30357 {
30358     init_vulkan,
30359     vk_is_available_instance_function,
30360     vk_is_available_device_function,
30361     thunk32_vkAcquireNextImage2KHR,
30362     thunk32_vkAcquireNextImageKHR,
30363     thunk32_vkAcquirePerformanceConfigurationINTEL,
30364     thunk32_vkAcquireProfilingLockKHR,
30365     thunk32_vkAllocateCommandBuffers,
30366     thunk32_vkAllocateDescriptorSets,
30367     thunk32_vkAllocateMemory,
30368     thunk32_vkBeginCommandBuffer,
30369     thunk32_vkBindAccelerationStructureMemoryNV,
30370     thunk32_vkBindBufferMemory,
30371     thunk32_vkBindBufferMemory2,
30372     thunk32_vkBindBufferMemory2KHR,
30373     thunk32_vkBindImageMemory,
30374     thunk32_vkBindImageMemory2,
30375     thunk32_vkBindImageMemory2KHR,
30376     thunk32_vkBindOpticalFlowSessionImageNV,
30377     thunk32_vkBuildAccelerationStructuresKHR,
30378     thunk32_vkBuildMicromapsEXT,
30379     thunk32_vkCmdBeginConditionalRenderingEXT,
30380     thunk32_vkCmdBeginDebugUtilsLabelEXT,
30381     thunk32_vkCmdBeginQuery,
30382     thunk32_vkCmdBeginQueryIndexedEXT,
30383     thunk32_vkCmdBeginRenderPass,
30384     thunk32_vkCmdBeginRenderPass2,
30385     thunk32_vkCmdBeginRenderPass2KHR,
30386     thunk32_vkCmdBeginRendering,
30387     thunk32_vkCmdBeginRenderingKHR,
30388     thunk32_vkCmdBeginTransformFeedbackEXT,
30389     thunk32_vkCmdBindDescriptorSets,
30390     thunk32_vkCmdBindIndexBuffer,
30391     thunk32_vkCmdBindInvocationMaskHUAWEI,
30392     thunk32_vkCmdBindPipeline,
30393     thunk32_vkCmdBindPipelineShaderGroupNV,
30394     thunk32_vkCmdBindShadingRateImageNV,
30395     thunk32_vkCmdBindTransformFeedbackBuffersEXT,
30396     thunk32_vkCmdBindVertexBuffers,
30397     thunk32_vkCmdBindVertexBuffers2,
30398     thunk32_vkCmdBindVertexBuffers2EXT,
30399     thunk32_vkCmdBlitImage,
30400     thunk32_vkCmdBlitImage2,
30401     thunk32_vkCmdBlitImage2KHR,
30402     thunk32_vkCmdBuildAccelerationStructureNV,
30403     thunk32_vkCmdBuildAccelerationStructuresIndirectKHR,
30404     thunk32_vkCmdBuildAccelerationStructuresKHR,
30405     thunk32_vkCmdBuildMicromapsEXT,
30406     thunk32_vkCmdClearAttachments,
30407     thunk32_vkCmdClearColorImage,
30408     thunk32_vkCmdClearDepthStencilImage,
30409     thunk32_vkCmdCopyAccelerationStructureKHR,
30410     thunk32_vkCmdCopyAccelerationStructureNV,
30411     thunk32_vkCmdCopyAccelerationStructureToMemoryKHR,
30412     thunk32_vkCmdCopyBuffer,
30413     thunk32_vkCmdCopyBuffer2,
30414     thunk32_vkCmdCopyBuffer2KHR,
30415     thunk32_vkCmdCopyBufferToImage,
30416     thunk32_vkCmdCopyBufferToImage2,
30417     thunk32_vkCmdCopyBufferToImage2KHR,
30418     thunk32_vkCmdCopyImage,
30419     thunk32_vkCmdCopyImage2,
30420     thunk32_vkCmdCopyImage2KHR,
30421     thunk32_vkCmdCopyImageToBuffer,
30422     thunk32_vkCmdCopyImageToBuffer2,
30423     thunk32_vkCmdCopyImageToBuffer2KHR,
30424     thunk32_vkCmdCopyMemoryIndirectNV,
30425     thunk32_vkCmdCopyMemoryToAccelerationStructureKHR,
30426     thunk32_vkCmdCopyMemoryToImageIndirectNV,
30427     thunk32_vkCmdCopyMemoryToMicromapEXT,
30428     thunk32_vkCmdCopyMicromapEXT,
30429     thunk32_vkCmdCopyMicromapToMemoryEXT,
30430     thunk32_vkCmdCopyQueryPoolResults,
30431     thunk32_vkCmdCuLaunchKernelNVX,
30432     thunk32_vkCmdDebugMarkerBeginEXT,
30433     thunk32_vkCmdDebugMarkerEndEXT,
30434     thunk32_vkCmdDebugMarkerInsertEXT,
30435     thunk32_vkCmdDecompressMemoryIndirectCountNV,
30436     thunk32_vkCmdDecompressMemoryNV,
30437     thunk32_vkCmdDispatch,
30438     thunk32_vkCmdDispatchBase,
30439     thunk32_vkCmdDispatchBaseKHR,
30440     thunk32_vkCmdDispatchIndirect,
30441     thunk32_vkCmdDraw,
30442     thunk32_vkCmdDrawIndexed,
30443     thunk32_vkCmdDrawIndexedIndirect,
30444     thunk32_vkCmdDrawIndexedIndirectCount,
30445     thunk32_vkCmdDrawIndexedIndirectCountAMD,
30446     thunk32_vkCmdDrawIndexedIndirectCountKHR,
30447     thunk32_vkCmdDrawIndirect,
30448     thunk32_vkCmdDrawIndirectByteCountEXT,
30449     thunk32_vkCmdDrawIndirectCount,
30450     thunk32_vkCmdDrawIndirectCountAMD,
30451     thunk32_vkCmdDrawIndirectCountKHR,
30452     thunk32_vkCmdDrawMeshTasksEXT,
30453     thunk32_vkCmdDrawMeshTasksIndirectCountEXT,
30454     thunk32_vkCmdDrawMeshTasksIndirectCountNV,
30455     thunk32_vkCmdDrawMeshTasksIndirectEXT,
30456     thunk32_vkCmdDrawMeshTasksIndirectNV,
30457     thunk32_vkCmdDrawMeshTasksNV,
30458     thunk32_vkCmdDrawMultiEXT,
30459     thunk32_vkCmdDrawMultiIndexedEXT,
30460     thunk32_vkCmdEndConditionalRenderingEXT,
30461     thunk32_vkCmdEndDebugUtilsLabelEXT,
30462     thunk32_vkCmdEndQuery,
30463     thunk32_vkCmdEndQueryIndexedEXT,
30464     thunk32_vkCmdEndRenderPass,
30465     thunk32_vkCmdEndRenderPass2,
30466     thunk32_vkCmdEndRenderPass2KHR,
30467     thunk32_vkCmdEndRendering,
30468     thunk32_vkCmdEndRenderingKHR,
30469     thunk32_vkCmdEndTransformFeedbackEXT,
30470     thunk32_vkCmdExecuteCommands,
30471     thunk32_vkCmdExecuteGeneratedCommandsNV,
30472     thunk32_vkCmdFillBuffer,
30473     thunk32_vkCmdInsertDebugUtilsLabelEXT,
30474     thunk32_vkCmdNextSubpass,
30475     thunk32_vkCmdNextSubpass2,
30476     thunk32_vkCmdNextSubpass2KHR,
30477     thunk32_vkCmdOpticalFlowExecuteNV,
30478     thunk32_vkCmdPipelineBarrier,
30479     thunk32_vkCmdPipelineBarrier2,
30480     thunk32_vkCmdPipelineBarrier2KHR,
30481     thunk32_vkCmdPreprocessGeneratedCommandsNV,
30482     thunk32_vkCmdPushConstants,
30483     thunk32_vkCmdPushDescriptorSetKHR,
30484     thunk32_vkCmdPushDescriptorSetWithTemplateKHR,
30485     thunk32_vkCmdResetEvent,
30486     thunk32_vkCmdResetEvent2,
30487     thunk32_vkCmdResetEvent2KHR,
30488     thunk32_vkCmdResetQueryPool,
30489     thunk32_vkCmdResolveImage,
30490     thunk32_vkCmdResolveImage2,
30491     thunk32_vkCmdResolveImage2KHR,
30492     thunk32_vkCmdSetAlphaToCoverageEnableEXT,
30493     thunk32_vkCmdSetAlphaToOneEnableEXT,
30494     thunk32_vkCmdSetBlendConstants,
30495     thunk32_vkCmdSetCheckpointNV,
30496     thunk32_vkCmdSetCoarseSampleOrderNV,
30497     thunk32_vkCmdSetColorBlendAdvancedEXT,
30498     thunk32_vkCmdSetColorBlendEnableEXT,
30499     thunk32_vkCmdSetColorBlendEquationEXT,
30500     thunk32_vkCmdSetColorWriteEnableEXT,
30501     thunk32_vkCmdSetColorWriteMaskEXT,
30502     thunk32_vkCmdSetConservativeRasterizationModeEXT,
30503     thunk32_vkCmdSetCoverageModulationModeNV,
30504     thunk32_vkCmdSetCoverageModulationTableEnableNV,
30505     thunk32_vkCmdSetCoverageModulationTableNV,
30506     thunk32_vkCmdSetCoverageReductionModeNV,
30507     thunk32_vkCmdSetCoverageToColorEnableNV,
30508     thunk32_vkCmdSetCoverageToColorLocationNV,
30509     thunk32_vkCmdSetCullMode,
30510     thunk32_vkCmdSetCullModeEXT,
30511     thunk32_vkCmdSetDepthBias,
30512     thunk32_vkCmdSetDepthBiasEnable,
30513     thunk32_vkCmdSetDepthBiasEnableEXT,
30514     thunk32_vkCmdSetDepthBounds,
30515     thunk32_vkCmdSetDepthBoundsTestEnable,
30516     thunk32_vkCmdSetDepthBoundsTestEnableEXT,
30517     thunk32_vkCmdSetDepthClampEnableEXT,
30518     thunk32_vkCmdSetDepthClipEnableEXT,
30519     thunk32_vkCmdSetDepthClipNegativeOneToOneEXT,
30520     thunk32_vkCmdSetDepthCompareOp,
30521     thunk32_vkCmdSetDepthCompareOpEXT,
30522     thunk32_vkCmdSetDepthTestEnable,
30523     thunk32_vkCmdSetDepthTestEnableEXT,
30524     thunk32_vkCmdSetDepthWriteEnable,
30525     thunk32_vkCmdSetDepthWriteEnableEXT,
30526     thunk32_vkCmdSetDeviceMask,
30527     thunk32_vkCmdSetDeviceMaskKHR,
30528     thunk32_vkCmdSetDiscardRectangleEXT,
30529     thunk32_vkCmdSetEvent,
30530     thunk32_vkCmdSetEvent2,
30531     thunk32_vkCmdSetEvent2KHR,
30532     thunk32_vkCmdSetExclusiveScissorNV,
30533     thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
30534     thunk32_vkCmdSetFragmentShadingRateEnumNV,
30535     thunk32_vkCmdSetFragmentShadingRateKHR,
30536     thunk32_vkCmdSetFrontFace,
30537     thunk32_vkCmdSetFrontFaceEXT,
30538     thunk32_vkCmdSetLineRasterizationModeEXT,
30539     thunk32_vkCmdSetLineStippleEXT,
30540     thunk32_vkCmdSetLineStippleEnableEXT,
30541     thunk32_vkCmdSetLineWidth,
30542     thunk32_vkCmdSetLogicOpEXT,
30543     thunk32_vkCmdSetLogicOpEnableEXT,
30544     thunk32_vkCmdSetPatchControlPointsEXT,
30545     thunk32_vkCmdSetPerformanceMarkerINTEL,
30546     thunk32_vkCmdSetPerformanceOverrideINTEL,
30547     thunk32_vkCmdSetPerformanceStreamMarkerINTEL,
30548     thunk32_vkCmdSetPolygonModeEXT,
30549     thunk32_vkCmdSetPrimitiveRestartEnable,
30550     thunk32_vkCmdSetPrimitiveRestartEnableEXT,
30551     thunk32_vkCmdSetPrimitiveTopology,
30552     thunk32_vkCmdSetPrimitiveTopologyEXT,
30553     thunk32_vkCmdSetProvokingVertexModeEXT,
30554     thunk32_vkCmdSetRasterizationSamplesEXT,
30555     thunk32_vkCmdSetRasterizationStreamEXT,
30556     thunk32_vkCmdSetRasterizerDiscardEnable,
30557     thunk32_vkCmdSetRasterizerDiscardEnableEXT,
30558     thunk32_vkCmdSetRayTracingPipelineStackSizeKHR,
30559     thunk32_vkCmdSetRepresentativeFragmentTestEnableNV,
30560     thunk32_vkCmdSetSampleLocationsEXT,
30561     thunk32_vkCmdSetSampleLocationsEnableEXT,
30562     thunk32_vkCmdSetSampleMaskEXT,
30563     thunk32_vkCmdSetScissor,
30564     thunk32_vkCmdSetScissorWithCount,
30565     thunk32_vkCmdSetScissorWithCountEXT,
30566     thunk32_vkCmdSetShadingRateImageEnableNV,
30567     thunk32_vkCmdSetStencilCompareMask,
30568     thunk32_vkCmdSetStencilOp,
30569     thunk32_vkCmdSetStencilOpEXT,
30570     thunk32_vkCmdSetStencilReference,
30571     thunk32_vkCmdSetStencilTestEnable,
30572     thunk32_vkCmdSetStencilTestEnableEXT,
30573     thunk32_vkCmdSetStencilWriteMask,
30574     thunk32_vkCmdSetTessellationDomainOriginEXT,
30575     thunk32_vkCmdSetVertexInputEXT,
30576     thunk32_vkCmdSetViewport,
30577     thunk32_vkCmdSetViewportShadingRatePaletteNV,
30578     thunk32_vkCmdSetViewportSwizzleNV,
30579     thunk32_vkCmdSetViewportWScalingEnableNV,
30580     thunk32_vkCmdSetViewportWScalingNV,
30581     thunk32_vkCmdSetViewportWithCount,
30582     thunk32_vkCmdSetViewportWithCountEXT,
30583     thunk32_vkCmdSubpassShadingHUAWEI,
30584     thunk32_vkCmdTraceRaysIndirect2KHR,
30585     thunk32_vkCmdTraceRaysIndirectKHR,
30586     thunk32_vkCmdTraceRaysKHR,
30587     thunk32_vkCmdTraceRaysNV,
30588     thunk32_vkCmdUpdateBuffer,
30589     thunk32_vkCmdWaitEvents,
30590     thunk32_vkCmdWaitEvents2,
30591     thunk32_vkCmdWaitEvents2KHR,
30592     thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR,
30593     thunk32_vkCmdWriteAccelerationStructuresPropertiesNV,
30594     thunk32_vkCmdWriteBufferMarker2AMD,
30595     thunk32_vkCmdWriteBufferMarkerAMD,
30596     thunk32_vkCmdWriteMicromapsPropertiesEXT,
30597     thunk32_vkCmdWriteTimestamp,
30598     thunk32_vkCmdWriteTimestamp2,
30599     thunk32_vkCmdWriteTimestamp2KHR,
30600     thunk32_vkCompileDeferredNV,
30601     thunk32_vkCopyAccelerationStructureKHR,
30602     thunk32_vkCopyAccelerationStructureToMemoryKHR,
30603     thunk32_vkCopyMemoryToAccelerationStructureKHR,
30604     thunk32_vkCopyMemoryToMicromapEXT,
30605     thunk32_vkCopyMicromapEXT,
30606     thunk32_vkCopyMicromapToMemoryEXT,
30607     thunk32_vkCreateAccelerationStructureKHR,
30608     thunk32_vkCreateAccelerationStructureNV,
30609     thunk32_vkCreateBuffer,
30610     thunk32_vkCreateBufferView,
30611     thunk32_vkCreateCommandPool,
30612     thunk32_vkCreateComputePipelines,
30613     thunk32_vkCreateCuFunctionNVX,
30614     thunk32_vkCreateCuModuleNVX,
30615     thunk32_vkCreateDebugReportCallbackEXT,
30616     thunk32_vkCreateDebugUtilsMessengerEXT,
30617     thunk32_vkCreateDeferredOperationKHR,
30618     thunk32_vkCreateDescriptorPool,
30619     thunk32_vkCreateDescriptorSetLayout,
30620     thunk32_vkCreateDescriptorUpdateTemplate,
30621     thunk32_vkCreateDescriptorUpdateTemplateKHR,
30622     thunk32_vkCreateDevice,
30623     thunk32_vkCreateEvent,
30624     thunk32_vkCreateFence,
30625     thunk32_vkCreateFramebuffer,
30626     thunk32_vkCreateGraphicsPipelines,
30627     thunk32_vkCreateImage,
30628     thunk32_vkCreateImageView,
30629     thunk32_vkCreateIndirectCommandsLayoutNV,
30630     thunk32_vkCreateInstance,
30631     thunk32_vkCreateMicromapEXT,
30632     thunk32_vkCreateOpticalFlowSessionNV,
30633     thunk32_vkCreatePipelineCache,
30634     thunk32_vkCreatePipelineLayout,
30635     thunk32_vkCreatePrivateDataSlot,
30636     thunk32_vkCreatePrivateDataSlotEXT,
30637     thunk32_vkCreateQueryPool,
30638     thunk32_vkCreateRayTracingPipelinesKHR,
30639     thunk32_vkCreateRayTracingPipelinesNV,
30640     thunk32_vkCreateRenderPass,
30641     thunk32_vkCreateRenderPass2,
30642     thunk32_vkCreateRenderPass2KHR,
30643     thunk32_vkCreateSampler,
30644     thunk32_vkCreateSamplerYcbcrConversion,
30645     thunk32_vkCreateSamplerYcbcrConversionKHR,
30646     thunk32_vkCreateSemaphore,
30647     thunk32_vkCreateShaderModule,
30648     thunk32_vkCreateSwapchainKHR,
30649     thunk32_vkCreateValidationCacheEXT,
30650     thunk32_vkCreateWin32SurfaceKHR,
30651     thunk32_vkDebugMarkerSetObjectNameEXT,
30652     thunk32_vkDebugMarkerSetObjectTagEXT,
30653     thunk32_vkDebugReportMessageEXT,
30654     thunk32_vkDeferredOperationJoinKHR,
30655     thunk32_vkDestroyAccelerationStructureKHR,
30656     thunk32_vkDestroyAccelerationStructureNV,
30657     thunk32_vkDestroyBuffer,
30658     thunk32_vkDestroyBufferView,
30659     thunk32_vkDestroyCommandPool,
30660     thunk32_vkDestroyCuFunctionNVX,
30661     thunk32_vkDestroyCuModuleNVX,
30662     thunk32_vkDestroyDebugReportCallbackEXT,
30663     thunk32_vkDestroyDebugUtilsMessengerEXT,
30664     thunk32_vkDestroyDeferredOperationKHR,
30665     thunk32_vkDestroyDescriptorPool,
30666     thunk32_vkDestroyDescriptorSetLayout,
30667     thunk32_vkDestroyDescriptorUpdateTemplate,
30668     thunk32_vkDestroyDescriptorUpdateTemplateKHR,
30669     thunk32_vkDestroyDevice,
30670     thunk32_vkDestroyEvent,
30671     thunk32_vkDestroyFence,
30672     thunk32_vkDestroyFramebuffer,
30673     thunk32_vkDestroyImage,
30674     thunk32_vkDestroyImageView,
30675     thunk32_vkDestroyIndirectCommandsLayoutNV,
30676     thunk32_vkDestroyInstance,
30677     thunk32_vkDestroyMicromapEXT,
30678     thunk32_vkDestroyOpticalFlowSessionNV,
30679     thunk32_vkDestroyPipeline,
30680     thunk32_vkDestroyPipelineCache,
30681     thunk32_vkDestroyPipelineLayout,
30682     thunk32_vkDestroyPrivateDataSlot,
30683     thunk32_vkDestroyPrivateDataSlotEXT,
30684     thunk32_vkDestroyQueryPool,
30685     thunk32_vkDestroyRenderPass,
30686     thunk32_vkDestroySampler,
30687     thunk32_vkDestroySamplerYcbcrConversion,
30688     thunk32_vkDestroySamplerYcbcrConversionKHR,
30689     thunk32_vkDestroySemaphore,
30690     thunk32_vkDestroyShaderModule,
30691     thunk32_vkDestroySurfaceKHR,
30692     thunk32_vkDestroySwapchainKHR,
30693     thunk32_vkDestroyValidationCacheEXT,
30694     thunk32_vkDeviceWaitIdle,
30695     thunk32_vkEndCommandBuffer,
30696     thunk32_vkEnumerateDeviceExtensionProperties,
30697     thunk32_vkEnumerateDeviceLayerProperties,
30698     thunk32_vkEnumerateInstanceExtensionProperties,
30699     thunk32_vkEnumerateInstanceVersion,
30700     thunk32_vkEnumeratePhysicalDeviceGroups,
30701     thunk32_vkEnumeratePhysicalDeviceGroupsKHR,
30702     thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
30703     thunk32_vkEnumeratePhysicalDevices,
30704     thunk32_vkFlushMappedMemoryRanges,
30705     thunk32_vkFreeCommandBuffers,
30706     thunk32_vkFreeDescriptorSets,
30707     thunk32_vkFreeMemory,
30708     thunk32_vkGetAccelerationStructureBuildSizesKHR,
30709     thunk32_vkGetAccelerationStructureDeviceAddressKHR,
30710     thunk32_vkGetAccelerationStructureHandleNV,
30711     thunk32_vkGetAccelerationStructureMemoryRequirementsNV,
30712     thunk32_vkGetBufferDeviceAddress,
30713     thunk32_vkGetBufferDeviceAddressEXT,
30714     thunk32_vkGetBufferDeviceAddressKHR,
30715     thunk32_vkGetBufferMemoryRequirements,
30716     thunk32_vkGetBufferMemoryRequirements2,
30717     thunk32_vkGetBufferMemoryRequirements2KHR,
30718     thunk32_vkGetBufferOpaqueCaptureAddress,
30719     thunk32_vkGetBufferOpaqueCaptureAddressKHR,
30720     thunk32_vkGetCalibratedTimestampsEXT,
30721     thunk32_vkGetDeferredOperationMaxConcurrencyKHR,
30722     thunk32_vkGetDeferredOperationResultKHR,
30723     thunk32_vkGetDescriptorSetHostMappingVALVE,
30724     thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
30725     thunk32_vkGetDescriptorSetLayoutSupport,
30726     thunk32_vkGetDescriptorSetLayoutSupportKHR,
30727     thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR,
30728     thunk32_vkGetDeviceBufferMemoryRequirements,
30729     thunk32_vkGetDeviceBufferMemoryRequirementsKHR,
30730     thunk32_vkGetDeviceFaultInfoEXT,
30731     thunk32_vkGetDeviceGroupPeerMemoryFeatures,
30732     thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR,
30733     thunk32_vkGetDeviceGroupPresentCapabilitiesKHR,
30734     thunk32_vkGetDeviceGroupSurfacePresentModesKHR,
30735     thunk32_vkGetDeviceImageMemoryRequirements,
30736     thunk32_vkGetDeviceImageMemoryRequirementsKHR,
30737     thunk32_vkGetDeviceImageSparseMemoryRequirements,
30738     thunk32_vkGetDeviceImageSparseMemoryRequirementsKHR,
30739     thunk32_vkGetDeviceMemoryCommitment,
30740     thunk32_vkGetDeviceMemoryOpaqueCaptureAddress,
30741     thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
30742     thunk32_vkGetDeviceMicromapCompatibilityEXT,
30743     thunk32_vkGetDeviceQueue,
30744     thunk32_vkGetDeviceQueue2,
30745     thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
30746     thunk32_vkGetDynamicRenderingTilePropertiesQCOM,
30747     thunk32_vkGetEventStatus,
30748     thunk32_vkGetFenceStatus,
30749     thunk32_vkGetFramebufferTilePropertiesQCOM,
30750     thunk32_vkGetGeneratedCommandsMemoryRequirementsNV,
30751     thunk32_vkGetImageMemoryRequirements,
30752     thunk32_vkGetImageMemoryRequirements2,
30753     thunk32_vkGetImageMemoryRequirements2KHR,
30754     thunk32_vkGetImageSparseMemoryRequirements,
30755     thunk32_vkGetImageSparseMemoryRequirements2,
30756     thunk32_vkGetImageSparseMemoryRequirements2KHR,
30757     thunk32_vkGetImageSubresourceLayout,
30758     thunk32_vkGetImageSubresourceLayout2EXT,
30759     thunk32_vkGetImageViewAddressNVX,
30760     thunk32_vkGetImageViewHandleNVX,
30761     thunk32_vkGetMemoryHostPointerPropertiesEXT,
30762     thunk32_vkGetMicromapBuildSizesEXT,
30763     thunk32_vkGetPerformanceParameterINTEL,
30764     thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
30765     thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
30766     thunk32_vkGetPhysicalDeviceExternalBufferProperties,
30767     thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
30768     thunk32_vkGetPhysicalDeviceExternalFenceProperties,
30769     thunk32_vkGetPhysicalDeviceExternalFencePropertiesKHR,
30770     thunk32_vkGetPhysicalDeviceExternalSemaphoreProperties,
30771     thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
30772     thunk32_vkGetPhysicalDeviceFeatures,
30773     thunk32_vkGetPhysicalDeviceFeatures2,
30774     thunk32_vkGetPhysicalDeviceFeatures2KHR,
30775     thunk32_vkGetPhysicalDeviceFormatProperties,
30776     thunk32_vkGetPhysicalDeviceFormatProperties2,
30777     thunk32_vkGetPhysicalDeviceFormatProperties2KHR,
30778     thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR,
30779     thunk32_vkGetPhysicalDeviceImageFormatProperties,
30780     thunk32_vkGetPhysicalDeviceImageFormatProperties2,
30781     thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR,
30782     thunk32_vkGetPhysicalDeviceMemoryProperties,
30783     thunk32_vkGetPhysicalDeviceMemoryProperties2,
30784     thunk32_vkGetPhysicalDeviceMemoryProperties2KHR,
30785     thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT,
30786     thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
30787     thunk32_vkGetPhysicalDevicePresentRectanglesKHR,
30788     thunk32_vkGetPhysicalDeviceProperties,
30789     thunk32_vkGetPhysicalDeviceProperties2,
30790     thunk32_vkGetPhysicalDeviceProperties2KHR,
30791     thunk32_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
30792     thunk32_vkGetPhysicalDeviceQueueFamilyProperties,
30793     thunk32_vkGetPhysicalDeviceQueueFamilyProperties2,
30794     thunk32_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
30795     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties,
30796     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2,
30797     thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
30798     thunk32_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
30799     thunk32_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
30800     thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
30801     thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR,
30802     thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR,
30803     thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR,
30804     thunk32_vkGetPhysicalDeviceSurfaceSupportKHR,
30805     thunk32_vkGetPhysicalDeviceToolProperties,
30806     thunk32_vkGetPhysicalDeviceToolPropertiesEXT,
30807     thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR,
30808     thunk32_vkGetPipelineCacheData,
30809     thunk32_vkGetPipelineExecutableInternalRepresentationsKHR,
30810     thunk32_vkGetPipelineExecutablePropertiesKHR,
30811     thunk32_vkGetPipelineExecutableStatisticsKHR,
30812     thunk32_vkGetPipelinePropertiesEXT,
30813     thunk32_vkGetPrivateData,
30814     thunk32_vkGetPrivateDataEXT,
30815     thunk32_vkGetQueryPoolResults,
30816     thunk32_vkGetQueueCheckpointData2NV,
30817     thunk32_vkGetQueueCheckpointDataNV,
30818     thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
30819     thunk32_vkGetRayTracingShaderGroupHandlesKHR,
30820     thunk32_vkGetRayTracingShaderGroupHandlesNV,
30821     thunk32_vkGetRayTracingShaderGroupStackSizeKHR,
30822     thunk32_vkGetRenderAreaGranularity,
30823     thunk32_vkGetSemaphoreCounterValue,
30824     thunk32_vkGetSemaphoreCounterValueKHR,
30825     thunk32_vkGetShaderInfoAMD,
30826     thunk32_vkGetShaderModuleCreateInfoIdentifierEXT,
30827     thunk32_vkGetShaderModuleIdentifierEXT,
30828     thunk32_vkGetSwapchainImagesKHR,
30829     thunk32_vkGetValidationCacheDataEXT,
30830     thunk32_vkInitializePerformanceApiINTEL,
30831     thunk32_vkInvalidateMappedMemoryRanges,
30832     thunk32_vkMapMemory,
30833     thunk32_vkMergePipelineCaches,
30834     thunk32_vkMergeValidationCachesEXT,
30835     thunk32_vkQueueBeginDebugUtilsLabelEXT,
30836     thunk32_vkQueueBindSparse,
30837     thunk32_vkQueueEndDebugUtilsLabelEXT,
30838     thunk32_vkQueueInsertDebugUtilsLabelEXT,
30839     thunk32_vkQueuePresentKHR,
30840     thunk32_vkQueueSetPerformanceConfigurationINTEL,
30841     thunk32_vkQueueSubmit,
30842     thunk32_vkQueueSubmit2,
30843     thunk32_vkQueueSubmit2KHR,
30844     thunk32_vkQueueWaitIdle,
30845     thunk32_vkReleasePerformanceConfigurationINTEL,
30846     thunk32_vkReleaseProfilingLockKHR,
30847     thunk32_vkResetCommandBuffer,
30848     thunk32_vkResetCommandPool,
30849     thunk32_vkResetDescriptorPool,
30850     thunk32_vkResetEvent,
30851     thunk32_vkResetFences,
30852     thunk32_vkResetQueryPool,
30853     thunk32_vkResetQueryPoolEXT,
30854     thunk32_vkSetDebugUtilsObjectNameEXT,
30855     thunk32_vkSetDebugUtilsObjectTagEXT,
30856     thunk32_vkSetDeviceMemoryPriorityEXT,
30857     thunk32_vkSetEvent,
30858     thunk32_vkSetPrivateData,
30859     thunk32_vkSetPrivateDataEXT,
30860     thunk32_vkSignalSemaphore,
30861     thunk32_vkSignalSemaphoreKHR,
30862     thunk32_vkSubmitDebugUtilsMessageEXT,
30863     thunk32_vkTrimCommandPool,
30864     thunk32_vkTrimCommandPoolKHR,
30865     thunk32_vkUninitializePerformanceApiINTEL,
30866     thunk32_vkUnmapMemory,
30867     thunk32_vkUpdateDescriptorSetWithTemplate,
30868     thunk32_vkUpdateDescriptorSetWithTemplateKHR,
30869     thunk32_vkUpdateDescriptorSets,
30870     thunk32_vkWaitForFences,
30871     thunk32_vkWaitForPresentKHR,
30872     thunk32_vkWaitSemaphores,
30873     thunk32_vkWaitSemaphoresKHR,
30874     thunk32_vkWriteAccelerationStructuresPropertiesKHR,
30875     thunk32_vkWriteMicromapsPropertiesEXT,
30876 };
30877 C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);
30878
30879 #endif /* USE_STRUCT_CONVERSION) */
30880
30881 NTSTATUS WINAPI vk_direct_unix_call(unixlib_handle_t handle, unsigned int code, void *params)
30882 {
30883     return __wine_unix_call_funcs[code](params);
30884 }