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