dlls/winevulkan/vulkan_thunks.c

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