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 (c) 2015-2020 The Khronos Group Inc.
   7  *
   8  * SPDX-License-Identifier: Apache-2.0 OR MIT
   9  *
  10  */
  11
  12 #include "config.h"
  13 #include "wine/port.h"
  14
  15 #include "vulkan_private.h"
  16
  17 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
  18
  19 #if defined(USE_STRUCT_CONVERSION)
  20 static inline void convert_VkAcquireNextImageInfoKHR_win_to_host(const VkAcquireNextImageInfoKHR *in, VkAcquireNextImageInfoKHR_host *out)
  21 {
  22     if (!in) return;
  23
  24     out->sType = in->sType;
  25     out->pNext = in->pNext;
  26     out->swapchain = in->swapchain;
  27     out->timeout = in->timeout;
  28     out->semaphore = in->semaphore;
  29     out->fence = in->fence;
  30     out->deviceMask = in->deviceMask;
  31 }
  32
  33 static inline void convert_VkAcquireProfilingLockInfoKHR_win_to_host(const VkAcquireProfilingLockInfoKHR *in, VkAcquireProfilingLockInfoKHR_host *out)
  34 {
  35     if (!in) return;
  36
  37     out->sType = in->sType;
  38     out->pNext = in->pNext;
  39     out->flags = in->flags;
  40     out->timeout = in->timeout;
  41 }
  42
  43 static inline void convert_VkDescriptorSetAllocateInfo_win_to_host(const VkDescriptorSetAllocateInfo *in, VkDescriptorSetAllocateInfo_host *out)
  44 {
  45     if (!in) return;
  46
  47     out->sType = in->sType;
  48     out->pNext = in->pNext;
  49     out->descriptorPool = in->descriptorPool;
  50     out->descriptorSetCount = in->descriptorSetCount;
  51     out->pSetLayouts = in->pSetLayouts;
  52 }
  53
  54 static inline void convert_VkMemoryAllocateInfo_win_to_host(const VkMemoryAllocateInfo *in, VkMemoryAllocateInfo_host *out)
  55 {
  56     if (!in) return;
  57
  58     out->sType = in->sType;
  59     out->pNext = in->pNext;
  60     out->allocationSize = in->allocationSize;
  61     out->memoryTypeIndex = in->memoryTypeIndex;
  62 }
  63
  64 static inline VkCommandBufferInheritanceInfo_host *convert_VkCommandBufferInheritanceInfo_array_win_to_host(const VkCommandBufferInheritanceInfo *in, uint32_t count)
  65 {
  66     VkCommandBufferInheritanceInfo_host *out;
  67     unsigned int i;
  68
  69     if (!in) return NULL;
  70
  71     out = heap_alloc(count * sizeof(*out));
  72     for (i = 0; i < count; i++)
  73     {
  74         out[i].sType = in[i].sType;
  75         out[i].pNext = in[i].pNext;
  76         out[i].renderPass = in[i].renderPass;
  77         out[i].subpass = in[i].subpass;
  78         out[i].framebuffer = in[i].framebuffer;
  79         out[i].occlusionQueryEnable = in[i].occlusionQueryEnable;
  80         out[i].queryFlags = in[i].queryFlags;
  81         out[i].pipelineStatistics = in[i].pipelineStatistics;
  82     }
  83
  84     return out;
  85 }
  86
  87 static inline void free_VkCommandBufferInheritanceInfo_array(VkCommandBufferInheritanceInfo_host *in, uint32_t count)
  88 {
  89     if (!in) return;
  90
  91     heap_free(in);
  92 }
  93
  94 static inline void convert_VkCommandBufferBeginInfo_win_to_host(const VkCommandBufferBeginInfo *in, VkCommandBufferBeginInfo_host *out)
  95 {
  96     if (!in) return;
  97
  98     out->sType = in->sType;
  99     out->pNext = in->pNext;
 100     out->flags = in->flags;
 101     out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win_to_host(in->pInheritanceInfo, 1);
 102 }
 103
 104 static inline void free_VkCommandBufferBeginInfo(VkCommandBufferBeginInfo_host *in)
 105 {
 106     free_VkCommandBufferInheritanceInfo_array((VkCommandBufferInheritanceInfo_host *)in->pInheritanceInfo, 1);
 107 }
 108
 109 static inline VkBindAccelerationStructureMemoryInfoKHR_host *convert_VkBindAccelerationStructureMemoryInfoKHR_array_win_to_host(const VkBindAccelerationStructureMemoryInfoKHR *in, uint32_t count)
 110 {
 111     VkBindAccelerationStructureMemoryInfoKHR_host *out;
 112     unsigned int i;
 113
 114     if (!in) return NULL;
 115
 116     out = heap_alloc(count * sizeof(*out));
 117     for (i = 0; i < count; i++)
 118     {
 119         out[i].sType = in[i].sType;
 120         out[i].pNext = in[i].pNext;
 121         out[i].accelerationStructure = in[i].accelerationStructure;
 122         out[i].memory = in[i].memory;
 123         out[i].memoryOffset = in[i].memoryOffset;
 124         out[i].deviceIndexCount = in[i].deviceIndexCount;
 125         out[i].pDeviceIndices = in[i].pDeviceIndices;
 126     }
 127
 128     return out;
 129 }
 130
 131 static inline void free_VkBindAccelerationStructureMemoryInfoKHR_array(VkBindAccelerationStructureMemoryInfoKHR_host *in, uint32_t count)
 132 {
 133     if (!in) return;
 134
 135     heap_free(in);
 136 }
 137
 138 static inline VkBindBufferMemoryInfo_host *convert_VkBindBufferMemoryInfo_array_win_to_host(const VkBindBufferMemoryInfo *in, uint32_t count)
 139 {
 140     VkBindBufferMemoryInfo_host *out;
 141     unsigned int i;
 142
 143     if (!in) return NULL;
 144
 145     out = heap_alloc(count * sizeof(*out));
 146     for (i = 0; i < count; i++)
 147     {
 148         out[i].sType = in[i].sType;
 149         out[i].pNext = in[i].pNext;
 150         out[i].buffer = in[i].buffer;
 151         out[i].memory = in[i].memory;
 152         out[i].memoryOffset = in[i].memoryOffset;
 153     }
 154
 155     return out;
 156 }
 157
 158 static inline void free_VkBindBufferMemoryInfo_array(VkBindBufferMemoryInfo_host *in, uint32_t count)
 159 {
 160     if (!in) return;
 161
 162     heap_free(in);
 163 }
 164
 165 static inline VkBindImageMemoryInfo_host *convert_VkBindImageMemoryInfo_array_win_to_host(const VkBindImageMemoryInfo *in, uint32_t count)
 166 {
 167     VkBindImageMemoryInfo_host *out;
 168     unsigned int i;
 169
 170     if (!in) return NULL;
 171
 172     out = heap_alloc(count * sizeof(*out));
 173     for (i = 0; i < count; i++)
 174     {
 175         out[i].sType = in[i].sType;
 176         out[i].pNext = in[i].pNext;
 177         out[i].image = in[i].image;
 178         out[i].memory = in[i].memory;
 179         out[i].memoryOffset = in[i].memoryOffset;
 180     }
 181
 182     return out;
 183 }
 184
 185 static inline void free_VkBindImageMemoryInfo_array(VkBindImageMemoryInfo_host *in, uint32_t count)
 186 {
 187     if (!in) return;
 188
 189     heap_free(in);
 190 }
 191
 192 static inline void convert_VkConditionalRenderingBeginInfoEXT_win_to_host(const VkConditionalRenderingBeginInfoEXT *in, VkConditionalRenderingBeginInfoEXT_host *out)
 193 {
 194     if (!in) return;
 195
 196     out->sType = in->sType;
 197     out->pNext = in->pNext;
 198     out->buffer = in->buffer;
 199     out->offset = in->offset;
 200     out->flags = in->flags;
 201 }
 202
 203 static inline void convert_VkRenderPassBeginInfo_win_to_host(const VkRenderPassBeginInfo *in, VkRenderPassBeginInfo_host *out)
 204 {
 205     if (!in) return;
 206
 207     out->sType = in->sType;
 208     out->pNext = in->pNext;
 209     out->renderPass = in->renderPass;
 210     out->framebuffer = in->framebuffer;
 211     out->renderArea = in->renderArea;
 212     out->clearValueCount = in->clearValueCount;
 213     out->pClearValues = in->pClearValues;
 214 }
 215
 216 static inline void convert_VkBlitImageInfo2KHR_win_to_host(const VkBlitImageInfo2KHR *in, VkBlitImageInfo2KHR_host *out)
 217 {
 218     if (!in) return;
 219
 220     out->sType = in->sType;
 221     out->pNext = in->pNext;
 222     out->srcImage = in->srcImage;
 223     out->srcImageLayout = in->srcImageLayout;
 224     out->dstImage = in->dstImage;
 225     out->dstImageLayout = in->dstImageLayout;
 226     out->regionCount = in->regionCount;
 227     out->pRegions = in->pRegions;
 228     out->filter = in->filter;
 229 }
 230
 231 static inline void convert_VkGeometryTrianglesNV_win_to_host(const VkGeometryTrianglesNV *in, VkGeometryTrianglesNV_host *out)
 232 {
 233     if (!in) return;
 234
 235     out->sType = in->sType;
 236     out->pNext = in->pNext;
 237     out->vertexData = in->vertexData;
 238     out->vertexOffset = in->vertexOffset;
 239     out->vertexCount = in->vertexCount;
 240     out->vertexStride = in->vertexStride;
 241     out->vertexFormat = in->vertexFormat;
 242     out->indexData = in->indexData;
 243     out->indexOffset = in->indexOffset;
 244     out->indexCount = in->indexCount;
 245     out->indexType = in->indexType;
 246     out->transformData = in->transformData;
 247     out->transformOffset = in->transformOffset;
 248 }
 249
 250 static inline void convert_VkGeometryAABBNV_win_to_host(const VkGeometryAABBNV *in, VkGeometryAABBNV_host *out)
 251 {
 252     if (!in) return;
 253
 254     out->sType = in->sType;
 255     out->pNext = in->pNext;
 256     out->aabbData = in->aabbData;
 257     out->numAABBs = in->numAABBs;
 258     out->stride = in->stride;
 259     out->offset = in->offset;
 260 }
 261
 262 static inline void convert_VkGeometryDataNV_win_to_host(const VkGeometryDataNV *in, VkGeometryDataNV_host *out)
 263 {
 264     if (!in) return;
 265
 266     convert_VkGeometryTrianglesNV_win_to_host(&in->triangles, &out->triangles);
 267     convert_VkGeometryAABBNV_win_to_host(&in->aabbs, &out->aabbs);
 268 }
 269
 270 static inline VkGeometryNV_host *convert_VkGeometryNV_array_win_to_host(const VkGeometryNV *in, uint32_t count)
 271 {
 272     VkGeometryNV_host *out;
 273     unsigned int i;
 274
 275     if (!in) return NULL;
 276
 277     out = heap_alloc(count * sizeof(*out));
 278     for (i = 0; i < count; i++)
 279     {
 280         out[i].sType = in[i].sType;
 281         out[i].pNext = in[i].pNext;
 282         out[i].geometryType = in[i].geometryType;
 283         convert_VkGeometryDataNV_win_to_host(&in[i].geometry, &out[i].geometry);
 284         out[i].flags = in[i].flags;
 285     }
 286
 287     return out;
 288 }
 289
 290 static inline void free_VkGeometryNV_array(VkGeometryNV_host *in, uint32_t count)
 291 {
 292     if (!in) return;
 293
 294     heap_free(in);
 295 }
 296
 297 static inline void convert_VkAccelerationStructureInfoNV_win_to_host(const VkAccelerationStructureInfoNV *in, VkAccelerationStructureInfoNV_host *out)
 298 {
 299     if (!in) return;
 300
 301     out->sType = in->sType;
 302     out->pNext = in->pNext;
 303     out->type = in->type;
 304     out->flags = in->flags;
 305     out->instanceCount = in->instanceCount;
 306     out->geometryCount = in->geometryCount;
 307     out->pGeometries = convert_VkGeometryNV_array_win_to_host(in->pGeometries, in->geometryCount);
 308 }
 309
 310 static inline void free_VkAccelerationStructureInfoNV(VkAccelerationStructureInfoNV_host *in)
 311 {
 312     free_VkGeometryNV_array((VkGeometryNV_host *)in->pGeometries, in->geometryCount);
 313 }
 314
 315 static inline VkBufferCopy_host *convert_VkBufferCopy_array_win_to_host(const VkBufferCopy *in, uint32_t count)
 316 {
 317     VkBufferCopy_host *out;
 318     unsigned int i;
 319
 320     if (!in) return NULL;
 321
 322     out = heap_alloc(count * sizeof(*out));
 323     for (i = 0; i < count; i++)
 324     {
 325         out[i].srcOffset = in[i].srcOffset;
 326         out[i].dstOffset = in[i].dstOffset;
 327         out[i].size = in[i].size;
 328     }
 329
 330     return out;
 331 }
 332
 333 static inline void free_VkBufferCopy_array(VkBufferCopy_host *in, uint32_t count)
 334 {
 335     if (!in) return;
 336
 337     heap_free(in);
 338 }
 339
 340 static inline VkBufferCopy2KHR_host *convert_VkBufferCopy2KHR_array_win_to_host(const VkBufferCopy2KHR *in, uint32_t count)
 341 {
 342     VkBufferCopy2KHR_host *out;
 343     unsigned int i;
 344
 345     if (!in) return NULL;
 346
 347     out = heap_alloc(count * sizeof(*out));
 348     for (i = 0; i < count; i++)
 349     {
 350         out[i].sType = in[i].sType;
 351         out[i].pNext = in[i].pNext;
 352         out[i].srcOffset = in[i].srcOffset;
 353         out[i].dstOffset = in[i].dstOffset;
 354         out[i].size = in[i].size;
 355     }
 356
 357     return out;
 358 }
 359
 360 static inline void free_VkBufferCopy2KHR_array(VkBufferCopy2KHR_host *in, uint32_t count)
 361 {
 362     if (!in) return;
 363
 364     heap_free(in);
 365 }
 366
 367 static inline void convert_VkCopyBufferInfo2KHR_win_to_host(const VkCopyBufferInfo2KHR *in, VkCopyBufferInfo2KHR_host *out)
 368 {
 369     if (!in) return;
 370
 371     out->sType = in->sType;
 372     out->pNext = in->pNext;
 373     out->srcBuffer = in->srcBuffer;
 374     out->dstBuffer = in->dstBuffer;
 375     out->regionCount = in->regionCount;
 376     out->pRegions = convert_VkBufferCopy2KHR_array_win_to_host(in->pRegions, in->regionCount);
 377 }
 378
 379 static inline void free_VkCopyBufferInfo2KHR(VkCopyBufferInfo2KHR_host *in)
 380 {
 381     free_VkBufferCopy2KHR_array((VkBufferCopy2KHR_host *)in->pRegions, in->regionCount);
 382 }
 383
 384 static inline VkBufferImageCopy_host *convert_VkBufferImageCopy_array_win_to_host(const VkBufferImageCopy *in, uint32_t count)
 385 {
 386     VkBufferImageCopy_host *out;
 387     unsigned int i;
 388
 389     if (!in) return NULL;
 390
 391     out = heap_alloc(count * sizeof(*out));
 392     for (i = 0; i < count; i++)
 393     {
 394         out[i].bufferOffset = in[i].bufferOffset;
 395         out[i].bufferRowLength = in[i].bufferRowLength;
 396         out[i].bufferImageHeight = in[i].bufferImageHeight;
 397         out[i].imageSubresource = in[i].imageSubresource;
 398         out[i].imageOffset = in[i].imageOffset;
 399         out[i].imageExtent = in[i].imageExtent;
 400     }
 401
 402     return out;
 403 }
 404
 405 static inline void free_VkBufferImageCopy_array(VkBufferImageCopy_host *in, uint32_t count)
 406 {
 407     if (!in) return;
 408
 409     heap_free(in);
 410 }
 411
 412 static inline VkBufferImageCopy2KHR_host *convert_VkBufferImageCopy2KHR_array_win_to_host(const VkBufferImageCopy2KHR *in, uint32_t count)
 413 {
 414     VkBufferImageCopy2KHR_host *out;
 415     unsigned int i;
 416
 417     if (!in) return NULL;
 418
 419     out = heap_alloc(count * sizeof(*out));
 420     for (i = 0; i < count; i++)
 421     {
 422         out[i].sType = in[i].sType;
 423         out[i].pNext = in[i].pNext;
 424         out[i].bufferOffset = in[i].bufferOffset;
 425         out[i].bufferRowLength = in[i].bufferRowLength;
 426         out[i].bufferImageHeight = in[i].bufferImageHeight;
 427         out[i].imageSubresource = in[i].imageSubresource;
 428         out[i].imageOffset = in[i].imageOffset;
 429         out[i].imageExtent = in[i].imageExtent;
 430     }
 431
 432     return out;
 433 }
 434
 435 static inline void free_VkBufferImageCopy2KHR_array(VkBufferImageCopy2KHR_host *in, uint32_t count)
 436 {
 437     if (!in) return;
 438
 439     heap_free(in);
 440 }
 441
 442 static inline void convert_VkCopyBufferToImageInfo2KHR_win_to_host(const VkCopyBufferToImageInfo2KHR *in, VkCopyBufferToImageInfo2KHR_host *out)
 443 {
 444     if (!in) return;
 445
 446     out->sType = in->sType;
 447     out->pNext = in->pNext;
 448     out->srcBuffer = in->srcBuffer;
 449     out->dstImage = in->dstImage;
 450     out->dstImageLayout = in->dstImageLayout;
 451     out->regionCount = in->regionCount;
 452     out->pRegions = convert_VkBufferImageCopy2KHR_array_win_to_host(in->pRegions, in->regionCount);
 453 }
 454
 455 static inline void free_VkCopyBufferToImageInfo2KHR(VkCopyBufferToImageInfo2KHR_host *in)
 456 {
 457     free_VkBufferImageCopy2KHR_array((VkBufferImageCopy2KHR_host *)in->pRegions, in->regionCount);
 458 }
 459
 460 static inline void convert_VkCopyImageInfo2KHR_win_to_host(const VkCopyImageInfo2KHR *in, VkCopyImageInfo2KHR_host *out)
 461 {
 462     if (!in) return;
 463
 464     out->sType = in->sType;
 465     out->pNext = in->pNext;
 466     out->srcImage = in->srcImage;
 467     out->srcImageLayout = in->srcImageLayout;
 468     out->dstImage = in->dstImage;
 469     out->dstImageLayout = in->dstImageLayout;
 470     out->regionCount = in->regionCount;
 471     out->pRegions = in->pRegions;
 472 }
 473
 474 static inline void convert_VkCopyImageToBufferInfo2KHR_win_to_host(const VkCopyImageToBufferInfo2KHR *in, VkCopyImageToBufferInfo2KHR_host *out)
 475 {
 476     if (!in) return;
 477
 478     out->sType = in->sType;
 479     out->pNext = in->pNext;
 480     out->srcImage = in->srcImage;
 481     out->srcImageLayout = in->srcImageLayout;
 482     out->dstBuffer = in->dstBuffer;
 483     out->regionCount = in->regionCount;
 484     out->pRegions = convert_VkBufferImageCopy2KHR_array_win_to_host(in->pRegions, in->regionCount);
 485 }
 486
 487 static inline void free_VkCopyImageToBufferInfo2KHR(VkCopyImageToBufferInfo2KHR_host *in)
 488 {
 489     free_VkBufferImageCopy2KHR_array((VkBufferImageCopy2KHR_host *)in->pRegions, in->regionCount);
 490 }
 491
 492 static inline VkIndirectCommandsStreamNV_host *convert_VkIndirectCommandsStreamNV_array_win_to_host(const VkIndirectCommandsStreamNV *in, uint32_t count)
 493 {
 494     VkIndirectCommandsStreamNV_host *out;
 495     unsigned int i;
 496
 497     if (!in) return NULL;
 498
 499     out = heap_alloc(count * sizeof(*out));
 500     for (i = 0; i < count; i++)
 501     {
 502         out[i].buffer = in[i].buffer;
 503         out[i].offset = in[i].offset;
 504     }
 505
 506     return out;
 507 }
 508
 509 static inline void free_VkIndirectCommandsStreamNV_array(VkIndirectCommandsStreamNV_host *in, uint32_t count)
 510 {
 511     if (!in) return;
 512
 513     heap_free(in);
 514 }
 515
 516 static inline void convert_VkGeneratedCommandsInfoNV_win_to_host(const VkGeneratedCommandsInfoNV *in, VkGeneratedCommandsInfoNV_host *out)
 517 {
 518     if (!in) return;
 519
 520     out->sType = in->sType;
 521     out->pNext = in->pNext;
 522     out->pipelineBindPoint = in->pipelineBindPoint;
 523     out->pipeline = in->pipeline;
 524     out->indirectCommandsLayout = in->indirectCommandsLayout;
 525     out->streamCount = in->streamCount;
 526     out->pStreams = convert_VkIndirectCommandsStreamNV_array_win_to_host(in->pStreams, in->streamCount);
 527     out->sequencesCount = in->sequencesCount;
 528     out->preprocessBuffer = in->preprocessBuffer;
 529     out->preprocessOffset = in->preprocessOffset;
 530     out->preprocessSize = in->preprocessSize;
 531     out->sequencesCountBuffer = in->sequencesCountBuffer;
 532     out->sequencesCountOffset = in->sequencesCountOffset;
 533     out->sequencesIndexBuffer = in->sequencesIndexBuffer;
 534     out->sequencesIndexOffset = in->sequencesIndexOffset;
 535 }
 536
 537 static inline void free_VkGeneratedCommandsInfoNV(VkGeneratedCommandsInfoNV_host *in)
 538 {
 539     free_VkIndirectCommandsStreamNV_array((VkIndirectCommandsStreamNV_host *)in->pStreams, in->streamCount);
 540 }
 541
 542 static inline VkBufferMemoryBarrier_host *convert_VkBufferMemoryBarrier_array_win_to_host(const VkBufferMemoryBarrier *in, uint32_t count)
 543 {
 544     VkBufferMemoryBarrier_host *out;
 545     unsigned int i;
 546
 547     if (!in) return NULL;
 548
 549     out = heap_alloc(count * sizeof(*out));
 550     for (i = 0; i < count; i++)
 551     {
 552         out[i].sType = in[i].sType;
 553         out[i].pNext = in[i].pNext;
 554         out[i].srcAccessMask = in[i].srcAccessMask;
 555         out[i].dstAccessMask = in[i].dstAccessMask;
 556         out[i].srcQueueFamilyIndex = in[i].srcQueueFamilyIndex;
 557         out[i].dstQueueFamilyIndex = in[i].dstQueueFamilyIndex;
 558         out[i].buffer = in[i].buffer;
 559         out[i].offset = in[i].offset;
 560         out[i].size = in[i].size;
 561     }
 562
 563     return out;
 564 }
 565
 566 static inline void free_VkBufferMemoryBarrier_array(VkBufferMemoryBarrier_host *in, uint32_t count)
 567 {
 568     if (!in) return;
 569
 570     heap_free(in);
 571 }
 572
 573 static inline VkImageMemoryBarrier_host *convert_VkImageMemoryBarrier_array_win_to_host(const VkImageMemoryBarrier *in, uint32_t count)
 574 {
 575     VkImageMemoryBarrier_host *out;
 576     unsigned int i;
 577
 578     if (!in) return NULL;
 579
 580     out = heap_alloc(count * sizeof(*out));
 581     for (i = 0; i < count; i++)
 582     {
 583         out[i].sType = in[i].sType;
 584         out[i].pNext = in[i].pNext;
 585         out[i].srcAccessMask = in[i].srcAccessMask;
 586         out[i].dstAccessMask = in[i].dstAccessMask;
 587         out[i].oldLayout = in[i].oldLayout;
 588         out[i].newLayout = in[i].newLayout;
 589         out[i].srcQueueFamilyIndex = in[i].srcQueueFamilyIndex;
 590         out[i].dstQueueFamilyIndex = in[i].dstQueueFamilyIndex;
 591         out[i].image = in[i].image;
 592         out[i].subresourceRange = in[i].subresourceRange;
 593     }
 594
 595     return out;
 596 }
 597
 598 static inline void free_VkImageMemoryBarrier_array(VkImageMemoryBarrier_host *in, uint32_t count)
 599 {
 600     if (!in) return;
 601
 602     heap_free(in);
 603 }
 604
 605 static inline VkDescriptorImageInfo_host *convert_VkDescriptorImageInfo_array_win_to_host(const VkDescriptorImageInfo *in, uint32_t count)
 606 {
 607     VkDescriptorImageInfo_host *out;
 608     unsigned int i;
 609
 610     if (!in) return NULL;
 611
 612     out = heap_alloc(count * sizeof(*out));
 613     for (i = 0; i < count; i++)
 614     {
 615         out[i].sampler = in[i].sampler;
 616         out[i].imageView = in[i].imageView;
 617         out[i].imageLayout = in[i].imageLayout;
 618     }
 619
 620     return out;
 621 }
 622
 623 static inline void free_VkDescriptorImageInfo_array(VkDescriptorImageInfo_host *in, uint32_t count)
 624 {
 625     if (!in) return;
 626
 627     heap_free(in);
 628 }
 629
 630 static inline VkDescriptorBufferInfo_host *convert_VkDescriptorBufferInfo_array_win_to_host(const VkDescriptorBufferInfo *in, uint32_t count)
 631 {
 632     VkDescriptorBufferInfo_host *out;
 633     unsigned int i;
 634
 635     if (!in) return NULL;
 636
 637     out = heap_alloc(count * sizeof(*out));
 638     for (i = 0; i < count; i++)
 639     {
 640         out[i].buffer = in[i].buffer;
 641         out[i].offset = in[i].offset;
 642         out[i].range = in[i].range;
 643     }
 644
 645     return out;
 646 }
 647
 648 static inline void free_VkDescriptorBufferInfo_array(VkDescriptorBufferInfo_host *in, uint32_t count)
 649 {
 650     if (!in) return;
 651
 652     heap_free(in);
 653 }
 654
 655 static inline VkWriteDescriptorSet_host *convert_VkWriteDescriptorSet_array_win_to_host(const VkWriteDescriptorSet *in, uint32_t count)
 656 {
 657     VkWriteDescriptorSet_host *out;
 658     unsigned int i;
 659
 660     if (!in) return NULL;
 661
 662     out = heap_alloc(count * sizeof(*out));
 663     for (i = 0; i < count; i++)
 664     {
 665         out[i].sType = in[i].sType;
 666         out[i].pNext = in[i].pNext;
 667         out[i].dstSet = in[i].dstSet;
 668         out[i].dstBinding = in[i].dstBinding;
 669         out[i].dstArrayElement = in[i].dstArrayElement;
 670         out[i].descriptorCount = in[i].descriptorCount;
 671         out[i].descriptorType = in[i].descriptorType;
 672         out[i].pImageInfo = convert_VkDescriptorImageInfo_array_win_to_host(in[i].pImageInfo, in[i].descriptorCount);
 673         out[i].pBufferInfo = convert_VkDescriptorBufferInfo_array_win_to_host(in[i].pBufferInfo, in[i].descriptorCount);
 674         out[i].pTexelBufferView = in[i].pTexelBufferView;
 675     }
 676
 677     return out;
 678 }
 679
 680 static inline void free_VkWriteDescriptorSet_array(VkWriteDescriptorSet_host *in, uint32_t count)
 681 {
 682     unsigned int i;
 683
 684     if (!in) return;
 685
 686     for (i = 0; i < count; i++)
 687     {
 688         free_VkDescriptorImageInfo_array((VkDescriptorImageInfo_host *)in[i].pImageInfo, in[i].descriptorCount);
 689         free_VkDescriptorBufferInfo_array((VkDescriptorBufferInfo_host *)in[i].pBufferInfo, in[i].descriptorCount);
 690     }
 691     heap_free(in);
 692 }
 693
 694 static inline void convert_VkResolveImageInfo2KHR_win_to_host(const VkResolveImageInfo2KHR *in, VkResolveImageInfo2KHR_host *out)
 695 {
 696     if (!in) return;
 697
 698     out->sType = in->sType;
 699     out->pNext = in->pNext;
 700     out->srcImage = in->srcImage;
 701     out->srcImageLayout = in->srcImageLayout;
 702     out->dstImage = in->dstImage;
 703     out->dstImageLayout = in->dstImageLayout;
 704     out->regionCount = in->regionCount;
 705     out->pRegions = in->pRegions;
 706 }
 707
 708 static inline void convert_VkPerformanceMarkerInfoINTEL_win_to_host(const VkPerformanceMarkerInfoINTEL *in, VkPerformanceMarkerInfoINTEL_host *out)
 709 {
 710     if (!in) return;
 711
 712     out->sType = in->sType;
 713     out->pNext = in->pNext;
 714     out->marker = in->marker;
 715 }
 716
 717 static inline void convert_VkPerformanceOverrideInfoINTEL_win_to_host(const VkPerformanceOverrideInfoINTEL *in, VkPerformanceOverrideInfoINTEL_host *out)
 718 {
 719     if (!in) return;
 720
 721     out->sType = in->sType;
 722     out->pNext = in->pNext;
 723     out->type = in->type;
 724     out->enable = in->enable;
 725     out->parameter = in->parameter;
 726 }
 727
 728 static inline void convert_VkAccelerationStructureCreateInfoNV_win_to_host(const VkAccelerationStructureCreateInfoNV *in, VkAccelerationStructureCreateInfoNV_host *out)
 729 {
 730     if (!in) return;
 731
 732     out->sType = in->sType;
 733     out->pNext = in->pNext;
 734     out->compactedSize = in->compactedSize;
 735     convert_VkAccelerationStructureInfoNV_win_to_host(&in->info, &out->info);
 736 }
 737
 738 static inline void convert_VkBufferCreateInfo_win_to_host(const VkBufferCreateInfo *in, VkBufferCreateInfo_host *out)
 739 {
 740     if (!in) return;
 741
 742     out->sType = in->sType;
 743     out->pNext = in->pNext;
 744     out->flags = in->flags;
 745     out->size = in->size;
 746     out->usage = in->usage;
 747     out->sharingMode = in->sharingMode;
 748     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
 749     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
 750 }
 751
 752 static inline void convert_VkBufferViewCreateInfo_win_to_host(const VkBufferViewCreateInfo *in, VkBufferViewCreateInfo_host *out)
 753 {
 754     if (!in) return;
 755
 756     out->sType = in->sType;
 757     out->pNext = in->pNext;
 758     out->flags = in->flags;
 759     out->buffer = in->buffer;
 760     out->format = in->format;
 761     out->offset = in->offset;
 762     out->range = in->range;
 763 }
 764
 765 static inline void convert_VkPipelineShaderStageCreateInfo_win_to_host(const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo_host *out)
 766 {
 767     if (!in) return;
 768
 769     out->sType = in->sType;
 770     out->pNext = in->pNext;
 771     out->flags = in->flags;
 772     out->stage = in->stage;
 773     out->module = in->module;
 774     out->pName = in->pName;
 775     out->pSpecializationInfo = in->pSpecializationInfo;
 776 }
 777
 778 static inline VkComputePipelineCreateInfo_host *convert_VkComputePipelineCreateInfo_array_win_to_host(const VkComputePipelineCreateInfo *in, uint32_t count)
 779 {
 780     VkComputePipelineCreateInfo_host *out;
 781     unsigned int i;
 782
 783     if (!in) return NULL;
 784
 785     out = heap_alloc(count * sizeof(*out));
 786     for (i = 0; i < count; i++)
 787     {
 788         out[i].sType = in[i].sType;
 789         out[i].pNext = in[i].pNext;
 790         out[i].flags = in[i].flags;
 791         convert_VkPipelineShaderStageCreateInfo_win_to_host(&in[i].stage, &out[i].stage);
 792         out[i].layout = in[i].layout;
 793         out[i].basePipelineHandle = in[i].basePipelineHandle;
 794         out[i].basePipelineIndex = in[i].basePipelineIndex;
 795     }
 796
 797     return out;
 798 }
 799
 800 static inline void free_VkComputePipelineCreateInfo_array(VkComputePipelineCreateInfo_host *in, uint32_t count)
 801 {
 802     if (!in) return;
 803
 804     heap_free(in);
 805 }
 806
 807 static inline void convert_VkDescriptorUpdateTemplateCreateInfo_win_to_host(const VkDescriptorUpdateTemplateCreateInfo *in, VkDescriptorUpdateTemplateCreateInfo_host *out)
 808 {
 809     if (!in) return;
 810
 811     out->sType = in->sType;
 812     out->pNext = in->pNext;
 813     out->flags = in->flags;
 814     out->descriptorUpdateEntryCount = in->descriptorUpdateEntryCount;
 815     out->pDescriptorUpdateEntries = in->pDescriptorUpdateEntries;
 816     out->templateType = in->templateType;
 817     out->descriptorSetLayout = in->descriptorSetLayout;
 818     out->pipelineBindPoint = in->pipelineBindPoint;
 819     out->pipelineLayout = in->pipelineLayout;
 820     out->set = in->set;
 821 }
 822
 823 static inline void convert_VkFramebufferCreateInfo_win_to_host(const VkFramebufferCreateInfo *in, VkFramebufferCreateInfo_host *out)
 824 {
 825     if (!in) return;
 826
 827     out->sType = in->sType;
 828     out->pNext = in->pNext;
 829     out->flags = in->flags;
 830     out->renderPass = in->renderPass;
 831     out->attachmentCount = in->attachmentCount;
 832     out->pAttachments = in->pAttachments;
 833     out->width = in->width;
 834     out->height = in->height;
 835     out->layers = in->layers;
 836 }
 837
 838 static inline VkPipelineShaderStageCreateInfo_host *convert_VkPipelineShaderStageCreateInfo_array_win_to_host(const VkPipelineShaderStageCreateInfo *in, uint32_t count)
 839 {
 840     VkPipelineShaderStageCreateInfo_host *out;
 841     unsigned int i;
 842
 843     if (!in) return NULL;
 844
 845     out = heap_alloc(count * sizeof(*out));
 846     for (i = 0; i < count; i++)
 847     {
 848         out[i].sType = in[i].sType;
 849         out[i].pNext = in[i].pNext;
 850         out[i].flags = in[i].flags;
 851         out[i].stage = in[i].stage;
 852         out[i].module = in[i].module;
 853         out[i].pName = in[i].pName;
 854         out[i].pSpecializationInfo = in[i].pSpecializationInfo;
 855     }
 856
 857     return out;
 858 }
 859
 860 static inline void free_VkPipelineShaderStageCreateInfo_array(VkPipelineShaderStageCreateInfo_host *in, uint32_t count)
 861 {
 862     if (!in) return;
 863
 864     heap_free(in);
 865 }
 866
 867 static inline VkGraphicsPipelineCreateInfo_host *convert_VkGraphicsPipelineCreateInfo_array_win_to_host(const VkGraphicsPipelineCreateInfo *in, uint32_t count)
 868 {
 869     VkGraphicsPipelineCreateInfo_host *out;
 870     unsigned int i;
 871
 872     if (!in) return NULL;
 873
 874     out = heap_alloc(count * sizeof(*out));
 875     for (i = 0; i < count; i++)
 876     {
 877         out[i].sType = in[i].sType;
 878         out[i].pNext = in[i].pNext;
 879         out[i].flags = in[i].flags;
 880         out[i].stageCount = in[i].stageCount;
 881         out[i].pStages = convert_VkPipelineShaderStageCreateInfo_array_win_to_host(in[i].pStages, in[i].stageCount);
 882         out[i].pVertexInputState = in[i].pVertexInputState;
 883         out[i].pInputAssemblyState = in[i].pInputAssemblyState;
 884         out[i].pTessellationState = in[i].pTessellationState;
 885         out[i].pViewportState = in[i].pViewportState;
 886         out[i].pRasterizationState = in[i].pRasterizationState;
 887         out[i].pMultisampleState = in[i].pMultisampleState;
 888         out[i].pDepthStencilState = in[i].pDepthStencilState;
 889         out[i].pColorBlendState = in[i].pColorBlendState;
 890         out[i].pDynamicState = in[i].pDynamicState;
 891         out[i].layout = in[i].layout;
 892         out[i].renderPass = in[i].renderPass;
 893         out[i].subpass = in[i].subpass;
 894         out[i].basePipelineHandle = in[i].basePipelineHandle;
 895         out[i].basePipelineIndex = in[i].basePipelineIndex;
 896     }
 897
 898     return out;
 899 }
 900
 901 static inline void free_VkGraphicsPipelineCreateInfo_array(VkGraphicsPipelineCreateInfo_host *in, uint32_t count)
 902 {
 903     unsigned int i;
 904
 905     if (!in) return;
 906
 907     for (i = 0; i < count; i++)
 908     {
 909         free_VkPipelineShaderStageCreateInfo_array((VkPipelineShaderStageCreateInfo_host *)in[i].pStages, in[i].stageCount);
 910     }
 911     heap_free(in);
 912 }
 913
 914 static inline void convert_VkImageViewCreateInfo_win_to_host(const VkImageViewCreateInfo *in, VkImageViewCreateInfo_host *out)
 915 {
 916     if (!in) return;
 917
 918     out->sType = in->sType;
 919     out->pNext = in->pNext;
 920     out->flags = in->flags;
 921     out->image = in->image;
 922     out->viewType = in->viewType;
 923     out->format = in->format;
 924     out->components = in->components;
 925     out->subresourceRange = in->subresourceRange;
 926 }
 927
 928 static inline VkIndirectCommandsLayoutTokenNV_host *convert_VkIndirectCommandsLayoutTokenNV_array_win_to_host(const VkIndirectCommandsLayoutTokenNV *in, uint32_t count)
 929 {
 930     VkIndirectCommandsLayoutTokenNV_host *out;
 931     unsigned int i;
 932
 933     if (!in) return NULL;
 934
 935     out = heap_alloc(count * sizeof(*out));
 936     for (i = 0; i < count; i++)
 937     {
 938         out[i].sType = in[i].sType;
 939         out[i].pNext = in[i].pNext;
 940         out[i].tokenType = in[i].tokenType;
 941         out[i].stream = in[i].stream;
 942         out[i].offset = in[i].offset;
 943         out[i].vertexBindingUnit = in[i].vertexBindingUnit;
 944         out[i].vertexDynamicStride = in[i].vertexDynamicStride;
 945         out[i].pushconstantPipelineLayout = in[i].pushconstantPipelineLayout;
 946         out[i].pushconstantShaderStageFlags = in[i].pushconstantShaderStageFlags;
 947         out[i].pushconstantOffset = in[i].pushconstantOffset;
 948         out[i].pushconstantSize = in[i].pushconstantSize;
 949         out[i].indirectStateFlags = in[i].indirectStateFlags;
 950         out[i].indexTypeCount = in[i].indexTypeCount;
 951         out[i].pIndexTypes = in[i].pIndexTypes;
 952         out[i].pIndexTypeValues = in[i].pIndexTypeValues;
 953     }
 954
 955     return out;
 956 }
 957
 958 static inline void free_VkIndirectCommandsLayoutTokenNV_array(VkIndirectCommandsLayoutTokenNV_host *in, uint32_t count)
 959 {
 960     if (!in) return;
 961
 962     heap_free(in);
 963 }
 964
 965 static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win_to_host(const VkIndirectCommandsLayoutCreateInfoNV *in, VkIndirectCommandsLayoutCreateInfoNV_host *out)
 966 {
 967     if (!in) return;
 968
 969     out->sType = in->sType;
 970     out->pNext = in->pNext;
 971     out->flags = in->flags;
 972     out->pipelineBindPoint = in->pipelineBindPoint;
 973     out->tokenCount = in->tokenCount;
 974     out->pTokens = convert_VkIndirectCommandsLayoutTokenNV_array_win_to_host(in->pTokens, in->tokenCount);
 975     out->streamCount = in->streamCount;
 976     out->pStreamStrides = in->pStreamStrides;
 977 }
 978
 979 static inline void free_VkIndirectCommandsLayoutCreateInfoNV(VkIndirectCommandsLayoutCreateInfoNV_host *in)
 980 {
 981     free_VkIndirectCommandsLayoutTokenNV_array((VkIndirectCommandsLayoutTokenNV_host *)in->pTokens, in->tokenCount);
 982 }
 983
 984 static inline VkRayTracingPipelineCreateInfoNV_host *convert_VkRayTracingPipelineCreateInfoNV_array_win_to_host(const VkRayTracingPipelineCreateInfoNV *in, uint32_t count)
 985 {
 986     VkRayTracingPipelineCreateInfoNV_host *out;
 987     unsigned int i;
 988
 989     if (!in) return NULL;
 990
 991     out = heap_alloc(count * sizeof(*out));
 992     for (i = 0; i < count; i++)
 993     {
 994         out[i].sType = in[i].sType;
 995         out[i].pNext = in[i].pNext;
 996         out[i].flags = in[i].flags;
 997         out[i].stageCount = in[i].stageCount;
 998         out[i].pStages = convert_VkPipelineShaderStageCreateInfo_array_win_to_host(in[i].pStages, in[i].stageCount);
 999         out[i].groupCount = in[i].groupCount;
1000         out[i].pGroups = in[i].pGroups;
1001         out[i].maxRecursionDepth = in[i].maxRecursionDepth;
1002         out[i].layout = in[i].layout;
1003         out[i].basePipelineHandle = in[i].basePipelineHandle;
1004         out[i].basePipelineIndex = in[i].basePipelineIndex;
1005     }
1006
1007     return out;
1008 }
1009
1010 static inline void free_VkRayTracingPipelineCreateInfoNV_array(VkRayTracingPipelineCreateInfoNV_host *in, uint32_t count)
1011 {
1012     unsigned int i;
1013
1014     if (!in) return;
1015
1016     for (i = 0; i < count; i++)
1017     {
1018         free_VkPipelineShaderStageCreateInfo_array((VkPipelineShaderStageCreateInfo_host *)in[i].pStages, in[i].stageCount);
1019     }
1020     heap_free(in);
1021 }
1022
1023 static inline void convert_VkSwapchainCreateInfoKHR_win_to_host(const VkSwapchainCreateInfoKHR *in, VkSwapchainCreateInfoKHR_host *out)
1024 {
1025     if (!in) return;
1026
1027     out->sType = in->sType;
1028     out->pNext = in->pNext;
1029     out->flags = in->flags;
1030     out->surface = in->surface;
1031     out->minImageCount = in->minImageCount;
1032     out->imageFormat = in->imageFormat;
1033     out->imageColorSpace = in->imageColorSpace;
1034     out->imageExtent = in->imageExtent;
1035     out->imageArrayLayers = in->imageArrayLayers;
1036     out->imageUsage = in->imageUsage;
1037     out->imageSharingMode = in->imageSharingMode;
1038     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
1039     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
1040     out->preTransform = in->preTransform;
1041     out->compositeAlpha = in->compositeAlpha;
1042     out->presentMode = in->presentMode;
1043     out->clipped = in->clipped;
1044     out->oldSwapchain = in->oldSwapchain;
1045 }
1046
1047 static inline VkMappedMemoryRange_host *convert_VkMappedMemoryRange_array_win_to_host(const VkMappedMemoryRange *in, uint32_t count)
1048 {
1049     VkMappedMemoryRange_host *out;
1050     unsigned int i;
1051
1052     if (!in) return NULL;
1053
1054     out = heap_alloc(count * sizeof(*out));
1055     for (i = 0; i < count; i++)
1056     {
1057         out[i].sType = in[i].sType;
1058         out[i].pNext = in[i].pNext;
1059         out[i].memory = in[i].memory;
1060         out[i].offset = in[i].offset;
1061         out[i].size = in[i].size;
1062     }
1063
1064     return out;
1065 }
1066
1067 static inline void free_VkMappedMemoryRange_array(VkMappedMemoryRange_host *in, uint32_t count)
1068 {
1069     if (!in) return;
1070
1071     heap_free(in);
1072 }
1073
1074 static inline void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win_to_host(const VkAccelerationStructureMemoryRequirementsInfoNV *in, VkAccelerationStructureMemoryRequirementsInfoNV_host *out)
1075 {
1076     if (!in) return;
1077
1078     out->sType = in->sType;
1079     out->pNext = in->pNext;
1080     out->type = in->type;
1081     out->accelerationStructure = in->accelerationStructure;
1082 }
1083
1084 static inline void convert_VkMemoryRequirements_host_to_win(const VkMemoryRequirements_host *in, VkMemoryRequirements *out)
1085 {
1086     if (!in) return;
1087
1088     out->size = in->size;
1089     out->alignment = in->alignment;
1090     out->memoryTypeBits = in->memoryTypeBits;
1091 }
1092
1093 static inline void convert_VkMemoryRequirements2KHR_win_to_host(const VkMemoryRequirements2KHR *in, VkMemoryRequirements2KHR_host *out)
1094 {
1095     if (!in) return;
1096
1097     out->pNext = in->pNext;
1098     out->sType = in->sType;
1099 }
1100
1101 static inline void convert_VkMemoryRequirements2KHR_host_to_win(const VkMemoryRequirements2KHR_host *in, VkMemoryRequirements2KHR *out)
1102 {
1103     if (!in) return;
1104
1105     out->sType = in->sType;
1106     out->pNext = in->pNext;
1107     convert_VkMemoryRequirements_host_to_win(&in->memoryRequirements, &out->memoryRequirements);
1108 }
1109
1110 static inline void convert_VkBufferDeviceAddressInfo_win_to_host(const VkBufferDeviceAddressInfo *in, VkBufferDeviceAddressInfo_host *out)
1111 {
1112     if (!in) return;
1113
1114     out->sType = in->sType;
1115     out->pNext = in->pNext;
1116     out->buffer = in->buffer;
1117 }
1118
1119 static inline void convert_VkBufferMemoryRequirementsInfo2_win_to_host(const VkBufferMemoryRequirementsInfo2 *in, VkBufferMemoryRequirementsInfo2_host *out)
1120 {
1121     if (!in) return;
1122
1123     out->sType = in->sType;
1124     out->pNext = in->pNext;
1125     out->buffer = in->buffer;
1126 }
1127
1128 static inline void convert_VkMemoryRequirements2_win_to_host(const VkMemoryRequirements2 *in, VkMemoryRequirements2_host *out)
1129 {
1130     if (!in) return;
1131
1132     out->pNext = in->pNext;
1133     out->sType = in->sType;
1134 }
1135
1136 static inline void convert_VkMemoryRequirements2_host_to_win(const VkMemoryRequirements2_host *in, VkMemoryRequirements2 *out)
1137 {
1138     if (!in) return;
1139
1140     out->sType = in->sType;
1141     out->pNext = in->pNext;
1142     convert_VkMemoryRequirements_host_to_win(&in->memoryRequirements, &out->memoryRequirements);
1143 }
1144
1145 static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo *in, VkDeviceMemoryOpaqueCaptureAddressInfo_host *out)
1146 {
1147     if (!in) return;
1148
1149     out->sType = in->sType;
1150     out->pNext = in->pNext;
1151     out->memory = in->memory;
1152 }
1153
1154 static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV *in, VkGeneratedCommandsMemoryRequirementsInfoNV_host *out)
1155 {
1156     if (!in) return;
1157
1158     out->sType = in->sType;
1159     out->pNext = in->pNext;
1160     out->pipelineBindPoint = in->pipelineBindPoint;
1161     out->pipeline = in->pipeline;
1162     out->indirectCommandsLayout = in->indirectCommandsLayout;
1163     out->maxSequencesCount = in->maxSequencesCount;
1164 }
1165
1166 static inline void convert_VkImageMemoryRequirementsInfo2_win_to_host(const VkImageMemoryRequirementsInfo2 *in, VkImageMemoryRequirementsInfo2_host *out)
1167 {
1168     if (!in) return;
1169
1170     out->sType = in->sType;
1171     out->pNext = in->pNext;
1172     out->image = in->image;
1173 }
1174
1175 static inline void convert_VkImageSparseMemoryRequirementsInfo2_win_to_host(const VkImageSparseMemoryRequirementsInfo2 *in, VkImageSparseMemoryRequirementsInfo2_host *out)
1176 {
1177     if (!in) return;
1178
1179     out->sType = in->sType;
1180     out->pNext = in->pNext;
1181     out->image = in->image;
1182 }
1183
1184 static inline void convert_VkSubresourceLayout_host_to_win(const VkSubresourceLayout_host *in, VkSubresourceLayout *out)
1185 {
1186     if (!in) return;
1187
1188     out->offset = in->offset;
1189     out->size = in->size;
1190     out->rowPitch = in->rowPitch;
1191     out->arrayPitch = in->arrayPitch;
1192     out->depthPitch = in->depthPitch;
1193 }
1194
1195 static inline void convert_VkImageFormatProperties_host_to_win(const VkImageFormatProperties_host *in, VkImageFormatProperties *out)
1196 {
1197     if (!in) return;
1198
1199     out->maxExtent = in->maxExtent;
1200     out->maxMipLevels = in->maxMipLevels;
1201     out->maxArrayLayers = in->maxArrayLayers;
1202     out->sampleCounts = in->sampleCounts;
1203     out->maxResourceSize = in->maxResourceSize;
1204 }
1205
1206 static inline void convert_VkImageFormatProperties2_win_to_host(const VkImageFormatProperties2 *in, VkImageFormatProperties2_host *out)
1207 {
1208     if (!in) return;
1209
1210     out->pNext = in->pNext;
1211     out->sType = in->sType;
1212 }
1213
1214 static inline void convert_VkImageFormatProperties2_host_to_win(const VkImageFormatProperties2_host *in, VkImageFormatProperties2 *out)
1215 {
1216     if (!in) return;
1217
1218     out->sType = in->sType;
1219     out->pNext = in->pNext;
1220     convert_VkImageFormatProperties_host_to_win(&in->imageFormatProperties, &out->imageFormatProperties);
1221 }
1222
1223 static inline void convert_VkMemoryHeap_static_array_host_to_win(const VkMemoryHeap_host *in, VkMemoryHeap *out, uint32_t count)
1224 {
1225     unsigned int i;
1226
1227     if (!in) return;
1228
1229     for (i = 0; i < count; i++)
1230     {
1231         out[i].size = in[i].size;
1232         out[i].flags = in[i].flags;
1233     }
1234 }
1235
1236 static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win(const VkPhysicalDeviceMemoryProperties_host *in, VkPhysicalDeviceMemoryProperties *out)
1237 {
1238     if (!in) return;
1239
1240     out->memoryTypeCount = in->memoryTypeCount;
1241     memcpy(out->memoryTypes, in->memoryTypes, VK_MAX_MEMORY_TYPES * sizeof(VkMemoryType));
1242     out->memoryHeapCount = in->memoryHeapCount;
1243     convert_VkMemoryHeap_static_array_host_to_win(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
1244 }
1245
1246 static inline void convert_VkPhysicalDeviceMemoryProperties2_win_to_host(const VkPhysicalDeviceMemoryProperties2 *in, VkPhysicalDeviceMemoryProperties2_host *out)
1247 {
1248     if (!in) return;
1249
1250     out->pNext = in->pNext;
1251     out->sType = in->sType;
1252 }
1253
1254 static inline void convert_VkPhysicalDeviceMemoryProperties2_host_to_win(const VkPhysicalDeviceMemoryProperties2_host *in, VkPhysicalDeviceMemoryProperties2 *out)
1255 {
1256     if (!in) return;
1257
1258     out->sType = in->sType;
1259     out->pNext = in->pNext;
1260     convert_VkPhysicalDeviceMemoryProperties_host_to_win(&in->memoryProperties, &out->memoryProperties);
1261 }
1262
1263 static inline void convert_VkPhysicalDeviceLimits_host_to_win(const VkPhysicalDeviceLimits_host *in, VkPhysicalDeviceLimits *out)
1264 {
1265     if (!in) return;
1266
1267     out->maxImageDimension1D = in->maxImageDimension1D;
1268     out->maxImageDimension2D = in->maxImageDimension2D;
1269     out->maxImageDimension3D = in->maxImageDimension3D;
1270     out->maxImageDimensionCube = in->maxImageDimensionCube;
1271     out->maxImageArrayLayers = in->maxImageArrayLayers;
1272     out->maxTexelBufferElements = in->maxTexelBufferElements;
1273     out->maxUniformBufferRange = in->maxUniformBufferRange;
1274     out->maxStorageBufferRange = in->maxStorageBufferRange;
1275     out->maxPushConstantsSize = in->maxPushConstantsSize;
1276     out->maxMemoryAllocationCount = in->maxMemoryAllocationCount;
1277     out->maxSamplerAllocationCount = in->maxSamplerAllocationCount;
1278     out->bufferImageGranularity = in->bufferImageGranularity;
1279     out->sparseAddressSpaceSize = in->sparseAddressSpaceSize;
1280     out->maxBoundDescriptorSets = in->maxBoundDescriptorSets;
1281     out->maxPerStageDescriptorSamplers = in->maxPerStageDescriptorSamplers;
1282     out->maxPerStageDescriptorUniformBuffers = in->maxPerStageDescriptorUniformBuffers;
1283     out->maxPerStageDescriptorStorageBuffers = in->maxPerStageDescriptorStorageBuffers;
1284     out->maxPerStageDescriptorSampledImages = in->maxPerStageDescriptorSampledImages;
1285     out->maxPerStageDescriptorStorageImages = in->maxPerStageDescriptorStorageImages;
1286     out->maxPerStageDescriptorInputAttachments = in->maxPerStageDescriptorInputAttachments;
1287     out->maxPerStageResources = in->maxPerStageResources;
1288     out->maxDescriptorSetSamplers = in->maxDescriptorSetSamplers;
1289     out->maxDescriptorSetUniformBuffers = in->maxDescriptorSetUniformBuffers;
1290     out->maxDescriptorSetUniformBuffersDynamic = in->maxDescriptorSetUniformBuffersDynamic;
1291     out->maxDescriptorSetStorageBuffers = in->maxDescriptorSetStorageBuffers;
1292     out->maxDescriptorSetStorageBuffersDynamic = in->maxDescriptorSetStorageBuffersDynamic;
1293     out->maxDescriptorSetSampledImages = in->maxDescriptorSetSampledImages;
1294     out->maxDescriptorSetStorageImages = in->maxDescriptorSetStorageImages;
1295     out->maxDescriptorSetInputAttachments = in->maxDescriptorSetInputAttachments;
1296     out->maxVertexInputAttributes = in->maxVertexInputAttributes;
1297     out->maxVertexInputBindings = in->maxVertexInputBindings;
1298     out->maxVertexInputAttributeOffset = in->maxVertexInputAttributeOffset;
1299     out->maxVertexInputBindingStride = in->maxVertexInputBindingStride;
1300     out->maxVertexOutputComponents = in->maxVertexOutputComponents;
1301     out->maxTessellationGenerationLevel = in->maxTessellationGenerationLevel;
1302     out->maxTessellationPatchSize = in->maxTessellationPatchSize;
1303     out->maxTessellationControlPerVertexInputComponents = in->maxTessellationControlPerVertexInputComponents;
1304     out->maxTessellationControlPerVertexOutputComponents = in->maxTessellationControlPerVertexOutputComponents;
1305     out->maxTessellationControlPerPatchOutputComponents = in->maxTessellationControlPerPatchOutputComponents;
1306     out->maxTessellationControlTotalOutputComponents = in->maxTessellationControlTotalOutputComponents;
1307     out->maxTessellationEvaluationInputComponents = in->maxTessellationEvaluationInputComponents;
1308     out->maxTessellationEvaluationOutputComponents = in->maxTessellationEvaluationOutputComponents;
1309     out->maxGeometryShaderInvocations = in->maxGeometryShaderInvocations;
1310     out->maxGeometryInputComponents = in->maxGeometryInputComponents;
1311     out->maxGeometryOutputComponents = in->maxGeometryOutputComponents;
1312     out->maxGeometryOutputVertices = in->maxGeometryOutputVertices;
1313     out->maxGeometryTotalOutputComponents = in->maxGeometryTotalOutputComponents;
1314     out->maxFragmentInputComponents = in->maxFragmentInputComponents;
1315     out->maxFragmentOutputAttachments = in->maxFragmentOutputAttachments;
1316     out->maxFragmentDualSrcAttachments = in->maxFragmentDualSrcAttachments;
1317     out->maxFragmentCombinedOutputResources = in->maxFragmentCombinedOutputResources;
1318     out->maxComputeSharedMemorySize = in->maxComputeSharedMemorySize;
1319     memcpy(out->maxComputeWorkGroupCount, in->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
1320     out->maxComputeWorkGroupInvocations = in->maxComputeWorkGroupInvocations;
1321     memcpy(out->maxComputeWorkGroupSize, in->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
1322     out->subPixelPrecisionBits = in->subPixelPrecisionBits;
1323     out->subTexelPrecisionBits = in->subTexelPrecisionBits;
1324     out->mipmapPrecisionBits = in->mipmapPrecisionBits;
1325     out->maxDrawIndexedIndexValue = in->maxDrawIndexedIndexValue;
1326     out->maxDrawIndirectCount = in->maxDrawIndirectCount;
1327     out->maxSamplerLodBias = in->maxSamplerLodBias;
1328     out->maxSamplerAnisotropy = in->maxSamplerAnisotropy;
1329     out->maxViewports = in->maxViewports;
1330     memcpy(out->maxViewportDimensions, in->maxViewportDimensions, 2 * sizeof(uint32_t));
1331     memcpy(out->viewportBoundsRange, in->viewportBoundsRange, 2 * sizeof(float));
1332     out->viewportSubPixelBits = in->viewportSubPixelBits;
1333     out->minMemoryMapAlignment = in->minMemoryMapAlignment;
1334     out->minTexelBufferOffsetAlignment = in->minTexelBufferOffsetAlignment;
1335     out->minUniformBufferOffsetAlignment = in->minUniformBufferOffsetAlignment;
1336     out->minStorageBufferOffsetAlignment = in->minStorageBufferOffsetAlignment;
1337     out->minTexelOffset = in->minTexelOffset;
1338     out->maxTexelOffset = in->maxTexelOffset;
1339     out->minTexelGatherOffset = in->minTexelGatherOffset;
1340     out->maxTexelGatherOffset = in->maxTexelGatherOffset;
1341     out->minInterpolationOffset = in->minInterpolationOffset;
1342     out->maxInterpolationOffset = in->maxInterpolationOffset;
1343     out->subPixelInterpolationOffsetBits = in->subPixelInterpolationOffsetBits;
1344     out->maxFramebufferWidth = in->maxFramebufferWidth;
1345     out->maxFramebufferHeight = in->maxFramebufferHeight;
1346     out->maxFramebufferLayers = in->maxFramebufferLayers;
1347     out->framebufferColorSampleCounts = in->framebufferColorSampleCounts;
1348     out->framebufferDepthSampleCounts = in->framebufferDepthSampleCounts;
1349     out->framebufferStencilSampleCounts = in->framebufferStencilSampleCounts;
1350     out->framebufferNoAttachmentsSampleCounts = in->framebufferNoAttachmentsSampleCounts;
1351     out->maxColorAttachments = in->maxColorAttachments;
1352     out->sampledImageColorSampleCounts = in->sampledImageColorSampleCounts;
1353     out->sampledImageIntegerSampleCounts = in->sampledImageIntegerSampleCounts;
1354     out->sampledImageDepthSampleCounts = in->sampledImageDepthSampleCounts;
1355     out->sampledImageStencilSampleCounts = in->sampledImageStencilSampleCounts;
1356     out->storageImageSampleCounts = in->storageImageSampleCounts;
1357     out->maxSampleMaskWords = in->maxSampleMaskWords;
1358     out->timestampComputeAndGraphics = in->timestampComputeAndGraphics;
1359     out->timestampPeriod = in->timestampPeriod;
1360     out->maxClipDistances = in->maxClipDistances;
1361     out->maxCullDistances = in->maxCullDistances;
1362     out->maxCombinedClipAndCullDistances = in->maxCombinedClipAndCullDistances;
1363     out->discreteQueuePriorities = in->discreteQueuePriorities;
1364     memcpy(out->pointSizeRange, in->pointSizeRange, 2 * sizeof(float));
1365     memcpy(out->lineWidthRange, in->lineWidthRange, 2 * sizeof(float));
1366     out->pointSizeGranularity = in->pointSizeGranularity;
1367     out->lineWidthGranularity = in->lineWidthGranularity;
1368     out->strictLines = in->strictLines;
1369     out->standardSampleLocations = in->standardSampleLocations;
1370     out->optimalBufferCopyOffsetAlignment = in->optimalBufferCopyOffsetAlignment;
1371     out->optimalBufferCopyRowPitchAlignment = in->optimalBufferCopyRowPitchAlignment;
1372     out->nonCoherentAtomSize = in->nonCoherentAtomSize;
1373 }
1374
1375 static inline void convert_VkPhysicalDeviceProperties_host_to_win(const VkPhysicalDeviceProperties_host *in, VkPhysicalDeviceProperties *out)
1376 {
1377     if (!in) return;
1378
1379     out->apiVersion = in->apiVersion;
1380     out->driverVersion = in->driverVersion;
1381     out->vendorID = in->vendorID;
1382     out->deviceID = in->deviceID;
1383     out->deviceType = in->deviceType;
1384     memcpy(out->deviceName, in->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
1385     memcpy(out->pipelineCacheUUID, in->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
1386     convert_VkPhysicalDeviceLimits_host_to_win(&in->limits, &out->limits);
1387     out->sparseProperties = in->sparseProperties;
1388 }
1389
1390 static inline void convert_VkPhysicalDeviceProperties2_win_to_host(const VkPhysicalDeviceProperties2 *in, VkPhysicalDeviceProperties2_host *out)
1391 {
1392     if (!in) return;
1393
1394     out->pNext = in->pNext;
1395     out->sType = in->sType;
1396 }
1397
1398 static inline void convert_VkPhysicalDeviceProperties2_host_to_win(const VkPhysicalDeviceProperties2_host *in, VkPhysicalDeviceProperties2 *out)
1399 {
1400     if (!in) return;
1401
1402     out->sType = in->sType;
1403     out->pNext = in->pNext;
1404     convert_VkPhysicalDeviceProperties_host_to_win(&in->properties, &out->properties);
1405 }
1406
1407 static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win_to_host(const VkPhysicalDeviceSurfaceInfo2KHR *in, VkPhysicalDeviceSurfaceInfo2KHR_host *out)
1408 {
1409     if (!in) return;
1410
1411     out->sType = in->sType;
1412     out->pNext = in->pNext;
1413     out->surface = in->surface;
1414 }
1415
1416 static inline void convert_VkPipelineExecutableInfoKHR_win_to_host(const VkPipelineExecutableInfoKHR *in, VkPipelineExecutableInfoKHR_host *out)
1417 {
1418     if (!in) return;
1419
1420     out->sType = in->sType;
1421     out->pNext = in->pNext;
1422     out->pipeline = in->pipeline;
1423     out->executableIndex = in->executableIndex;
1424 }
1425
1426 static inline void convert_VkPipelineInfoKHR_win_to_host(const VkPipelineInfoKHR *in, VkPipelineInfoKHR_host *out)
1427 {
1428     if (!in) return;
1429
1430     out->sType = in->sType;
1431     out->pNext = in->pNext;
1432     out->pipeline = in->pipeline;
1433 }
1434
1435 static inline VkSparseMemoryBind_host *convert_VkSparseMemoryBind_array_win_to_host(const VkSparseMemoryBind *in, uint32_t count)
1436 {
1437     VkSparseMemoryBind_host *out;
1438     unsigned int i;
1439
1440     if (!in) return NULL;
1441
1442     out = heap_alloc(count * sizeof(*out));
1443     for (i = 0; i < count; i++)
1444     {
1445         out[i].resourceOffset = in[i].resourceOffset;
1446         out[i].size = in[i].size;
1447         out[i].memory = in[i].memory;
1448         out[i].memoryOffset = in[i].memoryOffset;
1449         out[i].flags = in[i].flags;
1450     }
1451
1452     return out;
1453 }
1454
1455 static inline void free_VkSparseMemoryBind_array(VkSparseMemoryBind_host *in, uint32_t count)
1456 {
1457     if (!in) return;
1458
1459     heap_free(in);
1460 }
1461
1462 static inline VkSparseBufferMemoryBindInfo_host *convert_VkSparseBufferMemoryBindInfo_array_win_to_host(const VkSparseBufferMemoryBindInfo *in, uint32_t count)
1463 {
1464     VkSparseBufferMemoryBindInfo_host *out;
1465     unsigned int i;
1466
1467     if (!in) return NULL;
1468
1469     out = heap_alloc(count * sizeof(*out));
1470     for (i = 0; i < count; i++)
1471     {
1472         out[i].buffer = in[i].buffer;
1473         out[i].bindCount = in[i].bindCount;
1474         out[i].pBinds = convert_VkSparseMemoryBind_array_win_to_host(in[i].pBinds, in[i].bindCount);
1475     }
1476
1477     return out;
1478 }
1479
1480 static inline void free_VkSparseBufferMemoryBindInfo_array(VkSparseBufferMemoryBindInfo_host *in, uint32_t count)
1481 {
1482     unsigned int i;
1483
1484     if (!in) return;
1485
1486     for (i = 0; i < count; i++)
1487     {
1488         free_VkSparseMemoryBind_array((VkSparseMemoryBind_host *)in[i].pBinds, in[i].bindCount);
1489     }
1490     heap_free(in);
1491 }
1492
1493 static inline VkSparseImageOpaqueMemoryBindInfo_host *convert_VkSparseImageOpaqueMemoryBindInfo_array_win_to_host(const VkSparseImageOpaqueMemoryBindInfo *in, uint32_t count)
1494 {
1495     VkSparseImageOpaqueMemoryBindInfo_host *out;
1496     unsigned int i;
1497
1498     if (!in) return NULL;
1499
1500     out = heap_alloc(count * sizeof(*out));
1501     for (i = 0; i < count; i++)
1502     {
1503         out[i].image = in[i].image;
1504         out[i].bindCount = in[i].bindCount;
1505         out[i].pBinds = convert_VkSparseMemoryBind_array_win_to_host(in[i].pBinds, in[i].bindCount);
1506     }
1507
1508     return out;
1509 }
1510
1511 static inline void free_VkSparseImageOpaqueMemoryBindInfo_array(VkSparseImageOpaqueMemoryBindInfo_host *in, uint32_t count)
1512 {
1513     unsigned int i;
1514
1515     if (!in) return;
1516
1517     for (i = 0; i < count; i++)
1518     {
1519         free_VkSparseMemoryBind_array((VkSparseMemoryBind_host *)in[i].pBinds, in[i].bindCount);
1520     }
1521     heap_free(in);
1522 }
1523
1524 static inline VkSparseImageMemoryBind_host *convert_VkSparseImageMemoryBind_array_win_to_host(const VkSparseImageMemoryBind *in, uint32_t count)
1525 {
1526     VkSparseImageMemoryBind_host *out;
1527     unsigned int i;
1528
1529     if (!in) return NULL;
1530
1531     out = heap_alloc(count * sizeof(*out));
1532     for (i = 0; i < count; i++)
1533     {
1534         out[i].subresource = in[i].subresource;
1535         out[i].offset = in[i].offset;
1536         out[i].extent = in[i].extent;
1537         out[i].memory = in[i].memory;
1538         out[i].memoryOffset = in[i].memoryOffset;
1539         out[i].flags = in[i].flags;
1540     }
1541
1542     return out;
1543 }
1544
1545 static inline void free_VkSparseImageMemoryBind_array(VkSparseImageMemoryBind_host *in, uint32_t count)
1546 {
1547     if (!in) return;
1548
1549     heap_free(in);
1550 }
1551
1552 static inline VkSparseImageMemoryBindInfo_host *convert_VkSparseImageMemoryBindInfo_array_win_to_host(const VkSparseImageMemoryBindInfo *in, uint32_t count)
1553 {
1554     VkSparseImageMemoryBindInfo_host *out;
1555     unsigned int i;
1556
1557     if (!in) return NULL;
1558
1559     out = heap_alloc(count * sizeof(*out));
1560     for (i = 0; i < count; i++)
1561     {
1562         out[i].image = in[i].image;
1563         out[i].bindCount = in[i].bindCount;
1564         out[i].pBinds = convert_VkSparseImageMemoryBind_array_win_to_host(in[i].pBinds, in[i].bindCount);
1565     }
1566
1567     return out;
1568 }
1569
1570 static inline void free_VkSparseImageMemoryBindInfo_array(VkSparseImageMemoryBindInfo_host *in, uint32_t count)
1571 {
1572     unsigned int i;
1573
1574     if (!in) return;
1575
1576     for (i = 0; i < count; i++)
1577     {
1578         free_VkSparseImageMemoryBind_array((VkSparseImageMemoryBind_host *)in[i].pBinds, in[i].bindCount);
1579     }
1580     heap_free(in);
1581 }
1582
1583 static inline VkBindSparseInfo_host *convert_VkBindSparseInfo_array_win_to_host(const VkBindSparseInfo *in, uint32_t count)
1584 {
1585     VkBindSparseInfo_host *out;
1586     unsigned int i;
1587
1588     if (!in) return NULL;
1589
1590     out = heap_alloc(count * sizeof(*out));
1591     for (i = 0; i < count; i++)
1592     {
1593         out[i].sType = in[i].sType;
1594         out[i].pNext = in[i].pNext;
1595         out[i].waitSemaphoreCount = in[i].waitSemaphoreCount;
1596         out[i].pWaitSemaphores = in[i].pWaitSemaphores;
1597         out[i].bufferBindCount = in[i].bufferBindCount;
1598         out[i].pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win_to_host(in[i].pBufferBinds, in[i].bufferBindCount);
1599         out[i].imageOpaqueBindCount = in[i].imageOpaqueBindCount;
1600         out[i].pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win_to_host(in[i].pImageOpaqueBinds, in[i].imageOpaqueBindCount);
1601         out[i].imageBindCount = in[i].imageBindCount;
1602         out[i].pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win_to_host(in[i].pImageBinds, in[i].imageBindCount);
1603         out[i].signalSemaphoreCount = in[i].signalSemaphoreCount;
1604         out[i].pSignalSemaphores = in[i].pSignalSemaphores;
1605     }
1606
1607     return out;
1608 }
1609
1610 static inline void free_VkBindSparseInfo_array(VkBindSparseInfo_host *in, uint32_t count)
1611 {
1612     unsigned int i;
1613
1614     if (!in) return;
1615
1616     for (i = 0; i < count; i++)
1617     {
1618         free_VkSparseBufferMemoryBindInfo_array((VkSparseBufferMemoryBindInfo_host *)in[i].pBufferBinds, in[i].bufferBindCount);
1619         free_VkSparseImageOpaqueMemoryBindInfo_array((VkSparseImageOpaqueMemoryBindInfo_host *)in[i].pImageOpaqueBinds, in[i].imageOpaqueBindCount);
1620         free_VkSparseImageMemoryBindInfo_array((VkSparseImageMemoryBindInfo_host *)in[i].pImageBinds, in[i].imageBindCount);
1621     }
1622     heap_free(in);
1623 }
1624
1625 static inline void convert_VkDebugUtilsObjectNameInfoEXT_win_to_host(const VkDebugUtilsObjectNameInfoEXT *in, VkDebugUtilsObjectNameInfoEXT_host *out)
1626 {
1627     if (!in) return;
1628
1629     out->sType = in->sType;
1630     out->pNext = in->pNext;
1631     out->objectType = in->objectType;
1632     out->objectHandle = in->objectHandle;
1633     out->pObjectName = in->pObjectName;
1634 }
1635
1636 static inline void convert_VkDebugUtilsObjectTagInfoEXT_win_to_host(const VkDebugUtilsObjectTagInfoEXT *in, VkDebugUtilsObjectTagInfoEXT_host *out)
1637 {
1638     if (!in) return;
1639
1640     out->sType = in->sType;
1641     out->pNext = in->pNext;
1642     out->objectType = in->objectType;
1643     out->objectHandle = in->objectHandle;
1644     out->tagName = in->tagName;
1645     out->tagSize = in->tagSize;
1646     out->pTag = in->pTag;
1647 }
1648
1649 static inline void convert_VkSemaphoreSignalInfo_win_to_host(const VkSemaphoreSignalInfo *in, VkSemaphoreSignalInfo_host *out)
1650 {
1651     if (!in) return;
1652
1653     out->sType = in->sType;
1654     out->pNext = in->pNext;
1655     out->semaphore = in->semaphore;
1656     out->value = in->value;
1657 }
1658
1659 static inline VkDebugUtilsObjectNameInfoEXT_host *convert_VkDebugUtilsObjectNameInfoEXT_array_win_to_host(const VkDebugUtilsObjectNameInfoEXT *in, uint32_t count)
1660 {
1661     VkDebugUtilsObjectNameInfoEXT_host *out;
1662     unsigned int i;
1663
1664     if (!in) return NULL;
1665
1666     out = heap_alloc(count * sizeof(*out));
1667     for (i = 0; i < count; i++)
1668     {
1669         out[i].sType = in[i].sType;
1670         out[i].pNext = in[i].pNext;
1671         out[i].objectType = in[i].objectType;
1672         out[i].objectHandle = in[i].objectHandle;
1673         out[i].pObjectName = in[i].pObjectName;
1674     }
1675
1676     return out;
1677 }
1678
1679 static inline void free_VkDebugUtilsObjectNameInfoEXT_array(VkDebugUtilsObjectNameInfoEXT_host *in, uint32_t count)
1680 {
1681     if (!in) return;
1682
1683     heap_free(in);
1684 }
1685
1686 static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win_to_host(const VkDebugUtilsMessengerCallbackDataEXT *in, VkDebugUtilsMessengerCallbackDataEXT_host *out)
1687 {
1688     if (!in) return;
1689
1690     out->sType = in->sType;
1691     out->pNext = in->pNext;
1692     out->flags = in->flags;
1693     out->pMessageIdName = in->pMessageIdName;
1694     out->messageIdNumber = in->messageIdNumber;
1695     out->pMessage = in->pMessage;
1696     out->queueLabelCount = in->queueLabelCount;
1697     out->pQueueLabels = in->pQueueLabels;
1698     out->cmdBufLabelCount = in->cmdBufLabelCount;
1699     out->pCmdBufLabels = in->pCmdBufLabels;
1700     out->objectCount = in->objectCount;
1701     out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win_to_host(in->pObjects, in->objectCount);
1702 }
1703
1704 static inline void free_VkDebugUtilsMessengerCallbackDataEXT(VkDebugUtilsMessengerCallbackDataEXT_host *in)
1705 {
1706     free_VkDebugUtilsObjectNameInfoEXT_array((VkDebugUtilsObjectNameInfoEXT_host *)in->pObjects, in->objectCount);
1707 }
1708
1709 static inline VkCopyDescriptorSet_host *convert_VkCopyDescriptorSet_array_win_to_host(const VkCopyDescriptorSet *in, uint32_t count)
1710 {
1711     VkCopyDescriptorSet_host *out;
1712     unsigned int i;
1713
1714     if (!in) return NULL;
1715
1716     out = heap_alloc(count * sizeof(*out));
1717     for (i = 0; i < count; i++)
1718     {
1719         out[i].sType = in[i].sType;
1720         out[i].pNext = in[i].pNext;
1721         out[i].srcSet = in[i].srcSet;
1722         out[i].srcBinding = in[i].srcBinding;
1723         out[i].srcArrayElement = in[i].srcArrayElement;
1724         out[i].dstSet = in[i].dstSet;
1725         out[i].dstBinding = in[i].dstBinding;
1726         out[i].dstArrayElement = in[i].dstArrayElement;
1727         out[i].descriptorCount = in[i].descriptorCount;
1728     }
1729
1730     return out;
1731 }
1732
1733 static inline void free_VkCopyDescriptorSet_array(VkCopyDescriptorSet_host *in, uint32_t count)
1734 {
1735     if (!in) return;
1736
1737     heap_free(in);
1738 }
1739
1740 #endif /* USE_STRUCT_CONVERSION */
1741
1742 VkResult convert_VkDeviceCreateInfo_struct_chain(const void *pNext, VkDeviceCreateInfo *out_struct)
1743 {
1744     VkBaseOutStructure *out_header = (VkBaseOutStructure *)out_struct;
1745     const VkBaseInStructure *in_header;
1746
1747     out_header->pNext = NULL;
1748
1749     for (in_header = pNext; in_header; in_header = in_header->pNext)
1750     {
1751         switch (in_header->sType)
1752         {
1753         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
1754         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
1755             break;
1756
1757         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
1758         {
1759             const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header;
1760             VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out;
1761
1762             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1763
1764             out->sType = in->sType;
1765             out->pNext = NULL;
1766             out->deviceGeneratedCommands = in->deviceGeneratedCommands;
1767
1768             out_header->pNext = (VkBaseOutStructure *)out;
1769             out_header = out_header->pNext;
1770             break;
1771         }
1772
1773         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
1774         {
1775             const VkDevicePrivateDataCreateInfoEXT *in = (const VkDevicePrivateDataCreateInfoEXT *)in_header;
1776             VkDevicePrivateDataCreateInfoEXT *out;
1777
1778             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1779
1780             out->sType = in->sType;
1781             out->pNext = NULL;
1782             out->privateDataSlotRequestCount = in->privateDataSlotRequestCount;
1783
1784             out_header->pNext = (VkBaseOutStructure *)out;
1785             out_header = out_header->pNext;
1786             break;
1787         }
1788
1789         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
1790         {
1791             const VkPhysicalDevicePrivateDataFeaturesEXT *in = (const VkPhysicalDevicePrivateDataFeaturesEXT *)in_header;
1792             VkPhysicalDevicePrivateDataFeaturesEXT *out;
1793
1794             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1795
1796             out->sType = in->sType;
1797             out->pNext = NULL;
1798             out->privateData = in->privateData;
1799
1800             out_header->pNext = (VkBaseOutStructure *)out;
1801             out_header = out_header->pNext;
1802             break;
1803         }
1804
1805         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
1806         {
1807             const VkPhysicalDeviceFeatures2 *in = (const VkPhysicalDeviceFeatures2 *)in_header;
1808             VkPhysicalDeviceFeatures2 *out;
1809
1810             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1811
1812             out->sType = in->sType;
1813             out->pNext = NULL;
1814             out->features = in->features;
1815
1816             out_header->pNext = (VkBaseOutStructure *)out;
1817             out_header = out_header->pNext;
1818             break;
1819         }
1820
1821         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
1822         {
1823             const VkPhysicalDeviceVariablePointersFeatures *in = (const VkPhysicalDeviceVariablePointersFeatures *)in_header;
1824             VkPhysicalDeviceVariablePointersFeatures *out;
1825
1826             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1827
1828             out->sType = in->sType;
1829             out->pNext = NULL;
1830             out->variablePointersStorageBuffer = in->variablePointersStorageBuffer;
1831             out->variablePointers = in->variablePointers;
1832
1833             out_header->pNext = (VkBaseOutStructure *)out;
1834             out_header = out_header->pNext;
1835             break;
1836         }
1837
1838         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
1839         {
1840             const VkPhysicalDeviceMultiviewFeatures *in = (const VkPhysicalDeviceMultiviewFeatures *)in_header;
1841             VkPhysicalDeviceMultiviewFeatures *out;
1842
1843             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1844
1845             out->sType = in->sType;
1846             out->pNext = NULL;
1847             out->multiview = in->multiview;
1848             out->multiviewGeometryShader = in->multiviewGeometryShader;
1849             out->multiviewTessellationShader = in->multiviewTessellationShader;
1850
1851             out_header->pNext = (VkBaseOutStructure *)out;
1852             out_header = out_header->pNext;
1853             break;
1854         }
1855
1856         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
1857         {
1858             const VkDeviceGroupDeviceCreateInfo *in = (const VkDeviceGroupDeviceCreateInfo *)in_header;
1859             VkDeviceGroupDeviceCreateInfo *out;
1860
1861             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1862
1863             out->sType = in->sType;
1864             out->pNext = NULL;
1865             out->physicalDeviceCount = in->physicalDeviceCount;
1866             out->pPhysicalDevices = in->pPhysicalDevices;
1867
1868             out_header->pNext = (VkBaseOutStructure *)out;
1869             out_header = out_header->pNext;
1870             break;
1871         }
1872
1873         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
1874         {
1875             const VkPhysicalDevice16BitStorageFeatures *in = (const VkPhysicalDevice16BitStorageFeatures *)in_header;
1876             VkPhysicalDevice16BitStorageFeatures *out;
1877
1878             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1879
1880             out->sType = in->sType;
1881             out->pNext = NULL;
1882             out->storageBuffer16BitAccess = in->storageBuffer16BitAccess;
1883             out->uniformAndStorageBuffer16BitAccess = in->uniformAndStorageBuffer16BitAccess;
1884             out->storagePushConstant16 = in->storagePushConstant16;
1885             out->storageInputOutput16 = in->storageInputOutput16;
1886
1887             out_header->pNext = (VkBaseOutStructure *)out;
1888             out_header = out_header->pNext;
1889             break;
1890         }
1891
1892         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
1893         {
1894             const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header;
1895             VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out;
1896
1897             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1898
1899             out->sType = in->sType;
1900             out->pNext = NULL;
1901             out->shaderSubgroupExtendedTypes = in->shaderSubgroupExtendedTypes;
1902
1903             out_header->pNext = (VkBaseOutStructure *)out;
1904             out_header = out_header->pNext;
1905             break;
1906         }
1907
1908         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
1909         {
1910             const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header;
1911             VkPhysicalDeviceSamplerYcbcrConversionFeatures *out;
1912
1913             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1914
1915             out->sType = in->sType;
1916             out->pNext = NULL;
1917             out->samplerYcbcrConversion = in->samplerYcbcrConversion;
1918
1919             out_header->pNext = (VkBaseOutStructure *)out;
1920             out_header = out_header->pNext;
1921             break;
1922         }
1923
1924         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
1925         {
1926             const VkPhysicalDeviceProtectedMemoryFeatures *in = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header;
1927             VkPhysicalDeviceProtectedMemoryFeatures *out;
1928
1929             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1930
1931             out->sType = in->sType;
1932             out->pNext = NULL;
1933             out->protectedMemory = in->protectedMemory;
1934
1935             out_header->pNext = (VkBaseOutStructure *)out;
1936             out_header = out_header->pNext;
1937             break;
1938         }
1939
1940         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
1941         {
1942             const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header;
1943             VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out;
1944
1945             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1946
1947             out->sType = in->sType;
1948             out->pNext = NULL;
1949             out->advancedBlendCoherentOperations = in->advancedBlendCoherentOperations;
1950
1951             out_header->pNext = (VkBaseOutStructure *)out;
1952             out_header = out_header->pNext;
1953             break;
1954         }
1955
1956         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
1957         {
1958             const VkPhysicalDeviceInlineUniformBlockFeaturesEXT *in = (const VkPhysicalDeviceInlineUniformBlockFeaturesEXT *)in_header;
1959             VkPhysicalDeviceInlineUniformBlockFeaturesEXT *out;
1960
1961             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1962
1963             out->sType = in->sType;
1964             out->pNext = NULL;
1965             out->inlineUniformBlock = in->inlineUniformBlock;
1966             out->descriptorBindingInlineUniformBlockUpdateAfterBind = in->descriptorBindingInlineUniformBlockUpdateAfterBind;
1967
1968             out_header->pNext = (VkBaseOutStructure *)out;
1969             out_header = out_header->pNext;
1970             break;
1971         }
1972
1973         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
1974         {
1975             const VkPhysicalDeviceShaderDrawParametersFeatures *in = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header;
1976             VkPhysicalDeviceShaderDrawParametersFeatures *out;
1977
1978             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1979
1980             out->sType = in->sType;
1981             out->pNext = NULL;
1982             out->shaderDrawParameters = in->shaderDrawParameters;
1983
1984             out_header->pNext = (VkBaseOutStructure *)out;
1985             out_header = out_header->pNext;
1986             break;
1987         }
1988
1989         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
1990         {
1991             const VkPhysicalDeviceShaderFloat16Int8Features *in = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header;
1992             VkPhysicalDeviceShaderFloat16Int8Features *out;
1993
1994             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
1995
1996             out->sType = in->sType;
1997             out->pNext = NULL;
1998             out->shaderFloat16 = in->shaderFloat16;
1999             out->shaderInt8 = in->shaderInt8;
2000
2001             out_header->pNext = (VkBaseOutStructure *)out;
2002             out_header = out_header->pNext;
2003             break;
2004         }
2005
2006         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
2007         {
2008             const VkPhysicalDeviceHostQueryResetFeatures *in = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header;
2009             VkPhysicalDeviceHostQueryResetFeatures *out;
2010
2011             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2012
2013             out->sType = in->sType;
2014             out->pNext = NULL;
2015             out->hostQueryReset = in->hostQueryReset;
2016
2017             out_header->pNext = (VkBaseOutStructure *)out;
2018             out_header = out_header->pNext;
2019             break;
2020         }
2021
2022         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
2023         {
2024             const VkPhysicalDeviceDescriptorIndexingFeatures *in = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header;
2025             VkPhysicalDeviceDescriptorIndexingFeatures *out;
2026
2027             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2028
2029             out->sType = in->sType;
2030             out->pNext = NULL;
2031             out->shaderInputAttachmentArrayDynamicIndexing = in->shaderInputAttachmentArrayDynamicIndexing;
2032             out->shaderUniformTexelBufferArrayDynamicIndexing = in->shaderUniformTexelBufferArrayDynamicIndexing;
2033             out->shaderStorageTexelBufferArrayDynamicIndexing = in->shaderStorageTexelBufferArrayDynamicIndexing;
2034             out->shaderUniformBufferArrayNonUniformIndexing = in->shaderUniformBufferArrayNonUniformIndexing;
2035             out->shaderSampledImageArrayNonUniformIndexing = in->shaderSampledImageArrayNonUniformIndexing;
2036             out->shaderStorageBufferArrayNonUniformIndexing = in->shaderStorageBufferArrayNonUniformIndexing;
2037             out->shaderStorageImageArrayNonUniformIndexing = in->shaderStorageImageArrayNonUniformIndexing;
2038             out->shaderInputAttachmentArrayNonUniformIndexing = in->shaderInputAttachmentArrayNonUniformIndexing;
2039             out->shaderUniformTexelBufferArrayNonUniformIndexing = in->shaderUniformTexelBufferArrayNonUniformIndexing;
2040             out->shaderStorageTexelBufferArrayNonUniformIndexing = in->shaderStorageTexelBufferArrayNonUniformIndexing;
2041             out->descriptorBindingUniformBufferUpdateAfterBind = in->descriptorBindingUniformBufferUpdateAfterBind;
2042             out->descriptorBindingSampledImageUpdateAfterBind = in->descriptorBindingSampledImageUpdateAfterBind;
2043             out->descriptorBindingStorageImageUpdateAfterBind = in->descriptorBindingStorageImageUpdateAfterBind;
2044             out->descriptorBindingStorageBufferUpdateAfterBind = in->descriptorBindingStorageBufferUpdateAfterBind;
2045             out->descriptorBindingUniformTexelBufferUpdateAfterBind = in->descriptorBindingUniformTexelBufferUpdateAfterBind;
2046             out->descriptorBindingStorageTexelBufferUpdateAfterBind = in->descriptorBindingStorageTexelBufferUpdateAfterBind;
2047             out->descriptorBindingUpdateUnusedWhilePending = in->descriptorBindingUpdateUnusedWhilePending;
2048             out->descriptorBindingPartiallyBound = in->descriptorBindingPartiallyBound;
2049             out->descriptorBindingVariableDescriptorCount = in->descriptorBindingVariableDescriptorCount;
2050             out->runtimeDescriptorArray = in->runtimeDescriptorArray;
2051
2052             out_header->pNext = (VkBaseOutStructure *)out;
2053             out_header = out_header->pNext;
2054             break;
2055         }
2056
2057         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
2058         {
2059             const VkPhysicalDeviceTimelineSemaphoreFeatures *in = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header;
2060             VkPhysicalDeviceTimelineSemaphoreFeatures *out;
2061
2062             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2063
2064             out->sType = in->sType;
2065             out->pNext = NULL;
2066             out->timelineSemaphore = in->timelineSemaphore;
2067
2068             out_header->pNext = (VkBaseOutStructure *)out;
2069             out_header = out_header->pNext;
2070             break;
2071         }
2072
2073         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
2074         {
2075             const VkPhysicalDevice8BitStorageFeatures *in = (const VkPhysicalDevice8BitStorageFeatures *)in_header;
2076             VkPhysicalDevice8BitStorageFeatures *out;
2077
2078             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2079
2080             out->sType = in->sType;
2081             out->pNext = NULL;
2082             out->storageBuffer8BitAccess = in->storageBuffer8BitAccess;
2083             out->uniformAndStorageBuffer8BitAccess = in->uniformAndStorageBuffer8BitAccess;
2084             out->storagePushConstant8 = in->storagePushConstant8;
2085
2086             out_header->pNext = (VkBaseOutStructure *)out;
2087             out_header = out_header->pNext;
2088             break;
2089         }
2090
2091         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
2092         {
2093             const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header;
2094             VkPhysicalDeviceConditionalRenderingFeaturesEXT *out;
2095
2096             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2097
2098             out->sType = in->sType;
2099             out->pNext = NULL;
2100             out->conditionalRendering = in->conditionalRendering;
2101             out->inheritedConditionalRendering = in->inheritedConditionalRendering;
2102
2103             out_header->pNext = (VkBaseOutStructure *)out;
2104             out_header = out_header->pNext;
2105             break;
2106         }
2107
2108         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
2109         {
2110             const VkPhysicalDeviceVulkanMemoryModelFeatures *in = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header;
2111             VkPhysicalDeviceVulkanMemoryModelFeatures *out;
2112
2113             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2114
2115             out->sType = in->sType;
2116             out->pNext = NULL;
2117             out->vulkanMemoryModel = in->vulkanMemoryModel;
2118             out->vulkanMemoryModelDeviceScope = in->vulkanMemoryModelDeviceScope;
2119             out->vulkanMemoryModelAvailabilityVisibilityChains = in->vulkanMemoryModelAvailabilityVisibilityChains;
2120
2121             out_header->pNext = (VkBaseOutStructure *)out;
2122             out_header = out_header->pNext;
2123             break;
2124         }
2125
2126         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
2127         {
2128             const VkPhysicalDeviceShaderAtomicInt64Features *in = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header;
2129             VkPhysicalDeviceShaderAtomicInt64Features *out;
2130
2131             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2132
2133             out->sType = in->sType;
2134             out->pNext = NULL;
2135             out->shaderBufferInt64Atomics = in->shaderBufferInt64Atomics;
2136             out->shaderSharedInt64Atomics = in->shaderSharedInt64Atomics;
2137
2138             out_header->pNext = (VkBaseOutStructure *)out;
2139             out_header = out_header->pNext;
2140             break;
2141         }
2142
2143         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
2144         {
2145             const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header;
2146             VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out;
2147
2148             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2149
2150             out->sType = in->sType;
2151             out->pNext = NULL;
2152             out->shaderBufferFloat32Atomics = in->shaderBufferFloat32Atomics;
2153             out->shaderBufferFloat32AtomicAdd = in->shaderBufferFloat32AtomicAdd;
2154             out->shaderBufferFloat64Atomics = in->shaderBufferFloat64Atomics;
2155             out->shaderBufferFloat64AtomicAdd = in->shaderBufferFloat64AtomicAdd;
2156             out->shaderSharedFloat32Atomics = in->shaderSharedFloat32Atomics;
2157             out->shaderSharedFloat32AtomicAdd = in->shaderSharedFloat32AtomicAdd;
2158             out->shaderSharedFloat64Atomics = in->shaderSharedFloat64Atomics;
2159             out->shaderSharedFloat64AtomicAdd = in->shaderSharedFloat64AtomicAdd;
2160             out->shaderImageFloat32Atomics = in->shaderImageFloat32Atomics;
2161             out->shaderImageFloat32AtomicAdd = in->shaderImageFloat32AtomicAdd;
2162             out->sparseImageFloat32Atomics = in->sparseImageFloat32Atomics;
2163             out->sparseImageFloat32AtomicAdd = in->sparseImageFloat32AtomicAdd;
2164
2165             out_header->pNext = (VkBaseOutStructure *)out;
2166             out_header = out_header->pNext;
2167             break;
2168         }
2169
2170         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
2171         {
2172             const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header;
2173             VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out;
2174
2175             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2176
2177             out->sType = in->sType;
2178             out->pNext = NULL;
2179             out->vertexAttributeInstanceRateDivisor = in->vertexAttributeInstanceRateDivisor;
2180             out->vertexAttributeInstanceRateZeroDivisor = in->vertexAttributeInstanceRateZeroDivisor;
2181
2182             out_header->pNext = (VkBaseOutStructure *)out;
2183             out_header = out_header->pNext;
2184             break;
2185         }
2186
2187         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
2188         {
2189             const VkPhysicalDeviceASTCDecodeFeaturesEXT *in = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header;
2190             VkPhysicalDeviceASTCDecodeFeaturesEXT *out;
2191
2192             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2193
2194             out->sType = in->sType;
2195             out->pNext = NULL;
2196             out->decodeModeSharedExponent = in->decodeModeSharedExponent;
2197
2198             out_header->pNext = (VkBaseOutStructure *)out;
2199             out_header = out_header->pNext;
2200             break;
2201         }
2202
2203         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
2204         {
2205             const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header;
2206             VkPhysicalDeviceTransformFeedbackFeaturesEXT *out;
2207
2208             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2209
2210             out->sType = in->sType;
2211             out->pNext = NULL;
2212             out->transformFeedback = in->transformFeedback;
2213             out->geometryStreams = in->geometryStreams;
2214
2215             out_header->pNext = (VkBaseOutStructure *)out;
2216             out_header = out_header->pNext;
2217             break;
2218         }
2219
2220         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
2221         {
2222             const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header;
2223             VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out;
2224
2225             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2226
2227             out->sType = in->sType;
2228             out->pNext = NULL;
2229             out->representativeFragmentTest = in->representativeFragmentTest;
2230
2231             out_header->pNext = (VkBaseOutStructure *)out;
2232             out_header = out_header->pNext;
2233             break;
2234         }
2235
2236         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
2237         {
2238             const VkPhysicalDeviceExclusiveScissorFeaturesNV *in = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header;
2239             VkPhysicalDeviceExclusiveScissorFeaturesNV *out;
2240
2241             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2242
2243             out->sType = in->sType;
2244             out->pNext = NULL;
2245             out->exclusiveScissor = in->exclusiveScissor;
2246
2247             out_header->pNext = (VkBaseOutStructure *)out;
2248             out_header = out_header->pNext;
2249             break;
2250         }
2251
2252         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
2253         {
2254             const VkPhysicalDeviceCornerSampledImageFeaturesNV *in = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header;
2255             VkPhysicalDeviceCornerSampledImageFeaturesNV *out;
2256
2257             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2258
2259             out->sType = in->sType;
2260             out->pNext = NULL;
2261             out->cornerSampledImage = in->cornerSampledImage;
2262
2263             out_header->pNext = (VkBaseOutStructure *)out;
2264             out_header = out_header->pNext;
2265             break;
2266         }
2267
2268         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
2269         {
2270             const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header;
2271             VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out;
2272
2273             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2274
2275             out->sType = in->sType;
2276             out->pNext = NULL;
2277             out->computeDerivativeGroupQuads = in->computeDerivativeGroupQuads;
2278             out->computeDerivativeGroupLinear = in->computeDerivativeGroupLinear;
2279
2280             out_header->pNext = (VkBaseOutStructure *)out;
2281             out_header = out_header->pNext;
2282             break;
2283         }
2284
2285         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
2286         {
2287             const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *in = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *)in_header;
2288             VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *out;
2289
2290             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2291
2292             out->sType = in->sType;
2293             out->pNext = NULL;
2294             out->fragmentShaderBarycentric = in->fragmentShaderBarycentric;
2295
2296             out_header->pNext = (VkBaseOutStructure *)out;
2297             out_header = out_header->pNext;
2298             break;
2299         }
2300
2301         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
2302         {
2303             const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header;
2304             VkPhysicalDeviceShaderImageFootprintFeaturesNV *out;
2305
2306             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2307
2308             out->sType = in->sType;
2309             out->pNext = NULL;
2310             out->imageFootprint = in->imageFootprint;
2311
2312             out_header->pNext = (VkBaseOutStructure *)out;
2313             out_header = out_header->pNext;
2314             break;
2315         }
2316
2317         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
2318         {
2319             const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header;
2320             VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out;
2321
2322             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2323
2324             out->sType = in->sType;
2325             out->pNext = NULL;
2326             out->dedicatedAllocationImageAliasing = in->dedicatedAllocationImageAliasing;
2327
2328             out_header->pNext = (VkBaseOutStructure *)out;
2329             out_header = out_header->pNext;
2330             break;
2331         }
2332
2333         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
2334         {
2335             const VkPhysicalDeviceShadingRateImageFeaturesNV *in = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header;
2336             VkPhysicalDeviceShadingRateImageFeaturesNV *out;
2337
2338             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2339
2340             out->sType = in->sType;
2341             out->pNext = NULL;
2342             out->shadingRateImage = in->shadingRateImage;
2343             out->shadingRateCoarseSampleOrder = in->shadingRateCoarseSampleOrder;
2344
2345             out_header->pNext = (VkBaseOutStructure *)out;
2346             out_header = out_header->pNext;
2347             break;
2348         }
2349
2350         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
2351         {
2352             const VkPhysicalDeviceMeshShaderFeaturesNV *in = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header;
2353             VkPhysicalDeviceMeshShaderFeaturesNV *out;
2354
2355             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2356
2357             out->sType = in->sType;
2358             out->pNext = NULL;
2359             out->taskShader = in->taskShader;
2360             out->meshShader = in->meshShader;
2361
2362             out_header->pNext = (VkBaseOutStructure *)out;
2363             out_header = out_header->pNext;
2364             break;
2365         }
2366
2367         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
2368         {
2369             const VkDeviceMemoryOverallocationCreateInfoAMD *in = (const VkDeviceMemoryOverallocationCreateInfoAMD *)in_header;
2370             VkDeviceMemoryOverallocationCreateInfoAMD *out;
2371
2372             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2373
2374             out->sType = in->sType;
2375             out->pNext = NULL;
2376             out->overallocationBehavior = in->overallocationBehavior;
2377
2378             out_header->pNext = (VkBaseOutStructure *)out;
2379             out_header = out_header->pNext;
2380             break;
2381         }
2382
2383         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
2384         {
2385             const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header;
2386             VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out;
2387
2388             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2389
2390             out->sType = in->sType;
2391             out->pNext = NULL;
2392             out->fragmentDensityMap = in->fragmentDensityMap;
2393             out->fragmentDensityMapDynamic = in->fragmentDensityMapDynamic;
2394             out->fragmentDensityMapNonSubsampledImages = in->fragmentDensityMapNonSubsampledImages;
2395
2396             out_header->pNext = (VkBaseOutStructure *)out;
2397             out_header = out_header->pNext;
2398             break;
2399         }
2400
2401         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
2402         {
2403             const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header;
2404             VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out;
2405
2406             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2407
2408             out->sType = in->sType;
2409             out->pNext = NULL;
2410             out->fragmentDensityMapDeferred = in->fragmentDensityMapDeferred;
2411
2412             out_header->pNext = (VkBaseOutStructure *)out;
2413             out_header = out_header->pNext;
2414             break;
2415         }
2416
2417         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
2418         {
2419             const VkPhysicalDeviceScalarBlockLayoutFeatures *in = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header;
2420             VkPhysicalDeviceScalarBlockLayoutFeatures *out;
2421
2422             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2423
2424             out->sType = in->sType;
2425             out->pNext = NULL;
2426             out->scalarBlockLayout = in->scalarBlockLayout;
2427
2428             out_header->pNext = (VkBaseOutStructure *)out;
2429             out_header = out_header->pNext;
2430             break;
2431         }
2432
2433         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
2434         {
2435             const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header;
2436             VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out;
2437
2438             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2439
2440             out->sType = in->sType;
2441             out->pNext = NULL;
2442             out->uniformBufferStandardLayout = in->uniformBufferStandardLayout;
2443
2444             out_header->pNext = (VkBaseOutStructure *)out;
2445             out_header = out_header->pNext;
2446             break;
2447         }
2448
2449         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
2450         {
2451             const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header;
2452             VkPhysicalDeviceDepthClipEnableFeaturesEXT *out;
2453
2454             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2455
2456             out->sType = in->sType;
2457             out->pNext = NULL;
2458             out->depthClipEnable = in->depthClipEnable;
2459
2460             out_header->pNext = (VkBaseOutStructure *)out;
2461             out_header = out_header->pNext;
2462             break;
2463         }
2464
2465         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
2466         {
2467             const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header;
2468             VkPhysicalDeviceMemoryPriorityFeaturesEXT *out;
2469
2470             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2471
2472             out->sType = in->sType;
2473             out->pNext = NULL;
2474             out->memoryPriority = in->memoryPriority;
2475
2476             out_header->pNext = (VkBaseOutStructure *)out;
2477             out_header = out_header->pNext;
2478             break;
2479         }
2480
2481         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
2482         {
2483             const VkPhysicalDeviceBufferDeviceAddressFeatures *in = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header;
2484             VkPhysicalDeviceBufferDeviceAddressFeatures *out;
2485
2486             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2487
2488             out->sType = in->sType;
2489             out->pNext = NULL;
2490             out->bufferDeviceAddress = in->bufferDeviceAddress;
2491             out->bufferDeviceAddressCaptureReplay = in->bufferDeviceAddressCaptureReplay;
2492             out->bufferDeviceAddressMultiDevice = in->bufferDeviceAddressMultiDevice;
2493
2494             out_header->pNext = (VkBaseOutStructure *)out;
2495             out_header = out_header->pNext;
2496             break;
2497         }
2498
2499         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
2500         {
2501             const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header;
2502             VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out;
2503
2504             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2505
2506             out->sType = in->sType;
2507             out->pNext = NULL;
2508             out->bufferDeviceAddress = in->bufferDeviceAddress;
2509             out->bufferDeviceAddressCaptureReplay = in->bufferDeviceAddressCaptureReplay;
2510             out->bufferDeviceAddressMultiDevice = in->bufferDeviceAddressMultiDevice;
2511
2512             out_header->pNext = (VkBaseOutStructure *)out;
2513             out_header = out_header->pNext;
2514             break;
2515         }
2516
2517         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
2518         {
2519             const VkPhysicalDeviceImagelessFramebufferFeatures *in = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header;
2520             VkPhysicalDeviceImagelessFramebufferFeatures *out;
2521
2522             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2523
2524             out->sType = in->sType;
2525             out->pNext = NULL;
2526             out->imagelessFramebuffer = in->imagelessFramebuffer;
2527
2528             out_header->pNext = (VkBaseOutStructure *)out;
2529             out_header = out_header->pNext;
2530             break;
2531         }
2532
2533         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
2534         {
2535             const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *in = (const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *)in_header;
2536             VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *out;
2537
2538             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2539
2540             out->sType = in->sType;
2541             out->pNext = NULL;
2542             out->textureCompressionASTC_HDR = in->textureCompressionASTC_HDR;
2543
2544             out_header->pNext = (VkBaseOutStructure *)out;
2545             out_header = out_header->pNext;
2546             break;
2547         }
2548
2549         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
2550         {
2551             const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header;
2552             VkPhysicalDeviceCooperativeMatrixFeaturesNV *out;
2553
2554             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2555
2556             out->sType = in->sType;
2557             out->pNext = NULL;
2558             out->cooperativeMatrix = in->cooperativeMatrix;
2559             out->cooperativeMatrixRobustBufferAccess = in->cooperativeMatrixRobustBufferAccess;
2560
2561             out_header->pNext = (VkBaseOutStructure *)out;
2562             out_header = out_header->pNext;
2563             break;
2564         }
2565
2566         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
2567         {
2568             const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header;
2569             VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out;
2570
2571             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2572
2573             out->sType = in->sType;
2574             out->pNext = NULL;
2575             out->ycbcrImageArrays = in->ycbcrImageArrays;
2576
2577             out_header->pNext = (VkBaseOutStructure *)out;
2578             out_header = out_header->pNext;
2579             break;
2580         }
2581
2582         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
2583         {
2584             const VkPhysicalDevicePerformanceQueryFeaturesKHR *in = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header;
2585             VkPhysicalDevicePerformanceQueryFeaturesKHR *out;
2586
2587             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2588
2589             out->sType = in->sType;
2590             out->pNext = NULL;
2591             out->performanceCounterQueryPools = in->performanceCounterQueryPools;
2592             out->performanceCounterMultipleQueryPools = in->performanceCounterMultipleQueryPools;
2593
2594             out_header->pNext = (VkBaseOutStructure *)out;
2595             out_header = out_header->pNext;
2596             break;
2597         }
2598
2599         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
2600         {
2601             const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header;
2602             VkPhysicalDeviceCoverageReductionModeFeaturesNV *out;
2603
2604             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2605
2606             out->sType = in->sType;
2607             out->pNext = NULL;
2608             out->coverageReductionMode = in->coverageReductionMode;
2609
2610             out_header->pNext = (VkBaseOutStructure *)out;
2611             out_header = out_header->pNext;
2612             break;
2613         }
2614
2615         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
2616         {
2617             const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header;
2618             VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out;
2619
2620             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2621
2622             out->sType = in->sType;
2623             out->pNext = NULL;
2624             out->shaderIntegerFunctions2 = in->shaderIntegerFunctions2;
2625
2626             out_header->pNext = (VkBaseOutStructure *)out;
2627             out_header = out_header->pNext;
2628             break;
2629         }
2630
2631         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
2632         {
2633             const VkPhysicalDeviceShaderClockFeaturesKHR *in = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header;
2634             VkPhysicalDeviceShaderClockFeaturesKHR *out;
2635
2636             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2637
2638             out->sType = in->sType;
2639             out->pNext = NULL;
2640             out->shaderSubgroupClock = in->shaderSubgroupClock;
2641             out->shaderDeviceClock = in->shaderDeviceClock;
2642
2643             out_header->pNext = (VkBaseOutStructure *)out;
2644             out_header = out_header->pNext;
2645             break;
2646         }
2647
2648         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
2649         {
2650             const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header;
2651             VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out;
2652
2653             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2654
2655             out->sType = in->sType;
2656             out->pNext = NULL;
2657             out->indexTypeUint8 = in->indexTypeUint8;
2658
2659             out_header->pNext = (VkBaseOutStructure *)out;
2660             out_header = out_header->pNext;
2661             break;
2662         }
2663
2664         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
2665         {
2666             const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header;
2667             VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out;
2668
2669             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2670
2671             out->sType = in->sType;
2672             out->pNext = NULL;
2673             out->shaderSMBuiltins = in->shaderSMBuiltins;
2674
2675             out_header->pNext = (VkBaseOutStructure *)out;
2676             out_header = out_header->pNext;
2677             break;
2678         }
2679
2680         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
2681         {
2682             const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header;
2683             VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out;
2684
2685             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2686
2687             out->sType = in->sType;
2688             out->pNext = NULL;
2689             out->fragmentShaderSampleInterlock = in->fragmentShaderSampleInterlock;
2690             out->fragmentShaderPixelInterlock = in->fragmentShaderPixelInterlock;
2691             out->fragmentShaderShadingRateInterlock = in->fragmentShaderShadingRateInterlock;
2692
2693             out_header->pNext = (VkBaseOutStructure *)out;
2694             out_header = out_header->pNext;
2695             break;
2696         }
2697
2698         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
2699         {
2700             const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header;
2701             VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out;
2702
2703             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2704
2705             out->sType = in->sType;
2706             out->pNext = NULL;
2707             out->separateDepthStencilLayouts = in->separateDepthStencilLayouts;
2708
2709             out_header->pNext = (VkBaseOutStructure *)out;
2710             out_header = out_header->pNext;
2711             break;
2712         }
2713
2714         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
2715         {
2716             const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header;
2717             VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out;
2718
2719             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2720
2721             out->sType = in->sType;
2722             out->pNext = NULL;
2723             out->pipelineExecutableInfo = in->pipelineExecutableInfo;
2724
2725             out_header->pNext = (VkBaseOutStructure *)out;
2726             out_header = out_header->pNext;
2727             break;
2728         }
2729
2730         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
2731         {
2732             const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *in = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *)in_header;
2733             VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *out;
2734
2735             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2736
2737             out->sType = in->sType;
2738             out->pNext = NULL;
2739             out->shaderDemoteToHelperInvocation = in->shaderDemoteToHelperInvocation;
2740
2741             out_header->pNext = (VkBaseOutStructure *)out;
2742             out_header = out_header->pNext;
2743             break;
2744         }
2745
2746         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
2747         {
2748             const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header;
2749             VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out;
2750
2751             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2752
2753             out->sType = in->sType;
2754             out->pNext = NULL;
2755             out->texelBufferAlignment = in->texelBufferAlignment;
2756
2757             out_header->pNext = (VkBaseOutStructure *)out;
2758             out_header = out_header->pNext;
2759             break;
2760         }
2761
2762         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
2763         {
2764             const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *in = (const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *)in_header;
2765             VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *out;
2766
2767             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2768
2769             out->sType = in->sType;
2770             out->pNext = NULL;
2771             out->subgroupSizeControl = in->subgroupSizeControl;
2772             out->computeFullSubgroups = in->computeFullSubgroups;
2773
2774             out_header->pNext = (VkBaseOutStructure *)out;
2775             out_header = out_header->pNext;
2776             break;
2777         }
2778
2779         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
2780         {
2781             const VkPhysicalDeviceLineRasterizationFeaturesEXT *in = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header;
2782             VkPhysicalDeviceLineRasterizationFeaturesEXT *out;
2783
2784             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2785
2786             out->sType = in->sType;
2787             out->pNext = NULL;
2788             out->rectangularLines = in->rectangularLines;
2789             out->bresenhamLines = in->bresenhamLines;
2790             out->smoothLines = in->smoothLines;
2791             out->stippledRectangularLines = in->stippledRectangularLines;
2792             out->stippledBresenhamLines = in->stippledBresenhamLines;
2793             out->stippledSmoothLines = in->stippledSmoothLines;
2794
2795             out_header->pNext = (VkBaseOutStructure *)out;
2796             out_header = out_header->pNext;
2797             break;
2798         }
2799
2800         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
2801         {
2802             const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *in = (const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *)in_header;
2803             VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *out;
2804
2805             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2806
2807             out->sType = in->sType;
2808             out->pNext = NULL;
2809             out->pipelineCreationCacheControl = in->pipelineCreationCacheControl;
2810
2811             out_header->pNext = (VkBaseOutStructure *)out;
2812             out_header = out_header->pNext;
2813             break;
2814         }
2815
2816         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
2817         {
2818             const VkPhysicalDeviceVulkan11Features *in = (const VkPhysicalDeviceVulkan11Features *)in_header;
2819             VkPhysicalDeviceVulkan11Features *out;
2820
2821             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2822
2823             out->sType = in->sType;
2824             out->pNext = NULL;
2825             out->storageBuffer16BitAccess = in->storageBuffer16BitAccess;
2826             out->uniformAndStorageBuffer16BitAccess = in->uniformAndStorageBuffer16BitAccess;
2827             out->storagePushConstant16 = in->storagePushConstant16;
2828             out->storageInputOutput16 = in->storageInputOutput16;
2829             out->multiview = in->multiview;
2830             out->multiviewGeometryShader = in->multiviewGeometryShader;
2831             out->multiviewTessellationShader = in->multiviewTessellationShader;
2832             out->variablePointersStorageBuffer = in->variablePointersStorageBuffer;
2833             out->variablePointers = in->variablePointers;
2834             out->protectedMemory = in->protectedMemory;
2835             out->samplerYcbcrConversion = in->samplerYcbcrConversion;
2836             out->shaderDrawParameters = in->shaderDrawParameters;
2837
2838             out_header->pNext = (VkBaseOutStructure *)out;
2839             out_header = out_header->pNext;
2840             break;
2841         }
2842
2843         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
2844         {
2845             const VkPhysicalDeviceVulkan12Features *in = (const VkPhysicalDeviceVulkan12Features *)in_header;
2846             VkPhysicalDeviceVulkan12Features *out;
2847
2848             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2849
2850             out->sType = in->sType;
2851             out->pNext = NULL;
2852             out->samplerMirrorClampToEdge = in->samplerMirrorClampToEdge;
2853             out->drawIndirectCount = in->drawIndirectCount;
2854             out->storageBuffer8BitAccess = in->storageBuffer8BitAccess;
2855             out->uniformAndStorageBuffer8BitAccess = in->uniformAndStorageBuffer8BitAccess;
2856             out->storagePushConstant8 = in->storagePushConstant8;
2857             out->shaderBufferInt64Atomics = in->shaderBufferInt64Atomics;
2858             out->shaderSharedInt64Atomics = in->shaderSharedInt64Atomics;
2859             out->shaderFloat16 = in->shaderFloat16;
2860             out->shaderInt8 = in->shaderInt8;
2861             out->descriptorIndexing = in->descriptorIndexing;
2862             out->shaderInputAttachmentArrayDynamicIndexing = in->shaderInputAttachmentArrayDynamicIndexing;
2863             out->shaderUniformTexelBufferArrayDynamicIndexing = in->shaderUniformTexelBufferArrayDynamicIndexing;
2864             out->shaderStorageTexelBufferArrayDynamicIndexing = in->shaderStorageTexelBufferArrayDynamicIndexing;
2865             out->shaderUniformBufferArrayNonUniformIndexing = in->shaderUniformBufferArrayNonUniformIndexing;
2866             out->shaderSampledImageArrayNonUniformIndexing = in->shaderSampledImageArrayNonUniformIndexing;
2867             out->shaderStorageBufferArrayNonUniformIndexing = in->shaderStorageBufferArrayNonUniformIndexing;
2868             out->shaderStorageImageArrayNonUniformIndexing = in->shaderStorageImageArrayNonUniformIndexing;
2869             out->shaderInputAttachmentArrayNonUniformIndexing = in->shaderInputAttachmentArrayNonUniformIndexing;
2870             out->shaderUniformTexelBufferArrayNonUniformIndexing = in->shaderUniformTexelBufferArrayNonUniformIndexing;
2871             out->shaderStorageTexelBufferArrayNonUniformIndexing = in->shaderStorageTexelBufferArrayNonUniformIndexing;
2872             out->descriptorBindingUniformBufferUpdateAfterBind = in->descriptorBindingUniformBufferUpdateAfterBind;
2873             out->descriptorBindingSampledImageUpdateAfterBind = in->descriptorBindingSampledImageUpdateAfterBind;
2874             out->descriptorBindingStorageImageUpdateAfterBind = in->descriptorBindingStorageImageUpdateAfterBind;
2875             out->descriptorBindingStorageBufferUpdateAfterBind = in->descriptorBindingStorageBufferUpdateAfterBind;
2876             out->descriptorBindingUniformTexelBufferUpdateAfterBind = in->descriptorBindingUniformTexelBufferUpdateAfterBind;
2877             out->descriptorBindingStorageTexelBufferUpdateAfterBind = in->descriptorBindingStorageTexelBufferUpdateAfterBind;
2878             out->descriptorBindingUpdateUnusedWhilePending = in->descriptorBindingUpdateUnusedWhilePending;
2879             out->descriptorBindingPartiallyBound = in->descriptorBindingPartiallyBound;
2880             out->descriptorBindingVariableDescriptorCount = in->descriptorBindingVariableDescriptorCount;
2881             out->runtimeDescriptorArray = in->runtimeDescriptorArray;
2882             out->samplerFilterMinmax = in->samplerFilterMinmax;
2883             out->scalarBlockLayout = in->scalarBlockLayout;
2884             out->imagelessFramebuffer = in->imagelessFramebuffer;
2885             out->uniformBufferStandardLayout = in->uniformBufferStandardLayout;
2886             out->shaderSubgroupExtendedTypes = in->shaderSubgroupExtendedTypes;
2887             out->separateDepthStencilLayouts = in->separateDepthStencilLayouts;
2888             out->hostQueryReset = in->hostQueryReset;
2889             out->timelineSemaphore = in->timelineSemaphore;
2890             out->bufferDeviceAddress = in->bufferDeviceAddress;
2891             out->bufferDeviceAddressCaptureReplay = in->bufferDeviceAddressCaptureReplay;
2892             out->bufferDeviceAddressMultiDevice = in->bufferDeviceAddressMultiDevice;
2893             out->vulkanMemoryModel = in->vulkanMemoryModel;
2894             out->vulkanMemoryModelDeviceScope = in->vulkanMemoryModelDeviceScope;
2895             out->vulkanMemoryModelAvailabilityVisibilityChains = in->vulkanMemoryModelAvailabilityVisibilityChains;
2896             out->shaderOutputViewportIndex = in->shaderOutputViewportIndex;
2897             out->shaderOutputLayer = in->shaderOutputLayer;
2898             out->subgroupBroadcastDynamicId = in->subgroupBroadcastDynamicId;
2899
2900             out_header->pNext = (VkBaseOutStructure *)out;
2901             out_header = out_header->pNext;
2902             break;
2903         }
2904
2905         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
2906         {
2907             const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header;
2908             VkPhysicalDeviceCoherentMemoryFeaturesAMD *out;
2909
2910             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2911
2912             out->sType = in->sType;
2913             out->pNext = NULL;
2914             out->deviceCoherentMemory = in->deviceCoherentMemory;
2915
2916             out_header->pNext = (VkBaseOutStructure *)out;
2917             out_header = out_header->pNext;
2918             break;
2919         }
2920
2921         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
2922         {
2923             const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header;
2924             VkPhysicalDeviceCustomBorderColorFeaturesEXT *out;
2925
2926             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2927
2928             out->sType = in->sType;
2929             out->pNext = NULL;
2930             out->customBorderColors = in->customBorderColors;
2931             out->customBorderColorWithoutFormat = in->customBorderColorWithoutFormat;
2932
2933             out_header->pNext = (VkBaseOutStructure *)out;
2934             out_header = out_header->pNext;
2935             break;
2936         }
2937
2938         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
2939         {
2940             const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header;
2941             VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out;
2942
2943             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2944
2945             out->sType = in->sType;
2946             out->pNext = NULL;
2947             out->extendedDynamicState = in->extendedDynamicState;
2948
2949             out_header->pNext = (VkBaseOutStructure *)out;
2950             out_header = out_header->pNext;
2951             break;
2952         }
2953
2954         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
2955         {
2956             const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header;
2957             VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out;
2958
2959             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2960
2961             out->sType = in->sType;
2962             out->pNext = NULL;
2963             out->diagnosticsConfig = in->diagnosticsConfig;
2964
2965             out_header->pNext = (VkBaseOutStructure *)out;
2966             out_header = out_header->pNext;
2967             break;
2968         }
2969
2970         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
2971         {
2972             const VkDeviceDiagnosticsConfigCreateInfoNV *in = (const VkDeviceDiagnosticsConfigCreateInfoNV *)in_header;
2973             VkDeviceDiagnosticsConfigCreateInfoNV *out;
2974
2975             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2976
2977             out->sType = in->sType;
2978             out->pNext = NULL;
2979             out->flags = in->flags;
2980
2981             out_header->pNext = (VkBaseOutStructure *)out;
2982             out_header = out_header->pNext;
2983             break;
2984         }
2985
2986         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
2987         {
2988             const VkPhysicalDeviceRobustness2FeaturesEXT *in = (const VkPhysicalDeviceRobustness2FeaturesEXT *)in_header;
2989             VkPhysicalDeviceRobustness2FeaturesEXT *out;
2990
2991             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
2992
2993             out->sType = in->sType;
2994             out->pNext = NULL;
2995             out->robustBufferAccess2 = in->robustBufferAccess2;
2996             out->robustImageAccess2 = in->robustImageAccess2;
2997             out->nullDescriptor = in->nullDescriptor;
2998
2999             out_header->pNext = (VkBaseOutStructure *)out;
3000             out_header = out_header->pNext;
3001             break;
3002         }
3003
3004         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
3005         {
3006             const VkPhysicalDeviceImageRobustnessFeaturesEXT *in = (const VkPhysicalDeviceImageRobustnessFeaturesEXT *)in_header;
3007             VkPhysicalDeviceImageRobustnessFeaturesEXT *out;
3008
3009             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
3010
3011             out->sType = in->sType;
3012             out->pNext = NULL;
3013             out->robustImageAccess = in->robustImageAccess;
3014
3015             out_header->pNext = (VkBaseOutStructure *)out;
3016             out_header = out_header->pNext;
3017             break;
3018         }
3019
3020         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
3021         {
3022             const VkPhysicalDevice4444FormatsFeaturesEXT *in = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header;
3023             VkPhysicalDevice4444FormatsFeaturesEXT *out;
3024
3025             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
3026
3027             out->sType = in->sType;
3028             out->pNext = NULL;
3029             out->formatA4R4G4B4 = in->formatA4R4G4B4;
3030             out->formatA4B4G4R4 = in->formatA4B4G4R4;
3031
3032             out_header->pNext = (VkBaseOutStructure *)out;
3033             out_header = out_header->pNext;
3034             break;
3035         }
3036
3037         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
3038         {
3039             const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header;
3040             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out;
3041
3042             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
3043
3044             out->sType = in->sType;
3045             out->pNext = NULL;
3046             out->shaderImageInt64Atomics = in->shaderImageInt64Atomics;
3047             out->sparseImageInt64Atomics = in->sparseImageInt64Atomics;
3048
3049             out_header->pNext = (VkBaseOutStructure *)out;
3050             out_header = out_header->pNext;
3051             break;
3052         }
3053
3054         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
3055         {
3056             const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header;
3057             VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out;
3058
3059             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
3060
3061             out->sType = in->sType;
3062             out->pNext = NULL;
3063             out->pipelineFragmentShadingRate = in->pipelineFragmentShadingRate;
3064             out->primitiveFragmentShadingRate = in->primitiveFragmentShadingRate;
3065             out->attachmentFragmentShadingRate = in->attachmentFragmentShadingRate;
3066
3067             out_header->pNext = (VkBaseOutStructure *)out;
3068             out_header = out_header->pNext;
3069             break;
3070         }
3071
3072         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
3073         {
3074             const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *in = (const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *)in_header;
3075             VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *out;
3076
3077             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
3078
3079             out->sType = in->sType;
3080             out->pNext = NULL;
3081             out->shaderTerminateInvocation = in->shaderTerminateInvocation;
3082
3083             out_header->pNext = (VkBaseOutStructure *)out;
3084             out_header = out_header->pNext;
3085             break;
3086         }
3087
3088         default:
3089             FIXME("Application requested a linked structure of type %u.\n", in_header->sType);
3090         }
3091     }
3092
3093     return VK_SUCCESS;
3094
3095 out_of_memory:
3096     free_VkDeviceCreateInfo_struct_chain(out_struct);
3097     return VK_ERROR_OUT_OF_HOST_MEMORY;
3098 }
3099
3100 void free_VkDeviceCreateInfo_struct_chain(VkDeviceCreateInfo *s)
3101 {
3102     VkBaseOutStructure *header = (void *)s->pNext;
3103
3104     while (header)
3105     {
3106         void *prev = header;
3107         header = header->pNext;
3108         heap_free(prev);
3109     }
3110
3111     s->pNext = NULL;
3112 }
3113
3114 VkResult convert_VkInstanceCreateInfo_struct_chain(const void *pNext, VkInstanceCreateInfo *out_struct)
3115 {
3116     VkBaseOutStructure *out_header = (VkBaseOutStructure *)out_struct;
3117     const VkBaseInStructure *in_header;
3118
3119     out_header->pNext = NULL;
3120
3121     for (in_header = pNext; in_header; in_header = in_header->pNext)
3122     {
3123         switch (in_header->sType)
3124         {
3125         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
3126         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
3127             break;
3128
3129         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
3130         {
3131             const VkDebugUtilsMessengerCreateInfoEXT *in = (const VkDebugUtilsMessengerCreateInfoEXT *)in_header;
3132             VkDebugUtilsMessengerCreateInfoEXT *out;
3133
3134             if (!(out = heap_alloc(sizeof(*out)))) goto out_of_memory;
3135
3136             out->sType = in->sType;
3137             out->pNext = NULL;
3138             out->flags = in->flags;
3139             out->messageSeverity = in->messageSeverity;
3140             out->messageType = in->messageType;
3141             out->pfnUserCallback = in->pfnUserCallback;
3142             out->pUserData = in->pUserData;
3143
3144             out_header->pNext = (VkBaseOutStructure *)out;
3145             out_header = out_header->pNext;
3146             break;
3147         }
3148
3149         default:
3150             FIXME("Application requested a linked structure of type %u.\n", in_header->sType);
3151         }
3152     }
3153
3154     return VK_SUCCESS;
3155
3156 out_of_memory:
3157     free_VkInstanceCreateInfo_struct_chain(out_struct);
3158     return VK_ERROR_OUT_OF_HOST_MEMORY;
3159 }
3160
3161 void free_VkInstanceCreateInfo_struct_chain(VkInstanceCreateInfo *s)
3162 {
3163     VkBaseOutStructure *header = (void *)s->pNext;
3164
3165     while (header)
3166     {
3167         void *prev = header;
3168         header = header->pNext;
3169         heap_free(prev);
3170     }
3171
3172     s->pNext = NULL;
3173 }
3174
3175 VkResult WINAPI wine_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
3176 {
3177 #if defined(USE_STRUCT_CONVERSION)
3178     VkResult result;
3179     VkAcquireNextImageInfoKHR_host pAcquireInfo_host;
3180     TRACE("%p, %p, %p\n", device, pAcquireInfo, pImageIndex);
3181
3182     convert_VkAcquireNextImageInfoKHR_win_to_host(pAcquireInfo, &pAcquireInfo_host);
3183     result = device->funcs.p_vkAcquireNextImage2KHR(device->device, &pAcquireInfo_host, pImageIndex);
3184
3185     return result;
3186 #else
3187     TRACE("%p, %p, %p\n", device, pAcquireInfo, pImageIndex);
3188     return device->funcs.p_vkAcquireNextImage2KHR(device->device, pAcquireInfo, pImageIndex);
3189 #endif
3190 }
3191
3192 VkResult WINAPI wine_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
3193 {
3194     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(swapchain), wine_dbgstr_longlong(timeout), wine_dbgstr_longlong(semaphore), wine_dbgstr_longlong(fence), pImageIndex);
3195     return device->funcs.p_vkAcquireNextImageKHR(device->device, swapchain, timeout, semaphore, fence, pImageIndex);
3196 }
3197
3198 static VkResult WINAPI wine_vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
3199 {
3200     TRACE("%p, %p, %p\n", device, pAcquireInfo, pConfiguration);
3201     return device->funcs.p_vkAcquirePerformanceConfigurationINTEL(device->device, pAcquireInfo, pConfiguration);
3202 }
3203
3204 static VkResult WINAPI wine_vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
3205 {
3206 #if defined(USE_STRUCT_CONVERSION)
3207     VkResult result;
3208     VkAcquireProfilingLockInfoKHR_host pInfo_host;
3209     TRACE("%p, %p\n", device, pInfo);
3210
3211     convert_VkAcquireProfilingLockInfoKHR_win_to_host(pInfo, &pInfo_host);
3212     result = device->funcs.p_vkAcquireProfilingLockKHR(device->device, &pInfo_host);
3213
3214     return result;
3215 #else
3216     TRACE("%p, %p\n", device, pInfo);
3217     return device->funcs.p_vkAcquireProfilingLockKHR(device->device, pInfo);
3218 #endif
3219 }
3220
3221 VkResult WINAPI wine_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
3222 {
3223 #if defined(USE_STRUCT_CONVERSION)
3224     VkResult result;
3225     VkDescriptorSetAllocateInfo_host pAllocateInfo_host;
3226     TRACE("%p, %p, %p\n", device, pAllocateInfo, pDescriptorSets);
3227
3228     convert_VkDescriptorSetAllocateInfo_win_to_host(pAllocateInfo, &pAllocateInfo_host);
3229     result = device->funcs.p_vkAllocateDescriptorSets(device->device, &pAllocateInfo_host, pDescriptorSets);
3230
3231     return result;
3232 #else
3233     TRACE("%p, %p, %p\n", device, pAllocateInfo, pDescriptorSets);
3234     return device->funcs.p_vkAllocateDescriptorSets(device->device, pAllocateInfo, pDescriptorSets);
3235 #endif
3236 }
3237
3238 VkResult WINAPI wine_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
3239 {
3240 #if defined(USE_STRUCT_CONVERSION)
3241     VkResult result;
3242     VkMemoryAllocateInfo_host pAllocateInfo_host;
3243     TRACE("%p, %p, %p, %p\n", device, pAllocateInfo, pAllocator, pMemory);
3244
3245     convert_VkMemoryAllocateInfo_win_to_host(pAllocateInfo, &pAllocateInfo_host);
3246     result = device->funcs.p_vkAllocateMemory(device->device, &pAllocateInfo_host, NULL, pMemory);
3247
3248     return result;
3249 #else
3250     TRACE("%p, %p, %p, %p\n", device, pAllocateInfo, pAllocator, pMemory);
3251     return device->funcs.p_vkAllocateMemory(device->device, pAllocateInfo, NULL, pMemory);
3252 #endif
3253 }
3254
3255 VkResult WINAPI wine_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
3256 {
3257 #if defined(USE_STRUCT_CONVERSION)
3258     VkResult result;
3259     VkCommandBufferBeginInfo_host pBeginInfo_host;
3260     TRACE("%p, %p\n", commandBuffer, pBeginInfo);
3261
3262     convert_VkCommandBufferBeginInfo_win_to_host(pBeginInfo, &pBeginInfo_host);
3263     result = commandBuffer->device->funcs.p_vkBeginCommandBuffer(commandBuffer->command_buffer, &pBeginInfo_host);
3264
3265     free_VkCommandBufferBeginInfo(&pBeginInfo_host);
3266     return result;
3267 #else
3268     TRACE("%p, %p\n", commandBuffer, pBeginInfo);
3269     return commandBuffer->device->funcs.p_vkBeginCommandBuffer(commandBuffer->command_buffer, pBeginInfo);
3270 #endif
3271 }
3272
3273 static VkResult WINAPI wine_vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoKHR *pBindInfos)
3274 {
3275 #if defined(USE_STRUCT_CONVERSION)
3276     VkResult result;
3277     VkBindAccelerationStructureMemoryInfoKHR_host *pBindInfos_host;
3278     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
3279
3280     pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoKHR_array_win_to_host(pBindInfos, bindInfoCount);
3281     result = device->funcs.p_vkBindAccelerationStructureMemoryNV(device->device, bindInfoCount, pBindInfos_host);
3282
3283     free_VkBindAccelerationStructureMemoryInfoKHR_array(pBindInfos_host, bindInfoCount);
3284     return result;
3285 #else
3286     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
3287     return device->funcs.p_vkBindAccelerationStructureMemoryNV(device->device, bindInfoCount, pBindInfos);
3288 #endif
3289 }
3290
3291 VkResult WINAPI wine_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
3292 {
3293     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset));
3294     return device->funcs.p_vkBindBufferMemory(device->device, buffer, memory, memoryOffset);
3295 }
3296
3297 VkResult WINAPI wine_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
3298 {
3299 #if defined(USE_STRUCT_CONVERSION)
3300     VkResult result;
3301     VkBindBufferMemoryInfo_host *pBindInfos_host;
3302     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
3303
3304     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win_to_host(pBindInfos, bindInfoCount);
3305     result = device->funcs.p_vkBindBufferMemory2(device->device, bindInfoCount, pBindInfos_host);
3306
3307     free_VkBindBufferMemoryInfo_array(pBindInfos_host, bindInfoCount);
3308     return result;
3309 #else
3310     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
3311     return device->funcs.p_vkBindBufferMemory2(device->device, bindInfoCount, pBindInfos);
3312 #endif
3313 }
3314
3315 static VkResult WINAPI wine_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
3316 {
3317 #if defined(USE_STRUCT_CONVERSION)
3318     VkResult result;
3319     VkBindBufferMemoryInfo_host *pBindInfos_host;
3320     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
3321
3322     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win_to_host(pBindInfos, bindInfoCount);
3323     result = device->funcs.p_vkBindBufferMemory2KHR(device->device, bindInfoCount, pBindInfos_host);
3324
3325     free_VkBindBufferMemoryInfo_array(pBindInfos_host, bindInfoCount);
3326     return result;
3327 #else
3328     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
3329     return device->funcs.p_vkBindBufferMemory2KHR(device->device, bindInfoCount, pBindInfos);
3330 #endif
3331 }
3332
3333 VkResult WINAPI wine_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
3334 {
3335     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(image), wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset));
3336     return device->funcs.p_vkBindImageMemory(device->device, image, memory, memoryOffset);
3337 }
3338
3339 VkResult WINAPI wine_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
3340 {
3341 #if defined(USE_STRUCT_CONVERSION)
3342     VkResult result;
3343     VkBindImageMemoryInfo_host *pBindInfos_host;
3344     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
3345
3346     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win_to_host(pBindInfos, bindInfoCount);
3347     result = device->funcs.p_vkBindImageMemory2(device->device, bindInfoCount, pBindInfos_host);
3348
3349     free_VkBindImageMemoryInfo_array(pBindInfos_host, bindInfoCount);
3350     return result;
3351 #else
3352     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
3353     return device->funcs.p_vkBindImageMemory2(device->device, bindInfoCount, pBindInfos);
3354 #endif
3355 }
3356
3357 static VkResult WINAPI wine_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
3358 {
3359 #if defined(USE_STRUCT_CONVERSION)
3360     VkResult result;
3361     VkBindImageMemoryInfo_host *pBindInfos_host;
3362     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
3363
3364     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win_to_host(pBindInfos, bindInfoCount);
3365     result = device->funcs.p_vkBindImageMemory2KHR(device->device, bindInfoCount, pBindInfos_host);
3366
3367     free_VkBindImageMemoryInfo_array(pBindInfos_host, bindInfoCount);
3368     return result;
3369 #else
3370     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
3371     return device->funcs.p_vkBindImageMemory2KHR(device->device, bindInfoCount, pBindInfos);
3372 #endif
3373 }
3374
3375 static void WINAPI wine_vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
3376 {
3377 #if defined(USE_STRUCT_CONVERSION)
3378     VkConditionalRenderingBeginInfoEXT_host pConditionalRenderingBegin_host;
3379     TRACE("%p, %p\n", commandBuffer, pConditionalRenderingBegin);
3380
3381     convert_VkConditionalRenderingBeginInfoEXT_win_to_host(pConditionalRenderingBegin, &pConditionalRenderingBegin_host);
3382     commandBuffer->device->funcs.p_vkCmdBeginConditionalRenderingEXT(commandBuffer->command_buffer, &pConditionalRenderingBegin_host);
3383
3384 #else
3385     TRACE("%p, %p\n", commandBuffer, pConditionalRenderingBegin);
3386     commandBuffer->device->funcs.p_vkCmdBeginConditionalRenderingEXT(commandBuffer->command_buffer, pConditionalRenderingBegin);
3387 #endif
3388 }
3389
3390 static void WINAPI wine_vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
3391 {
3392     TRACE("%p, %p\n", commandBuffer, pLabelInfo);
3393     commandBuffer->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(commandBuffer->command_buffer, pLabelInfo);
3394 }
3395
3396 void WINAPI wine_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
3397 {
3398     TRACE("%p, 0x%s, %u, %#x\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, flags);
3399     commandBuffer->device->funcs.p_vkCmdBeginQuery(commandBuffer->command_buffer, queryPool, query, flags);
3400 }
3401
3402 static void WINAPI wine_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
3403 {
3404     TRACE("%p, 0x%s, %u, %#x, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, flags, index);
3405     commandBuffer->device->funcs.p_vkCmdBeginQueryIndexedEXT(commandBuffer->command_buffer, queryPool, query, flags, index);
3406 }
3407
3408 void WINAPI wine_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
3409 {
3410 #if defined(USE_STRUCT_CONVERSION)
3411     VkRenderPassBeginInfo_host pRenderPassBegin_host;
3412     TRACE("%p, %p, %#x\n", commandBuffer, pRenderPassBegin, contents);
3413
3414     convert_VkRenderPassBeginInfo_win_to_host(pRenderPassBegin, &pRenderPassBegin_host);
3415     commandBuffer->device->funcs.p_vkCmdBeginRenderPass(commandBuffer->command_buffer, &pRenderPassBegin_host, contents);
3416
3417 #else
3418     TRACE("%p, %p, %#x\n", commandBuffer, pRenderPassBegin, contents);
3419     commandBuffer->device->funcs.p_vkCmdBeginRenderPass(commandBuffer->command_buffer, pRenderPassBegin, contents);
3420 #endif
3421 }
3422
3423 void WINAPI wine_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
3424 {
3425 #if defined(USE_STRUCT_CONVERSION)
3426     VkRenderPassBeginInfo_host pRenderPassBegin_host;
3427     TRACE("%p, %p, %p\n", commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
3428
3429     convert_VkRenderPassBeginInfo_win_to_host(pRenderPassBegin, &pRenderPassBegin_host);
3430     commandBuffer->device->funcs.p_vkCmdBeginRenderPass2(commandBuffer->command_buffer, &pRenderPassBegin_host, pSubpassBeginInfo);
3431
3432 #else
3433     TRACE("%p, %p, %p\n", commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
3434     commandBuffer->device->funcs.p_vkCmdBeginRenderPass2(commandBuffer->command_buffer, pRenderPassBegin, pSubpassBeginInfo);
3435 #endif
3436 }
3437
3438 static void WINAPI wine_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
3439 {
3440 #if defined(USE_STRUCT_CONVERSION)
3441     VkRenderPassBeginInfo_host pRenderPassBegin_host;
3442     TRACE("%p, %p, %p\n", commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
3443
3444     convert_VkRenderPassBeginInfo_win_to_host(pRenderPassBegin, &pRenderPassBegin_host);
3445     commandBuffer->device->funcs.p_vkCmdBeginRenderPass2KHR(commandBuffer->command_buffer, &pRenderPassBegin_host, pSubpassBeginInfo);
3446
3447 #else
3448     TRACE("%p, %p, %p\n", commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
3449     commandBuffer->device->funcs.p_vkCmdBeginRenderPass2KHR(commandBuffer->command_buffer, pRenderPassBegin, pSubpassBeginInfo);
3450 #endif
3451 }
3452
3453 static void WINAPI wine_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
3454 {
3455     TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
3456     commandBuffer->device->funcs.p_vkCmdBeginTransformFeedbackEXT(commandBuffer->command_buffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
3457 }
3458
3459 void WINAPI wine_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
3460 {
3461     TRACE("%p, %#x, 0x%s, %u, %u, %p, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
3462     commandBuffer->device->funcs.p_vkCmdBindDescriptorSets(commandBuffer->command_buffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
3463 }
3464
3465 void WINAPI wine_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
3466 {
3467     TRACE("%p, 0x%s, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), indexType);
3468     commandBuffer->device->funcs.p_vkCmdBindIndexBuffer(commandBuffer->command_buffer, buffer, offset, indexType);
3469 }
3470
3471 void WINAPI wine_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
3472 {
3473     TRACE("%p, %#x, 0x%s\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(pipeline));
3474     commandBuffer->device->funcs.p_vkCmdBindPipeline(commandBuffer->command_buffer, pipelineBindPoint, pipeline);
3475 }
3476
3477 static void WINAPI wine_vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
3478 {
3479     TRACE("%p, %#x, 0x%s, %u\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(pipeline), groupIndex);
3480     commandBuffer->device->funcs.p_vkCmdBindPipelineShaderGroupNV(commandBuffer->command_buffer, pipelineBindPoint, pipeline, groupIndex);
3481 }
3482
3483 static void WINAPI wine_vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
3484 {
3485     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(imageView), imageLayout);
3486     commandBuffer->device->funcs.p_vkCmdBindShadingRateImageNV(commandBuffer->command_buffer, imageView, imageLayout);
3487 }
3488
3489 static void WINAPI wine_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
3490 {
3491     TRACE("%p, %u, %u, %p, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
3492     commandBuffer->device->funcs.p_vkCmdBindTransformFeedbackBuffersEXT(commandBuffer->command_buffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
3493 }
3494
3495 void WINAPI wine_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
3496 {
3497     TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
3498     commandBuffer->device->funcs.p_vkCmdBindVertexBuffers(commandBuffer->command_buffer, firstBinding, bindingCount, pBuffers, pOffsets);
3499 }
3500
3501 static void WINAPI wine_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
3502 {
3503     TRACE("%p, %u, %u, %p, %p, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
3504     commandBuffer->device->funcs.p_vkCmdBindVertexBuffers2EXT(commandBuffer->command_buffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
3505 }
3506
3507 void WINAPI wine_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
3508 {
3509     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p, %#x\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions, filter);
3510     commandBuffer->device->funcs.p_vkCmdBlitImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
3511 }
3512
3513 static void WINAPI wine_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo)
3514 {
3515 #if defined(USE_STRUCT_CONVERSION)
3516     VkBlitImageInfo2KHR_host pBlitImageInfo_host;
3517     TRACE("%p, %p\n", commandBuffer, pBlitImageInfo);
3518
3519     convert_VkBlitImageInfo2KHR_win_to_host(pBlitImageInfo, &pBlitImageInfo_host);
3520     commandBuffer->device->funcs.p_vkCmdBlitImage2KHR(commandBuffer->command_buffer, &pBlitImageInfo_host);
3521
3522 #else
3523     TRACE("%p, %p\n", commandBuffer, pBlitImageInfo);
3524     commandBuffer->device->funcs.p_vkCmdBlitImage2KHR(commandBuffer->command_buffer, pBlitImageInfo);
3525 #endif
3526 }
3527
3528 static void WINAPI wine_vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureKHR dst, VkAccelerationStructureKHR src, VkBuffer scratch, VkDeviceSize scratchOffset)
3529 {
3530 #if defined(USE_STRUCT_CONVERSION)
3531     VkAccelerationStructureInfoNV_host pInfo_host;
3532     TRACE("%p, %p, 0x%s, 0x%s, %u, 0x%s, 0x%s, 0x%s, 0x%s\n", commandBuffer, pInfo, wine_dbgstr_longlong(instanceData), wine_dbgstr_longlong(instanceOffset), update, wine_dbgstr_longlong(dst), wine_dbgstr_longlong(src), wine_dbgstr_longlong(scratch), wine_dbgstr_longlong(scratchOffset));
3533
3534     convert_VkAccelerationStructureInfoNV_win_to_host(pInfo, &pInfo_host);
3535     commandBuffer->device->funcs.p_vkCmdBuildAccelerationStructureNV(commandBuffer->command_buffer, &pInfo_host, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
3536
3537     free_VkAccelerationStructureInfoNV(&pInfo_host);
3538 #else
3539     TRACE("%p, %p, 0x%s, 0x%s, %u, 0x%s, 0x%s, 0x%s, 0x%s\n", commandBuffer, pInfo, wine_dbgstr_longlong(instanceData), wine_dbgstr_longlong(instanceOffset), update, wine_dbgstr_longlong(dst), wine_dbgstr_longlong(src), wine_dbgstr_longlong(scratch), wine_dbgstr_longlong(scratchOffset));
3540     commandBuffer->device->funcs.p_vkCmdBuildAccelerationStructureNV(commandBuffer->command_buffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
3541 #endif
3542 }
3543
3544 void WINAPI wine_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
3545 {
3546     TRACE("%p, %u, %p, %u, %p\n", commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
3547     commandBuffer->device->funcs.p_vkCmdClearAttachments(commandBuffer->command_buffer, attachmentCount, pAttachments, rectCount, pRects);
3548 }
3549
3550 void WINAPI wine_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
3551 {
3552     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, pColor, rangeCount, pRanges);
3553     commandBuffer->device->funcs.p_vkCmdClearColorImage(commandBuffer->command_buffer, image, imageLayout, pColor, rangeCount, pRanges);
3554 }
3555
3556 void WINAPI wine_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
3557 {
3558     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, pDepthStencil, rangeCount, pRanges);
3559     commandBuffer->device->funcs.p_vkCmdClearDepthStencilImage(commandBuffer->command_buffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
3560 }
3561
3562 static void WINAPI wine_vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureKHR dst, VkAccelerationStructureKHR src, VkCopyAccelerationStructureModeKHR mode)
3563 {
3564     TRACE("%p, 0x%s, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(dst), wine_dbgstr_longlong(src), mode);
3565     commandBuffer->device->funcs.p_vkCmdCopyAccelerationStructureNV(commandBuffer->command_buffer, dst, src, mode);
3566 }
3567
3568 void WINAPI wine_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
3569 {
3570 #if defined(USE_STRUCT_CONVERSION)
3571     VkBufferCopy_host *pRegions_host;
3572     TRACE("%p, 0x%s, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
3573
3574     pRegions_host = convert_VkBufferCopy_array_win_to_host(pRegions, regionCount);
3575     commandBuffer->device->funcs.p_vkCmdCopyBuffer(commandBuffer->command_buffer, srcBuffer, dstBuffer, regionCount, pRegions_host);
3576
3577     free_VkBufferCopy_array(pRegions_host, regionCount);
3578 #else
3579     TRACE("%p, 0x%s, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
3580     commandBuffer->device->funcs.p_vkCmdCopyBuffer(commandBuffer->command_buffer, srcBuffer, dstBuffer, regionCount, pRegions);
3581 #endif
3582 }
3583
3584 static void WINAPI wine_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR *pCopyBufferInfo)
3585 {
3586 #if defined(USE_STRUCT_CONVERSION)
3587     VkCopyBufferInfo2KHR_host pCopyBufferInfo_host;
3588     TRACE("%p, %p\n", commandBuffer, pCopyBufferInfo);
3589
3590     convert_VkCopyBufferInfo2KHR_win_to_host(pCopyBufferInfo, &pCopyBufferInfo_host);
3591     commandBuffer->device->funcs.p_vkCmdCopyBuffer2KHR(commandBuffer->command_buffer, &pCopyBufferInfo_host);
3592
3593     free_VkCopyBufferInfo2KHR(&pCopyBufferInfo_host);
3594 #else
3595     TRACE("%p, %p\n", commandBuffer, pCopyBufferInfo);
3596     commandBuffer->device->funcs.p_vkCmdCopyBuffer2KHR(commandBuffer->command_buffer, pCopyBufferInfo);
3597 #endif
3598 }
3599
3600 void WINAPI wine_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
3601 {
3602 #if defined(USE_STRUCT_CONVERSION)
3603     VkBufferImageCopy_host *pRegions_host;
3604     TRACE("%p, 0x%s, 0x%s, %#x, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
3605
3606     pRegions_host = convert_VkBufferImageCopy_array_win_to_host(pRegions, regionCount);
3607     commandBuffer->device->funcs.p_vkCmdCopyBufferToImage(commandBuffer->command_buffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions_host);
3608
3609     free_VkBufferImageCopy_array(pRegions_host, regionCount);
3610 #else
3611     TRACE("%p, 0x%s, 0x%s, %#x, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
3612     commandBuffer->device->funcs.p_vkCmdCopyBufferToImage(commandBuffer->command_buffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
3613 #endif
3614 }
3615
3616 static void WINAPI wine_vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo)
3617 {
3618 #if defined(USE_STRUCT_CONVERSION)
3619     VkCopyBufferToImageInfo2KHR_host pCopyBufferToImageInfo_host;
3620     TRACE("%p, %p\n", commandBuffer, pCopyBufferToImageInfo);
3621
3622     convert_VkCopyBufferToImageInfo2KHR_win_to_host(pCopyBufferToImageInfo, &pCopyBufferToImageInfo_host);
3623     commandBuffer->device->funcs.p_vkCmdCopyBufferToImage2KHR(commandBuffer->command_buffer, &pCopyBufferToImageInfo_host);
3624
3625     free_VkCopyBufferToImageInfo2KHR(&pCopyBufferToImageInfo_host);
3626 #else
3627     TRACE("%p, %p\n", commandBuffer, pCopyBufferToImageInfo);
3628     commandBuffer->device->funcs.p_vkCmdCopyBufferToImage2KHR(commandBuffer->command_buffer, pCopyBufferToImageInfo);
3629 #endif
3630 }
3631
3632 void WINAPI wine_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
3633 {
3634     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
3635     commandBuffer->device->funcs.p_vkCmdCopyImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
3636 }
3637
3638 static void WINAPI wine_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR *pCopyImageInfo)
3639 {
3640 #if defined(USE_STRUCT_CONVERSION)
3641     VkCopyImageInfo2KHR_host pCopyImageInfo_host;
3642     TRACE("%p, %p\n", commandBuffer, pCopyImageInfo);
3643
3644     convert_VkCopyImageInfo2KHR_win_to_host(pCopyImageInfo, &pCopyImageInfo_host);
3645     commandBuffer->device->funcs.p_vkCmdCopyImage2KHR(commandBuffer->command_buffer, &pCopyImageInfo_host);
3646
3647 #else
3648     TRACE("%p, %p\n", commandBuffer, pCopyImageInfo);
3649     commandBuffer->device->funcs.p_vkCmdCopyImage2KHR(commandBuffer->command_buffer, pCopyImageInfo);
3650 #endif
3651 }
3652
3653 void WINAPI wine_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
3654 {
3655 #if defined(USE_STRUCT_CONVERSION)
3656     VkBufferImageCopy_host *pRegions_host;
3657     TRACE("%p, 0x%s, %#x, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
3658
3659     pRegions_host = convert_VkBufferImageCopy_array_win_to_host(pRegions, regionCount);
3660     commandBuffer->device->funcs.p_vkCmdCopyImageToBuffer(commandBuffer->command_buffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions_host);
3661
3662     free_VkBufferImageCopy_array(pRegions_host, regionCount);
3663 #else
3664     TRACE("%p, 0x%s, %#x, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
3665     commandBuffer->device->funcs.p_vkCmdCopyImageToBuffer(commandBuffer->command_buffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
3666 #endif
3667 }
3668
3669 static void WINAPI wine_vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo)
3670 {
3671 #if defined(USE_STRUCT_CONVERSION)
3672     VkCopyImageToBufferInfo2KHR_host pCopyImageToBufferInfo_host;
3673     TRACE("%p, %p\n", commandBuffer, pCopyImageToBufferInfo);
3674
3675     convert_VkCopyImageToBufferInfo2KHR_win_to_host(pCopyImageToBufferInfo, &pCopyImageToBufferInfo_host);
3676     commandBuffer->device->funcs.p_vkCmdCopyImageToBuffer2KHR(commandBuffer->command_buffer, &pCopyImageToBufferInfo_host);
3677
3678     free_VkCopyImageToBufferInfo2KHR(&pCopyImageToBufferInfo_host);
3679 #else
3680     TRACE("%p, %p\n", commandBuffer, pCopyImageToBufferInfo);
3681     commandBuffer->device->funcs.p_vkCmdCopyImageToBuffer2KHR(commandBuffer->command_buffer, pCopyImageToBufferInfo);
3682 #endif
3683 }
3684
3685 void WINAPI wine_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
3686 {
3687     TRACE("%p, 0x%s, %u, %u, 0x%s, 0x%s, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(queryPool), firstQuery, queryCount, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(stride), flags);
3688     commandBuffer->device->funcs.p_vkCmdCopyQueryPoolResults(commandBuffer->command_buffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
3689 }
3690
3691 void WINAPI wine_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
3692 {
3693     TRACE("%p, %u, %u, %u\n", commandBuffer, groupCountX, groupCountY, groupCountZ);
3694     commandBuffer->device->funcs.p_vkCmdDispatch(commandBuffer->command_buffer, groupCountX, groupCountY, groupCountZ);
3695 }
3696
3697 void WINAPI wine_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
3698 {
3699     TRACE("%p, %u, %u, %u, %u, %u, %u\n", commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
3700     commandBuffer->device->funcs.p_vkCmdDispatchBase(commandBuffer->command_buffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
3701 }
3702
3703 static void WINAPI wine_vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
3704 {
3705     TRACE("%p, %u, %u, %u, %u, %u, %u\n", commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
3706     commandBuffer->device->funcs.p_vkCmdDispatchBaseKHR(commandBuffer->command_buffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
3707 }
3708
3709 void WINAPI wine_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
3710 {
3711     TRACE("%p, 0x%s, 0x%s\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset));
3712     commandBuffer->device->funcs.p_vkCmdDispatchIndirect(commandBuffer->command_buffer, buffer, offset);
3713 }
3714
3715 void WINAPI wine_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
3716 {
3717     TRACE("%p, %u, %u, %u, %u\n", commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
3718     commandBuffer->device->funcs.p_vkCmdDraw(commandBuffer->command_buffer, vertexCount, instanceCount, firstVertex, firstInstance);
3719 }
3720
3721 void WINAPI wine_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
3722 {
3723     TRACE("%p, %u, %u, %u, %d, %u\n", commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
3724     commandBuffer->device->funcs.p_vkCmdDrawIndexed(commandBuffer->command_buffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
3725 }
3726
3727 void WINAPI wine_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
3728 {
3729     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
3730     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirect(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
3731 }
3732
3733 void WINAPI wine_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
3734 {
3735     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
3736     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirectCount(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
3737 }
3738
3739 static void WINAPI wine_vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
3740 {
3741     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
3742     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirectCountAMD(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
3743 }
3744
3745 static void WINAPI wine_vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
3746 {
3747     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
3748     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirectCountKHR(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
3749 }
3750
3751 void WINAPI wine_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
3752 {
3753     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
3754     commandBuffer->device->funcs.p_vkCmdDrawIndirect(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
3755 }
3756
3757 static void WINAPI wine_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
3758 {
3759     TRACE("%p, %u, %u, 0x%s, 0x%s, %u, %u\n", commandBuffer, instanceCount, firstInstance, wine_dbgstr_longlong(counterBuffer), wine_dbgstr_longlong(counterBufferOffset), counterOffset, vertexStride);
3760     commandBuffer->device->funcs.p_vkCmdDrawIndirectByteCountEXT(commandBuffer->command_buffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
3761 }
3762
3763 void WINAPI wine_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
3764 {
3765     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
3766     commandBuffer->device->funcs.p_vkCmdDrawIndirectCount(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
3767 }
3768
3769 static void WINAPI wine_vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
3770 {
3771     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
3772     commandBuffer->device->funcs.p_vkCmdDrawIndirectCountAMD(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
3773 }
3774
3775 static void WINAPI wine_vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
3776 {
3777     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
3778     commandBuffer->device->funcs.p_vkCmdDrawIndirectCountKHR(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
3779 }
3780
3781 static void WINAPI wine_vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
3782 {
3783     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
3784     commandBuffer->device->funcs.p_vkCmdDrawMeshTasksIndirectCountNV(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
3785 }
3786
3787 static void WINAPI wine_vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
3788 {
3789     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
3790     commandBuffer->device->funcs.p_vkCmdDrawMeshTasksIndirectNV(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
3791 }
3792
3793 static void WINAPI wine_vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
3794 {
3795     TRACE("%p, %u, %u\n", commandBuffer, taskCount, firstTask);
3796     commandBuffer->device->funcs.p_vkCmdDrawMeshTasksNV(commandBuffer->command_buffer, taskCount, firstTask);
3797 }
3798
3799 static void WINAPI wine_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
3800 {
3801     TRACE("%p\n", commandBuffer);
3802     commandBuffer->device->funcs.p_vkCmdEndConditionalRenderingEXT(commandBuffer->command_buffer);
3803 }
3804
3805 static void WINAPI wine_vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
3806 {
3807     TRACE("%p\n", commandBuffer);
3808     commandBuffer->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(commandBuffer->command_buffer);
3809 }
3810
3811 void WINAPI wine_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
3812 {
3813     TRACE("%p, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query);
3814     commandBuffer->device->funcs.p_vkCmdEndQuery(commandBuffer->command_buffer, queryPool, query);
3815 }
3816
3817 static void WINAPI wine_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
3818 {
3819     TRACE("%p, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, index);
3820     commandBuffer->device->funcs.p_vkCmdEndQueryIndexedEXT(commandBuffer->command_buffer, queryPool, query, index);
3821 }
3822
3823 void WINAPI wine_vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
3824 {
3825     TRACE("%p\n", commandBuffer);
3826     commandBuffer->device->funcs.p_vkCmdEndRenderPass(commandBuffer->command_buffer);
3827 }
3828
3829 void WINAPI wine_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
3830 {
3831     TRACE("%p, %p\n", commandBuffer, pSubpassEndInfo);
3832     commandBuffer->device->funcs.p_vkCmdEndRenderPass2(commandBuffer->command_buffer, pSubpassEndInfo);
3833 }
3834
3835 static void WINAPI wine_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
3836 {
3837     TRACE("%p, %p\n", commandBuffer, pSubpassEndInfo);
3838     commandBuffer->device->funcs.p_vkCmdEndRenderPass2KHR(commandBuffer->command_buffer, pSubpassEndInfo);
3839 }
3840
3841 static void WINAPI wine_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
3842 {
3843     TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
3844     commandBuffer->device->funcs.p_vkCmdEndTransformFeedbackEXT(commandBuffer->command_buffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
3845 }
3846
3847 static void WINAPI wine_vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
3848 {
3849 #if defined(USE_STRUCT_CONVERSION)
3850     VkGeneratedCommandsInfoNV_host pGeneratedCommandsInfo_host;
3851     TRACE("%p, %u, %p\n", commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
3852
3853     convert_VkGeneratedCommandsInfoNV_win_to_host(pGeneratedCommandsInfo, &pGeneratedCommandsInfo_host);
3854     commandBuffer->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(commandBuffer->command_buffer, isPreprocessed, &pGeneratedCommandsInfo_host);
3855
3856     free_VkGeneratedCommandsInfoNV(&pGeneratedCommandsInfo_host);
3857 #else
3858     TRACE("%p, %u, %p\n", commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
3859     commandBuffer->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(commandBuffer->command_buffer, isPreprocessed, pGeneratedCommandsInfo);
3860 #endif
3861 }
3862
3863 void WINAPI wine_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
3864 {
3865     TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(size), data);
3866     commandBuffer->device->funcs.p_vkCmdFillBuffer(commandBuffer->command_buffer, dstBuffer, dstOffset, size, data);
3867 }
3868
3869 static void WINAPI wine_vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
3870 {
3871     TRACE("%p, %p\n", commandBuffer, pLabelInfo);
3872     commandBuffer->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(commandBuffer->command_buffer, pLabelInfo);
3873 }
3874
3875 void WINAPI wine_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
3876 {
3877     TRACE("%p, %#x\n", commandBuffer, contents);
3878     commandBuffer->device->funcs.p_vkCmdNextSubpass(commandBuffer->command_buffer, contents);
3879 }
3880
3881 void WINAPI wine_vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
3882 {
3883     TRACE("%p, %p, %p\n", commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
3884     commandBuffer->device->funcs.p_vkCmdNextSubpass2(commandBuffer->command_buffer, pSubpassBeginInfo, pSubpassEndInfo);
3885 }
3886
3887 static void WINAPI wine_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
3888 {
3889     TRACE("%p, %p, %p\n", commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
3890     commandBuffer->device->funcs.p_vkCmdNextSubpass2KHR(commandBuffer->command_buffer, pSubpassBeginInfo, pSubpassEndInfo);
3891 }
3892
3893 void WINAPI wine_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
3894 {
3895 #if defined(USE_STRUCT_CONVERSION)
3896     VkBufferMemoryBarrier_host *pBufferMemoryBarriers_host;
3897     VkImageMemoryBarrier_host *pImageMemoryBarriers_host;
3898     TRACE("%p, %#x, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
3899
3900     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win_to_host(pBufferMemoryBarriers, bufferMemoryBarrierCount);
3901     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win_to_host(pImageMemoryBarriers, imageMemoryBarrierCount);
3902     commandBuffer->device->funcs.p_vkCmdPipelineBarrier(commandBuffer->command_buffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers_host, imageMemoryBarrierCount, pImageMemoryBarriers_host);
3903
3904     free_VkBufferMemoryBarrier_array(pBufferMemoryBarriers_host, bufferMemoryBarrierCount);
3905     free_VkImageMemoryBarrier_array(pImageMemoryBarriers_host, imageMemoryBarrierCount);
3906 #else
3907     TRACE("%p, %#x, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
3908     commandBuffer->device->funcs.p_vkCmdPipelineBarrier(commandBuffer->command_buffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
3909 #endif
3910 }
3911
3912 static void WINAPI wine_vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
3913 {
3914 #if defined(USE_STRUCT_CONVERSION)
3915     VkGeneratedCommandsInfoNV_host pGeneratedCommandsInfo_host;
3916     TRACE("%p, %p\n", commandBuffer, pGeneratedCommandsInfo);
3917
3918     convert_VkGeneratedCommandsInfoNV_win_to_host(pGeneratedCommandsInfo, &pGeneratedCommandsInfo_host);
3919     commandBuffer->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(commandBuffer->command_buffer, &pGeneratedCommandsInfo_host);
3920
3921     free_VkGeneratedCommandsInfoNV(&pGeneratedCommandsInfo_host);
3922 #else
3923     TRACE("%p, %p\n", commandBuffer, pGeneratedCommandsInfo);
3924     commandBuffer->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(commandBuffer->command_buffer, pGeneratedCommandsInfo);
3925 #endif
3926 }
3927
3928 void WINAPI wine_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
3929 {
3930     TRACE("%p, 0x%s, %#x, %u, %u, %p\n", commandBuffer, wine_dbgstr_longlong(layout), stageFlags, offset, size, pValues);
3931     commandBuffer->device->funcs.p_vkCmdPushConstants(commandBuffer->command_buffer, layout, stageFlags, offset, size, pValues);
3932 }
3933
3934 static void WINAPI wine_vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
3935 {
3936 #if defined(USE_STRUCT_CONVERSION)
3937     VkWriteDescriptorSet_host *pDescriptorWrites_host;
3938     TRACE("%p, %#x, 0x%s, %u, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), set, descriptorWriteCount, pDescriptorWrites);
3939
3940     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win_to_host(pDescriptorWrites, descriptorWriteCount);
3941     commandBuffer->device->funcs.p_vkCmdPushDescriptorSetKHR(commandBuffer->command_buffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites_host);
3942
3943     free_VkWriteDescriptorSet_array(pDescriptorWrites_host, descriptorWriteCount);
3944 #else
3945     TRACE("%p, %#x, 0x%s, %u, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), set, descriptorWriteCount, pDescriptorWrites);
3946     commandBuffer->device->funcs.p_vkCmdPushDescriptorSetKHR(commandBuffer->command_buffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
3947 #endif
3948 }
3949
3950 static void WINAPI wine_vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
3951 {
3952     TRACE("%p, 0x%s, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(descriptorUpdateTemplate), wine_dbgstr_longlong(layout), set, pData);
3953     commandBuffer->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer->command_buffer, descriptorUpdateTemplate, layout, set, pData);
3954 }
3955
3956 void WINAPI wine_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
3957 {
3958     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(event), stageMask);
3959     commandBuffer->device->funcs.p_vkCmdResetEvent(commandBuffer->command_buffer, event, stageMask);
3960 }
3961
3962 void WINAPI wine_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
3963 {
3964     TRACE("%p, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), firstQuery, queryCount);
3965     commandBuffer->device->funcs.p_vkCmdResetQueryPool(commandBuffer->command_buffer, queryPool, firstQuery, queryCount);
3966 }
3967
3968 void WINAPI wine_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
3969 {
3970     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
3971     commandBuffer->device->funcs.p_vkCmdResolveImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
3972 }
3973
3974 static void WINAPI wine_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR *pResolveImageInfo)
3975 {
3976 #if defined(USE_STRUCT_CONVERSION)
3977     VkResolveImageInfo2KHR_host pResolveImageInfo_host;
3978     TRACE("%p, %p\n", commandBuffer, pResolveImageInfo);
3979
3980     convert_VkResolveImageInfo2KHR_win_to_host(pResolveImageInfo, &pResolveImageInfo_host);
3981     commandBuffer->device->funcs.p_vkCmdResolveImage2KHR(commandBuffer->command_buffer, &pResolveImageInfo_host);
3982
3983 #else
3984     TRACE("%p, %p\n", commandBuffer, pResolveImageInfo);
3985     commandBuffer->device->funcs.p_vkCmdResolveImage2KHR(commandBuffer->command_buffer, pResolveImageInfo);
3986 #endif
3987 }
3988
3989 void WINAPI wine_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
3990 {
3991     TRACE("%p, %p\n", commandBuffer, blendConstants);
3992     commandBuffer->device->funcs.p_vkCmdSetBlendConstants(commandBuffer->command_buffer, blendConstants);
3993 }
3994
3995 static void WINAPI wine_vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
3996 {
3997     TRACE("%p, %p\n", commandBuffer, pCheckpointMarker);
3998     commandBuffer->device->funcs.p_vkCmdSetCheckpointNV(commandBuffer->command_buffer, pCheckpointMarker);
3999 }
4000
4001 static void WINAPI wine_vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
4002 {
4003     TRACE("%p, %#x, %u, %p\n", commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
4004     commandBuffer->device->funcs.p_vkCmdSetCoarseSampleOrderNV(commandBuffer->command_buffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
4005 }
4006
4007 static void WINAPI wine_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
4008 {
4009     TRACE("%p, %#x\n", commandBuffer, cullMode);
4010     commandBuffer->device->funcs.p_vkCmdSetCullModeEXT(commandBuffer->command_buffer, cullMode);
4011 }
4012
4013 void WINAPI wine_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
4014 {
4015     TRACE("%p, %f, %f, %f\n", commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
4016     commandBuffer->device->funcs.p_vkCmdSetDepthBias(commandBuffer->command_buffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
4017 }
4018
4019 void WINAPI wine_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
4020 {
4021     TRACE("%p, %f, %f\n", commandBuffer, minDepthBounds, maxDepthBounds);
4022     commandBuffer->device->funcs.p_vkCmdSetDepthBounds(commandBuffer->command_buffer, minDepthBounds, maxDepthBounds);
4023 }
4024
4025 static void WINAPI wine_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
4026 {
4027     TRACE("%p, %u\n", commandBuffer, depthBoundsTestEnable);
4028     commandBuffer->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(commandBuffer->command_buffer, depthBoundsTestEnable);
4029 }
4030
4031 static void WINAPI wine_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
4032 {
4033     TRACE("%p, %#x\n", commandBuffer, depthCompareOp);
4034     commandBuffer->device->funcs.p_vkCmdSetDepthCompareOpEXT(commandBuffer->command_buffer, depthCompareOp);
4035 }
4036
4037 static void WINAPI wine_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
4038 {
4039     TRACE("%p, %u\n", commandBuffer, depthTestEnable);
4040     commandBuffer->device->funcs.p_vkCmdSetDepthTestEnableEXT(commandBuffer->command_buffer, depthTestEnable);
4041 }
4042
4043 static void WINAPI wine_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
4044 {
4045     TRACE("%p, %u\n", commandBuffer, depthWriteEnable);
4046     commandBuffer->device->funcs.p_vkCmdSetDepthWriteEnableEXT(commandBuffer->command_buffer, depthWriteEnable);
4047 }
4048
4049 void WINAPI wine_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
4050 {
4051     TRACE("%p, %u\n", commandBuffer, deviceMask);
4052     commandBuffer->device->funcs.p_vkCmdSetDeviceMask(commandBuffer->command_buffer, deviceMask);
4053 }
4054
4055 static void WINAPI wine_vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
4056 {
4057     TRACE("%p, %u\n", commandBuffer, deviceMask);
4058     commandBuffer->device->funcs.p_vkCmdSetDeviceMaskKHR(commandBuffer->command_buffer, deviceMask);
4059 }
4060
4061 static void WINAPI wine_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
4062 {
4063     TRACE("%p, %u, %u, %p\n", commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
4064     commandBuffer->device->funcs.p_vkCmdSetDiscardRectangleEXT(commandBuffer->command_buffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
4065 }
4066
4067 void WINAPI wine_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
4068 {
4069     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(event), stageMask);
4070     commandBuffer->device->funcs.p_vkCmdSetEvent(commandBuffer->command_buffer, event, stageMask);
4071 }
4072
4073 static void WINAPI wine_vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
4074 {
4075     TRACE("%p, %u, %u, %p\n", commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
4076     commandBuffer->device->funcs.p_vkCmdSetExclusiveScissorNV(commandBuffer->command_buffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
4077 }
4078
4079 static void WINAPI wine_vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
4080 {
4081     TRACE("%p, %p, %p\n", commandBuffer, pFragmentSize, combinerOps);
4082     commandBuffer->device->funcs.p_vkCmdSetFragmentShadingRateKHR(commandBuffer->command_buffer, pFragmentSize, combinerOps);
4083 }
4084
4085 static void WINAPI wine_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
4086 {
4087     TRACE("%p, %#x\n", commandBuffer, frontFace);
4088     commandBuffer->device->funcs.p_vkCmdSetFrontFaceEXT(commandBuffer->command_buffer, frontFace);
4089 }
4090
4091 static void WINAPI wine_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
4092 {
4093     TRACE("%p, %u, %u\n", commandBuffer, lineStippleFactor, lineStipplePattern);
4094     commandBuffer->device->funcs.p_vkCmdSetLineStippleEXT(commandBuffer->command_buffer, lineStippleFactor, lineStipplePattern);
4095 }
4096
4097 void WINAPI wine_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
4098 {
4099     TRACE("%p, %f\n", commandBuffer, lineWidth);
4100     commandBuffer->device->funcs.p_vkCmdSetLineWidth(commandBuffer->command_buffer, lineWidth);
4101 }
4102
4103 static VkResult WINAPI wine_vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
4104 {
4105 #if defined(USE_STRUCT_CONVERSION)
4106     VkResult result;
4107     VkPerformanceMarkerInfoINTEL_host pMarkerInfo_host;
4108     TRACE("%p, %p\n", commandBuffer, pMarkerInfo);
4109
4110     convert_VkPerformanceMarkerInfoINTEL_win_to_host(pMarkerInfo, &pMarkerInfo_host);
4111     result = commandBuffer->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(commandBuffer->command_buffer, &pMarkerInfo_host);
4112
4113     return result;
4114 #else
4115     TRACE("%p, %p\n", commandBuffer, pMarkerInfo);
4116     return commandBuffer->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(commandBuffer->command_buffer, pMarkerInfo);
4117 #endif
4118 }
4119
4120 static VkResult WINAPI wine_vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
4121 {
4122 #if defined(USE_STRUCT_CONVERSION)
4123     VkResult result;
4124     VkPerformanceOverrideInfoINTEL_host pOverrideInfo_host;
4125     TRACE("%p, %p\n", commandBuffer, pOverrideInfo);
4126
4127     convert_VkPerformanceOverrideInfoINTEL_win_to_host(pOverrideInfo, &pOverrideInfo_host);
4128     result = commandBuffer->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(commandBuffer->command_buffer, &pOverrideInfo_host);
4129
4130     return result;
4131 #else
4132     TRACE("%p, %p\n", commandBuffer, pOverrideInfo);
4133     return commandBuffer->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(commandBuffer->command_buffer, pOverrideInfo);
4134 #endif
4135 }
4136
4137 static VkResult WINAPI wine_vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
4138 {
4139     TRACE("%p, %p\n", commandBuffer, pMarkerInfo);
4140     return commandBuffer->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer->command_buffer, pMarkerInfo);
4141 }
4142
4143 static void WINAPI wine_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
4144 {
4145     TRACE("%p, %#x\n", commandBuffer, primitiveTopology);
4146     commandBuffer->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(commandBuffer->command_buffer, primitiveTopology);
4147 }
4148
4149 static void WINAPI wine_vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
4150 {
4151     TRACE("%p, %p\n", commandBuffer, pSampleLocationsInfo);
4152     commandBuffer->device->funcs.p_vkCmdSetSampleLocationsEXT(commandBuffer->command_buffer, pSampleLocationsInfo);
4153 }
4154
4155 void WINAPI wine_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
4156 {
4157     TRACE("%p, %u, %u, %p\n", commandBuffer, firstScissor, scissorCount, pScissors);
4158     commandBuffer->device->funcs.p_vkCmdSetScissor(commandBuffer->command_buffer, firstScissor, scissorCount, pScissors);
4159 }
4160
4161 static void WINAPI wine_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
4162 {
4163     TRACE("%p, %u, %p\n", commandBuffer, scissorCount, pScissors);
4164     commandBuffer->device->funcs.p_vkCmdSetScissorWithCountEXT(commandBuffer->command_buffer, scissorCount, pScissors);
4165 }
4166
4167 void WINAPI wine_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
4168 {
4169     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, compareMask);
4170     commandBuffer->device->funcs.p_vkCmdSetStencilCompareMask(commandBuffer->command_buffer, faceMask, compareMask);
4171 }
4172
4173 static void WINAPI wine_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
4174 {
4175     TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
4176     commandBuffer->device->funcs.p_vkCmdSetStencilOpEXT(commandBuffer->command_buffer, faceMask, failOp, passOp, depthFailOp, compareOp);
4177 }
4178
4179 void WINAPI wine_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
4180 {
4181     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, reference);
4182     commandBuffer->device->funcs.p_vkCmdSetStencilReference(commandBuffer->command_buffer, faceMask, reference);
4183 }
4184
4185 static void WINAPI wine_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
4186 {
4187     TRACE("%p, %u\n", commandBuffer, stencilTestEnable);
4188     commandBuffer->device->funcs.p_vkCmdSetStencilTestEnableEXT(commandBuffer->command_buffer, stencilTestEnable);
4189 }
4190
4191 void WINAPI wine_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
4192 {
4193     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, writeMask);
4194     commandBuffer->device->funcs.p_vkCmdSetStencilWriteMask(commandBuffer->command_buffer, faceMask, writeMask);
4195 }
4196
4197 void WINAPI wine_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
4198 {
4199     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pViewports);
4200     commandBuffer->device->funcs.p_vkCmdSetViewport(commandBuffer->command_buffer, firstViewport, viewportCount, pViewports);
4201 }
4202
4203 static void WINAPI wine_vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
4204 {
4205     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
4206     commandBuffer->device->funcs.p_vkCmdSetViewportShadingRatePaletteNV(commandBuffer->command_buffer, firstViewport, viewportCount, pShadingRatePalettes);
4207 }
4208
4209 static void WINAPI wine_vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
4210 {
4211     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pViewportWScalings);
4212     commandBuffer->device->funcs.p_vkCmdSetViewportWScalingNV(commandBuffer->command_buffer, firstViewport, viewportCount, pViewportWScalings);
4213 }
4214
4215 static void WINAPI wine_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
4216 {
4217     TRACE("%p, %u, %p\n", commandBuffer, viewportCount, pViewports);
4218     commandBuffer->device->funcs.p_vkCmdSetViewportWithCountEXT(commandBuffer->command_buffer, viewportCount, pViewports);
4219 }
4220
4221 static void WINAPI wine_vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
4222 {
4223     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", commandBuffer, wine_dbgstr_longlong(raygenShaderBindingTableBuffer), wine_dbgstr_longlong(raygenShaderBindingOffset), wine_dbgstr_longlong(missShaderBindingTableBuffer), wine_dbgstr_longlong(missShaderBindingOffset), wine_dbgstr_longlong(missShaderBindingStride), wine_dbgstr_longlong(hitShaderBindingTableBuffer), wine_dbgstr_longlong(hitShaderBindingOffset), wine_dbgstr_longlong(hitShaderBindingStride), wine_dbgstr_longlong(callableShaderBindingTableBuffer), wine_dbgstr_longlong(callableShaderBindingOffset), wine_dbgstr_longlong(callableShaderBindingStride), width, height, depth);
4224     commandBuffer->device->funcs.p_vkCmdTraceRaysNV(commandBuffer->command_buffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
4225 }
4226
4227 void WINAPI wine_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
4228 {
4229     TRACE("%p, 0x%s, 0x%s, 0x%s, %p\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(dataSize), pData);
4230     commandBuffer->device->funcs.p_vkCmdUpdateBuffer(commandBuffer->command_buffer, dstBuffer, dstOffset, dataSize, pData);
4231 }
4232
4233 void WINAPI wine_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
4234 {
4235 #if defined(USE_STRUCT_CONVERSION)
4236     VkBufferMemoryBarrier_host *pBufferMemoryBarriers_host;
4237     VkImageMemoryBarrier_host *pImageMemoryBarriers_host;
4238     TRACE("%p, %u, %p, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
4239
4240     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win_to_host(pBufferMemoryBarriers, bufferMemoryBarrierCount);
4241     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win_to_host(pImageMemoryBarriers, imageMemoryBarrierCount);
4242     commandBuffer->device->funcs.p_vkCmdWaitEvents(commandBuffer->command_buffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers_host, imageMemoryBarrierCount, pImageMemoryBarriers_host);
4243
4244     free_VkBufferMemoryBarrier_array(pBufferMemoryBarriers_host, bufferMemoryBarrierCount);
4245     free_VkImageMemoryBarrier_array(pImageMemoryBarriers_host, imageMemoryBarrierCount);
4246 #else
4247     TRACE("%p, %u, %p, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
4248     commandBuffer->device->funcs.p_vkCmdWaitEvents(commandBuffer->command_buffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
4249 #endif
4250 }
4251
4252 static void WINAPI wine_vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
4253 {
4254     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, wine_dbgstr_longlong(queryPool), firstQuery);
4255     commandBuffer->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer->command_buffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
4256 }
4257
4258 static void WINAPI wine_vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
4259 {
4260     TRACE("%p, %#x, 0x%s, 0x%s, %u\n", commandBuffer, pipelineStage, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), marker);
4261     commandBuffer->device->funcs.p_vkCmdWriteBufferMarkerAMD(commandBuffer->command_buffer, pipelineStage, dstBuffer, dstOffset, marker);
4262 }
4263
4264 void WINAPI wine_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
4265 {
4266     TRACE("%p, %#x, 0x%s, %u\n", commandBuffer, pipelineStage, wine_dbgstr_longlong(queryPool), query);
4267     commandBuffer->device->funcs.p_vkCmdWriteTimestamp(commandBuffer->command_buffer, pipelineStage, queryPool, query);
4268 }
4269
4270 static VkResult WINAPI wine_vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
4271 {
4272     TRACE("%p, 0x%s, %u\n", device, wine_dbgstr_longlong(pipeline), shader);
4273     return device->funcs.p_vkCompileDeferredNV(device->device, pipeline, shader);
4274 }
4275
4276 static VkResult WINAPI wine_vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
4277 {
4278 #if defined(USE_STRUCT_CONVERSION)
4279     VkResult result;
4280     VkAccelerationStructureCreateInfoNV_host pCreateInfo_host;
4281     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pAccelerationStructure);
4282
4283     convert_VkAccelerationStructureCreateInfoNV_win_to_host(pCreateInfo, &pCreateInfo_host);
4284     result = device->funcs.p_vkCreateAccelerationStructureNV(device->device, &pCreateInfo_host, NULL, pAccelerationStructure);
4285
4286     return result;
4287 #else
4288     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pAccelerationStructure);
4289     return device->funcs.p_vkCreateAccelerationStructureNV(device->device, pCreateInfo, NULL, pAccelerationStructure);
4290 #endif
4291 }
4292
4293 VkResult WINAPI wine_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
4294 {
4295 #if defined(USE_STRUCT_CONVERSION)
4296     VkResult result;
4297     VkBufferCreateInfo_host pCreateInfo_host;
4298     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pBuffer);
4299
4300     convert_VkBufferCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
4301     result = device->funcs.p_vkCreateBuffer(device->device, &pCreateInfo_host, NULL, pBuffer);
4302
4303     return result;
4304 #else
4305     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pBuffer);
4306     return device->funcs.p_vkCreateBuffer(device->device, pCreateInfo, NULL, pBuffer);
4307 #endif
4308 }
4309
4310 VkResult WINAPI wine_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
4311 {
4312 #if defined(USE_STRUCT_CONVERSION)
4313     VkResult result;
4314     VkBufferViewCreateInfo_host pCreateInfo_host;
4315     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
4316
4317     convert_VkBufferViewCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
4318     result = device->funcs.p_vkCreateBufferView(device->device, &pCreateInfo_host, NULL, pView);
4319
4320     return result;
4321 #else
4322     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
4323     return device->funcs.p_vkCreateBufferView(device->device, pCreateInfo, NULL, pView);
4324 #endif
4325 }
4326
4327 VkResult WINAPI wine_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
4328 {
4329 #if defined(USE_STRUCT_CONVERSION)
4330     VkResult result;
4331     VkComputePipelineCreateInfo_host *pCreateInfos_host;
4332     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
4333
4334     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win_to_host(pCreateInfos, createInfoCount);
4335     result = device->funcs.p_vkCreateComputePipelines(device->device, pipelineCache, createInfoCount, pCreateInfos_host, NULL, pPipelines);
4336
4337     free_VkComputePipelineCreateInfo_array(pCreateInfos_host, createInfoCount);
4338     return result;
4339 #else
4340     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
4341     return device->funcs.p_vkCreateComputePipelines(device->device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines);
4342 #endif
4343 }
4344
4345 VkResult WINAPI wine_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
4346 {
4347     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorPool);
4348     return device->funcs.p_vkCreateDescriptorPool(device->device, pCreateInfo, NULL, pDescriptorPool);
4349 }
4350
4351 VkResult WINAPI wine_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
4352 {
4353     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSetLayout);
4354     return device->funcs.p_vkCreateDescriptorSetLayout(device->device, pCreateInfo, NULL, pSetLayout);
4355 }
4356
4357 VkResult WINAPI wine_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
4358 {
4359 #if defined(USE_STRUCT_CONVERSION)
4360     VkResult result;
4361     VkDescriptorUpdateTemplateCreateInfo_host pCreateInfo_host;
4362     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
4363
4364     convert_VkDescriptorUpdateTemplateCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
4365     result = device->funcs.p_vkCreateDescriptorUpdateTemplate(device->device, &pCreateInfo_host, NULL, pDescriptorUpdateTemplate);
4366
4367     return result;
4368 #else
4369     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
4370     return device->funcs.p_vkCreateDescriptorUpdateTemplate(device->device, pCreateInfo, NULL, pDescriptorUpdateTemplate);
4371 #endif
4372 }
4373
4374 static VkResult WINAPI wine_vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
4375 {
4376 #if defined(USE_STRUCT_CONVERSION)
4377     VkResult result;
4378     VkDescriptorUpdateTemplateCreateInfo_host pCreateInfo_host;
4379     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
4380
4381     convert_VkDescriptorUpdateTemplateCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
4382     result = device->funcs.p_vkCreateDescriptorUpdateTemplateKHR(device->device, &pCreateInfo_host, NULL, pDescriptorUpdateTemplate);
4383
4384     return result;
4385 #else
4386     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
4387     return device->funcs.p_vkCreateDescriptorUpdateTemplateKHR(device->device, pCreateInfo, NULL, pDescriptorUpdateTemplate);
4388 #endif
4389 }
4390
4391 VkResult WINAPI wine_vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
4392 {
4393     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pEvent);
4394     return device->funcs.p_vkCreateEvent(device->device, pCreateInfo, NULL, pEvent);
4395 }
4396
4397 VkResult WINAPI wine_vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
4398 {
4399     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFence);
4400     return device->funcs.p_vkCreateFence(device->device, pCreateInfo, NULL, pFence);
4401 }
4402
4403 VkResult WINAPI wine_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
4404 {
4405 #if defined(USE_STRUCT_CONVERSION)
4406     VkResult result;
4407     VkFramebufferCreateInfo_host pCreateInfo_host;
4408     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFramebuffer);
4409
4410     convert_VkFramebufferCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
4411     result = device->funcs.p_vkCreateFramebuffer(device->device, &pCreateInfo_host, NULL, pFramebuffer);
4412
4413     return result;
4414 #else
4415     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFramebuffer);
4416     return device->funcs.p_vkCreateFramebuffer(device->device, pCreateInfo, NULL, pFramebuffer);
4417 #endif
4418 }
4419
4420 VkResult WINAPI wine_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
4421 {
4422 #if defined(USE_STRUCT_CONVERSION)
4423     VkResult result;
4424     VkGraphicsPipelineCreateInfo_host *pCreateInfos_host;
4425     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
4426
4427     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win_to_host(pCreateInfos, createInfoCount);
4428     result = device->funcs.p_vkCreateGraphicsPipelines(device->device, pipelineCache, createInfoCount, pCreateInfos_host, NULL, pPipelines);
4429
4430     free_VkGraphicsPipelineCreateInfo_array(pCreateInfos_host, createInfoCount);
4431     return result;
4432 #else
4433     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
4434     return device->funcs.p_vkCreateGraphicsPipelines(device->device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines);
4435 #endif
4436 }
4437
4438 static VkResult WINAPI wine_vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
4439 {
4440     TRACE("%p, %p, %p, %p\n", instance, pCreateInfo, pAllocator, pSurface);
4441     return instance->funcs.p_vkCreateHeadlessSurfaceEXT(instance->instance, pCreateInfo, NULL, pSurface);
4442 }
4443
4444 VkResult WINAPI wine_vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
4445 {
4446     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pImage);
4447     return device->funcs.p_vkCreateImage(device->device, pCreateInfo, NULL, pImage);
4448 }
4449
4450 VkResult WINAPI wine_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
4451 {
4452 #if defined(USE_STRUCT_CONVERSION)
4453     VkResult result;
4454     VkImageViewCreateInfo_host pCreateInfo_host;
4455     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
4456
4457     convert_VkImageViewCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
4458     result = device->funcs.p_vkCreateImageView(device->device, &pCreateInfo_host, NULL, pView);
4459
4460     return result;
4461 #else
4462     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
4463     return device->funcs.p_vkCreateImageView(device->device, pCreateInfo, NULL, pView);
4464 #endif
4465 }
4466
4467 static VkResult WINAPI wine_vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
4468 {
4469 #if defined(USE_STRUCT_CONVERSION)
4470     VkResult result;
4471     VkIndirectCommandsLayoutCreateInfoNV_host pCreateInfo_host;
4472     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
4473
4474     convert_VkIndirectCommandsLayoutCreateInfoNV_win_to_host(pCreateInfo, &pCreateInfo_host);
4475     result = device->funcs.p_vkCreateIndirectCommandsLayoutNV(device->device, &pCreateInfo_host, NULL, pIndirectCommandsLayout);
4476
4477     free_VkIndirectCommandsLayoutCreateInfoNV(&pCreateInfo_host);
4478     return result;
4479 #else
4480     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
4481     return device->funcs.p_vkCreateIndirectCommandsLayoutNV(device->device, pCreateInfo, NULL, pIndirectCommandsLayout);
4482 #endif
4483 }
4484
4485 VkResult WINAPI wine_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
4486 {
4487     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPipelineCache);
4488     return device->funcs.p_vkCreatePipelineCache(device->device, pCreateInfo, NULL, pPipelineCache);
4489 }
4490
4491 VkResult WINAPI wine_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
4492 {
4493     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPipelineLayout);
4494     return device->funcs.p_vkCreatePipelineLayout(device->device, pCreateInfo, NULL, pPipelineLayout);
4495 }
4496
4497 static VkResult WINAPI wine_vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlotEXT *pPrivateDataSlot)
4498 {
4499     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPrivateDataSlot);
4500     return device->funcs.p_vkCreatePrivateDataSlotEXT(device->device, pCreateInfo, NULL, pPrivateDataSlot);
4501 }
4502
4503 VkResult WINAPI wine_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
4504 {
4505     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pQueryPool);
4506     return device->funcs.p_vkCreateQueryPool(device->device, pCreateInfo, NULL, pQueryPool);
4507 }
4508
4509 static VkResult WINAPI wine_vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
4510 {
4511 #if defined(USE_STRUCT_CONVERSION)
4512     VkResult result;
4513     VkRayTracingPipelineCreateInfoNV_host *pCreateInfos_host;
4514     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
4515
4516     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win_to_host(pCreateInfos, createInfoCount);
4517     result = device->funcs.p_vkCreateRayTracingPipelinesNV(device->device, pipelineCache, createInfoCount, pCreateInfos_host, NULL, pPipelines);
4518
4519     free_VkRayTracingPipelineCreateInfoNV_array(pCreateInfos_host, createInfoCount);
4520     return result;
4521 #else
4522     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
4523     return device->funcs.p_vkCreateRayTracingPipelinesNV(device->device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines);
4524 #endif
4525 }
4526
4527 VkResult WINAPI wine_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
4528 {
4529     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass);
4530     return device->funcs.p_vkCreateRenderPass(device->device, pCreateInfo, NULL, pRenderPass);
4531 }
4532
4533 VkResult WINAPI wine_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
4534 {
4535     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass);
4536     return device->funcs.p_vkCreateRenderPass2(device->device, pCreateInfo, NULL, pRenderPass);
4537 }
4538
4539 static VkResult WINAPI wine_vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
4540 {
4541     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass);
4542     return device->funcs.p_vkCreateRenderPass2KHR(device->device, pCreateInfo, NULL, pRenderPass);
4543 }
4544
4545 VkResult WINAPI wine_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
4546 {
4547     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSampler);
4548     return device->funcs.p_vkCreateSampler(device->device, pCreateInfo, NULL, pSampler);
4549 }
4550
4551 VkResult WINAPI wine_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
4552 {
4553     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pYcbcrConversion);
4554     return device->funcs.p_vkCreateSamplerYcbcrConversion(device->device, pCreateInfo, NULL, pYcbcrConversion);
4555 }
4556
4557 static VkResult WINAPI wine_vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
4558 {
4559     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pYcbcrConversion);
4560     return device->funcs.p_vkCreateSamplerYcbcrConversionKHR(device->device, pCreateInfo, NULL, pYcbcrConversion);
4561 }
4562
4563 VkResult WINAPI wine_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
4564 {
4565     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSemaphore);
4566     return device->funcs.p_vkCreateSemaphore(device->device, pCreateInfo, NULL, pSemaphore);
4567 }
4568
4569 VkResult WINAPI wine_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
4570 {
4571     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pShaderModule);
4572     return device->funcs.p_vkCreateShaderModule(device->device, pCreateInfo, NULL, pShaderModule);
4573 }
4574
4575 VkResult WINAPI wine_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
4576 {
4577 #if defined(USE_STRUCT_CONVERSION)
4578     VkResult result;
4579     VkSwapchainCreateInfoKHR_host pCreateInfo_host;
4580     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSwapchain);
4581
4582     convert_VkSwapchainCreateInfoKHR_win_to_host(pCreateInfo, &pCreateInfo_host);
4583     result = device->funcs.p_vkCreateSwapchainKHR(device->device, &pCreateInfo_host, NULL, pSwapchain);
4584
4585     return result;
4586 #else
4587     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSwapchain);
4588     return device->funcs.p_vkCreateSwapchainKHR(device->device, pCreateInfo, NULL, pSwapchain);
4589 #endif
4590 }
4591
4592 static VkResult WINAPI wine_vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
4593 {
4594     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pValidationCache);
4595     return device->funcs.p_vkCreateValidationCacheEXT(device->device, pCreateInfo, NULL, pValidationCache);
4596 }
4597
4598 VkResult WINAPI wine_vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
4599 {
4600     TRACE("%p, %p, %p, %p\n", instance, pCreateInfo, pAllocator, pSurface);
4601     return instance->funcs.p_vkCreateWin32SurfaceKHR(instance->instance, pCreateInfo, NULL, pSurface);
4602 }
4603
4604 static void WINAPI wine_vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
4605 {
4606     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(accelerationStructure), pAllocator);
4607     device->funcs.p_vkDestroyAccelerationStructureNV(device->device, accelerationStructure, NULL);
4608 }
4609
4610 void WINAPI wine_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
4611 {
4612     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pAllocator);
4613     device->funcs.p_vkDestroyBuffer(device->device, buffer, NULL);
4614 }
4615
4616 void WINAPI wine_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
4617 {
4618     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(bufferView), pAllocator);
4619     device->funcs.p_vkDestroyBufferView(device->device, bufferView, NULL);
4620 }
4621
4622 void WINAPI wine_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
4623 {
4624     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorPool), pAllocator);
4625     device->funcs.p_vkDestroyDescriptorPool(device->device, descriptorPool, NULL);
4626 }
4627
4628 void WINAPI wine_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
4629 {
4630     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSetLayout), pAllocator);
4631     device->funcs.p_vkDestroyDescriptorSetLayout(device->device, descriptorSetLayout, NULL);
4632 }
4633
4634 void WINAPI wine_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
4635 {
4636     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorUpdateTemplate), pAllocator);
4637     device->funcs.p_vkDestroyDescriptorUpdateTemplate(device->device, descriptorUpdateTemplate, NULL);
4638 }
4639
4640 static void WINAPI wine_vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
4641 {
4642     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorUpdateTemplate), pAllocator);
4643     device->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(device->device, descriptorUpdateTemplate, NULL);
4644 }
4645
4646 void WINAPI wine_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
4647 {
4648     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(event), pAllocator);
4649     device->funcs.p_vkDestroyEvent(device->device, event, NULL);
4650 }
4651
4652 void WINAPI wine_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
4653 {
4654     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(fence), pAllocator);
4655     device->funcs.p_vkDestroyFence(device->device, fence, NULL);
4656 }
4657
4658 void WINAPI wine_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
4659 {
4660     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(framebuffer), pAllocator);
4661     device->funcs.p_vkDestroyFramebuffer(device->device, framebuffer, NULL);
4662 }
4663
4664 void WINAPI wine_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
4665 {
4666     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pAllocator);
4667     device->funcs.p_vkDestroyImage(device->device, image, NULL);
4668 }
4669
4670 void WINAPI wine_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
4671 {
4672     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(imageView), pAllocator);
4673     device->funcs.p_vkDestroyImageView(device->device, imageView, NULL);
4674 }
4675
4676 static void WINAPI wine_vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
4677 {
4678     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(indirectCommandsLayout), pAllocator);
4679     device->funcs.p_vkDestroyIndirectCommandsLayoutNV(device->device, indirectCommandsLayout, NULL);
4680 }
4681
4682 void WINAPI wine_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
4683 {
4684     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), pAllocator);
4685     device->funcs.p_vkDestroyPipeline(device->device, pipeline, NULL);
4686 }
4687
4688 void WINAPI wine_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
4689 {
4690     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipelineCache), pAllocator);
4691     device->funcs.p_vkDestroyPipelineCache(device->device, pipelineCache, NULL);
4692 }
4693
4694 void WINAPI wine_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
4695 {
4696     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipelineLayout), pAllocator);
4697     device->funcs.p_vkDestroyPipelineLayout(device->device, pipelineLayout, NULL);
4698 }
4699
4700 static void WINAPI wine_vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks *pAllocator)
4701 {
4702     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(privateDataSlot), pAllocator);
4703     device->funcs.p_vkDestroyPrivateDataSlotEXT(device->device, privateDataSlot, NULL);
4704 }
4705
4706 void WINAPI wine_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
4707 {
4708     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(queryPool), pAllocator);
4709     device->funcs.p_vkDestroyQueryPool(device->device, queryPool, NULL);
4710 }
4711
4712 void WINAPI wine_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
4713 {
4714     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pAllocator);
4715     device->funcs.p_vkDestroyRenderPass(device->device, renderPass, NULL);
4716 }
4717
4718 void WINAPI wine_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
4719 {
4720     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(sampler), pAllocator);
4721     device->funcs.p_vkDestroySampler(device->device, sampler, NULL);
4722 }
4723
4724 void WINAPI wine_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
4725 {
4726     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(ycbcrConversion), pAllocator);
4727     device->funcs.p_vkDestroySamplerYcbcrConversion(device->device, ycbcrConversion, NULL);
4728 }
4729
4730 static void WINAPI wine_vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
4731 {
4732     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(ycbcrConversion), pAllocator);
4733     device->funcs.p_vkDestroySamplerYcbcrConversionKHR(device->device, ycbcrConversion, NULL);
4734 }
4735
4736 void WINAPI wine_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
4737 {
4738     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(semaphore), pAllocator);
4739     device->funcs.p_vkDestroySemaphore(device->device, semaphore, NULL);
4740 }
4741
4742 void WINAPI wine_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
4743 {
4744     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(shaderModule), pAllocator);
4745     device->funcs.p_vkDestroyShaderModule(device->device, shaderModule, NULL);
4746 }
4747
4748 void WINAPI wine_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
4749 {
4750     TRACE("%p, 0x%s, %p\n", instance, wine_dbgstr_longlong(surface), pAllocator);
4751     instance->funcs.p_vkDestroySurfaceKHR(instance->instance, surface, NULL);
4752 }
4753
4754 void WINAPI wine_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
4755 {
4756     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(swapchain), pAllocator);
4757     device->funcs.p_vkDestroySwapchainKHR(device->device, swapchain, NULL);
4758 }
4759
4760 static void WINAPI wine_vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
4761 {
4762     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(validationCache), pAllocator);
4763     device->funcs.p_vkDestroyValidationCacheEXT(device->device, validationCache, NULL);
4764 }
4765
4766 VkResult WINAPI wine_vkDeviceWaitIdle(VkDevice device)
4767 {
4768     TRACE("%p\n", device);
4769     return device->funcs.p_vkDeviceWaitIdle(device->device);
4770 }
4771
4772 VkResult WINAPI wine_vkEndCommandBuffer(VkCommandBuffer commandBuffer)
4773 {
4774     TRACE("%p\n", commandBuffer);
4775     return commandBuffer->device->funcs.p_vkEndCommandBuffer(commandBuffer->command_buffer);
4776 }
4777
4778 VkResult WINAPI wine_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
4779 {
4780     TRACE("%p, %p, %p\n", physicalDevice, pPropertyCount, pProperties);
4781     return physicalDevice->instance->funcs.p_vkEnumerateDeviceLayerProperties(physicalDevice->phys_dev, pPropertyCount, pProperties);
4782 }
4783
4784 static VkResult WINAPI wine_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
4785 {
4786     TRACE("%p, %u, %p, %p, %p\n", physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
4787     return physicalDevice->instance->funcs.p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice->phys_dev, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
4788 }
4789
4790 VkResult WINAPI wine_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
4791 {
4792 #if defined(USE_STRUCT_CONVERSION)
4793     VkResult result;
4794     VkMappedMemoryRange_host *pMemoryRanges_host;
4795     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
4796
4797     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win_to_host(pMemoryRanges, memoryRangeCount);
4798     result = device->funcs.p_vkFlushMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges_host);
4799
4800     free_VkMappedMemoryRange_array(pMemoryRanges_host, memoryRangeCount);
4801     return result;
4802 #else
4803     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
4804     return device->funcs.p_vkFlushMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges);
4805 #endif
4806 }
4807
4808 VkResult WINAPI wine_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
4809 {
4810     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(descriptorPool), descriptorSetCount, pDescriptorSets);
4811     return device->funcs.p_vkFreeDescriptorSets(device->device, descriptorPool, descriptorSetCount, pDescriptorSets);
4812 }
4813
4814 void WINAPI wine_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
4815 {
4816     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(memory), pAllocator);
4817     device->funcs.p_vkFreeMemory(device->device, memory, NULL);
4818 }
4819
4820 static VkResult WINAPI wine_vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureKHR accelerationStructure, size_t dataSize, void *pData)
4821 {
4822     TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(accelerationStructure), wine_dbgstr_longlong(dataSize), pData);
4823     return device->funcs.p_vkGetAccelerationStructureHandleNV(device->device, accelerationStructure, dataSize, pData);
4824 }
4825
4826 static void WINAPI wine_vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
4827 {
4828 #if defined(USE_STRUCT_CONVERSION)
4829     VkAccelerationStructureMemoryRequirementsInfoNV_host pInfo_host;
4830     VkMemoryRequirements2KHR_host pMemoryRequirements_host;
4831     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
4832
4833     convert_VkAccelerationStructureMemoryRequirementsInfoNV_win_to_host(pInfo, &pInfo_host);
4834     convert_VkMemoryRequirements2KHR_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
4835     device->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(device->device, &pInfo_host, &pMemoryRequirements_host);
4836
4837     convert_VkMemoryRequirements2KHR_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
4838 #else
4839     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
4840     device->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(device->device, pInfo, pMemoryRequirements);
4841 #endif
4842 }
4843
4844 VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
4845 {
4846 #if defined(USE_STRUCT_CONVERSION)
4847     VkDeviceAddress result;
4848     VkBufferDeviceAddressInfo_host pInfo_host;
4849     TRACE("%p, %p\n", device, pInfo);
4850
4851     convert_VkBufferDeviceAddressInfo_win_to_host(pInfo, &pInfo_host);
4852     result = device->funcs.p_vkGetBufferDeviceAddress(device->device, &pInfo_host);
4853
4854     return result;
4855 #else
4856     TRACE("%p, %p\n", device, pInfo);
4857     return device->funcs.p_vkGetBufferDeviceAddress(device->device, pInfo);
4858 #endif
4859 }
4860
4861 static VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
4862 {
4863 #if defined(USE_STRUCT_CONVERSION)
4864     VkDeviceAddress result;
4865     VkBufferDeviceAddressInfo_host pInfo_host;
4866     TRACE("%p, %p\n", device, pInfo);
4867
4868     convert_VkBufferDeviceAddressInfo_win_to_host(pInfo, &pInfo_host);
4869     result = device->funcs.p_vkGetBufferDeviceAddressEXT(device->device, &pInfo_host);
4870
4871     return result;
4872 #else
4873     TRACE("%p, %p\n", device, pInfo);
4874     return device->funcs.p_vkGetBufferDeviceAddressEXT(device->device, pInfo);
4875 #endif
4876 }
4877
4878 static VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
4879 {
4880 #if defined(USE_STRUCT_CONVERSION)
4881     VkDeviceAddress result;
4882     VkBufferDeviceAddressInfo_host pInfo_host;
4883     TRACE("%p, %p\n", device, pInfo);
4884
4885     convert_VkBufferDeviceAddressInfo_win_to_host(pInfo, &pInfo_host);
4886     result = device->funcs.p_vkGetBufferDeviceAddressKHR(device->device, &pInfo_host);
4887
4888     return result;
4889 #else
4890     TRACE("%p, %p\n", device, pInfo);
4891     return device->funcs.p_vkGetBufferDeviceAddressKHR(device->device, pInfo);
4892 #endif
4893 }
4894
4895 void WINAPI wine_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
4896 {
4897 #if defined(USE_STRUCT_CONVERSION)
4898     VkMemoryRequirements_host pMemoryRequirements_host;
4899     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pMemoryRequirements);
4900
4901     device->funcs.p_vkGetBufferMemoryRequirements(device->device, buffer, &pMemoryRequirements_host);
4902
4903     convert_VkMemoryRequirements_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
4904 #else
4905     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pMemoryRequirements);
4906     device->funcs.p_vkGetBufferMemoryRequirements(device->device, buffer, pMemoryRequirements);
4907 #endif
4908 }
4909
4910 void WINAPI wine_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
4911 {
4912 #if defined(USE_STRUCT_CONVERSION)
4913     VkBufferMemoryRequirementsInfo2_host pInfo_host;
4914     VkMemoryRequirements2_host pMemoryRequirements_host;
4915     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
4916
4917     convert_VkBufferMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
4918     convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
4919     device->funcs.p_vkGetBufferMemoryRequirements2(device->device, &pInfo_host, &pMemoryRequirements_host);
4920
4921     convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
4922 #else
4923     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
4924     device->funcs.p_vkGetBufferMemoryRequirements2(device->device, pInfo, pMemoryRequirements);
4925 #endif
4926 }
4927
4928 static void WINAPI wine_vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
4929 {
4930 #if defined(USE_STRUCT_CONVERSION)
4931     VkBufferMemoryRequirementsInfo2_host pInfo_host;
4932     VkMemoryRequirements2_host pMemoryRequirements_host;
4933     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
4934
4935     convert_VkBufferMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
4936     convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
4937     device->funcs.p_vkGetBufferMemoryRequirements2KHR(device->device, &pInfo_host, &pMemoryRequirements_host);
4938
4939     convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
4940 #else
4941     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
4942     device->funcs.p_vkGetBufferMemoryRequirements2KHR(device->device, pInfo, pMemoryRequirements);
4943 #endif
4944 }
4945
4946 uint64_t WINAPI wine_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
4947 {
4948 #if defined(USE_STRUCT_CONVERSION)
4949     uint64_t result;
4950     VkBufferDeviceAddressInfo_host pInfo_host;
4951     TRACE("%p, %p\n", device, pInfo);
4952
4953     convert_VkBufferDeviceAddressInfo_win_to_host(pInfo, &pInfo_host);
4954     result = device->funcs.p_vkGetBufferOpaqueCaptureAddress(device->device, &pInfo_host);
4955
4956     return result;
4957 #else
4958     TRACE("%p, %p\n", device, pInfo);
4959     return device->funcs.p_vkGetBufferOpaqueCaptureAddress(device->device, pInfo);
4960 #endif
4961 }
4962
4963 static uint64_t WINAPI wine_vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
4964 {
4965 #if defined(USE_STRUCT_CONVERSION)
4966     uint64_t result;
4967     VkBufferDeviceAddressInfo_host pInfo_host;
4968     TRACE("%p, %p\n", device, pInfo);
4969
4970     convert_VkBufferDeviceAddressInfo_win_to_host(pInfo, &pInfo_host);
4971     result = device->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(device->device, &pInfo_host);
4972
4973     return result;
4974 #else
4975     TRACE("%p, %p\n", device, pInfo);
4976     return device->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(device->device, pInfo);
4977 #endif
4978 }
4979
4980 void WINAPI wine_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
4981 {
4982     TRACE("%p, %p, %p\n", device, pCreateInfo, pSupport);
4983     device->funcs.p_vkGetDescriptorSetLayoutSupport(device->device, pCreateInfo, pSupport);
4984 }
4985
4986 static void WINAPI wine_vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
4987 {
4988     TRACE("%p, %p, %p\n", device, pCreateInfo, pSupport);
4989     device->funcs.p_vkGetDescriptorSetLayoutSupportKHR(device->device, pCreateInfo, pSupport);
4990 }
4991
4992 void WINAPI wine_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
4993 {
4994     TRACE("%p, %u, %u, %u, %p\n", device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
4995     device->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(device->device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
4996 }
4997
4998 static void WINAPI wine_vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
4999 {
5000     TRACE("%p, %u, %u, %u, %p\n", device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
5001     device->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(device->device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
5002 }
5003
5004 VkResult WINAPI wine_vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
5005 {
5006     TRACE("%p, %p\n", device, pDeviceGroupPresentCapabilities);
5007     return device->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(device->device, pDeviceGroupPresentCapabilities);
5008 }
5009
5010 VkResult WINAPI wine_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
5011 {
5012     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(surface), pModes);
5013     return device->funcs.p_vkGetDeviceGroupSurfacePresentModesKHR(device->device, surface, pModes);
5014 }
5015
5016 void WINAPI wine_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
5017 {
5018     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(memory), pCommittedMemoryInBytes);
5019     device->funcs.p_vkGetDeviceMemoryCommitment(device->device, memory, pCommittedMemoryInBytes);
5020 }
5021
5022 uint64_t WINAPI wine_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
5023 {
5024 #if defined(USE_STRUCT_CONVERSION)
5025     uint64_t result;
5026     VkDeviceMemoryOpaqueCaptureAddressInfo_host pInfo_host;
5027     TRACE("%p, %p\n", device, pInfo);
5028
5029     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win_to_host(pInfo, &pInfo_host);
5030     result = device->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(device->device, &pInfo_host);
5031
5032     return result;
5033 #else
5034     TRACE("%p, %p\n", device, pInfo);
5035     return device->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(device->device, pInfo);
5036 #endif
5037 }
5038
5039 static uint64_t WINAPI wine_vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
5040 {
5041 #if defined(USE_STRUCT_CONVERSION)
5042     uint64_t result;
5043     VkDeviceMemoryOpaqueCaptureAddressInfo_host pInfo_host;
5044     TRACE("%p, %p\n", device, pInfo);
5045
5046     convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win_to_host(pInfo, &pInfo_host);
5047     result = device->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(device->device, &pInfo_host);
5048
5049     return result;
5050 #else
5051     TRACE("%p, %p\n", device, pInfo);
5052     return device->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(device->device, pInfo);
5053 #endif
5054 }
5055
5056 VkResult WINAPI wine_vkGetEventStatus(VkDevice device, VkEvent event)
5057 {
5058     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
5059     return device->funcs.p_vkGetEventStatus(device->device, event);
5060 }
5061
5062 VkResult WINAPI wine_vkGetFenceStatus(VkDevice device, VkFence fence)
5063 {
5064     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(fence));
5065     return device->funcs.p_vkGetFenceStatus(device->device, fence);
5066 }
5067
5068 static void WINAPI wine_vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
5069 {
5070 #if defined(USE_STRUCT_CONVERSION)
5071     VkGeneratedCommandsMemoryRequirementsInfoNV_host pInfo_host;
5072     VkMemoryRequirements2_host pMemoryRequirements_host;
5073     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
5074
5075     convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win_to_host(pInfo, &pInfo_host);
5076     convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
5077     device->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(device->device, &pInfo_host, &pMemoryRequirements_host);
5078
5079     convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
5080 #else
5081     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
5082     device->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(device->device, pInfo, pMemoryRequirements);
5083 #endif
5084 }
5085
5086 void WINAPI wine_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
5087 {
5088 #if defined(USE_STRUCT_CONVERSION)
5089     VkMemoryRequirements_host pMemoryRequirements_host;
5090     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pMemoryRequirements);
5091
5092     device->funcs.p_vkGetImageMemoryRequirements(device->device, image, &pMemoryRequirements_host);
5093
5094     convert_VkMemoryRequirements_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
5095 #else
5096     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pMemoryRequirements);
5097     device->funcs.p_vkGetImageMemoryRequirements(device->device, image, pMemoryRequirements);
5098 #endif
5099 }
5100
5101 void WINAPI wine_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
5102 {
5103 #if defined(USE_STRUCT_CONVERSION)
5104     VkImageMemoryRequirementsInfo2_host pInfo_host;
5105     VkMemoryRequirements2_host pMemoryRequirements_host;
5106     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
5107
5108     convert_VkImageMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
5109     convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
5110     device->funcs.p_vkGetImageMemoryRequirements2(device->device, &pInfo_host, &pMemoryRequirements_host);
5111
5112     convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
5113 #else
5114     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
5115     device->funcs.p_vkGetImageMemoryRequirements2(device->device, pInfo, pMemoryRequirements);
5116 #endif
5117 }
5118
5119 static void WINAPI wine_vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
5120 {
5121 #if defined(USE_STRUCT_CONVERSION)
5122     VkImageMemoryRequirementsInfo2_host pInfo_host;
5123     VkMemoryRequirements2_host pMemoryRequirements_host;
5124     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
5125
5126     convert_VkImageMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
5127     convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
5128     device->funcs.p_vkGetImageMemoryRequirements2KHR(device->device, &pInfo_host, &pMemoryRequirements_host);
5129
5130     convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
5131 #else
5132     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
5133     device->funcs.p_vkGetImageMemoryRequirements2KHR(device->device, pInfo, pMemoryRequirements);
5134 #endif
5135 }
5136
5137 void WINAPI wine_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
5138 {
5139     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSparseMemoryRequirementCount, pSparseMemoryRequirements);
5140     device->funcs.p_vkGetImageSparseMemoryRequirements(device->device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
5141 }
5142
5143 void WINAPI wine_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
5144 {
5145 #if defined(USE_STRUCT_CONVERSION)
5146     VkImageSparseMemoryRequirementsInfo2_host pInfo_host;
5147     TRACE("%p, %p, %p, %p\n", device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
5148
5149     convert_VkImageSparseMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
5150     device->funcs.p_vkGetImageSparseMemoryRequirements2(device->device, &pInfo_host, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
5151
5152 #else
5153     TRACE("%p, %p, %p, %p\n", device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
5154     device->funcs.p_vkGetImageSparseMemoryRequirements2(device->device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
5155 #endif
5156 }
5157
5158 static void WINAPI wine_vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
5159 {
5160 #if defined(USE_STRUCT_CONVERSION)
5161     VkImageSparseMemoryRequirementsInfo2_host pInfo_host;
5162     TRACE("%p, %p, %p, %p\n", device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
5163
5164     convert_VkImageSparseMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
5165     device->funcs.p_vkGetImageSparseMemoryRequirements2KHR(device->device, &pInfo_host, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
5166
5167 #else
5168     TRACE("%p, %p, %p, %p\n", device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
5169     device->funcs.p_vkGetImageSparseMemoryRequirements2KHR(device->device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
5170 #endif
5171 }
5172
5173 void WINAPI wine_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
5174 {
5175 #if defined(USE_STRUCT_CONVERSION)
5176     VkSubresourceLayout_host pLayout_host;
5177     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSubresource, pLayout);
5178
5179     device->funcs.p_vkGetImageSubresourceLayout(device->device, image, pSubresource, &pLayout_host);
5180
5181     convert_VkSubresourceLayout_host_to_win(&pLayout_host, pLayout);
5182 #else
5183     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSubresource, pLayout);
5184     device->funcs.p_vkGetImageSubresourceLayout(device->device, image, pSubresource, pLayout);
5185 #endif
5186 }
5187
5188 static VkResult WINAPI wine_vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
5189 {
5190     TRACE("%p, %#x, %p, %p\n", device, handleType, pHostPointer, pMemoryHostPointerProperties);
5191     return device->funcs.p_vkGetMemoryHostPointerPropertiesEXT(device->device, handleType, pHostPointer, pMemoryHostPointerProperties);
5192 }
5193
5194 static VkResult WINAPI wine_vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
5195 {
5196     TRACE("%p, %#x, %p\n", device, parameter, pValue);
5197     return device->funcs.p_vkGetPerformanceParameterINTEL(device->device, parameter, pValue);
5198 }
5199
5200 static VkResult WINAPI wine_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
5201 {
5202     TRACE("%p, %p, %p\n", physicalDevice, pPropertyCount, pProperties);
5203     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice->phys_dev, pPropertyCount, pProperties);
5204 }
5205
5206 void WINAPI wine_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
5207 {
5208     TRACE("%p, %p\n", physicalDevice, pFeatures);
5209     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures(physicalDevice->phys_dev, pFeatures);
5210 }
5211
5212 void WINAPI wine_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
5213 {
5214     TRACE("%p, %p\n", physicalDevice, pFeatures);
5215     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures2(physicalDevice->phys_dev, pFeatures);
5216 }
5217
5218 static void WINAPI wine_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
5219 {
5220     TRACE("%p, %p\n", physicalDevice, pFeatures);
5221     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(physicalDevice->phys_dev, pFeatures);
5222 }
5223
5224 void WINAPI wine_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
5225 {
5226     TRACE("%p, %#x, %p\n", physicalDevice, format, pFormatProperties);
5227     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(physicalDevice->phys_dev, format, pFormatProperties);
5228 }
5229
5230 void WINAPI wine_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
5231 {
5232     TRACE("%p, %#x, %p\n", physicalDevice, format, pFormatProperties);
5233     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(physicalDevice->phys_dev, format, pFormatProperties);
5234 }
5235
5236 static void WINAPI wine_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
5237 {
5238     TRACE("%p, %#x, %p\n", physicalDevice, format, pFormatProperties);
5239     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice->phys_dev, format, pFormatProperties);
5240 }
5241
5242 static VkResult WINAPI wine_vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
5243 {
5244     TRACE("%p, %p, %p\n", physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
5245     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice->phys_dev, pFragmentShadingRateCount, pFragmentShadingRates);
5246 }
5247
5248 VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
5249 {
5250 #if defined(USE_STRUCT_CONVERSION)
5251     VkResult result;
5252     VkImageFormatProperties_host pImageFormatProperties_host;
5253     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
5254
5255     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(physicalDevice->phys_dev, format, type, tiling, usage, flags, &pImageFormatProperties_host);
5256
5257     convert_VkImageFormatProperties_host_to_win(&pImageFormatProperties_host, pImageFormatProperties);
5258     return result;
5259 #else
5260     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
5261     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(physicalDevice->phys_dev, format, type, tiling, usage, flags, pImageFormatProperties);
5262 #endif
5263 }
5264
5265 VkResult thunk_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
5266 {
5267 #if defined(USE_STRUCT_CONVERSION)
5268     VkResult result;
5269     VkImageFormatProperties2_host pImageFormatProperties_host;
5270     convert_VkImageFormatProperties2_win_to_host(pImageFormatProperties, &pImageFormatProperties_host);
5271     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice->phys_dev, pImageFormatInfo, &pImageFormatProperties_host);
5272
5273     convert_VkImageFormatProperties2_host_to_win(&pImageFormatProperties_host, pImageFormatProperties);
5274     return result;
5275 #else
5276     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice->phys_dev, pImageFormatInfo, pImageFormatProperties);
5277 #endif
5278 }
5279
5280 VkResult thunk_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
5281 {
5282 #if defined(USE_STRUCT_CONVERSION)
5283     VkResult result;
5284     VkImageFormatProperties2_host pImageFormatProperties_host;
5285     convert_VkImageFormatProperties2_win_to_host(pImageFormatProperties, &pImageFormatProperties_host);
5286     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice->phys_dev, pImageFormatInfo, &pImageFormatProperties_host);
5287
5288     convert_VkImageFormatProperties2_host_to_win(&pImageFormatProperties_host, pImageFormatProperties);
5289     return result;
5290 #else
5291     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice->phys_dev, pImageFormatInfo, pImageFormatProperties);
5292 #endif
5293 }
5294
5295 void WINAPI wine_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
5296 {
5297 #if defined(USE_STRUCT_CONVERSION)
5298     VkPhysicalDeviceMemoryProperties_host pMemoryProperties_host;
5299     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
5300
5301     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(physicalDevice->phys_dev, &pMemoryProperties_host);
5302
5303     convert_VkPhysicalDeviceMemoryProperties_host_to_win(&pMemoryProperties_host, pMemoryProperties);
5304 #else
5305     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
5306     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(physicalDevice->phys_dev, pMemoryProperties);
5307 #endif
5308 }
5309
5310 void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
5311 {
5312 #if defined(USE_STRUCT_CONVERSION)
5313     VkPhysicalDeviceMemoryProperties2_host pMemoryProperties_host;
5314     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
5315
5316     convert_VkPhysicalDeviceMemoryProperties2_win_to_host(pMemoryProperties, &pMemoryProperties_host);
5317     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(physicalDevice->phys_dev, &pMemoryProperties_host);
5318
5319     convert_VkPhysicalDeviceMemoryProperties2_host_to_win(&pMemoryProperties_host, pMemoryProperties);
5320 #else
5321     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
5322     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(physicalDevice->phys_dev, pMemoryProperties);
5323 #endif
5324 }
5325
5326 static void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
5327 {
5328 #if defined(USE_STRUCT_CONVERSION)
5329     VkPhysicalDeviceMemoryProperties2_host pMemoryProperties_host;
5330     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
5331
5332     convert_VkPhysicalDeviceMemoryProperties2_win_to_host(pMemoryProperties, &pMemoryProperties_host);
5333     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice->phys_dev, &pMemoryProperties_host);
5334
5335     convert_VkPhysicalDeviceMemoryProperties2_host_to_win(&pMemoryProperties_host, pMemoryProperties);
5336 #else
5337     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
5338     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice->phys_dev, pMemoryProperties);
5339 #endif
5340 }
5341
5342 static void WINAPI wine_vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
5343 {
5344     TRACE("%p, %#x, %p\n", physicalDevice, samples, pMultisampleProperties);
5345     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice->phys_dev, samples, pMultisampleProperties);
5346 }
5347
5348 VkResult WINAPI wine_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
5349 {
5350     TRACE("%p, 0x%s, %p, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pRectCount, pRects);
5351     return physicalDevice->instance->funcs.p_vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice->phys_dev, surface, pRectCount, pRects);
5352 }
5353
5354 void WINAPI wine_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
5355 {
5356 #if defined(USE_STRUCT_CONVERSION)
5357     VkPhysicalDeviceProperties_host pProperties_host;
5358     TRACE("%p, %p\n", physicalDevice, pProperties);
5359
5360     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties(physicalDevice->phys_dev, &pProperties_host);
5361
5362     convert_VkPhysicalDeviceProperties_host_to_win(&pProperties_host, pProperties);
5363 #else
5364     TRACE("%p, %p\n", physicalDevice, pProperties);
5365     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties(physicalDevice->phys_dev, pProperties);
5366 #endif
5367 }
5368
5369 void thunk_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
5370 {
5371 #if defined(USE_STRUCT_CONVERSION)
5372     VkPhysicalDeviceProperties2_host pProperties_host;
5373     convert_VkPhysicalDeviceProperties2_win_to_host(pProperties, &pProperties_host);
5374     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2(physicalDevice->phys_dev, &pProperties_host);
5375
5376     convert_VkPhysicalDeviceProperties2_host_to_win(&pProperties_host, pProperties);
5377 #else
5378     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2(physicalDevice->phys_dev, pProperties);
5379 #endif
5380 }
5381
5382 void thunk_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
5383 {
5384 #if defined(USE_STRUCT_CONVERSION)
5385     VkPhysicalDeviceProperties2_host pProperties_host;
5386     convert_VkPhysicalDeviceProperties2_win_to_host(pProperties, &pProperties_host);
5387     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(physicalDevice->phys_dev, &pProperties_host);
5388
5389     convert_VkPhysicalDeviceProperties2_host_to_win(&pProperties_host, pProperties);
5390 #else
5391     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(physicalDevice->phys_dev, pProperties);
5392 #endif
5393 }
5394
5395 static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
5396 {
5397     TRACE("%p, %p, %p\n", physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
5398     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice->phys_dev, pPerformanceQueryCreateInfo, pNumPasses);
5399 }
5400
5401 void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
5402 {
5403     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
5404     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
5405 }
5406
5407 void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
5408 {
5409     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
5410     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
5411 }
5412
5413 static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
5414 {
5415     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
5416     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
5417 }
5418
5419 void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
5420 {
5421     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p, %p\n", physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
5422     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice->phys_dev, format, type, samples, usage, tiling, pPropertyCount, pProperties);
5423 }
5424
5425 void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
5426 {
5427     TRACE("%p, %p, %p, %p\n", physicalDevice, pFormatInfo, pPropertyCount, pProperties);
5428     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice->phys_dev, pFormatInfo, pPropertyCount, pProperties);
5429 }
5430
5431 static void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
5432 {
5433     TRACE("%p, %p, %p, %p\n", physicalDevice, pFormatInfo, pPropertyCount, pProperties);
5434     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice->phys_dev, pFormatInfo, pPropertyCount, pProperties);
5435 }
5436
5437 static VkResult WINAPI wine_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
5438 {
5439     TRACE("%p, %p, %p\n", physicalDevice, pCombinationCount, pCombinations);
5440     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice->phys_dev, pCombinationCount, pCombinations);
5441 }
5442
5443 VkResult thunk_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
5444 {
5445 #if defined(USE_STRUCT_CONVERSION)
5446     VkResult result;
5447     VkPhysicalDeviceSurfaceInfo2KHR_host pSurfaceInfo_host;
5448     convert_VkPhysicalDeviceSurfaceInfo2KHR_win_to_host(pSurfaceInfo, &pSurfaceInfo_host);
5449     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice->phys_dev, &pSurfaceInfo_host, pSurfaceCapabilities);
5450
5451     return result;
5452 #else
5453     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice->phys_dev, pSurfaceInfo, pSurfaceCapabilities);
5454 #endif
5455 }
5456
5457 VkResult thunk_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
5458 {
5459     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice->phys_dev, surface, pSurfaceCapabilities);
5460 }
5461
5462 VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
5463 {
5464 #if defined(USE_STRUCT_CONVERSION)
5465     VkResult result;
5466     VkPhysicalDeviceSurfaceInfo2KHR_host pSurfaceInfo_host;
5467     TRACE("%p, %p, %p, %p\n", physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
5468
5469     convert_VkPhysicalDeviceSurfaceInfo2KHR_win_to_host(pSurfaceInfo, &pSurfaceInfo_host);
5470     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice->phys_dev, &pSurfaceInfo_host, pSurfaceFormatCount, pSurfaceFormats);
5471
5472     return result;
5473 #else
5474     TRACE("%p, %p, %p, %p\n", physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
5475     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice->phys_dev, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
5476 #endif
5477 }
5478
5479 VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
5480 {
5481     TRACE("%p, 0x%s, %p, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pSurfaceFormatCount, pSurfaceFormats);
5482     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice->phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats);
5483 }
5484
5485 VkResult WINAPI wine_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
5486 {
5487     TRACE("%p, 0x%s, %p, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pPresentModeCount, pPresentModes);
5488     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice->phys_dev, surface, pPresentModeCount, pPresentModes);
5489 }
5490
5491 VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
5492 {
5493     TRACE("%p, %u, 0x%s, %p\n", physicalDevice, queueFamilyIndex, wine_dbgstr_longlong(surface), pSupported);
5494     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice->phys_dev, queueFamilyIndex, surface, pSupported);
5495 }
5496
5497 static VkResult WINAPI wine_vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolPropertiesEXT *pToolProperties)
5498 {
5499     TRACE("%p, %p, %p\n", physicalDevice, pToolCount, pToolProperties);
5500     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice->phys_dev, pToolCount, pToolProperties);
5501 }
5502
5503 VkBool32 WINAPI wine_vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
5504 {
5505     TRACE("%p, %u\n", physicalDevice, queueFamilyIndex);
5506     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice->phys_dev, queueFamilyIndex);
5507 }
5508
5509 VkResult WINAPI wine_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
5510 {
5511     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), pDataSize, pData);
5512     return device->funcs.p_vkGetPipelineCacheData(device->device, pipelineCache, pDataSize, pData);
5513 }
5514
5515 static VkResult WINAPI wine_vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
5516 {
5517 #if defined(USE_STRUCT_CONVERSION)
5518     VkResult result;
5519     VkPipelineExecutableInfoKHR_host pExecutableInfo_host;
5520     TRACE("%p, %p, %p, %p\n", device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
5521
5522     convert_VkPipelineExecutableInfoKHR_win_to_host(pExecutableInfo, &pExecutableInfo_host);
5523     result = device->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(device->device, &pExecutableInfo_host, pInternalRepresentationCount, pInternalRepresentations);
5524
5525     return result;
5526 #else
5527     TRACE("%p, %p, %p, %p\n", device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
5528     return device->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(device->device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
5529 #endif
5530 }
5531
5532 static VkResult WINAPI wine_vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
5533 {
5534 #if defined(USE_STRUCT_CONVERSION)
5535     VkResult result;
5536     VkPipelineInfoKHR_host pPipelineInfo_host;
5537     TRACE("%p, %p, %p, %p\n", device, pPipelineInfo, pExecutableCount, pProperties);
5538
5539     convert_VkPipelineInfoKHR_win_to_host(pPipelineInfo, &pPipelineInfo_host);
5540     result = device->funcs.p_vkGetPipelineExecutablePropertiesKHR(device->device, &pPipelineInfo_host, pExecutableCount, pProperties);
5541
5542     return result;
5543 #else
5544     TRACE("%p, %p, %p, %p\n", device, pPipelineInfo, pExecutableCount, pProperties);
5545     return device->funcs.p_vkGetPipelineExecutablePropertiesKHR(device->device, pPipelineInfo, pExecutableCount, pProperties);
5546 #endif
5547 }
5548
5549 static VkResult WINAPI wine_vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
5550 {
5551 #if defined(USE_STRUCT_CONVERSION)
5552     VkResult result;
5553     VkPipelineExecutableInfoKHR_host pExecutableInfo_host;
5554     TRACE("%p, %p, %p, %p\n", device, pExecutableInfo, pStatisticCount, pStatistics);
5555
5556     convert_VkPipelineExecutableInfoKHR_win_to_host(pExecutableInfo, &pExecutableInfo_host);
5557     result = device->funcs.p_vkGetPipelineExecutableStatisticsKHR(device->device, &pExecutableInfo_host, pStatisticCount, pStatistics);
5558
5559     return result;
5560 #else
5561     TRACE("%p, %p, %p, %p\n", device, pExecutableInfo, pStatisticCount, pStatistics);
5562     return device->funcs.p_vkGetPipelineExecutableStatisticsKHR(device->device, pExecutableInfo, pStatisticCount, pStatistics);
5563 #endif
5564 }
5565
5566 VkResult WINAPI wine_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
5567 {
5568     TRACE("%p, 0x%s, %u, %u, 0x%s, %p, 0x%s, %#x\n", device, wine_dbgstr_longlong(queryPool), firstQuery, queryCount, wine_dbgstr_longlong(dataSize), pData, wine_dbgstr_longlong(stride), flags);
5569     return device->funcs.p_vkGetQueryPoolResults(device->device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
5570 }
5571
5572 static void WINAPI wine_vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
5573 {
5574     TRACE("%p, %p, %p\n", queue, pCheckpointDataCount, pCheckpointData);
5575     queue->device->funcs.p_vkGetQueueCheckpointDataNV(queue->queue, pCheckpointDataCount, pCheckpointData);
5576 }
5577
5578 static VkResult WINAPI wine_vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
5579 {
5580     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), firstGroup, groupCount, wine_dbgstr_longlong(dataSize), pData);
5581     return device->funcs.p_vkGetRayTracingShaderGroupHandlesNV(device->device, pipeline, firstGroup, groupCount, dataSize, pData);
5582 }
5583
5584 void WINAPI wine_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
5585 {
5586     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pGranularity);
5587     device->funcs.p_vkGetRenderAreaGranularity(device->device, renderPass, pGranularity);
5588 }
5589
5590 VkResult WINAPI wine_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
5591 {
5592     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(semaphore), pValue);
5593     return device->funcs.p_vkGetSemaphoreCounterValue(device->device, semaphore, pValue);
5594 }
5595
5596 static VkResult WINAPI wine_vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
5597 {
5598     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(semaphore), pValue);
5599     return device->funcs.p_vkGetSemaphoreCounterValueKHR(device->device, semaphore, pValue);
5600 }
5601
5602 static VkResult WINAPI wine_vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
5603 {
5604     TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", device, wine_dbgstr_longlong(pipeline), shaderStage, infoType, pInfoSize, pInfo);
5605     return device->funcs.p_vkGetShaderInfoAMD(device->device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
5606 }
5607
5608 VkResult WINAPI wine_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
5609 {
5610     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(swapchain), pSwapchainImageCount, pSwapchainImages);
5611     return device->funcs.p_vkGetSwapchainImagesKHR(device->device, swapchain, pSwapchainImageCount, pSwapchainImages);
5612 }
5613
5614 static VkResult WINAPI wine_vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
5615 {
5616     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(validationCache), pDataSize, pData);
5617     return device->funcs.p_vkGetValidationCacheDataEXT(device->device, validationCache, pDataSize, pData);
5618 }
5619
5620 static VkResult WINAPI wine_vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
5621 {
5622     TRACE("%p, %p\n", device, pInitializeInfo);
5623     return device->funcs.p_vkInitializePerformanceApiINTEL(device->device, pInitializeInfo);
5624 }
5625
5626 VkResult WINAPI wine_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
5627 {
5628 #if defined(USE_STRUCT_CONVERSION)
5629     VkResult result;
5630     VkMappedMemoryRange_host *pMemoryRanges_host;
5631     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
5632
5633     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win_to_host(pMemoryRanges, memoryRangeCount);
5634     result = device->funcs.p_vkInvalidateMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges_host);
5635
5636     free_VkMappedMemoryRange_array(pMemoryRanges_host, memoryRangeCount);
5637     return result;
5638 #else
5639     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
5640     return device->funcs.p_vkInvalidateMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges);
5641 #endif
5642 }
5643
5644 VkResult WINAPI wine_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
5645 {
5646     TRACE("%p, 0x%s, 0x%s, 0x%s, %#x, %p\n", device, wine_dbgstr_longlong(memory), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(size), flags, ppData);
5647     return device->funcs.p_vkMapMemory(device->device, memory, offset, size, flags, ppData);
5648 }
5649
5650 VkResult WINAPI wine_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
5651 {
5652     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(dstCache), srcCacheCount, pSrcCaches);
5653     return device->funcs.p_vkMergePipelineCaches(device->device, dstCache, srcCacheCount, pSrcCaches);
5654 }
5655
5656 static VkResult WINAPI wine_vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
5657 {
5658     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(dstCache), srcCacheCount, pSrcCaches);
5659     return device->funcs.p_vkMergeValidationCachesEXT(device->device, dstCache, srcCacheCount, pSrcCaches);
5660 }
5661
5662 static void WINAPI wine_vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
5663 {
5664     TRACE("%p, %p\n", queue, pLabelInfo);
5665     queue->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(queue->queue, pLabelInfo);
5666 }
5667
5668 VkResult WINAPI wine_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
5669 {
5670 #if defined(USE_STRUCT_CONVERSION)
5671     VkResult result;
5672     VkBindSparseInfo_host *pBindInfo_host;
5673     TRACE("%p, %u, %p, 0x%s\n", queue, bindInfoCount, pBindInfo, wine_dbgstr_longlong(fence));
5674
5675     pBindInfo_host = convert_VkBindSparseInfo_array_win_to_host(pBindInfo, bindInfoCount);
5676     result = queue->device->funcs.p_vkQueueBindSparse(queue->queue, bindInfoCount, pBindInfo_host, fence);
5677
5678     free_VkBindSparseInfo_array(pBindInfo_host, bindInfoCount);
5679     return result;
5680 #else
5681     TRACE("%p, %u, %p, 0x%s\n", queue, bindInfoCount, pBindInfo, wine_dbgstr_longlong(fence));
5682     return queue->device->funcs.p_vkQueueBindSparse(queue->queue, bindInfoCount, pBindInfo, fence);
5683 #endif
5684 }
5685
5686 static void WINAPI wine_vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
5687 {
5688     TRACE("%p\n", queue);
5689     queue->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(queue->queue);
5690 }
5691
5692 static void WINAPI wine_vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
5693 {
5694     TRACE("%p, %p\n", queue, pLabelInfo);
5695     queue->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(queue->queue, pLabelInfo);
5696 }
5697
5698 VkResult WINAPI wine_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
5699 {
5700     TRACE("%p, %p\n", queue, pPresentInfo);
5701     return queue->device->funcs.p_vkQueuePresentKHR(queue->queue, pPresentInfo);
5702 }
5703
5704 static VkResult WINAPI wine_vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
5705 {
5706     TRACE("%p, 0x%s\n", queue, wine_dbgstr_longlong(configuration));
5707     return queue->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(queue->queue, configuration);
5708 }
5709
5710 VkResult WINAPI wine_vkQueueWaitIdle(VkQueue queue)
5711 {
5712     TRACE("%p\n", queue);
5713     return queue->device->funcs.p_vkQueueWaitIdle(queue->queue);
5714 }
5715
5716 static VkResult WINAPI wine_vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
5717 {
5718     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(configuration));
5719     return device->funcs.p_vkReleasePerformanceConfigurationINTEL(device->device, configuration);
5720 }
5721
5722 static void WINAPI wine_vkReleaseProfilingLockKHR(VkDevice device)
5723 {
5724     TRACE("%p\n", device);
5725     device->funcs.p_vkReleaseProfilingLockKHR(device->device);
5726 }
5727
5728 VkResult WINAPI wine_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
5729 {
5730     TRACE("%p, %#x\n", commandBuffer, flags);
5731     return commandBuffer->device->funcs.p_vkResetCommandBuffer(commandBuffer->command_buffer, flags);
5732 }
5733
5734 VkResult WINAPI wine_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
5735 {
5736     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
5737     return device->funcs.p_vkResetCommandPool(device->device, wine_cmd_pool_from_handle(commandPool)->command_pool, flags);
5738 }
5739
5740 VkResult WINAPI wine_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
5741 {
5742     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(descriptorPool), flags);
5743     return device->funcs.p_vkResetDescriptorPool(device->device, descriptorPool, flags);
5744 }
5745
5746 VkResult WINAPI wine_vkResetEvent(VkDevice device, VkEvent event)
5747 {
5748     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
5749     return device->funcs.p_vkResetEvent(device->device, event);
5750 }
5751
5752 VkResult WINAPI wine_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
5753 {
5754     TRACE("%p, %u, %p\n", device, fenceCount, pFences);
5755     return device->funcs.p_vkResetFences(device->device, fenceCount, pFences);
5756 }
5757
5758 void WINAPI wine_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
5759 {
5760     TRACE("%p, 0x%s, %u, %u\n", device, wine_dbgstr_longlong(queryPool), firstQuery, queryCount);
5761     device->funcs.p_vkResetQueryPool(device->device, queryPool, firstQuery, queryCount);
5762 }
5763
5764 static void WINAPI wine_vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
5765 {
5766     TRACE("%p, 0x%s, %u, %u\n", device, wine_dbgstr_longlong(queryPool), firstQuery, queryCount);
5767     device->funcs.p_vkResetQueryPoolEXT(device->device, queryPool, firstQuery, queryCount);
5768 }
5769
5770 VkResult thunk_vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
5771 {
5772 #if defined(USE_STRUCT_CONVERSION)
5773     VkResult result;
5774     VkDebugUtilsObjectNameInfoEXT_host pNameInfo_host;
5775     convert_VkDebugUtilsObjectNameInfoEXT_win_to_host(pNameInfo, &pNameInfo_host);
5776     result = device->funcs.p_vkSetDebugUtilsObjectNameEXT(device->device, &pNameInfo_host);
5777
5778     return result;
5779 #else
5780     return device->funcs.p_vkSetDebugUtilsObjectNameEXT(device->device, pNameInfo);
5781 #endif
5782 }
5783
5784 VkResult thunk_vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
5785 {
5786 #if defined(USE_STRUCT_CONVERSION)
5787     VkResult result;
5788     VkDebugUtilsObjectTagInfoEXT_host pTagInfo_host;
5789     convert_VkDebugUtilsObjectTagInfoEXT_win_to_host(pTagInfo, &pTagInfo_host);
5790     result = device->funcs.p_vkSetDebugUtilsObjectTagEXT(device->device, &pTagInfo_host);
5791
5792     return result;
5793 #else
5794     return device->funcs.p_vkSetDebugUtilsObjectTagEXT(device->device, pTagInfo);
5795 #endif
5796 }
5797
5798 VkResult WINAPI wine_vkSetEvent(VkDevice device, VkEvent event)
5799 {
5800     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
5801     return device->funcs.p_vkSetEvent(device->device, event);
5802 }
5803
5804 VkResult WINAPI wine_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
5805 {
5806 #if defined(USE_STRUCT_CONVERSION)
5807     VkResult result;
5808     VkSemaphoreSignalInfo_host pSignalInfo_host;
5809     TRACE("%p, %p\n", device, pSignalInfo);
5810
5811     convert_VkSemaphoreSignalInfo_win_to_host(pSignalInfo, &pSignalInfo_host);
5812     result = device->funcs.p_vkSignalSemaphore(device->device, &pSignalInfo_host);
5813
5814     return result;
5815 #else
5816     TRACE("%p, %p\n", device, pSignalInfo);
5817     return device->funcs.p_vkSignalSemaphore(device->device, pSignalInfo);
5818 #endif
5819 }
5820
5821 static VkResult WINAPI wine_vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
5822 {
5823 #if defined(USE_STRUCT_CONVERSION)
5824     VkResult result;
5825     VkSemaphoreSignalInfo_host pSignalInfo_host;
5826     TRACE("%p, %p\n", device, pSignalInfo);
5827
5828     convert_VkSemaphoreSignalInfo_win_to_host(pSignalInfo, &pSignalInfo_host);
5829     result = device->funcs.p_vkSignalSemaphoreKHR(device->device, &pSignalInfo_host);
5830
5831     return result;
5832 #else
5833     TRACE("%p, %p\n", device, pSignalInfo);
5834     return device->funcs.p_vkSignalSemaphoreKHR(device->device, pSignalInfo);
5835 #endif
5836 }
5837
5838 void thunk_vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
5839 {
5840 #if defined(USE_STRUCT_CONVERSION)
5841     VkDebugUtilsMessengerCallbackDataEXT_host pCallbackData_host;
5842     convert_VkDebugUtilsMessengerCallbackDataEXT_win_to_host(pCallbackData, &pCallbackData_host);
5843     instance->funcs.p_vkSubmitDebugUtilsMessageEXT(instance->instance, messageSeverity, messageTypes, &pCallbackData_host);
5844
5845     free_VkDebugUtilsMessengerCallbackDataEXT(&pCallbackData_host);
5846 #else
5847     instance->funcs.p_vkSubmitDebugUtilsMessageEXT(instance->instance, messageSeverity, messageTypes, pCallbackData);
5848 #endif
5849 }
5850
5851 void WINAPI wine_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
5852 {
5853     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
5854     device->funcs.p_vkTrimCommandPool(device->device, wine_cmd_pool_from_handle(commandPool)->command_pool, flags);
5855 }
5856
5857 static void WINAPI wine_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
5858 {
5859     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
5860     device->funcs.p_vkTrimCommandPoolKHR(device->device, wine_cmd_pool_from_handle(commandPool)->command_pool, flags);
5861 }
5862
5863 static void WINAPI wine_vkUninitializePerformanceApiINTEL(VkDevice device)
5864 {
5865     TRACE("%p\n", device);
5866     device->funcs.p_vkUninitializePerformanceApiINTEL(device->device);
5867 }
5868
5869 void WINAPI wine_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
5870 {
5871     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(memory));
5872     device->funcs.p_vkUnmapMemory(device->device, memory);
5873 }
5874
5875 void WINAPI wine_vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
5876 {
5877     TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSet), wine_dbgstr_longlong(descriptorUpdateTemplate), pData);
5878     device->funcs.p_vkUpdateDescriptorSetWithTemplate(device->device, descriptorSet, descriptorUpdateTemplate, pData);
5879 }
5880
5881 static void WINAPI wine_vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
5882 {
5883     TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSet), wine_dbgstr_longlong(descriptorUpdateTemplate), pData);
5884     device->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(device->device, descriptorSet, descriptorUpdateTemplate, pData);
5885 }
5886
5887 void WINAPI wine_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
5888 {
5889 #if defined(USE_STRUCT_CONVERSION)
5890     VkWriteDescriptorSet_host *pDescriptorWrites_host;
5891     VkCopyDescriptorSet_host *pDescriptorCopies_host;
5892     TRACE("%p, %u, %p, %u, %p\n", device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
5893
5894     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win_to_host(pDescriptorWrites, descriptorWriteCount);
5895     pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win_to_host(pDescriptorCopies, descriptorCopyCount);
5896     device->funcs.p_vkUpdateDescriptorSets(device->device, descriptorWriteCount, pDescriptorWrites_host, descriptorCopyCount, pDescriptorCopies_host);
5897
5898     free_VkWriteDescriptorSet_array(pDescriptorWrites_host, descriptorWriteCount);
5899     free_VkCopyDescriptorSet_array(pDescriptorCopies_host, descriptorCopyCount);
5900 #else
5901     TRACE("%p, %u, %p, %u, %p\n", device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
5902     device->funcs.p_vkUpdateDescriptorSets(device->device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
5903 #endif
5904 }
5905
5906 VkResult WINAPI wine_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
5907 {
5908     TRACE("%p, %u, %p, %u, 0x%s\n", device, fenceCount, pFences, waitAll, wine_dbgstr_longlong(timeout));
5909     return device->funcs.p_vkWaitForFences(device->device, fenceCount, pFences, waitAll, timeout);
5910 }
5911
5912 VkResult WINAPI wine_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
5913 {
5914     TRACE("%p, %p, 0x%s\n", device, pWaitInfo, wine_dbgstr_longlong(timeout));
5915     return device->funcs.p_vkWaitSemaphores(device->device, pWaitInfo, timeout);
5916 }
5917
5918 static VkResult WINAPI wine_vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
5919 {
5920     TRACE("%p, %p, 0x%s\n", device, pWaitInfo, wine_dbgstr_longlong(timeout));
5921     return device->funcs.p_vkWaitSemaphoresKHR(device->device, pWaitInfo, timeout);
5922 }
5923
5924 static const struct vulkan_func vk_device_dispatch_table[] =
5925 {
5926     {"vkAcquireNextImage2KHR", &wine_vkAcquireNextImage2KHR},
5927     {"vkAcquireNextImageKHR", &wine_vkAcquireNextImageKHR},
5928     {"vkAcquirePerformanceConfigurationINTEL", &wine_vkAcquirePerformanceConfigurationINTEL},
5929     {"vkAcquireProfilingLockKHR", &wine_vkAcquireProfilingLockKHR},
5930     {"vkAllocateCommandBuffers", &wine_vkAllocateCommandBuffers},
5931     {"vkAllocateDescriptorSets", &wine_vkAllocateDescriptorSets},
5932     {"vkAllocateMemory", &wine_vkAllocateMemory},
5933     {"vkBeginCommandBuffer", &wine_vkBeginCommandBuffer},
5934     {"vkBindAccelerationStructureMemoryNV", &wine_vkBindAccelerationStructureMemoryNV},
5935     {"vkBindBufferMemory", &wine_vkBindBufferMemory},
5936     {"vkBindBufferMemory2", &wine_vkBindBufferMemory2},
5937     {"vkBindBufferMemory2KHR", &wine_vkBindBufferMemory2KHR},
5938     {"vkBindImageMemory", &wine_vkBindImageMemory},
5939     {"vkBindImageMemory2", &wine_vkBindImageMemory2},
5940     {"vkBindImageMemory2KHR", &wine_vkBindImageMemory2KHR},
5941     {"vkCmdBeginConditionalRenderingEXT", &wine_vkCmdBeginConditionalRenderingEXT},
5942     {"vkCmdBeginDebugUtilsLabelEXT", &wine_vkCmdBeginDebugUtilsLabelEXT},
5943     {"vkCmdBeginQuery", &wine_vkCmdBeginQuery},
5944     {"vkCmdBeginQueryIndexedEXT", &wine_vkCmdBeginQueryIndexedEXT},
5945     {"vkCmdBeginRenderPass", &wine_vkCmdBeginRenderPass},
5946     {"vkCmdBeginRenderPass2", &wine_vkCmdBeginRenderPass2},
5947     {"vkCmdBeginRenderPass2KHR", &wine_vkCmdBeginRenderPass2KHR},
5948     {"vkCmdBeginTransformFeedbackEXT", &wine_vkCmdBeginTransformFeedbackEXT},
5949     {"vkCmdBindDescriptorSets", &wine_vkCmdBindDescriptorSets},
5950     {"vkCmdBindIndexBuffer", &wine_vkCmdBindIndexBuffer},
5951     {"vkCmdBindPipeline", &wine_vkCmdBindPipeline},
5952     {"vkCmdBindPipelineShaderGroupNV", &wine_vkCmdBindPipelineShaderGroupNV},
5953     {"vkCmdBindShadingRateImageNV", &wine_vkCmdBindShadingRateImageNV},
5954     {"vkCmdBindTransformFeedbackBuffersEXT", &wine_vkCmdBindTransformFeedbackBuffersEXT},
5955     {"vkCmdBindVertexBuffers", &wine_vkCmdBindVertexBuffers},
5956     {"vkCmdBindVertexBuffers2EXT", &wine_vkCmdBindVertexBuffers2EXT},
5957     {"vkCmdBlitImage", &wine_vkCmdBlitImage},
5958     {"vkCmdBlitImage2KHR", &wine_vkCmdBlitImage2KHR},
5959     {"vkCmdBuildAccelerationStructureNV", &wine_vkCmdBuildAccelerationStructureNV},
5960     {"vkCmdClearAttachments", &wine_vkCmdClearAttachments},
5961     {"vkCmdClearColorImage", &wine_vkCmdClearColorImage},
5962     {"vkCmdClearDepthStencilImage", &wine_vkCmdClearDepthStencilImage},
5963     {"vkCmdCopyAccelerationStructureNV", &wine_vkCmdCopyAccelerationStructureNV},
5964     {"vkCmdCopyBuffer", &wine_vkCmdCopyBuffer},
5965     {"vkCmdCopyBuffer2KHR", &wine_vkCmdCopyBuffer2KHR},
5966     {"vkCmdCopyBufferToImage", &wine_vkCmdCopyBufferToImage},
5967     {"vkCmdCopyBufferToImage2KHR", &wine_vkCmdCopyBufferToImage2KHR},
5968     {"vkCmdCopyImage", &wine_vkCmdCopyImage},
5969     {"vkCmdCopyImage2KHR", &wine_vkCmdCopyImage2KHR},
5970     {"vkCmdCopyImageToBuffer", &wine_vkCmdCopyImageToBuffer},
5971     {"vkCmdCopyImageToBuffer2KHR", &wine_vkCmdCopyImageToBuffer2KHR},
5972     {"vkCmdCopyQueryPoolResults", &wine_vkCmdCopyQueryPoolResults},
5973     {"vkCmdDispatch", &wine_vkCmdDispatch},
5974     {"vkCmdDispatchBase", &wine_vkCmdDispatchBase},
5975     {"vkCmdDispatchBaseKHR", &wine_vkCmdDispatchBaseKHR},
5976     {"vkCmdDispatchIndirect", &wine_vkCmdDispatchIndirect},
5977     {"vkCmdDraw", &wine_vkCmdDraw},
5978     {"vkCmdDrawIndexed", &wine_vkCmdDrawIndexed},
5979     {"vkCmdDrawIndexedIndirect", &wine_vkCmdDrawIndexedIndirect},
5980     {"vkCmdDrawIndexedIndirectCount", &wine_vkCmdDrawIndexedIndirectCount},
5981     {"vkCmdDrawIndexedIndirectCountAMD", &wine_vkCmdDrawIndexedIndirectCountAMD},
5982     {"vkCmdDrawIndexedIndirectCountKHR", &wine_vkCmdDrawIndexedIndirectCountKHR},
5983     {"vkCmdDrawIndirect", &wine_vkCmdDrawIndirect},
5984     {"vkCmdDrawIndirectByteCountEXT", &wine_vkCmdDrawIndirectByteCountEXT},
5985     {"vkCmdDrawIndirectCount", &wine_vkCmdDrawIndirectCount},
5986     {"vkCmdDrawIndirectCountAMD", &wine_vkCmdDrawIndirectCountAMD},
5987     {"vkCmdDrawIndirectCountKHR", &wine_vkCmdDrawIndirectCountKHR},
5988     {"vkCmdDrawMeshTasksIndirectCountNV", &wine_vkCmdDrawMeshTasksIndirectCountNV},
5989     {"vkCmdDrawMeshTasksIndirectNV", &wine_vkCmdDrawMeshTasksIndirectNV},
5990     {"vkCmdDrawMeshTasksNV", &wine_vkCmdDrawMeshTasksNV},
5991     {"vkCmdEndConditionalRenderingEXT", &wine_vkCmdEndConditionalRenderingEXT},
5992     {"vkCmdEndDebugUtilsLabelEXT", &wine_vkCmdEndDebugUtilsLabelEXT},
5993     {"vkCmdEndQuery", &wine_vkCmdEndQuery},
5994     {"vkCmdEndQueryIndexedEXT", &wine_vkCmdEndQueryIndexedEXT},
5995     {"vkCmdEndRenderPass", &wine_vkCmdEndRenderPass},
5996     {"vkCmdEndRenderPass2", &wine_vkCmdEndRenderPass2},
5997     {"vkCmdEndRenderPass2KHR", &wine_vkCmdEndRenderPass2KHR},
5998     {"vkCmdEndTransformFeedbackEXT", &wine_vkCmdEndTransformFeedbackEXT},
5999     {"vkCmdExecuteCommands", &wine_vkCmdExecuteCommands},
6000     {"vkCmdExecuteGeneratedCommandsNV", &wine_vkCmdExecuteGeneratedCommandsNV},
6001     {"vkCmdFillBuffer", &wine_vkCmdFillBuffer},
6002     {"vkCmdInsertDebugUtilsLabelEXT", &wine_vkCmdInsertDebugUtilsLabelEXT},
6003     {"vkCmdNextSubpass", &wine_vkCmdNextSubpass},
6004     {"vkCmdNextSubpass2", &wine_vkCmdNextSubpass2},
6005     {"vkCmdNextSubpass2KHR", &wine_vkCmdNextSubpass2KHR},
6006     {"vkCmdPipelineBarrier", &wine_vkCmdPipelineBarrier},
6007     {"vkCmdPreprocessGeneratedCommandsNV", &wine_vkCmdPreprocessGeneratedCommandsNV},
6008     {"vkCmdPushConstants", &wine_vkCmdPushConstants},
6009     {"vkCmdPushDescriptorSetKHR", &wine_vkCmdPushDescriptorSetKHR},
6010     {"vkCmdPushDescriptorSetWithTemplateKHR", &wine_vkCmdPushDescriptorSetWithTemplateKHR},
6011     {"vkCmdResetEvent", &wine_vkCmdResetEvent},
6012     {"vkCmdResetQueryPool", &wine_vkCmdResetQueryPool},
6013     {"vkCmdResolveImage", &wine_vkCmdResolveImage},
6014     {"vkCmdResolveImage2KHR", &wine_vkCmdResolveImage2KHR},
6015     {"vkCmdSetBlendConstants", &wine_vkCmdSetBlendConstants},
6016     {"vkCmdSetCheckpointNV", &wine_vkCmdSetCheckpointNV},
6017     {"vkCmdSetCoarseSampleOrderNV", &wine_vkCmdSetCoarseSampleOrderNV},
6018     {"vkCmdSetCullModeEXT", &wine_vkCmdSetCullModeEXT},
6019     {"vkCmdSetDepthBias", &wine_vkCmdSetDepthBias},
6020     {"vkCmdSetDepthBounds", &wine_vkCmdSetDepthBounds},
6021     {"vkCmdSetDepthBoundsTestEnableEXT", &wine_vkCmdSetDepthBoundsTestEnableEXT},
6022     {"vkCmdSetDepthCompareOpEXT", &wine_vkCmdSetDepthCompareOpEXT},
6023     {"vkCmdSetDepthTestEnableEXT", &wine_vkCmdSetDepthTestEnableEXT},
6024     {"vkCmdSetDepthWriteEnableEXT", &wine_vkCmdSetDepthWriteEnableEXT},
6025     {"vkCmdSetDeviceMask", &wine_vkCmdSetDeviceMask},
6026     {"vkCmdSetDeviceMaskKHR", &wine_vkCmdSetDeviceMaskKHR},
6027     {"vkCmdSetDiscardRectangleEXT", &wine_vkCmdSetDiscardRectangleEXT},
6028     {"vkCmdSetEvent", &wine_vkCmdSetEvent},
6029     {"vkCmdSetExclusiveScissorNV", &wine_vkCmdSetExclusiveScissorNV},
6030     {"vkCmdSetFragmentShadingRateKHR", &wine_vkCmdSetFragmentShadingRateKHR},
6031     {"vkCmdSetFrontFaceEXT", &wine_vkCmdSetFrontFaceEXT},
6032     {"vkCmdSetLineStippleEXT", &wine_vkCmdSetLineStippleEXT},
6033     {"vkCmdSetLineWidth", &wine_vkCmdSetLineWidth},
6034     {"vkCmdSetPerformanceMarkerINTEL", &wine_vkCmdSetPerformanceMarkerINTEL},
6035     {"vkCmdSetPerformanceOverrideINTEL", &wine_vkCmdSetPerformanceOverrideINTEL},
6036     {"vkCmdSetPerformanceStreamMarkerINTEL", &wine_vkCmdSetPerformanceStreamMarkerINTEL},
6037     {"vkCmdSetPrimitiveTopologyEXT", &wine_vkCmdSetPrimitiveTopologyEXT},
6038     {"vkCmdSetSampleLocationsEXT", &wine_vkCmdSetSampleLocationsEXT},
6039     {"vkCmdSetScissor", &wine_vkCmdSetScissor},
6040     {"vkCmdSetScissorWithCountEXT", &wine_vkCmdSetScissorWithCountEXT},
6041     {"vkCmdSetStencilCompareMask", &wine_vkCmdSetStencilCompareMask},
6042     {"vkCmdSetStencilOpEXT", &wine_vkCmdSetStencilOpEXT},
6043     {"vkCmdSetStencilReference", &wine_vkCmdSetStencilReference},
6044     {"vkCmdSetStencilTestEnableEXT", &wine_vkCmdSetStencilTestEnableEXT},
6045     {"vkCmdSetStencilWriteMask", &wine_vkCmdSetStencilWriteMask},
6046     {"vkCmdSetViewport", &wine_vkCmdSetViewport},
6047     {"vkCmdSetViewportShadingRatePaletteNV", &wine_vkCmdSetViewportShadingRatePaletteNV},
6048     {"vkCmdSetViewportWScalingNV", &wine_vkCmdSetViewportWScalingNV},
6049     {"vkCmdSetViewportWithCountEXT", &wine_vkCmdSetViewportWithCountEXT},
6050     {"vkCmdTraceRaysNV", &wine_vkCmdTraceRaysNV},
6051     {"vkCmdUpdateBuffer", &wine_vkCmdUpdateBuffer},
6052     {"vkCmdWaitEvents", &wine_vkCmdWaitEvents},
6053     {"vkCmdWriteAccelerationStructuresPropertiesNV", &wine_vkCmdWriteAccelerationStructuresPropertiesNV},
6054     {"vkCmdWriteBufferMarkerAMD", &wine_vkCmdWriteBufferMarkerAMD},
6055     {"vkCmdWriteTimestamp", &wine_vkCmdWriteTimestamp},
6056     {"vkCompileDeferredNV", &wine_vkCompileDeferredNV},
6057     {"vkCreateAccelerationStructureNV", &wine_vkCreateAccelerationStructureNV},
6058     {"vkCreateBuffer", &wine_vkCreateBuffer},
6059     {"vkCreateBufferView", &wine_vkCreateBufferView},
6060     {"vkCreateCommandPool", &wine_vkCreateCommandPool},
6061     {"vkCreateComputePipelines", &wine_vkCreateComputePipelines},
6062     {"vkCreateDescriptorPool", &wine_vkCreateDescriptorPool},
6063     {"vkCreateDescriptorSetLayout", &wine_vkCreateDescriptorSetLayout},
6064     {"vkCreateDescriptorUpdateTemplate", &wine_vkCreateDescriptorUpdateTemplate},
6065     {"vkCreateDescriptorUpdateTemplateKHR", &wine_vkCreateDescriptorUpdateTemplateKHR},
6066     {"vkCreateEvent", &wine_vkCreateEvent},
6067     {"vkCreateFence", &wine_vkCreateFence},
6068     {"vkCreateFramebuffer", &wine_vkCreateFramebuffer},
6069     {"vkCreateGraphicsPipelines", &wine_vkCreateGraphicsPipelines},
6070     {"vkCreateImage", &wine_vkCreateImage},
6071     {"vkCreateImageView", &wine_vkCreateImageView},
6072     {"vkCreateIndirectCommandsLayoutNV", &wine_vkCreateIndirectCommandsLayoutNV},
6073     {"vkCreatePipelineCache", &wine_vkCreatePipelineCache},
6074     {"vkCreatePipelineLayout", &wine_vkCreatePipelineLayout},
6075     {"vkCreatePrivateDataSlotEXT", &wine_vkCreatePrivateDataSlotEXT},
6076     {"vkCreateQueryPool", &wine_vkCreateQueryPool},
6077     {"vkCreateRayTracingPipelinesNV", &wine_vkCreateRayTracingPipelinesNV},
6078     {"vkCreateRenderPass", &wine_vkCreateRenderPass},
6079     {"vkCreateRenderPass2", &wine_vkCreateRenderPass2},
6080     {"vkCreateRenderPass2KHR", &wine_vkCreateRenderPass2KHR},
6081     {"vkCreateSampler", &wine_vkCreateSampler},
6082     {"vkCreateSamplerYcbcrConversion", &wine_vkCreateSamplerYcbcrConversion},
6083     {"vkCreateSamplerYcbcrConversionKHR", &wine_vkCreateSamplerYcbcrConversionKHR},
6084     {"vkCreateSemaphore", &wine_vkCreateSemaphore},
6085     {"vkCreateShaderModule", &wine_vkCreateShaderModule},
6086     {"vkCreateSwapchainKHR", &wine_vkCreateSwapchainKHR},
6087     {"vkCreateValidationCacheEXT", &wine_vkCreateValidationCacheEXT},
6088     {"vkDestroyAccelerationStructureNV", &wine_vkDestroyAccelerationStructureNV},
6089     {"vkDestroyBuffer", &wine_vkDestroyBuffer},
6090     {"vkDestroyBufferView", &wine_vkDestroyBufferView},
6091     {"vkDestroyCommandPool", &wine_vkDestroyCommandPool},
6092     {"vkDestroyDescriptorPool", &wine_vkDestroyDescriptorPool},
6093     {"vkDestroyDescriptorSetLayout", &wine_vkDestroyDescriptorSetLayout},
6094     {"vkDestroyDescriptorUpdateTemplate", &wine_vkDestroyDescriptorUpdateTemplate},
6095     {"vkDestroyDescriptorUpdateTemplateKHR", &wine_vkDestroyDescriptorUpdateTemplateKHR},
6096     {"vkDestroyDevice", &wine_vkDestroyDevice},
6097     {"vkDestroyEvent", &wine_vkDestroyEvent},
6098     {"vkDestroyFence", &wine_vkDestroyFence},
6099     {"vkDestroyFramebuffer", &wine_vkDestroyFramebuffer},
6100     {"vkDestroyImage", &wine_vkDestroyImage},
6101     {"vkDestroyImageView", &wine_vkDestroyImageView},
6102     {"vkDestroyIndirectCommandsLayoutNV", &wine_vkDestroyIndirectCommandsLayoutNV},
6103     {"vkDestroyPipeline", &wine_vkDestroyPipeline},
6104     {"vkDestroyPipelineCache", &wine_vkDestroyPipelineCache},
6105     {"vkDestroyPipelineLayout", &wine_vkDestroyPipelineLayout},
6106     {"vkDestroyPrivateDataSlotEXT", &wine_vkDestroyPrivateDataSlotEXT},
6107     {"vkDestroyQueryPool", &wine_vkDestroyQueryPool},
6108     {"vkDestroyRenderPass", &wine_vkDestroyRenderPass},
6109     {"vkDestroySampler", &wine_vkDestroySampler},
6110     {"vkDestroySamplerYcbcrConversion", &wine_vkDestroySamplerYcbcrConversion},
6111     {"vkDestroySamplerYcbcrConversionKHR", &wine_vkDestroySamplerYcbcrConversionKHR},
6112     {"vkDestroySemaphore", &wine_vkDestroySemaphore},
6113     {"vkDestroyShaderModule", &wine_vkDestroyShaderModule},
6114     {"vkDestroySwapchainKHR", &wine_vkDestroySwapchainKHR},
6115     {"vkDestroyValidationCacheEXT", &wine_vkDestroyValidationCacheEXT},
6116     {"vkDeviceWaitIdle", &wine_vkDeviceWaitIdle},
6117     {"vkEndCommandBuffer", &wine_vkEndCommandBuffer},
6118     {"vkFlushMappedMemoryRanges", &wine_vkFlushMappedMemoryRanges},
6119     {"vkFreeCommandBuffers", &wine_vkFreeCommandBuffers},
6120     {"vkFreeDescriptorSets", &wine_vkFreeDescriptorSets},
6121     {"vkFreeMemory", &wine_vkFreeMemory},
6122     {"vkGetAccelerationStructureHandleNV", &wine_vkGetAccelerationStructureHandleNV},
6123     {"vkGetAccelerationStructureMemoryRequirementsNV", &wine_vkGetAccelerationStructureMemoryRequirementsNV},
6124     {"vkGetBufferDeviceAddress", &wine_vkGetBufferDeviceAddress},
6125     {"vkGetBufferDeviceAddressEXT", &wine_vkGetBufferDeviceAddressEXT},
6126     {"vkGetBufferDeviceAddressKHR", &wine_vkGetBufferDeviceAddressKHR},
6127     {"vkGetBufferMemoryRequirements", &wine_vkGetBufferMemoryRequirements},
6128     {"vkGetBufferMemoryRequirements2", &wine_vkGetBufferMemoryRequirements2},
6129     {"vkGetBufferMemoryRequirements2KHR", &wine_vkGetBufferMemoryRequirements2KHR},
6130     {"vkGetBufferOpaqueCaptureAddress", &wine_vkGetBufferOpaqueCaptureAddress},
6131     {"vkGetBufferOpaqueCaptureAddressKHR", &wine_vkGetBufferOpaqueCaptureAddressKHR},
6132     {"vkGetCalibratedTimestampsEXT", &wine_vkGetCalibratedTimestampsEXT},
6133     {"vkGetDescriptorSetLayoutSupport", &wine_vkGetDescriptorSetLayoutSupport},
6134     {"vkGetDescriptorSetLayoutSupportKHR", &wine_vkGetDescriptorSetLayoutSupportKHR},
6135     {"vkGetDeviceGroupPeerMemoryFeatures", &wine_vkGetDeviceGroupPeerMemoryFeatures},
6136     {"vkGetDeviceGroupPeerMemoryFeaturesKHR", &wine_vkGetDeviceGroupPeerMemoryFeaturesKHR},
6137     {"vkGetDeviceGroupPresentCapabilitiesKHR", &wine_vkGetDeviceGroupPresentCapabilitiesKHR},
6138     {"vkGetDeviceGroupSurfacePresentModesKHR", &wine_vkGetDeviceGroupSurfacePresentModesKHR},
6139     {"vkGetDeviceMemoryCommitment", &wine_vkGetDeviceMemoryCommitment},
6140     {"vkGetDeviceMemoryOpaqueCaptureAddress", &wine_vkGetDeviceMemoryOpaqueCaptureAddress},
6141     {"vkGetDeviceMemoryOpaqueCaptureAddressKHR", &wine_vkGetDeviceMemoryOpaqueCaptureAddressKHR},
6142     {"vkGetDeviceProcAddr", &wine_vkGetDeviceProcAddr},
6143     {"vkGetDeviceQueue", &wine_vkGetDeviceQueue},
6144     {"vkGetDeviceQueue2", &wine_vkGetDeviceQueue2},
6145     {"vkGetEventStatus", &wine_vkGetEventStatus},
6146     {"vkGetFenceStatus", &wine_vkGetFenceStatus},
6147     {"vkGetGeneratedCommandsMemoryRequirementsNV", &wine_vkGetGeneratedCommandsMemoryRequirementsNV},
6148     {"vkGetImageMemoryRequirements", &wine_vkGetImageMemoryRequirements},
6149     {"vkGetImageMemoryRequirements2", &wine_vkGetImageMemoryRequirements2},
6150     {"vkGetImageMemoryRequirements2KHR", &wine_vkGetImageMemoryRequirements2KHR},
6151     {"vkGetImageSparseMemoryRequirements", &wine_vkGetImageSparseMemoryRequirements},
6152     {"vkGetImageSparseMemoryRequirements2", &wine_vkGetImageSparseMemoryRequirements2},
6153     {"vkGetImageSparseMemoryRequirements2KHR", &wine_vkGetImageSparseMemoryRequirements2KHR},
6154     {"vkGetImageSubresourceLayout", &wine_vkGetImageSubresourceLayout},
6155     {"vkGetMemoryHostPointerPropertiesEXT", &wine_vkGetMemoryHostPointerPropertiesEXT},
6156     {"vkGetPerformanceParameterINTEL", &wine_vkGetPerformanceParameterINTEL},
6157     {"vkGetPipelineCacheData", &wine_vkGetPipelineCacheData},
6158     {"vkGetPipelineExecutableInternalRepresentationsKHR", &wine_vkGetPipelineExecutableInternalRepresentationsKHR},
6159     {"vkGetPipelineExecutablePropertiesKHR", &wine_vkGetPipelineExecutablePropertiesKHR},
6160     {"vkGetPipelineExecutableStatisticsKHR", &wine_vkGetPipelineExecutableStatisticsKHR},
6161     {"vkGetPrivateDataEXT", &wine_vkGetPrivateDataEXT},
6162     {"vkGetQueryPoolResults", &wine_vkGetQueryPoolResults},
6163     {"vkGetQueueCheckpointDataNV", &wine_vkGetQueueCheckpointDataNV},
6164     {"vkGetRayTracingShaderGroupHandlesNV", &wine_vkGetRayTracingShaderGroupHandlesNV},
6165     {"vkGetRenderAreaGranularity", &wine_vkGetRenderAreaGranularity},
6166     {"vkGetSemaphoreCounterValue", &wine_vkGetSemaphoreCounterValue},
6167     {"vkGetSemaphoreCounterValueKHR", &wine_vkGetSemaphoreCounterValueKHR},
6168     {"vkGetShaderInfoAMD", &wine_vkGetShaderInfoAMD},
6169     {"vkGetSwapchainImagesKHR", &wine_vkGetSwapchainImagesKHR},
6170     {"vkGetValidationCacheDataEXT", &wine_vkGetValidationCacheDataEXT},
6171     {"vkInitializePerformanceApiINTEL", &wine_vkInitializePerformanceApiINTEL},
6172     {"vkInvalidateMappedMemoryRanges", &wine_vkInvalidateMappedMemoryRanges},
6173     {"vkMapMemory", &wine_vkMapMemory},
6174     {"vkMergePipelineCaches", &wine_vkMergePipelineCaches},
6175     {"vkMergeValidationCachesEXT", &wine_vkMergeValidationCachesEXT},
6176     {"vkQueueBeginDebugUtilsLabelEXT", &wine_vkQueueBeginDebugUtilsLabelEXT},
6177     {"vkQueueBindSparse", &wine_vkQueueBindSparse},
6178     {"vkQueueEndDebugUtilsLabelEXT", &wine_vkQueueEndDebugUtilsLabelEXT},
6179     {"vkQueueInsertDebugUtilsLabelEXT", &wine_vkQueueInsertDebugUtilsLabelEXT},
6180     {"vkQueuePresentKHR", &wine_vkQueuePresentKHR},
6181     {"vkQueueSetPerformanceConfigurationINTEL", &wine_vkQueueSetPerformanceConfigurationINTEL},
6182     {"vkQueueSubmit", &wine_vkQueueSubmit},
6183     {"vkQueueWaitIdle", &wine_vkQueueWaitIdle},
6184     {"vkReleasePerformanceConfigurationINTEL", &wine_vkReleasePerformanceConfigurationINTEL},
6185     {"vkReleaseProfilingLockKHR", &wine_vkReleaseProfilingLockKHR},
6186     {"vkResetCommandBuffer", &wine_vkResetCommandBuffer},
6187     {"vkResetCommandPool", &wine_vkResetCommandPool},
6188     {"vkResetDescriptorPool", &wine_vkResetDescriptorPool},
6189     {"vkResetEvent", &wine_vkResetEvent},
6190     {"vkResetFences", &wine_vkResetFences},
6191     {"vkResetQueryPool", &wine_vkResetQueryPool},
6192     {"vkResetQueryPoolEXT", &wine_vkResetQueryPoolEXT},
6193     {"vkSetDebugUtilsObjectNameEXT", &wine_vkSetDebugUtilsObjectNameEXT},
6194     {"vkSetDebugUtilsObjectTagEXT", &wine_vkSetDebugUtilsObjectTagEXT},
6195     {"vkSetEvent", &wine_vkSetEvent},
6196     {"vkSetPrivateDataEXT", &wine_vkSetPrivateDataEXT},
6197     {"vkSignalSemaphore", &wine_vkSignalSemaphore},
6198     {"vkSignalSemaphoreKHR", &wine_vkSignalSemaphoreKHR},
6199     {"vkTrimCommandPool", &wine_vkTrimCommandPool},
6200     {"vkTrimCommandPoolKHR", &wine_vkTrimCommandPoolKHR},
6201     {"vkUninitializePerformanceApiINTEL", &wine_vkUninitializePerformanceApiINTEL},
6202     {"vkUnmapMemory", &wine_vkUnmapMemory},
6203     {"vkUpdateDescriptorSetWithTemplate", &wine_vkUpdateDescriptorSetWithTemplate},
6204     {"vkUpdateDescriptorSetWithTemplateKHR", &wine_vkUpdateDescriptorSetWithTemplateKHR},
6205     {"vkUpdateDescriptorSets", &wine_vkUpdateDescriptorSets},
6206     {"vkWaitForFences", &wine_vkWaitForFences},
6207     {"vkWaitSemaphores", &wine_vkWaitSemaphores},
6208     {"vkWaitSemaphoresKHR", &wine_vkWaitSemaphoresKHR},
6209 };
6210
6211 static const struct vulkan_func vk_instance_dispatch_table[] =
6212 {
6213     {"vkCreateDebugUtilsMessengerEXT", &wine_vkCreateDebugUtilsMessengerEXT},
6214     {"vkCreateDevice", &wine_vkCreateDevice},
6215     {"vkCreateHeadlessSurfaceEXT", &wine_vkCreateHeadlessSurfaceEXT},
6216     {"vkCreateWin32SurfaceKHR", &wine_vkCreateWin32SurfaceKHR},
6217     {"vkDestroyDebugUtilsMessengerEXT", &wine_vkDestroyDebugUtilsMessengerEXT},
6218     {"vkDestroyInstance", &wine_vkDestroyInstance},
6219     {"vkDestroySurfaceKHR", &wine_vkDestroySurfaceKHR},
6220     {"vkEnumerateDeviceExtensionProperties", &wine_vkEnumerateDeviceExtensionProperties},
6221     {"vkEnumerateDeviceLayerProperties", &wine_vkEnumerateDeviceLayerProperties},
6222     {"vkEnumeratePhysicalDeviceGroups", &wine_vkEnumeratePhysicalDeviceGroups},
6223     {"vkEnumeratePhysicalDeviceGroupsKHR", &wine_vkEnumeratePhysicalDeviceGroupsKHR},
6224     {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", &wine_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR},
6225     {"vkEnumeratePhysicalDevices", &wine_vkEnumeratePhysicalDevices},
6226     {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", &wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT},
6227     {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", &wine_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV},
6228     {"vkGetPhysicalDeviceExternalBufferProperties", &wine_vkGetPhysicalDeviceExternalBufferProperties},
6229     {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", &wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR},
6230     {"vkGetPhysicalDeviceExternalFenceProperties", &wine_vkGetPhysicalDeviceExternalFenceProperties},
6231     {"vkGetPhysicalDeviceExternalFencePropertiesKHR", &wine_vkGetPhysicalDeviceExternalFencePropertiesKHR},
6232     {"vkGetPhysicalDeviceExternalSemaphoreProperties", &wine_vkGetPhysicalDeviceExternalSemaphoreProperties},
6233     {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", &wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR},
6234     {"vkGetPhysicalDeviceFeatures", &wine_vkGetPhysicalDeviceFeatures},
6235     {"vkGetPhysicalDeviceFeatures2", &wine_vkGetPhysicalDeviceFeatures2},
6236     {"vkGetPhysicalDeviceFeatures2KHR", &wine_vkGetPhysicalDeviceFeatures2KHR},
6237     {"vkGetPhysicalDeviceFormatProperties", &wine_vkGetPhysicalDeviceFormatProperties},
6238     {"vkGetPhysicalDeviceFormatProperties2", &wine_vkGetPhysicalDeviceFormatProperties2},
6239     {"vkGetPhysicalDeviceFormatProperties2KHR", &wine_vkGetPhysicalDeviceFormatProperties2KHR},
6240     {"vkGetPhysicalDeviceFragmentShadingRatesKHR", &wine_vkGetPhysicalDeviceFragmentShadingRatesKHR},
6241     {"vkGetPhysicalDeviceImageFormatProperties", &wine_vkGetPhysicalDeviceImageFormatProperties},
6242     {"vkGetPhysicalDeviceImageFormatProperties2", &wine_vkGetPhysicalDeviceImageFormatProperties2},
6243     {"vkGetPhysicalDeviceImageFormatProperties2KHR", &wine_vkGetPhysicalDeviceImageFormatProperties2KHR},
6244     {"vkGetPhysicalDeviceMemoryProperties", &wine_vkGetPhysicalDeviceMemoryProperties},
6245     {"vkGetPhysicalDeviceMemoryProperties2", &wine_vkGetPhysicalDeviceMemoryProperties2},
6246     {"vkGetPhysicalDeviceMemoryProperties2KHR", &wine_vkGetPhysicalDeviceMemoryProperties2KHR},
6247     {"vkGetPhysicalDeviceMultisamplePropertiesEXT", &wine_vkGetPhysicalDeviceMultisamplePropertiesEXT},
6248     {"vkGetPhysicalDevicePresentRectanglesKHR", &wine_vkGetPhysicalDevicePresentRectanglesKHR},
6249     {"vkGetPhysicalDeviceProperties", &wine_vkGetPhysicalDeviceProperties},
6250     {"vkGetPhysicalDeviceProperties2", &wine_vkGetPhysicalDeviceProperties2},
6251     {"vkGetPhysicalDeviceProperties2KHR", &wine_vkGetPhysicalDeviceProperties2KHR},
6252     {"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", &wine_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR},
6253     {"vkGetPhysicalDeviceQueueFamilyProperties", &wine_vkGetPhysicalDeviceQueueFamilyProperties},
6254     {"vkGetPhysicalDeviceQueueFamilyProperties2", &wine_vkGetPhysicalDeviceQueueFamilyProperties2},
6255     {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", &wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR},
6256     {"vkGetPhysicalDeviceSparseImageFormatProperties", &wine_vkGetPhysicalDeviceSparseImageFormatProperties},
6257     {"vkGetPhysicalDeviceSparseImageFormatProperties2", &wine_vkGetPhysicalDeviceSparseImageFormatProperties2},
6258     {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", &wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR},
6259     {"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", &wine_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV},
6260     {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", &wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR},
6261     {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", &wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR},
6262     {"vkGetPhysicalDeviceSurfaceFormats2KHR", &wine_vkGetPhysicalDeviceSurfaceFormats2KHR},
6263     {"vkGetPhysicalDeviceSurfaceFormatsKHR", &wine_vkGetPhysicalDeviceSurfaceFormatsKHR},
6264     {"vkGetPhysicalDeviceSurfacePresentModesKHR", &wine_vkGetPhysicalDeviceSurfacePresentModesKHR},
6265     {"vkGetPhysicalDeviceSurfaceSupportKHR", &wine_vkGetPhysicalDeviceSurfaceSupportKHR},
6266     {"vkGetPhysicalDeviceToolPropertiesEXT", &wine_vkGetPhysicalDeviceToolPropertiesEXT},
6267     {"vkGetPhysicalDeviceWin32PresentationSupportKHR", &wine_vkGetPhysicalDeviceWin32PresentationSupportKHR},
6268     {"vkSubmitDebugUtilsMessageEXT", &wine_vkSubmitDebugUtilsMessageEXT},
6269 };
6270
6271 void *wine_vk_get_device_proc_addr(const char *name)
6272 {
6273     unsigned int i;
6274     for (i = 0; i < ARRAY_SIZE(vk_device_dispatch_table); i++)
6275     {
6276         if (strcmp(vk_device_dispatch_table[i].name, name) == 0)
6277         {
6278             TRACE("Found name=%s in device table\n", debugstr_a(name));
6279             return vk_device_dispatch_table[i].func;
6280         }
6281     }
6282     return NULL;
6283 }
6284
6285 void *wine_vk_get_instance_proc_addr(const char *name)
6286 {
6287     unsigned int i;
6288     for (i = 0; i < ARRAY_SIZE(vk_instance_dispatch_table); i++)
6289     {
6290         if (strcmp(vk_instance_dispatch_table[i].name, name) == 0)
6291         {
6292             TRACE("Found name=%s in instance table\n", debugstr_a(name));
6293             return vk_instance_dispatch_table[i].func;
6294         }
6295     }
6296     return NULL;
6297 }
6298
6299 static const char * const vk_device_extensions[] =
6300 {
6301     "VK_AMD_buffer_marker",
6302     "VK_AMD_device_coherent_memory",
6303     "VK_AMD_draw_indirect_count",
6304     "VK_AMD_gcn_shader",
6305     "VK_AMD_gpu_shader_half_float",
6306     "VK_AMD_gpu_shader_int16",
6307     "VK_AMD_memory_overallocation_behavior",
6308     "VK_AMD_mixed_attachment_samples",
6309     "VK_AMD_negative_viewport_height",
6310     "VK_AMD_pipeline_compiler_control",
6311     "VK_AMD_rasterization_order",
6312     "VK_AMD_shader_ballot",
6313     "VK_AMD_shader_core_properties",
6314     "VK_AMD_shader_core_properties2",
6315     "VK_AMD_shader_explicit_vertex_parameter",
6316     "VK_AMD_shader_fragment_mask",
6317     "VK_AMD_shader_image_load_store_lod",
6318     "VK_AMD_shader_info",
6319     "VK_AMD_shader_trinary_minmax",
6320     "VK_AMD_texture_gather_bias_lod",
6321     "VK_EXT_4444_formats",
6322     "VK_EXT_astc_decode_mode",
6323     "VK_EXT_blend_operation_advanced",
6324     "VK_EXT_buffer_device_address",
6325     "VK_EXT_calibrated_timestamps",
6326     "VK_EXT_conditional_rendering",
6327     "VK_EXT_conservative_rasterization",
6328     "VK_EXT_custom_border_color",
6329     "VK_EXT_depth_clip_enable",
6330     "VK_EXT_depth_range_unrestricted",
6331     "VK_EXT_descriptor_indexing",
6332     "VK_EXT_discard_rectangles",
6333     "VK_EXT_extended_dynamic_state",
6334     "VK_EXT_external_memory_host",
6335     "VK_EXT_filter_cubic",
6336     "VK_EXT_fragment_density_map",
6337     "VK_EXT_fragment_density_map2",
6338     "VK_EXT_fragment_shader_interlock",
6339     "VK_EXT_global_priority",
6340     "VK_EXT_host_query_reset",
6341     "VK_EXT_image_robustness",
6342     "VK_EXT_index_type_uint8",
6343     "VK_EXT_inline_uniform_block",
6344     "VK_EXT_line_rasterization",
6345     "VK_EXT_memory_budget",
6346     "VK_EXT_memory_priority",
6347     "VK_EXT_pci_bus_info",
6348     "VK_EXT_pipeline_creation_cache_control",
6349     "VK_EXT_post_depth_coverage",
6350     "VK_EXT_private_data",
6351     "VK_EXT_queue_family_foreign",
6352     "VK_EXT_robustness2",
6353     "VK_EXT_sample_locations",
6354     "VK_EXT_sampler_filter_minmax",
6355     "VK_EXT_scalar_block_layout",
6356     "VK_EXT_separate_stencil_usage",
6357     "VK_EXT_shader_atomic_float",
6358     "VK_EXT_shader_demote_to_helper_invocation",
6359     "VK_EXT_shader_image_atomic_int64",
6360     "VK_EXT_shader_stencil_export",
6361     "VK_EXT_shader_subgroup_ballot",
6362     "VK_EXT_shader_subgroup_vote",
6363     "VK_EXT_shader_viewport_index_layer",
6364     "VK_EXT_subgroup_size_control",
6365     "VK_EXT_texel_buffer_alignment",
6366     "VK_EXT_texture_compression_astc_hdr",
6367     "VK_EXT_tooling_info",
6368     "VK_EXT_transform_feedback",
6369     "VK_EXT_validation_cache",
6370     "VK_EXT_vertex_attribute_divisor",
6371     "VK_EXT_ycbcr_image_arrays",
6372     "VK_GOOGLE_decorate_string",
6373     "VK_GOOGLE_hlsl_functionality1",
6374     "VK_GOOGLE_user_type",
6375     "VK_IMG_filter_cubic",
6376     "VK_IMG_format_pvrtc",
6377     "VK_INTEL_performance_query",
6378     "VK_INTEL_shader_integer_functions2",
6379     "VK_KHR_16bit_storage",
6380     "VK_KHR_8bit_storage",
6381     "VK_KHR_bind_memory2",
6382     "VK_KHR_buffer_device_address",
6383     "VK_KHR_copy_commands2",
6384     "VK_KHR_create_renderpass2",
6385     "VK_KHR_dedicated_allocation",
6386     "VK_KHR_depth_stencil_resolve",
6387     "VK_KHR_descriptor_update_template",
6388     "VK_KHR_device_group",
6389     "VK_KHR_draw_indirect_count",
6390     "VK_KHR_driver_properties",
6391     "VK_KHR_external_fence",
6392     "VK_KHR_external_memory",
6393     "VK_KHR_external_semaphore",
6394     "VK_KHR_fragment_shading_rate",
6395     "VK_KHR_get_memory_requirements2",
6396     "VK_KHR_image_format_list",
6397     "VK_KHR_imageless_framebuffer",
6398     "VK_KHR_incremental_present",
6399     "VK_KHR_maintenance1",
6400     "VK_KHR_maintenance2",
6401     "VK_KHR_maintenance3",
6402     "VK_KHR_multiview",
6403     "VK_KHR_performance_query",
6404     "VK_KHR_pipeline_executable_properties",
6405     "VK_KHR_push_descriptor",
6406     "VK_KHR_relaxed_block_layout",
6407     "VK_KHR_sampler_mirror_clamp_to_edge",
6408     "VK_KHR_sampler_ycbcr_conversion",
6409     "VK_KHR_separate_depth_stencil_layouts",
6410     "VK_KHR_shader_atomic_int64",
6411     "VK_KHR_shader_clock",
6412     "VK_KHR_shader_draw_parameters",
6413     "VK_KHR_shader_float16_int8",
6414     "VK_KHR_shader_float_controls",
6415     "VK_KHR_shader_non_semantic_info",
6416     "VK_KHR_shader_subgroup_extended_types",
6417     "VK_KHR_shader_terminate_invocation",
6418     "VK_KHR_spirv_1_4",
6419     "VK_KHR_storage_buffer_storage_class",
6420     "VK_KHR_swapchain",
6421     "VK_KHR_swapchain_mutable_format",
6422     "VK_KHR_timeline_semaphore",
6423     "VK_KHR_uniform_buffer_standard_layout",
6424     "VK_KHR_variable_pointers",
6425     "VK_KHR_vulkan_memory_model",
6426     "VK_NV_clip_space_w_scaling",
6427     "VK_NV_compute_shader_derivatives",
6428     "VK_NV_cooperative_matrix",
6429     "VK_NV_corner_sampled_image",
6430     "VK_NV_coverage_reduction_mode",
6431     "VK_NV_dedicated_allocation",
6432     "VK_NV_dedicated_allocation_image_aliasing",
6433     "VK_NV_device_diagnostic_checkpoints",
6434     "VK_NV_device_diagnostics_config",
6435     "VK_NV_device_generated_commands",
6436     "VK_NV_fill_rectangle",
6437     "VK_NV_fragment_coverage_to_color",
6438     "VK_NV_fragment_shader_barycentric",
6439     "VK_NV_framebuffer_mixed_samples",
6440     "VK_NV_geometry_shader_passthrough",
6441     "VK_NV_glsl_shader",
6442     "VK_NV_mesh_shader",
6443     "VK_NV_ray_tracing",
6444     "VK_NV_representative_fragment_test",
6445     "VK_NV_sample_mask_override_coverage",
6446     "VK_NV_scissor_exclusive",
6447     "VK_NV_shader_image_footprint",
6448     "VK_NV_shader_sm_builtins",
6449     "VK_NV_shader_subgroup_partitioned",
6450     "VK_NV_shading_rate_image",
6451     "VK_NV_viewport_array2",
6452     "VK_NV_viewport_swizzle",
6453     "VK_QCOM_render_pass_shader_resolve",
6454     "VK_QCOM_render_pass_store_ops",
6455     "VK_QCOM_render_pass_transform",
6456 };
6457
6458 static const char * const vk_instance_extensions[] =
6459 {
6460     "VK_EXT_debug_utils",
6461     "VK_EXT_headless_surface",
6462     "VK_EXT_swapchain_colorspace",
6463     "VK_KHR_device_group_creation",
6464     "VK_KHR_external_fence_capabilities",
6465     "VK_KHR_external_memory_capabilities",
6466     "VK_KHR_external_semaphore_capabilities",
6467     "VK_KHR_get_physical_device_properties2",
6468     "VK_KHR_get_surface_capabilities2",
6469     "VK_KHR_surface",
6470     "VK_KHR_win32_surface",
6471 };
6472
6473 BOOL wine_vk_device_extension_supported(const char *name)
6474 {
6475     unsigned int i;
6476     for (i = 0; i < ARRAY_SIZE(vk_device_extensions); i++)
6477     {
6478         if (strcmp(vk_device_extensions[i], name) == 0)
6479             return TRUE;
6480     }
6481     return FALSE;
6482 }
6483
6484 BOOL wine_vk_instance_extension_supported(const char *name)
6485 {
6486     unsigned int i;
6487     for (i = 0; i < ARRAY_SIZE(vk_instance_extensions); i++)
6488     {
6489         if (strcmp(vk_instance_extensions[i], name) == 0)
6490             return TRUE;
6491     }
6492     return FALSE;
6493 }
6494
6495 BOOL wine_vk_is_type_wrapped(VkObjectType type)
6496 {
6497     return FALSE ||
6498         type == VK_OBJECT_TYPE_COMMAND_BUFFER ||
6499         type == VK_OBJECT_TYPE_COMMAND_POOL ||
6500         type == VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT ||
6501         type == VK_OBJECT_TYPE_DEVICE ||
6502         type == VK_OBJECT_TYPE_INSTANCE ||
6503         type == VK_OBJECT_TYPE_PHYSICAL_DEVICE ||
6504         type == VK_OBJECT_TYPE_QUEUE;
6505 }
6506
6507 uint64_t wine_vk_unwrap_handle(VkObjectType type, uint64_t handle)
6508 {
6509     switch(type)
6510     {
6511     case VK_OBJECT_TYPE_COMMAND_BUFFER:
6512         return (uint64_t) (uintptr_t) ((VkCommandBuffer) (uintptr_t) handle)->command_buffer;
6513     case VK_OBJECT_TYPE_COMMAND_POOL:
6514         return (uint64_t) wine_cmd_pool_from_handle(handle)->command_pool;
6515     case VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT:
6516         return (uint64_t) wine_debug_utils_messenger_from_handle(handle)->debug_messenger;
6517     case VK_OBJECT_TYPE_DEVICE:
6518         return (uint64_t) (uintptr_t) ((VkDevice) (uintptr_t) handle)->device;
6519     case VK_OBJECT_TYPE_INSTANCE:
6520         return (uint64_t) (uintptr_t) ((VkInstance) (uintptr_t) handle)->instance;
6521     case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
6522         return (uint64_t) (uintptr_t) ((VkPhysicalDevice) (uintptr_t) handle)->phys_dev;
6523     case VK_OBJECT_TYPE_QUEUE:
6524         return (uint64_t) (uintptr_t) ((VkQueue) (uintptr_t) handle)->queue;
6525     default:
6526        return handle;
6527     }
6528 }