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