dlls/winevulkan/vulkan_thunks.c

   1 /* Automatically generated from Vulkan vk.xml; DO NOT EDIT!
   2  *
   3  * This file is generated from Vulkan vk.xml file covered
   4  * by the following copyright and permission notice:
   5  *
   6  * Copyright (c) 2015-2019 The Khronos Group Inc.
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  * ---- Exceptions to the Apache 2.0 License: ----
  21  *
  22  * As an exception, if you use this Software to generate code and portions of
  23  * this Software are embedded into the generated code as a result, you may
  24  * redistribute such product without providing attribution as would otherwise
  25  * be required by Sections 4(a), 4(b) and 4(d) of the License.
  26  *
  27  * In addition, if you combine or link code generated by this Software with
  28  * software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1
  29  * ("`Combined Software`") and if a court of competent jurisdiction determines
  30  * that the patent provision (Section 3), the indemnity provision (Section 9)
  31  * or other Section of the License conflicts with the conditions of the
  32  * applicable GPL or LGPL license, you may retroactively and prospectively
  33  * choose to deem waived or otherwise exclude such Section(s) of the License,
  34  * but only in their entirety and only with respect to the Combined Software.
  35  *
  36  */
  37
  38 #include "config.h"
  39 #include "wine/port.h"
  40
  41 #include "vulkan_private.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
  44
  45 #if defined(USE_STRUCT_CONVERSION)
  46 static inline void convert_VkAcquireNextImageInfoKHR_win_to_host(const VkAcquireNextImageInfoKHR *in, VkAcquireNextImageInfoKHR_host *out)
  47 {
  48     if (!in) return;
  49
  50     out->sType = in->sType;
  51     out->pNext = in->pNext;
  52     out->swapchain = in->swapchain;
  53     out->timeout = in->timeout;
  54     out->semaphore = in->semaphore;
  55     out->fence = in->fence;
  56     out->deviceMask = in->deviceMask;
  57 }
  58
  59 static inline void convert_VkDescriptorSetAllocateInfo_win_to_host(const VkDescriptorSetAllocateInfo *in, VkDescriptorSetAllocateInfo_host *out)
  60 {
  61     if (!in) return;
  62
  63     out->sType = in->sType;
  64     out->pNext = in->pNext;
  65     out->descriptorPool = in->descriptorPool;
  66     out->descriptorSetCount = in->descriptorSetCount;
  67     out->pSetLayouts = in->pSetLayouts;
  68 }
  69
  70 static inline void convert_VkMemoryAllocateInfo_win_to_host(const VkMemoryAllocateInfo *in, VkMemoryAllocateInfo_host *out)
  71 {
  72     if (!in) return;
  73
  74     out->sType = in->sType;
  75     out->pNext = in->pNext;
  76     out->allocationSize = in->allocationSize;
  77     out->memoryTypeIndex = in->memoryTypeIndex;
  78 }
  79
  80 static inline VkCommandBufferInheritanceInfo_host *convert_VkCommandBufferInheritanceInfo_array_win_to_host(const VkCommandBufferInheritanceInfo *in, uint32_t count)
  81 {
  82     VkCommandBufferInheritanceInfo_host *out;
  83     unsigned int i;
  84
  85     if (!in) return NULL;
  86
  87     out = heap_alloc(count * sizeof(*out));
  88     for (i = 0; i < count; i++)
  89     {
  90         out[i].sType = in[i].sType;
  91         out[i].pNext = in[i].pNext;
  92         out[i].renderPass = in[i].renderPass;
  93         out[i].subpass = in[i].subpass;
  94         out[i].framebuffer = in[i].framebuffer;
  95         out[i].occlusionQueryEnable = in[i].occlusionQueryEnable;
  96         out[i].queryFlags = in[i].queryFlags;
  97         out[i].pipelineStatistics = in[i].pipelineStatistics;
  98     }
  99
 100     return out;
 101 }
 102
 103 static inline void free_VkCommandBufferInheritanceInfo_array(VkCommandBufferInheritanceInfo_host *in, uint32_t count)
 104 {
 105     if (!in) return;
 106
 107     heap_free(in);
 108 }
 109
 110 static inline void convert_VkCommandBufferBeginInfo_win_to_host(const VkCommandBufferBeginInfo *in, VkCommandBufferBeginInfo_host *out)
 111 {
 112     if (!in) return;
 113
 114     out->sType = in->sType;
 115     out->pNext = in->pNext;
 116     out->flags = in->flags;
 117     out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win_to_host(in->pInheritanceInfo, 1);
 118 }
 119
 120 static inline void free_VkCommandBufferBeginInfo(VkCommandBufferBeginInfo_host *in)
 121 {
 122     free_VkCommandBufferInheritanceInfo_array((VkCommandBufferInheritanceInfo_host *)in->pInheritanceInfo, 1);
 123 }
 124
 125 static inline VkBindAccelerationStructureMemoryInfoNV_host *convert_VkBindAccelerationStructureMemoryInfoNV_array_win_to_host(const VkBindAccelerationStructureMemoryInfoNV *in, uint32_t count)
 126 {
 127     VkBindAccelerationStructureMemoryInfoNV_host *out;
 128     unsigned int i;
 129
 130     if (!in) return NULL;
 131
 132     out = heap_alloc(count * sizeof(*out));
 133     for (i = 0; i < count; i++)
 134     {
 135         out[i].sType = in[i].sType;
 136         out[i].pNext = in[i].pNext;
 137         out[i].accelerationStructure = in[i].accelerationStructure;
 138         out[i].memory = in[i].memory;
 139         out[i].memoryOffset = in[i].memoryOffset;
 140         out[i].deviceIndexCount = in[i].deviceIndexCount;
 141         out[i].pDeviceIndices = in[i].pDeviceIndices;
 142     }
 143
 144     return out;
 145 }
 146
 147 static inline void free_VkBindAccelerationStructureMemoryInfoNV_array(VkBindAccelerationStructureMemoryInfoNV_host *in, uint32_t count)
 148 {
 149     if (!in) return;
 150
 151     heap_free(in);
 152 }
 153
 154 static inline VkBindBufferMemoryInfo_host *convert_VkBindBufferMemoryInfo_array_win_to_host(const VkBindBufferMemoryInfo *in, uint32_t count)
 155 {
 156     VkBindBufferMemoryInfo_host *out;
 157     unsigned int i;
 158
 159     if (!in) return NULL;
 160
 161     out = heap_alloc(count * sizeof(*out));
 162     for (i = 0; i < count; i++)
 163     {
 164         out[i].sType = in[i].sType;
 165         out[i].pNext = in[i].pNext;
 166         out[i].buffer = in[i].buffer;
 167         out[i].memory = in[i].memory;
 168         out[i].memoryOffset = in[i].memoryOffset;
 169     }
 170
 171     return out;
 172 }
 173
 174 static inline void free_VkBindBufferMemoryInfo_array(VkBindBufferMemoryInfo_host *in, uint32_t count)
 175 {
 176     if (!in) return;
 177
 178     heap_free(in);
 179 }
 180
 181 static inline VkBindImageMemoryInfo_host *convert_VkBindImageMemoryInfo_array_win_to_host(const VkBindImageMemoryInfo *in, uint32_t count)
 182 {
 183     VkBindImageMemoryInfo_host *out;
 184     unsigned int i;
 185
 186     if (!in) return NULL;
 187
 188     out = heap_alloc(count * sizeof(*out));
 189     for (i = 0; i < count; i++)
 190     {
 191         out[i].sType = in[i].sType;
 192         out[i].pNext = in[i].pNext;
 193         out[i].image = in[i].image;
 194         out[i].memory = in[i].memory;
 195         out[i].memoryOffset = in[i].memoryOffset;
 196     }
 197
 198     return out;
 199 }
 200
 201 static inline void free_VkBindImageMemoryInfo_array(VkBindImageMemoryInfo_host *in, uint32_t count)
 202 {
 203     if (!in) return;
 204
 205     heap_free(in);
 206 }
 207
 208 static inline void convert_VkConditionalRenderingBeginInfoEXT_win_to_host(const VkConditionalRenderingBeginInfoEXT *in, VkConditionalRenderingBeginInfoEXT_host *out)
 209 {
 210     if (!in) return;
 211
 212     out->sType = in->sType;
 213     out->pNext = in->pNext;
 214     out->buffer = in->buffer;
 215     out->offset = in->offset;
 216     out->flags = in->flags;
 217 }
 218
 219 static inline void convert_VkRenderPassBeginInfo_win_to_host(const VkRenderPassBeginInfo *in, VkRenderPassBeginInfo_host *out)
 220 {
 221     if (!in) return;
 222
 223     out->sType = in->sType;
 224     out->pNext = in->pNext;
 225     out->renderPass = in->renderPass;
 226     out->framebuffer = in->framebuffer;
 227     out->renderArea = in->renderArea;
 228     out->clearValueCount = in->clearValueCount;
 229     out->pClearValues = in->pClearValues;
 230 }
 231
 232 static inline void convert_VkGeometryTrianglesNV_win_to_host(const VkGeometryTrianglesNV *in, VkGeometryTrianglesNV_host *out)
 233 {
 234     if (!in) return;
 235
 236     out->sType = in->sType;
 237     out->pNext = in->pNext;
 238     out->vertexData = in->vertexData;
 239     out->vertexOffset = in->vertexOffset;
 240     out->vertexCount = in->vertexCount;
 241     out->vertexStride = in->vertexStride;
 242     out->vertexFormat = in->vertexFormat;
 243     out->indexData = in->indexData;
 244     out->indexOffset = in->indexOffset;
 245     out->indexCount = in->indexCount;
 246     out->indexType = in->indexType;
 247     out->transformData = in->transformData;
 248     out->transformOffset = in->transformOffset;
 249 }
 250
 251 static inline void convert_VkGeometryAABBNV_win_to_host(const VkGeometryAABBNV *in, VkGeometryAABBNV_host *out)
 252 {
 253     if (!in) return;
 254
 255     out->sType = in->sType;
 256     out->pNext = in->pNext;
 257     out->aabbData = in->aabbData;
 258     out->numAABBs = in->numAABBs;
 259     out->stride = in->stride;
 260     out->offset = in->offset;
 261 }
 262
 263 static inline void convert_VkGeometryDataNV_win_to_host(const VkGeometryDataNV *in, VkGeometryDataNV_host *out)
 264 {
 265     if (!in) return;
 266
 267     convert_VkGeometryTrianglesNV_win_to_host(&in->triangles, &out->triangles);
 268     convert_VkGeometryAABBNV_win_to_host(&in->aabbs, &out->aabbs);
 269 }
 270
 271 static inline VkGeometryNV_host *convert_VkGeometryNV_array_win_to_host(const VkGeometryNV *in, uint32_t count)
 272 {
 273     VkGeometryNV_host *out;
 274     unsigned int i;
 275
 276     if (!in) return NULL;
 277
 278     out = heap_alloc(count * sizeof(*out));
 279     for (i = 0; i < count; i++)
 280     {
 281         out[i].sType = in[i].sType;
 282         out[i].pNext = in[i].pNext;
 283         out[i].geometryType = in[i].geometryType;
 284         convert_VkGeometryDataNV_win_to_host(&in[i].geometry, &out[i].geometry);
 285         out[i].flags = in[i].flags;
 286     }
 287
 288     return out;
 289 }
 290
 291 static inline void free_VkGeometryNV_array(VkGeometryNV_host *in, uint32_t count)
 292 {
 293     if (!in) return;
 294
 295     heap_free(in);
 296 }
 297
 298 static inline void convert_VkAccelerationStructureInfoNV_win_to_host(const VkAccelerationStructureInfoNV *in, VkAccelerationStructureInfoNV_host *out)
 299 {
 300     if (!in) return;
 301
 302     out->sType = in->sType;
 303     out->pNext = in->pNext;
 304     out->type = in->type;
 305     out->flags = in->flags;
 306     out->instanceCount = in->instanceCount;
 307     out->geometryCount = in->geometryCount;
 308     out->pGeometries = convert_VkGeometryNV_array_win_to_host(in->pGeometries, in->geometryCount);
 309 }
 310
 311 static inline void free_VkAccelerationStructureInfoNV(VkAccelerationStructureInfoNV_host *in)
 312 {
 313     free_VkGeometryNV_array((VkGeometryNV_host *)in->pGeometries, in->geometryCount);
 314 }
 315
 316 static inline VkBufferCopy_host *convert_VkBufferCopy_array_win_to_host(const VkBufferCopy *in, uint32_t count)
 317 {
 318     VkBufferCopy_host *out;
 319     unsigned int i;
 320
 321     if (!in) return NULL;
 322
 323     out = heap_alloc(count * sizeof(*out));
 324     for (i = 0; i < count; i++)
 325     {
 326         out[i].srcOffset = in[i].srcOffset;
 327         out[i].dstOffset = in[i].dstOffset;
 328         out[i].size = in[i].size;
 329     }
 330
 331     return out;
 332 }
 333
 334 static inline void free_VkBufferCopy_array(VkBufferCopy_host *in, uint32_t count)
 335 {
 336     if (!in) return;
 337
 338     heap_free(in);
 339 }
 340
 341 static inline VkBufferImageCopy_host *convert_VkBufferImageCopy_array_win_to_host(const VkBufferImageCopy *in, uint32_t count)
 342 {
 343     VkBufferImageCopy_host *out;
 344     unsigned int i;
 345
 346     if (!in) return NULL;
 347
 348     out = heap_alloc(count * sizeof(*out));
 349     for (i = 0; i < count; i++)
 350     {
 351         out[i].bufferOffset = in[i].bufferOffset;
 352         out[i].bufferRowLength = in[i].bufferRowLength;
 353         out[i].bufferImageHeight = in[i].bufferImageHeight;
 354         out[i].imageSubresource = in[i].imageSubresource;
 355         out[i].imageOffset = in[i].imageOffset;
 356         out[i].imageExtent = in[i].imageExtent;
 357     }
 358
 359     return out;
 360 }
 361
 362 static inline void free_VkBufferImageCopy_array(VkBufferImageCopy_host *in, uint32_t count)
 363 {
 364     if (!in) return;
 365
 366     heap_free(in);
 367 }
 368
 369 static inline VkBufferMemoryBarrier_host *convert_VkBufferMemoryBarrier_array_win_to_host(const VkBufferMemoryBarrier *in, uint32_t count)
 370 {
 371     VkBufferMemoryBarrier_host *out;
 372     unsigned int i;
 373
 374     if (!in) return NULL;
 375
 376     out = heap_alloc(count * sizeof(*out));
 377     for (i = 0; i < count; i++)
 378     {
 379         out[i].sType = in[i].sType;
 380         out[i].pNext = in[i].pNext;
 381         out[i].srcAccessMask = in[i].srcAccessMask;
 382         out[i].dstAccessMask = in[i].dstAccessMask;
 383         out[i].srcQueueFamilyIndex = in[i].srcQueueFamilyIndex;
 384         out[i].dstQueueFamilyIndex = in[i].dstQueueFamilyIndex;
 385         out[i].buffer = in[i].buffer;
 386         out[i].offset = in[i].offset;
 387         out[i].size = in[i].size;
 388     }
 389
 390     return out;
 391 }
 392
 393 static inline void free_VkBufferMemoryBarrier_array(VkBufferMemoryBarrier_host *in, uint32_t count)
 394 {
 395     if (!in) return;
 396
 397     heap_free(in);
 398 }
 399
 400 static inline VkImageMemoryBarrier_host *convert_VkImageMemoryBarrier_array_win_to_host(const VkImageMemoryBarrier *in, uint32_t count)
 401 {
 402     VkImageMemoryBarrier_host *out;
 403     unsigned int i;
 404
 405     if (!in) return NULL;
 406
 407     out = heap_alloc(count * sizeof(*out));
 408     for (i = 0; i < count; i++)
 409     {
 410         out[i].sType = in[i].sType;
 411         out[i].pNext = in[i].pNext;
 412         out[i].srcAccessMask = in[i].srcAccessMask;
 413         out[i].dstAccessMask = in[i].dstAccessMask;
 414         out[i].oldLayout = in[i].oldLayout;
 415         out[i].newLayout = in[i].newLayout;
 416         out[i].srcQueueFamilyIndex = in[i].srcQueueFamilyIndex;
 417         out[i].dstQueueFamilyIndex = in[i].dstQueueFamilyIndex;
 418         out[i].image = in[i].image;
 419         out[i].subresourceRange = in[i].subresourceRange;
 420     }
 421
 422     return out;
 423 }
 424
 425 static inline void free_VkImageMemoryBarrier_array(VkImageMemoryBarrier_host *in, uint32_t count)
 426 {
 427     if (!in) return;
 428
 429     heap_free(in);
 430 }
 431
 432 static inline VkDescriptorImageInfo_host *convert_VkDescriptorImageInfo_array_win_to_host(const VkDescriptorImageInfo *in, uint32_t count)
 433 {
 434     VkDescriptorImageInfo_host *out;
 435     unsigned int i;
 436
 437     if (!in) return NULL;
 438
 439     out = heap_alloc(count * sizeof(*out));
 440     for (i = 0; i < count; i++)
 441     {
 442         out[i].sampler = in[i].sampler;
 443         out[i].imageView = in[i].imageView;
 444         out[i].imageLayout = in[i].imageLayout;
 445     }
 446
 447     return out;
 448 }
 449
 450 static inline void free_VkDescriptorImageInfo_array(VkDescriptorImageInfo_host *in, uint32_t count)
 451 {
 452     if (!in) return;
 453
 454     heap_free(in);
 455 }
 456
 457 static inline VkDescriptorBufferInfo_host *convert_VkDescriptorBufferInfo_array_win_to_host(const VkDescriptorBufferInfo *in, uint32_t count)
 458 {
 459     VkDescriptorBufferInfo_host *out;
 460     unsigned int i;
 461
 462     if (!in) return NULL;
 463
 464     out = heap_alloc(count * sizeof(*out));
 465     for (i = 0; i < count; i++)
 466     {
 467         out[i].buffer = in[i].buffer;
 468         out[i].offset = in[i].offset;
 469         out[i].range = in[i].range;
 470     }
 471
 472     return out;
 473 }
 474
 475 static inline void free_VkDescriptorBufferInfo_array(VkDescriptorBufferInfo_host *in, uint32_t count)
 476 {
 477     if (!in) return;
 478
 479     heap_free(in);
 480 }
 481
 482 static inline VkWriteDescriptorSet_host *convert_VkWriteDescriptorSet_array_win_to_host(const VkWriteDescriptorSet *in, uint32_t count)
 483 {
 484     VkWriteDescriptorSet_host *out;
 485     unsigned int i;
 486
 487     if (!in) return NULL;
 488
 489     out = heap_alloc(count * sizeof(*out));
 490     for (i = 0; i < count; i++)
 491     {
 492         out[i].sType = in[i].sType;
 493         out[i].pNext = in[i].pNext;
 494         out[i].dstSet = in[i].dstSet;
 495         out[i].dstBinding = in[i].dstBinding;
 496         out[i].dstArrayElement = in[i].dstArrayElement;
 497         out[i].descriptorCount = in[i].descriptorCount;
 498         out[i].descriptorType = in[i].descriptorType;
 499         out[i].pImageInfo = convert_VkDescriptorImageInfo_array_win_to_host(in[i].pImageInfo, in[i].descriptorCount);
 500         out[i].pBufferInfo = convert_VkDescriptorBufferInfo_array_win_to_host(in[i].pBufferInfo, in[i].descriptorCount);
 501         out[i].pTexelBufferView = in[i].pTexelBufferView;
 502     }
 503
 504     return out;
 505 }
 506
 507 static inline void free_VkWriteDescriptorSet_array(VkWriteDescriptorSet_host *in, uint32_t count)
 508 {
 509     unsigned int i;
 510
 511     if (!in) return;
 512
 513     for (i = 0; i < count; i++)
 514     {
 515         free_VkDescriptorImageInfo_array((VkDescriptorImageInfo_host *)in[i].pImageInfo, in[i].descriptorCount);
 516         free_VkDescriptorBufferInfo_array((VkDescriptorBufferInfo_host *)in[i].pBufferInfo, in[i].descriptorCount);
 517     }
 518     heap_free(in);
 519 }
 520
 521 static inline void convert_VkAccelerationStructureCreateInfoNV_win_to_host(const VkAccelerationStructureCreateInfoNV *in, VkAccelerationStructureCreateInfoNV_host *out)
 522 {
 523     if (!in) return;
 524
 525     out->sType = in->sType;
 526     out->pNext = in->pNext;
 527     out->compactedSize = in->compactedSize;
 528     convert_VkAccelerationStructureInfoNV_win_to_host(&in->info, &out->info);
 529 }
 530
 531 static inline void convert_VkBufferCreateInfo_win_to_host(const VkBufferCreateInfo *in, VkBufferCreateInfo_host *out)
 532 {
 533     if (!in) return;
 534
 535     out->sType = in->sType;
 536     out->pNext = in->pNext;
 537     out->flags = in->flags;
 538     out->size = in->size;
 539     out->usage = in->usage;
 540     out->sharingMode = in->sharingMode;
 541     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
 542     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
 543 }
 544
 545 static inline void convert_VkBufferViewCreateInfo_win_to_host(const VkBufferViewCreateInfo *in, VkBufferViewCreateInfo_host *out)
 546 {
 547     if (!in) return;
 548
 549     out->sType = in->sType;
 550     out->pNext = in->pNext;
 551     out->flags = in->flags;
 552     out->buffer = in->buffer;
 553     out->format = in->format;
 554     out->offset = in->offset;
 555     out->range = in->range;
 556 }
 557
 558 static inline void convert_VkPipelineShaderStageCreateInfo_win_to_host(const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo_host *out)
 559 {
 560     if (!in) return;
 561
 562     out->sType = in->sType;
 563     out->pNext = in->pNext;
 564     out->flags = in->flags;
 565     out->stage = in->stage;
 566     out->module = in->module;
 567     out->pName = in->pName;
 568     out->pSpecializationInfo = in->pSpecializationInfo;
 569 }
 570
 571 static inline VkComputePipelineCreateInfo_host *convert_VkComputePipelineCreateInfo_array_win_to_host(const VkComputePipelineCreateInfo *in, uint32_t count)
 572 {
 573     VkComputePipelineCreateInfo_host *out;
 574     unsigned int i;
 575
 576     if (!in) return NULL;
 577
 578     out = heap_alloc(count * sizeof(*out));
 579     for (i = 0; i < count; i++)
 580     {
 581         out[i].sType = in[i].sType;
 582         out[i].pNext = in[i].pNext;
 583         out[i].flags = in[i].flags;
 584         convert_VkPipelineShaderStageCreateInfo_win_to_host(&in[i].stage, &out[i].stage);
 585         out[i].layout = in[i].layout;
 586         out[i].basePipelineHandle = in[i].basePipelineHandle;
 587         out[i].basePipelineIndex = in[i].basePipelineIndex;
 588     }
 589
 590     return out;
 591 }
 592
 593 static inline void free_VkComputePipelineCreateInfo_array(VkComputePipelineCreateInfo_host *in, uint32_t count)
 594 {
 595     if (!in) return;
 596
 597     heap_free(in);
 598 }
 599
 600 static inline void convert_VkDescriptorUpdateTemplateCreateInfo_win_to_host(const VkDescriptorUpdateTemplateCreateInfo *in, VkDescriptorUpdateTemplateCreateInfo_host *out)
 601 {
 602     if (!in) return;
 603
 604     out->sType = in->sType;
 605     out->pNext = in->pNext;
 606     out->flags = in->flags;
 607     out->descriptorUpdateEntryCount = in->descriptorUpdateEntryCount;
 608     out->pDescriptorUpdateEntries = in->pDescriptorUpdateEntries;
 609     out->templateType = in->templateType;
 610     out->descriptorSetLayout = in->descriptorSetLayout;
 611     out->pipelineBindPoint = in->pipelineBindPoint;
 612     out->pipelineLayout = in->pipelineLayout;
 613     out->set = in->set;
 614 }
 615
 616 static inline void convert_VkFramebufferCreateInfo_win_to_host(const VkFramebufferCreateInfo *in, VkFramebufferCreateInfo_host *out)
 617 {
 618     if (!in) return;
 619
 620     out->sType = in->sType;
 621     out->pNext = in->pNext;
 622     out->flags = in->flags;
 623     out->renderPass = in->renderPass;
 624     out->attachmentCount = in->attachmentCount;
 625     out->pAttachments = in->pAttachments;
 626     out->width = in->width;
 627     out->height = in->height;
 628     out->layers = in->layers;
 629 }
 630
 631 static inline VkPipelineShaderStageCreateInfo_host *convert_VkPipelineShaderStageCreateInfo_array_win_to_host(const VkPipelineShaderStageCreateInfo *in, uint32_t count)
 632 {
 633     VkPipelineShaderStageCreateInfo_host *out;
 634     unsigned int i;
 635
 636     if (!in) return NULL;
 637
 638     out = heap_alloc(count * sizeof(*out));
 639     for (i = 0; i < count; i++)
 640     {
 641         out[i].sType = in[i].sType;
 642         out[i].pNext = in[i].pNext;
 643         out[i].flags = in[i].flags;
 644         out[i].stage = in[i].stage;
 645         out[i].module = in[i].module;
 646         out[i].pName = in[i].pName;
 647         out[i].pSpecializationInfo = in[i].pSpecializationInfo;
 648     }
 649
 650     return out;
 651 }
 652
 653 static inline void free_VkPipelineShaderStageCreateInfo_array(VkPipelineShaderStageCreateInfo_host *in, uint32_t count)
 654 {
 655     if (!in) return;
 656
 657     heap_free(in);
 658 }
 659
 660 static inline VkGraphicsPipelineCreateInfo_host *convert_VkGraphicsPipelineCreateInfo_array_win_to_host(const VkGraphicsPipelineCreateInfo *in, uint32_t count)
 661 {
 662     VkGraphicsPipelineCreateInfo_host *out;
 663     unsigned int i;
 664
 665     if (!in) return NULL;
 666
 667     out = heap_alloc(count * sizeof(*out));
 668     for (i = 0; i < count; i++)
 669     {
 670         out[i].sType = in[i].sType;
 671         out[i].pNext = in[i].pNext;
 672         out[i].flags = in[i].flags;
 673         out[i].stageCount = in[i].stageCount;
 674         out[i].pStages = convert_VkPipelineShaderStageCreateInfo_array_win_to_host(in[i].pStages, in[i].stageCount);
 675         out[i].pVertexInputState = in[i].pVertexInputState;
 676         out[i].pInputAssemblyState = in[i].pInputAssemblyState;
 677         out[i].pTessellationState = in[i].pTessellationState;
 678         out[i].pViewportState = in[i].pViewportState;
 679         out[i].pRasterizationState = in[i].pRasterizationState;
 680         out[i].pMultisampleState = in[i].pMultisampleState;
 681         out[i].pDepthStencilState = in[i].pDepthStencilState;
 682         out[i].pColorBlendState = in[i].pColorBlendState;
 683         out[i].pDynamicState = in[i].pDynamicState;
 684         out[i].layout = in[i].layout;
 685         out[i].renderPass = in[i].renderPass;
 686         out[i].subpass = in[i].subpass;
 687         out[i].basePipelineHandle = in[i].basePipelineHandle;
 688         out[i].basePipelineIndex = in[i].basePipelineIndex;
 689     }
 690
 691     return out;
 692 }
 693
 694 static inline void free_VkGraphicsPipelineCreateInfo_array(VkGraphicsPipelineCreateInfo_host *in, uint32_t count)
 695 {
 696     unsigned int i;
 697
 698     if (!in) return;
 699
 700     for (i = 0; i < count; i++)
 701     {
 702         free_VkPipelineShaderStageCreateInfo_array((VkPipelineShaderStageCreateInfo_host *)in[i].pStages, in[i].stageCount);
 703     }
 704     heap_free(in);
 705 }
 706
 707 static inline void convert_VkImageViewCreateInfo_win_to_host(const VkImageViewCreateInfo *in, VkImageViewCreateInfo_host *out)
 708 {
 709     if (!in) return;
 710
 711     out->sType = in->sType;
 712     out->pNext = in->pNext;
 713     out->flags = in->flags;
 714     out->image = in->image;
 715     out->viewType = in->viewType;
 716     out->format = in->format;
 717     out->components = in->components;
 718     out->subresourceRange = in->subresourceRange;
 719 }
 720
 721 static inline VkRayTracingPipelineCreateInfoNV_host *convert_VkRayTracingPipelineCreateInfoNV_array_win_to_host(const VkRayTracingPipelineCreateInfoNV *in, uint32_t count)
 722 {
 723     VkRayTracingPipelineCreateInfoNV_host *out;
 724     unsigned int i;
 725
 726     if (!in) return NULL;
 727
 728     out = heap_alloc(count * sizeof(*out));
 729     for (i = 0; i < count; i++)
 730     {
 731         out[i].sType = in[i].sType;
 732         out[i].pNext = in[i].pNext;
 733         out[i].flags = in[i].flags;
 734         out[i].stageCount = in[i].stageCount;
 735         out[i].pStages = convert_VkPipelineShaderStageCreateInfo_array_win_to_host(in[i].pStages, in[i].stageCount);
 736         out[i].groupCount = in[i].groupCount;
 737         out[i].pGroups = in[i].pGroups;
 738         out[i].maxRecursionDepth = in[i].maxRecursionDepth;
 739         out[i].layout = in[i].layout;
 740         out[i].basePipelineHandle = in[i].basePipelineHandle;
 741         out[i].basePipelineIndex = in[i].basePipelineIndex;
 742     }
 743
 744     return out;
 745 }
 746
 747 static inline void free_VkRayTracingPipelineCreateInfoNV_array(VkRayTracingPipelineCreateInfoNV_host *in, uint32_t count)
 748 {
 749     unsigned int i;
 750
 751     if (!in) return;
 752
 753     for (i = 0; i < count; i++)
 754     {
 755         free_VkPipelineShaderStageCreateInfo_array((VkPipelineShaderStageCreateInfo_host *)in[i].pStages, in[i].stageCount);
 756     }
 757     heap_free(in);
 758 }
 759
 760 static inline void convert_VkSwapchainCreateInfoKHR_win_to_host(const VkSwapchainCreateInfoKHR *in, VkSwapchainCreateInfoKHR_host *out)
 761 {
 762     if (!in) return;
 763
 764     out->sType = in->sType;
 765     out->pNext = in->pNext;
 766     out->flags = in->flags;
 767     out->surface = in->surface;
 768     out->minImageCount = in->minImageCount;
 769     out->imageFormat = in->imageFormat;
 770     out->imageColorSpace = in->imageColorSpace;
 771     out->imageExtent = in->imageExtent;
 772     out->imageArrayLayers = in->imageArrayLayers;
 773     out->imageUsage = in->imageUsage;
 774     out->imageSharingMode = in->imageSharingMode;
 775     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
 776     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
 777     out->preTransform = in->preTransform;
 778     out->compositeAlpha = in->compositeAlpha;
 779     out->presentMode = in->presentMode;
 780     out->clipped = in->clipped;
 781     out->oldSwapchain = in->oldSwapchain;
 782 }
 783
 784 static inline VkMappedMemoryRange_host *convert_VkMappedMemoryRange_array_win_to_host(const VkMappedMemoryRange *in, uint32_t count)
 785 {
 786     VkMappedMemoryRange_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].sType = in[i].sType;
 795         out[i].pNext = in[i].pNext;
 796         out[i].memory = in[i].memory;
 797         out[i].offset = in[i].offset;
 798         out[i].size = in[i].size;
 799     }
 800
 801     return out;
 802 }
 803
 804 static inline void free_VkMappedMemoryRange_array(VkMappedMemoryRange_host *in, uint32_t count)
 805 {
 806     if (!in) return;
 807
 808     heap_free(in);
 809 }
 810
 811 static inline void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win_to_host(const VkAccelerationStructureMemoryRequirementsInfoNV *in, VkAccelerationStructureMemoryRequirementsInfoNV_host *out)
 812 {
 813     if (!in) return;
 814
 815     out->sType = in->sType;
 816     out->pNext = in->pNext;
 817     out->type = in->type;
 818     out->accelerationStructure = in->accelerationStructure;
 819 }
 820
 821 static inline void convert_VkMemoryRequirements_host_to_win(const VkMemoryRequirements_host *in, VkMemoryRequirements *out)
 822 {
 823     if (!in) return;
 824
 825     out->size = in->size;
 826     out->alignment = in->alignment;
 827     out->memoryTypeBits = in->memoryTypeBits;
 828 }
 829
 830 static inline void convert_VkMemoryRequirements2KHR_win_to_host(const VkMemoryRequirements2KHR *in, VkMemoryRequirements2KHR_host *out)
 831 {
 832     if (!in) return;
 833
 834     out->pNext = in->pNext;
 835     out->sType = in->sType;
 836 }
 837
 838 static inline void convert_VkMemoryRequirements2KHR_host_to_win(const VkMemoryRequirements2KHR_host *in, VkMemoryRequirements2KHR *out)
 839 {
 840     if (!in) return;
 841
 842     out->sType = in->sType;
 843     out->pNext = in->pNext;
 844     convert_VkMemoryRequirements_host_to_win(&in->memoryRequirements, &out->memoryRequirements);
 845 }
 846
 847 static inline void convert_VkBufferDeviceAddressInfoEXT_win_to_host(const VkBufferDeviceAddressInfoEXT *in, VkBufferDeviceAddressInfoEXT_host *out)
 848 {
 849     if (!in) return;
 850
 851     out->sType = in->sType;
 852     out->pNext = in->pNext;
 853     out->buffer = in->buffer;
 854 }
 855
 856 static inline void convert_VkBufferMemoryRequirementsInfo2_win_to_host(const VkBufferMemoryRequirementsInfo2 *in, VkBufferMemoryRequirementsInfo2_host *out)
 857 {
 858     if (!in) return;
 859
 860     out->sType = in->sType;
 861     out->pNext = in->pNext;
 862     out->buffer = in->buffer;
 863 }
 864
 865 static inline void convert_VkMemoryRequirements2_win_to_host(const VkMemoryRequirements2 *in, VkMemoryRequirements2_host *out)
 866 {
 867     if (!in) return;
 868
 869     out->pNext = in->pNext;
 870     out->sType = in->sType;
 871 }
 872
 873 static inline void convert_VkMemoryRequirements2_host_to_win(const VkMemoryRequirements2_host *in, VkMemoryRequirements2 *out)
 874 {
 875     if (!in) return;
 876
 877     out->sType = in->sType;
 878     out->pNext = in->pNext;
 879     convert_VkMemoryRequirements_host_to_win(&in->memoryRequirements, &out->memoryRequirements);
 880 }
 881
 882 static inline void convert_VkImageMemoryRequirementsInfo2_win_to_host(const VkImageMemoryRequirementsInfo2 *in, VkImageMemoryRequirementsInfo2_host *out)
 883 {
 884     if (!in) return;
 885
 886     out->sType = in->sType;
 887     out->pNext = in->pNext;
 888     out->image = in->image;
 889 }
 890
 891 static inline void convert_VkImageSparseMemoryRequirementsInfo2_win_to_host(const VkImageSparseMemoryRequirementsInfo2 *in, VkImageSparseMemoryRequirementsInfo2_host *out)
 892 {
 893     if (!in) return;
 894
 895     out->sType = in->sType;
 896     out->pNext = in->pNext;
 897     out->image = in->image;
 898 }
 899
 900 static inline void convert_VkSubresourceLayout_host_to_win(const VkSubresourceLayout_host *in, VkSubresourceLayout *out)
 901 {
 902     if (!in) return;
 903
 904     out->offset = in->offset;
 905     out->size = in->size;
 906     out->rowPitch = in->rowPitch;
 907     out->arrayPitch = in->arrayPitch;
 908     out->depthPitch = in->depthPitch;
 909 }
 910
 911 static inline void convert_VkImageFormatProperties_host_to_win(const VkImageFormatProperties_host *in, VkImageFormatProperties *out)
 912 {
 913     if (!in) return;
 914
 915     out->maxExtent = in->maxExtent;
 916     out->maxMipLevels = in->maxMipLevels;
 917     out->maxArrayLayers = in->maxArrayLayers;
 918     out->sampleCounts = in->sampleCounts;
 919     out->maxResourceSize = in->maxResourceSize;
 920 }
 921
 922 static inline void convert_VkImageFormatProperties2_win_to_host(const VkImageFormatProperties2 *in, VkImageFormatProperties2_host *out)
 923 {
 924     if (!in) return;
 925
 926     out->pNext = in->pNext;
 927     out->sType = in->sType;
 928 }
 929
 930 static inline void convert_VkImageFormatProperties2_host_to_win(const VkImageFormatProperties2_host *in, VkImageFormatProperties2 *out)
 931 {
 932     if (!in) return;
 933
 934     out->sType = in->sType;
 935     out->pNext = in->pNext;
 936     convert_VkImageFormatProperties_host_to_win(&in->imageFormatProperties, &out->imageFormatProperties);
 937 }
 938
 939 static inline void convert_VkMemoryHeap_static_array_host_to_win(const VkMemoryHeap_host *in, VkMemoryHeap *out, uint32_t count)
 940 {
 941     unsigned int i;
 942
 943     if (!in) return;
 944
 945     for (i = 0; i < count; i++)
 946     {
 947         out[i].size = in[i].size;
 948         out[i].flags = in[i].flags;
 949     }
 950 }
 951
 952 static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win(const VkPhysicalDeviceMemoryProperties_host *in, VkPhysicalDeviceMemoryProperties *out)
 953 {
 954     if (!in) return;
 955
 956     out->memoryTypeCount = in->memoryTypeCount;
 957     memcpy(out->memoryTypes, in->memoryTypes, VK_MAX_MEMORY_TYPES * sizeof(VkMemoryType));
 958     out->memoryHeapCount = in->memoryHeapCount;
 959     convert_VkMemoryHeap_static_array_host_to_win(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
 960 }
 961
 962 static inline void convert_VkPhysicalDeviceMemoryProperties2_win_to_host(const VkPhysicalDeviceMemoryProperties2 *in, VkPhysicalDeviceMemoryProperties2_host *out)
 963 {
 964     if (!in) return;
 965
 966     out->pNext = in->pNext;
 967     out->sType = in->sType;
 968 }
 969
 970 static inline void convert_VkPhysicalDeviceMemoryProperties2_host_to_win(const VkPhysicalDeviceMemoryProperties2_host *in, VkPhysicalDeviceMemoryProperties2 *out)
 971 {
 972     if (!in) return;
 973
 974     out->sType = in->sType;
 975     out->pNext = in->pNext;
 976     convert_VkPhysicalDeviceMemoryProperties_host_to_win(&in->memoryProperties, &out->memoryProperties);
 977 }
 978
 979 static inline void convert_VkPhysicalDeviceLimits_host_to_win(const VkPhysicalDeviceLimits_host *in, VkPhysicalDeviceLimits *out)
 980 {
 981     if (!in) return;
 982
 983     out->maxImageDimension1D = in->maxImageDimension1D;
 984     out->maxImageDimension2D = in->maxImageDimension2D;
 985     out->maxImageDimension3D = in->maxImageDimension3D;
 986     out->maxImageDimensionCube = in->maxImageDimensionCube;
 987     out->maxImageArrayLayers = in->maxImageArrayLayers;
 988     out->maxTexelBufferElements = in->maxTexelBufferElements;
 989     out->maxUniformBufferRange = in->maxUniformBufferRange;
 990     out->maxStorageBufferRange = in->maxStorageBufferRange;
 991     out->maxPushConstantsSize = in->maxPushConstantsSize;
 992     out->maxMemoryAllocationCount = in->maxMemoryAllocationCount;
 993     out->maxSamplerAllocationCount = in->maxSamplerAllocationCount;
 994     out->bufferImageGranularity = in->bufferImageGranularity;
 995     out->sparseAddressSpaceSize = in->sparseAddressSpaceSize;
 996     out->maxBoundDescriptorSets = in->maxBoundDescriptorSets;
 997     out->maxPerStageDescriptorSamplers = in->maxPerStageDescriptorSamplers;
 998     out->maxPerStageDescriptorUniformBuffers = in->maxPerStageDescriptorUniformBuffers;
 999     out->maxPerStageDescriptorStorageBuffers = in->maxPerStageDescriptorStorageBuffers;
1000     out->maxPerStageDescriptorSampledImages = in->maxPerStageDescriptorSampledImages;
1001     out->maxPerStageDescriptorStorageImages = in->maxPerStageDescriptorStorageImages;
1002     out->maxPerStageDescriptorInputAttachments = in->maxPerStageDescriptorInputAttachments;
1003     out->maxPerStageResources = in->maxPerStageResources;
1004     out->maxDescriptorSetSamplers = in->maxDescriptorSetSamplers;
1005     out->maxDescriptorSetUniformBuffers = in->maxDescriptorSetUniformBuffers;
1006     out->maxDescriptorSetUniformBuffersDynamic = in->maxDescriptorSetUniformBuffersDynamic;
1007     out->maxDescriptorSetStorageBuffers = in->maxDescriptorSetStorageBuffers;
1008     out->maxDescriptorSetStorageBuffersDynamic = in->maxDescriptorSetStorageBuffersDynamic;
1009     out->maxDescriptorSetSampledImages = in->maxDescriptorSetSampledImages;
1010     out->maxDescriptorSetStorageImages = in->maxDescriptorSetStorageImages;
1011     out->maxDescriptorSetInputAttachments = in->maxDescriptorSetInputAttachments;
1012     out->maxVertexInputAttributes = in->maxVertexInputAttributes;
1013     out->maxVertexInputBindings = in->maxVertexInputBindings;
1014     out->maxVertexInputAttributeOffset = in->maxVertexInputAttributeOffset;
1015     out->maxVertexInputBindingStride = in->maxVertexInputBindingStride;
1016     out->maxVertexOutputComponents = in->maxVertexOutputComponents;
1017     out->maxTessellationGenerationLevel = in->maxTessellationGenerationLevel;
1018     out->maxTessellationPatchSize = in->maxTessellationPatchSize;
1019     out->maxTessellationControlPerVertexInputComponents = in->maxTessellationControlPerVertexInputComponents;
1020     out->maxTessellationControlPerVertexOutputComponents = in->maxTessellationControlPerVertexOutputComponents;
1021     out->maxTessellationControlPerPatchOutputComponents = in->maxTessellationControlPerPatchOutputComponents;
1022     out->maxTessellationControlTotalOutputComponents = in->maxTessellationControlTotalOutputComponents;
1023     out->maxTessellationEvaluationInputComponents = in->maxTessellationEvaluationInputComponents;
1024     out->maxTessellationEvaluationOutputComponents = in->maxTessellationEvaluationOutputComponents;
1025     out->maxGeometryShaderInvocations = in->maxGeometryShaderInvocations;
1026     out->maxGeometryInputComponents = in->maxGeometryInputComponents;
1027     out->maxGeometryOutputComponents = in->maxGeometryOutputComponents;
1028     out->maxGeometryOutputVertices = in->maxGeometryOutputVertices;
1029     out->maxGeometryTotalOutputComponents = in->maxGeometryTotalOutputComponents;
1030     out->maxFragmentInputComponents = in->maxFragmentInputComponents;
1031     out->maxFragmentOutputAttachments = in->maxFragmentOutputAttachments;
1032     out->maxFragmentDualSrcAttachments = in->maxFragmentDualSrcAttachments;
1033     out->maxFragmentCombinedOutputResources = in->maxFragmentCombinedOutputResources;
1034     out->maxComputeSharedMemorySize = in->maxComputeSharedMemorySize;
1035     memcpy(out->maxComputeWorkGroupCount, in->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
1036     out->maxComputeWorkGroupInvocations = in->maxComputeWorkGroupInvocations;
1037     memcpy(out->maxComputeWorkGroupSize, in->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
1038     out->subPixelPrecisionBits = in->subPixelPrecisionBits;
1039     out->subTexelPrecisionBits = in->subTexelPrecisionBits;
1040     out->mipmapPrecisionBits = in->mipmapPrecisionBits;
1041     out->maxDrawIndexedIndexValue = in->maxDrawIndexedIndexValue;
1042     out->maxDrawIndirectCount = in->maxDrawIndirectCount;
1043     out->maxSamplerLodBias = in->maxSamplerLodBias;
1044     out->maxSamplerAnisotropy = in->maxSamplerAnisotropy;
1045     out->maxViewports = in->maxViewports;
1046     memcpy(out->maxViewportDimensions, in->maxViewportDimensions, 2 * sizeof(uint32_t));
1047     memcpy(out->viewportBoundsRange, in->viewportBoundsRange, 2 * sizeof(float));
1048     out->viewportSubPixelBits = in->viewportSubPixelBits;
1049     out->minMemoryMapAlignment = in->minMemoryMapAlignment;
1050     out->minTexelBufferOffsetAlignment = in->minTexelBufferOffsetAlignment;
1051     out->minUniformBufferOffsetAlignment = in->minUniformBufferOffsetAlignment;
1052     out->minStorageBufferOffsetAlignment = in->minStorageBufferOffsetAlignment;
1053     out->minTexelOffset = in->minTexelOffset;
1054     out->maxTexelOffset = in->maxTexelOffset;
1055     out->minTexelGatherOffset = in->minTexelGatherOffset;
1056     out->maxTexelGatherOffset = in->maxTexelGatherOffset;
1057     out->minInterpolationOffset = in->minInterpolationOffset;
1058     out->maxInterpolationOffset = in->maxInterpolationOffset;
1059     out->subPixelInterpolationOffsetBits = in->subPixelInterpolationOffsetBits;
1060     out->maxFramebufferWidth = in->maxFramebufferWidth;
1061     out->maxFramebufferHeight = in->maxFramebufferHeight;
1062     out->maxFramebufferLayers = in->maxFramebufferLayers;
1063     out->framebufferColorSampleCounts = in->framebufferColorSampleCounts;
1064     out->framebufferDepthSampleCounts = in->framebufferDepthSampleCounts;
1065     out->framebufferStencilSampleCounts = in->framebufferStencilSampleCounts;
1066     out->framebufferNoAttachmentsSampleCounts = in->framebufferNoAttachmentsSampleCounts;
1067     out->maxColorAttachments = in->maxColorAttachments;
1068     out->sampledImageColorSampleCounts = in->sampledImageColorSampleCounts;
1069     out->sampledImageIntegerSampleCounts = in->sampledImageIntegerSampleCounts;
1070     out->sampledImageDepthSampleCounts = in->sampledImageDepthSampleCounts;
1071     out->sampledImageStencilSampleCounts = in->sampledImageStencilSampleCounts;
1072     out->storageImageSampleCounts = in->storageImageSampleCounts;
1073     out->maxSampleMaskWords = in->maxSampleMaskWords;
1074     out->timestampComputeAndGraphics = in->timestampComputeAndGraphics;
1075     out->timestampPeriod = in->timestampPeriod;
1076     out->maxClipDistances = in->maxClipDistances;
1077     out->maxCullDistances = in->maxCullDistances;
1078     out->maxCombinedClipAndCullDistances = in->maxCombinedClipAndCullDistances;
1079     out->discreteQueuePriorities = in->discreteQueuePriorities;
1080     memcpy(out->pointSizeRange, in->pointSizeRange, 2 * sizeof(float));
1081     memcpy(out->lineWidthRange, in->lineWidthRange, 2 * sizeof(float));
1082     out->pointSizeGranularity = in->pointSizeGranularity;
1083     out->lineWidthGranularity = in->lineWidthGranularity;
1084     out->strictLines = in->strictLines;
1085     out->standardSampleLocations = in->standardSampleLocations;
1086     out->optimalBufferCopyOffsetAlignment = in->optimalBufferCopyOffsetAlignment;
1087     out->optimalBufferCopyRowPitchAlignment = in->optimalBufferCopyRowPitchAlignment;
1088     out->nonCoherentAtomSize = in->nonCoherentAtomSize;
1089 }
1090
1091 static inline void convert_VkPhysicalDeviceProperties_host_to_win(const VkPhysicalDeviceProperties_host *in, VkPhysicalDeviceProperties *out)
1092 {
1093     if (!in) return;
1094
1095     out->apiVersion = in->apiVersion;
1096     out->driverVersion = in->driverVersion;
1097     out->vendorID = in->vendorID;
1098     out->deviceID = in->deviceID;
1099     out->deviceType = in->deviceType;
1100     memcpy(out->deviceName, in->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
1101     memcpy(out->pipelineCacheUUID, in->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
1102     convert_VkPhysicalDeviceLimits_host_to_win(&in->limits, &out->limits);
1103     out->sparseProperties = in->sparseProperties;
1104 }
1105
1106 static inline void convert_VkPhysicalDeviceProperties2_win_to_host(const VkPhysicalDeviceProperties2 *in, VkPhysicalDeviceProperties2_host *out)
1107 {
1108     if (!in) return;
1109
1110     out->pNext = in->pNext;
1111     out->sType = in->sType;
1112 }
1113
1114 static inline void convert_VkPhysicalDeviceProperties2_host_to_win(const VkPhysicalDeviceProperties2_host *in, VkPhysicalDeviceProperties2 *out)
1115 {
1116     if (!in) return;
1117
1118     out->sType = in->sType;
1119     out->pNext = in->pNext;
1120     convert_VkPhysicalDeviceProperties_host_to_win(&in->properties, &out->properties);
1121 }
1122
1123 static inline VkSparseMemoryBind_host *convert_VkSparseMemoryBind_array_win_to_host(const VkSparseMemoryBind *in, uint32_t count)
1124 {
1125     VkSparseMemoryBind_host *out;
1126     unsigned int i;
1127
1128     if (!in) return NULL;
1129
1130     out = heap_alloc(count * sizeof(*out));
1131     for (i = 0; i < count; i++)
1132     {
1133         out[i].resourceOffset = in[i].resourceOffset;
1134         out[i].size = in[i].size;
1135         out[i].memory = in[i].memory;
1136         out[i].memoryOffset = in[i].memoryOffset;
1137         out[i].flags = in[i].flags;
1138     }
1139
1140     return out;
1141 }
1142
1143 static inline void free_VkSparseMemoryBind_array(VkSparseMemoryBind_host *in, uint32_t count)
1144 {
1145     if (!in) return;
1146
1147     heap_free(in);
1148 }
1149
1150 static inline VkSparseBufferMemoryBindInfo_host *convert_VkSparseBufferMemoryBindInfo_array_win_to_host(const VkSparseBufferMemoryBindInfo *in, uint32_t count)
1151 {
1152     VkSparseBufferMemoryBindInfo_host *out;
1153     unsigned int i;
1154
1155     if (!in) return NULL;
1156
1157     out = heap_alloc(count * sizeof(*out));
1158     for (i = 0; i < count; i++)
1159     {
1160         out[i].buffer = in[i].buffer;
1161         out[i].bindCount = in[i].bindCount;
1162         out[i].pBinds = convert_VkSparseMemoryBind_array_win_to_host(in[i].pBinds, in[i].bindCount);
1163     }
1164
1165     return out;
1166 }
1167
1168 static inline void free_VkSparseBufferMemoryBindInfo_array(VkSparseBufferMemoryBindInfo_host *in, uint32_t count)
1169 {
1170     unsigned int i;
1171
1172     if (!in) return;
1173
1174     for (i = 0; i < count; i++)
1175     {
1176         free_VkSparseMemoryBind_array((VkSparseMemoryBind_host *)in[i].pBinds, in[i].bindCount);
1177     }
1178     heap_free(in);
1179 }
1180
1181 static inline VkSparseImageOpaqueMemoryBindInfo_host *convert_VkSparseImageOpaqueMemoryBindInfo_array_win_to_host(const VkSparseImageOpaqueMemoryBindInfo *in, uint32_t count)
1182 {
1183     VkSparseImageOpaqueMemoryBindInfo_host *out;
1184     unsigned int i;
1185
1186     if (!in) return NULL;
1187
1188     out = heap_alloc(count * sizeof(*out));
1189     for (i = 0; i < count; i++)
1190     {
1191         out[i].image = in[i].image;
1192         out[i].bindCount = in[i].bindCount;
1193         out[i].pBinds = convert_VkSparseMemoryBind_array_win_to_host(in[i].pBinds, in[i].bindCount);
1194     }
1195
1196     return out;
1197 }
1198
1199 static inline void free_VkSparseImageOpaqueMemoryBindInfo_array(VkSparseImageOpaqueMemoryBindInfo_host *in, uint32_t count)
1200 {
1201     unsigned int i;
1202
1203     if (!in) return;
1204
1205     for (i = 0; i < count; i++)
1206     {
1207         free_VkSparseMemoryBind_array((VkSparseMemoryBind_host *)in[i].pBinds, in[i].bindCount);
1208     }
1209     heap_free(in);
1210 }
1211
1212 static inline VkSparseImageMemoryBind_host *convert_VkSparseImageMemoryBind_array_win_to_host(const VkSparseImageMemoryBind *in, uint32_t count)
1213 {
1214     VkSparseImageMemoryBind_host *out;
1215     unsigned int i;
1216
1217     if (!in) return NULL;
1218
1219     out = heap_alloc(count * sizeof(*out));
1220     for (i = 0; i < count; i++)
1221     {
1222         out[i].subresource = in[i].subresource;
1223         out[i].offset = in[i].offset;
1224         out[i].extent = in[i].extent;
1225         out[i].memory = in[i].memory;
1226         out[i].memoryOffset = in[i].memoryOffset;
1227         out[i].flags = in[i].flags;
1228     }
1229
1230     return out;
1231 }
1232
1233 static inline void free_VkSparseImageMemoryBind_array(VkSparseImageMemoryBind_host *in, uint32_t count)
1234 {
1235     if (!in) return;
1236
1237     heap_free(in);
1238 }
1239
1240 static inline VkSparseImageMemoryBindInfo_host *convert_VkSparseImageMemoryBindInfo_array_win_to_host(const VkSparseImageMemoryBindInfo *in, uint32_t count)
1241 {
1242     VkSparseImageMemoryBindInfo_host *out;
1243     unsigned int i;
1244
1245     if (!in) return NULL;
1246
1247     out = heap_alloc(count * sizeof(*out));
1248     for (i = 0; i < count; i++)
1249     {
1250         out[i].image = in[i].image;
1251         out[i].bindCount = in[i].bindCount;
1252         out[i].pBinds = convert_VkSparseImageMemoryBind_array_win_to_host(in[i].pBinds, in[i].bindCount);
1253     }
1254
1255     return out;
1256 }
1257
1258 static inline void free_VkSparseImageMemoryBindInfo_array(VkSparseImageMemoryBindInfo_host *in, uint32_t count)
1259 {
1260     unsigned int i;
1261
1262     if (!in) return;
1263
1264     for (i = 0; i < count; i++)
1265     {
1266         free_VkSparseImageMemoryBind_array((VkSparseImageMemoryBind_host *)in[i].pBinds, in[i].bindCount);
1267     }
1268     heap_free(in);
1269 }
1270
1271 static inline VkBindSparseInfo_host *convert_VkBindSparseInfo_array_win_to_host(const VkBindSparseInfo *in, uint32_t count)
1272 {
1273     VkBindSparseInfo_host *out;
1274     unsigned int i;
1275
1276     if (!in) return NULL;
1277
1278     out = heap_alloc(count * sizeof(*out));
1279     for (i = 0; i < count; i++)
1280     {
1281         out[i].sType = in[i].sType;
1282         out[i].pNext = in[i].pNext;
1283         out[i].waitSemaphoreCount = in[i].waitSemaphoreCount;
1284         out[i].pWaitSemaphores = in[i].pWaitSemaphores;
1285         out[i].bufferBindCount = in[i].bufferBindCount;
1286         out[i].pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win_to_host(in[i].pBufferBinds, in[i].bufferBindCount);
1287         out[i].imageOpaqueBindCount = in[i].imageOpaqueBindCount;
1288         out[i].pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win_to_host(in[i].pImageOpaqueBinds, in[i].imageOpaqueBindCount);
1289         out[i].imageBindCount = in[i].imageBindCount;
1290         out[i].pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win_to_host(in[i].pImageBinds, in[i].imageBindCount);
1291         out[i].signalSemaphoreCount = in[i].signalSemaphoreCount;
1292         out[i].pSignalSemaphores = in[i].pSignalSemaphores;
1293     }
1294
1295     return out;
1296 }
1297
1298 static inline void free_VkBindSparseInfo_array(VkBindSparseInfo_host *in, uint32_t count)
1299 {
1300     unsigned int i;
1301
1302     if (!in) return;
1303
1304     for (i = 0; i < count; i++)
1305     {
1306         free_VkSparseBufferMemoryBindInfo_array((VkSparseBufferMemoryBindInfo_host *)in[i].pBufferBinds, in[i].bufferBindCount);
1307         free_VkSparseImageOpaqueMemoryBindInfo_array((VkSparseImageOpaqueMemoryBindInfo_host *)in[i].pImageOpaqueBinds, in[i].imageOpaqueBindCount);
1308         free_VkSparseImageMemoryBindInfo_array((VkSparseImageMemoryBindInfo_host *)in[i].pImageBinds, in[i].imageBindCount);
1309     }
1310     heap_free(in);
1311 }
1312
1313 static inline VkCopyDescriptorSet_host *convert_VkCopyDescriptorSet_array_win_to_host(const VkCopyDescriptorSet *in, uint32_t count)
1314 {
1315     VkCopyDescriptorSet_host *out;
1316     unsigned int i;
1317
1318     if (!in) return NULL;
1319
1320     out = heap_alloc(count * sizeof(*out));
1321     for (i = 0; i < count; i++)
1322     {
1323         out[i].sType = in[i].sType;
1324         out[i].pNext = in[i].pNext;
1325         out[i].srcSet = in[i].srcSet;
1326         out[i].srcBinding = in[i].srcBinding;
1327         out[i].srcArrayElement = in[i].srcArrayElement;
1328         out[i].dstSet = in[i].dstSet;
1329         out[i].dstBinding = in[i].dstBinding;
1330         out[i].dstArrayElement = in[i].dstArrayElement;
1331         out[i].descriptorCount = in[i].descriptorCount;
1332     }
1333
1334     return out;
1335 }
1336
1337 static inline void free_VkCopyDescriptorSet_array(VkCopyDescriptorSet_host *in, uint32_t count)
1338 {
1339     if (!in) return;
1340
1341     heap_free(in);
1342 }
1343
1344 #endif /* USE_STRUCT_CONVERSION */
1345
1346 VkResult WINAPI wine_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
1347 {
1348 #if defined(USE_STRUCT_CONVERSION)
1349     VkResult result;
1350     VkAcquireNextImageInfoKHR_host pAcquireInfo_host;
1351     TRACE("%p, %p, %p\n", device, pAcquireInfo, pImageIndex);
1352
1353     convert_VkAcquireNextImageInfoKHR_win_to_host(pAcquireInfo, &pAcquireInfo_host);
1354     result = device->funcs.p_vkAcquireNextImage2KHR(device->device, &pAcquireInfo_host, pImageIndex);
1355
1356     return result;
1357 #else
1358     TRACE("%p, %p, %p\n", device, pAcquireInfo, pImageIndex);
1359     return device->funcs.p_vkAcquireNextImage2KHR(device->device, pAcquireInfo, pImageIndex);
1360 #endif
1361 }
1362
1363 VkResult WINAPI wine_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
1364 {
1365     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);
1366     return device->funcs.p_vkAcquireNextImageKHR(device->device, swapchain, timeout, semaphore, fence, pImageIndex);
1367 }
1368
1369 VkResult WINAPI wine_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
1370 {
1371 #if defined(USE_STRUCT_CONVERSION)
1372     VkResult result;
1373     VkDescriptorSetAllocateInfo_host pAllocateInfo_host;
1374     TRACE("%p, %p, %p\n", device, pAllocateInfo, pDescriptorSets);
1375
1376     convert_VkDescriptorSetAllocateInfo_win_to_host(pAllocateInfo, &pAllocateInfo_host);
1377     result = device->funcs.p_vkAllocateDescriptorSets(device->device, &pAllocateInfo_host, pDescriptorSets);
1378
1379     return result;
1380 #else
1381     TRACE("%p, %p, %p\n", device, pAllocateInfo, pDescriptorSets);
1382     return device->funcs.p_vkAllocateDescriptorSets(device->device, pAllocateInfo, pDescriptorSets);
1383 #endif
1384 }
1385
1386 VkResult WINAPI wine_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
1387 {
1388 #if defined(USE_STRUCT_CONVERSION)
1389     VkResult result;
1390     VkMemoryAllocateInfo_host pAllocateInfo_host;
1391     TRACE("%p, %p, %p, %p\n", device, pAllocateInfo, pAllocator, pMemory);
1392
1393     convert_VkMemoryAllocateInfo_win_to_host(pAllocateInfo, &pAllocateInfo_host);
1394     result = device->funcs.p_vkAllocateMemory(device->device, &pAllocateInfo_host, NULL, pMemory);
1395
1396     return result;
1397 #else
1398     TRACE("%p, %p, %p, %p\n", device, pAllocateInfo, pAllocator, pMemory);
1399     return device->funcs.p_vkAllocateMemory(device->device, pAllocateInfo, NULL, pMemory);
1400 #endif
1401 }
1402
1403 VkResult WINAPI wine_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
1404 {
1405 #if defined(USE_STRUCT_CONVERSION)
1406     VkResult result;
1407     VkCommandBufferBeginInfo_host pBeginInfo_host;
1408     TRACE("%p, %p\n", commandBuffer, pBeginInfo);
1409
1410     convert_VkCommandBufferBeginInfo_win_to_host(pBeginInfo, &pBeginInfo_host);
1411     result = commandBuffer->device->funcs.p_vkBeginCommandBuffer(commandBuffer->command_buffer, &pBeginInfo_host);
1412
1413     free_VkCommandBufferBeginInfo(&pBeginInfo_host);
1414     return result;
1415 #else
1416     TRACE("%p, %p\n", commandBuffer, pBeginInfo);
1417     return commandBuffer->device->funcs.p_vkBeginCommandBuffer(commandBuffer->command_buffer, pBeginInfo);
1418 #endif
1419 }
1420
1421 static VkResult WINAPI wine_vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
1422 {
1423 #if defined(USE_STRUCT_CONVERSION)
1424     VkResult result;
1425     VkBindAccelerationStructureMemoryInfoNV_host *pBindInfos_host;
1426     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
1427
1428     pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoNV_array_win_to_host(pBindInfos, bindInfoCount);
1429     result = device->funcs.p_vkBindAccelerationStructureMemoryNV(device->device, bindInfoCount, pBindInfos_host);
1430
1431     free_VkBindAccelerationStructureMemoryInfoNV_array(pBindInfos_host, bindInfoCount);
1432     return result;
1433 #else
1434     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
1435     return device->funcs.p_vkBindAccelerationStructureMemoryNV(device->device, bindInfoCount, pBindInfos);
1436 #endif
1437 }
1438
1439 VkResult WINAPI wine_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1440 {
1441     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset));
1442     return device->funcs.p_vkBindBufferMemory(device->device, buffer, memory, memoryOffset);
1443 }
1444
1445 VkResult WINAPI wine_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
1446 {
1447 #if defined(USE_STRUCT_CONVERSION)
1448     VkResult result;
1449     VkBindBufferMemoryInfo_host *pBindInfos_host;
1450     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
1451
1452     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win_to_host(pBindInfos, bindInfoCount);
1453     result = device->funcs.p_vkBindBufferMemory2(device->device, bindInfoCount, pBindInfos_host);
1454
1455     free_VkBindBufferMemoryInfo_array(pBindInfos_host, bindInfoCount);
1456     return result;
1457 #else
1458     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
1459     return device->funcs.p_vkBindBufferMemory2(device->device, bindInfoCount, pBindInfos);
1460 #endif
1461 }
1462
1463 static VkResult WINAPI wine_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
1464 {
1465 #if defined(USE_STRUCT_CONVERSION)
1466     VkResult result;
1467     VkBindBufferMemoryInfo_host *pBindInfos_host;
1468     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
1469
1470     pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win_to_host(pBindInfos, bindInfoCount);
1471     result = device->funcs.p_vkBindBufferMemory2KHR(device->device, bindInfoCount, pBindInfos_host);
1472
1473     free_VkBindBufferMemoryInfo_array(pBindInfos_host, bindInfoCount);
1474     return result;
1475 #else
1476     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
1477     return device->funcs.p_vkBindBufferMemory2KHR(device->device, bindInfoCount, pBindInfos);
1478 #endif
1479 }
1480
1481 VkResult WINAPI wine_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1482 {
1483     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(image), wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset));
1484     return device->funcs.p_vkBindImageMemory(device->device, image, memory, memoryOffset);
1485 }
1486
1487 VkResult WINAPI wine_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
1488 {
1489 #if defined(USE_STRUCT_CONVERSION)
1490     VkResult result;
1491     VkBindImageMemoryInfo_host *pBindInfos_host;
1492     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
1493
1494     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win_to_host(pBindInfos, bindInfoCount);
1495     result = device->funcs.p_vkBindImageMemory2(device->device, bindInfoCount, pBindInfos_host);
1496
1497     free_VkBindImageMemoryInfo_array(pBindInfos_host, bindInfoCount);
1498     return result;
1499 #else
1500     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
1501     return device->funcs.p_vkBindImageMemory2(device->device, bindInfoCount, pBindInfos);
1502 #endif
1503 }
1504
1505 static VkResult WINAPI wine_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
1506 {
1507 #if defined(USE_STRUCT_CONVERSION)
1508     VkResult result;
1509     VkBindImageMemoryInfo_host *pBindInfos_host;
1510     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
1511
1512     pBindInfos_host = convert_VkBindImageMemoryInfo_array_win_to_host(pBindInfos, bindInfoCount);
1513     result = device->funcs.p_vkBindImageMemory2KHR(device->device, bindInfoCount, pBindInfos_host);
1514
1515     free_VkBindImageMemoryInfo_array(pBindInfos_host, bindInfoCount);
1516     return result;
1517 #else
1518     TRACE("%p, %u, %p\n", device, bindInfoCount, pBindInfos);
1519     return device->funcs.p_vkBindImageMemory2KHR(device->device, bindInfoCount, pBindInfos);
1520 #endif
1521 }
1522
1523 static void WINAPI wine_vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
1524 {
1525 #if defined(USE_STRUCT_CONVERSION)
1526     VkConditionalRenderingBeginInfoEXT_host pConditionalRenderingBegin_host;
1527     TRACE("%p, %p\n", commandBuffer, pConditionalRenderingBegin);
1528
1529     convert_VkConditionalRenderingBeginInfoEXT_win_to_host(pConditionalRenderingBegin, &pConditionalRenderingBegin_host);
1530     commandBuffer->device->funcs.p_vkCmdBeginConditionalRenderingEXT(commandBuffer->command_buffer, &pConditionalRenderingBegin_host);
1531
1532 #else
1533     TRACE("%p, %p\n", commandBuffer, pConditionalRenderingBegin);
1534     commandBuffer->device->funcs.p_vkCmdBeginConditionalRenderingEXT(commandBuffer->command_buffer, pConditionalRenderingBegin);
1535 #endif
1536 }
1537
1538 void WINAPI wine_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
1539 {
1540     TRACE("%p, 0x%s, %u, %#x\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, flags);
1541     commandBuffer->device->funcs.p_vkCmdBeginQuery(commandBuffer->command_buffer, queryPool, query, flags);
1542 }
1543
1544 static void WINAPI wine_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
1545 {
1546     TRACE("%p, 0x%s, %u, %#x, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, flags, index);
1547     commandBuffer->device->funcs.p_vkCmdBeginQueryIndexedEXT(commandBuffer->command_buffer, queryPool, query, flags, index);
1548 }
1549
1550 void WINAPI wine_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
1551 {
1552 #if defined(USE_STRUCT_CONVERSION)
1553     VkRenderPassBeginInfo_host pRenderPassBegin_host;
1554     TRACE("%p, %p, %#x\n", commandBuffer, pRenderPassBegin, contents);
1555
1556     convert_VkRenderPassBeginInfo_win_to_host(pRenderPassBegin, &pRenderPassBegin_host);
1557     commandBuffer->device->funcs.p_vkCmdBeginRenderPass(commandBuffer->command_buffer, &pRenderPassBegin_host, contents);
1558
1559 #else
1560     TRACE("%p, %p, %#x\n", commandBuffer, pRenderPassBegin, contents);
1561     commandBuffer->device->funcs.p_vkCmdBeginRenderPass(commandBuffer->command_buffer, pRenderPassBegin, contents);
1562 #endif
1563 }
1564
1565 static void WINAPI wine_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfoKHR *pSubpassBeginInfo)
1566 {
1567 #if defined(USE_STRUCT_CONVERSION)
1568     VkRenderPassBeginInfo_host pRenderPassBegin_host;
1569     TRACE("%p, %p, %p\n", commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
1570
1571     convert_VkRenderPassBeginInfo_win_to_host(pRenderPassBegin, &pRenderPassBegin_host);
1572     commandBuffer->device->funcs.p_vkCmdBeginRenderPass2KHR(commandBuffer->command_buffer, &pRenderPassBegin_host, pSubpassBeginInfo);
1573
1574 #else
1575     TRACE("%p, %p, %p\n", commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
1576     commandBuffer->device->funcs.p_vkCmdBeginRenderPass2KHR(commandBuffer->command_buffer, pRenderPassBegin, pSubpassBeginInfo);
1577 #endif
1578 }
1579
1580 static void WINAPI wine_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
1581 {
1582     TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
1583     commandBuffer->device->funcs.p_vkCmdBeginTransformFeedbackEXT(commandBuffer->command_buffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
1584 }
1585
1586 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)
1587 {
1588     TRACE("%p, %#x, 0x%s, %u, %u, %p, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
1589     commandBuffer->device->funcs.p_vkCmdBindDescriptorSets(commandBuffer->command_buffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
1590 }
1591
1592 void WINAPI wine_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
1593 {
1594     TRACE("%p, 0x%s, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), indexType);
1595     commandBuffer->device->funcs.p_vkCmdBindIndexBuffer(commandBuffer->command_buffer, buffer, offset, indexType);
1596 }
1597
1598 void WINAPI wine_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
1599 {
1600     TRACE("%p, %#x, 0x%s\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(pipeline));
1601     commandBuffer->device->funcs.p_vkCmdBindPipeline(commandBuffer->command_buffer, pipelineBindPoint, pipeline);
1602 }
1603
1604 static void WINAPI wine_vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
1605 {
1606     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(imageView), imageLayout);
1607     commandBuffer->device->funcs.p_vkCmdBindShadingRateImageNV(commandBuffer->command_buffer, imageView, imageLayout);
1608 }
1609
1610 static void WINAPI wine_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
1611 {
1612     TRACE("%p, %u, %u, %p, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
1613     commandBuffer->device->funcs.p_vkCmdBindTransformFeedbackBuffersEXT(commandBuffer->command_buffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
1614 }
1615
1616 void WINAPI wine_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
1617 {
1618     TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
1619     commandBuffer->device->funcs.p_vkCmdBindVertexBuffers(commandBuffer->command_buffer, firstBinding, bindingCount, pBuffers, pOffsets);
1620 }
1621
1622 void WINAPI wine_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
1623 {
1624     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);
1625     commandBuffer->device->funcs.p_vkCmdBlitImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
1626 }
1627
1628 static void WINAPI wine_vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
1629 {
1630 #if defined(USE_STRUCT_CONVERSION)
1631     VkAccelerationStructureInfoNV_host pInfo_host;
1632     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));
1633
1634     convert_VkAccelerationStructureInfoNV_win_to_host(pInfo, &pInfo_host);
1635     commandBuffer->device->funcs.p_vkCmdBuildAccelerationStructureNV(commandBuffer->command_buffer, &pInfo_host, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
1636
1637     free_VkAccelerationStructureInfoNV(&pInfo_host);
1638 #else
1639     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));
1640     commandBuffer->device->funcs.p_vkCmdBuildAccelerationStructureNV(commandBuffer->command_buffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
1641 #endif
1642 }
1643
1644 void WINAPI wine_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
1645 {
1646     TRACE("%p, %u, %p, %u, %p\n", commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
1647     commandBuffer->device->funcs.p_vkCmdClearAttachments(commandBuffer->command_buffer, attachmentCount, pAttachments, rectCount, pRects);
1648 }
1649
1650 void WINAPI wine_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
1651 {
1652     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, pColor, rangeCount, pRanges);
1653     commandBuffer->device->funcs.p_vkCmdClearColorImage(commandBuffer->command_buffer, image, imageLayout, pColor, rangeCount, pRanges);
1654 }
1655
1656 void WINAPI wine_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
1657 {
1658     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, pDepthStencil, rangeCount, pRanges);
1659     commandBuffer->device->funcs.p_vkCmdClearDepthStencilImage(commandBuffer->command_buffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
1660 }
1661
1662 static void WINAPI wine_vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode)
1663 {
1664     TRACE("%p, 0x%s, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(dst), wine_dbgstr_longlong(src), mode);
1665     commandBuffer->device->funcs.p_vkCmdCopyAccelerationStructureNV(commandBuffer->command_buffer, dst, src, mode);
1666 }
1667
1668 void WINAPI wine_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
1669 {
1670 #if defined(USE_STRUCT_CONVERSION)
1671     VkBufferCopy_host *pRegions_host;
1672     TRACE("%p, 0x%s, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
1673
1674     pRegions_host = convert_VkBufferCopy_array_win_to_host(pRegions, regionCount);
1675     commandBuffer->device->funcs.p_vkCmdCopyBuffer(commandBuffer->command_buffer, srcBuffer, dstBuffer, regionCount, pRegions_host);
1676
1677     free_VkBufferCopy_array(pRegions_host, regionCount);
1678 #else
1679     TRACE("%p, 0x%s, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
1680     commandBuffer->device->funcs.p_vkCmdCopyBuffer(commandBuffer->command_buffer, srcBuffer, dstBuffer, regionCount, pRegions);
1681 #endif
1682 }
1683
1684 void WINAPI wine_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
1685 {
1686 #if defined(USE_STRUCT_CONVERSION)
1687     VkBufferImageCopy_host *pRegions_host;
1688     TRACE("%p, 0x%s, 0x%s, %#x, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
1689
1690     pRegions_host = convert_VkBufferImageCopy_array_win_to_host(pRegions, regionCount);
1691     commandBuffer->device->funcs.p_vkCmdCopyBufferToImage(commandBuffer->command_buffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions_host);
1692
1693     free_VkBufferImageCopy_array(pRegions_host, regionCount);
1694 #else
1695     TRACE("%p, 0x%s, 0x%s, %#x, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
1696     commandBuffer->device->funcs.p_vkCmdCopyBufferToImage(commandBuffer->command_buffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
1697 #endif
1698 }
1699
1700 void WINAPI wine_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
1701 {
1702     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
1703     commandBuffer->device->funcs.p_vkCmdCopyImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
1704 }
1705
1706 void WINAPI wine_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
1707 {
1708 #if defined(USE_STRUCT_CONVERSION)
1709     VkBufferImageCopy_host *pRegions_host;
1710     TRACE("%p, 0x%s, %#x, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
1711
1712     pRegions_host = convert_VkBufferImageCopy_array_win_to_host(pRegions, regionCount);
1713     commandBuffer->device->funcs.p_vkCmdCopyImageToBuffer(commandBuffer->command_buffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions_host);
1714
1715     free_VkBufferImageCopy_array(pRegions_host, regionCount);
1716 #else
1717     TRACE("%p, 0x%s, %#x, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
1718     commandBuffer->device->funcs.p_vkCmdCopyImageToBuffer(commandBuffer->command_buffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
1719 #endif
1720 }
1721
1722 void WINAPI wine_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
1723 {
1724     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);
1725     commandBuffer->device->funcs.p_vkCmdCopyQueryPoolResults(commandBuffer->command_buffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
1726 }
1727
1728 void WINAPI wine_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
1729 {
1730     TRACE("%p, %u, %u, %u\n", commandBuffer, groupCountX, groupCountY, groupCountZ);
1731     commandBuffer->device->funcs.p_vkCmdDispatch(commandBuffer->command_buffer, groupCountX, groupCountY, groupCountZ);
1732 }
1733
1734 void WINAPI wine_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
1735 {
1736     TRACE("%p, %u, %u, %u, %u, %u, %u\n", commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
1737     commandBuffer->device->funcs.p_vkCmdDispatchBase(commandBuffer->command_buffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
1738 }
1739
1740 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)
1741 {
1742     TRACE("%p, %u, %u, %u, %u, %u, %u\n", commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
1743     commandBuffer->device->funcs.p_vkCmdDispatchBaseKHR(commandBuffer->command_buffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
1744 }
1745
1746 void WINAPI wine_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
1747 {
1748     TRACE("%p, 0x%s, 0x%s\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset));
1749     commandBuffer->device->funcs.p_vkCmdDispatchIndirect(commandBuffer->command_buffer, buffer, offset);
1750 }
1751
1752 void WINAPI wine_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
1753 {
1754     TRACE("%p, %u, %u, %u, %u\n", commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
1755     commandBuffer->device->funcs.p_vkCmdDraw(commandBuffer->command_buffer, vertexCount, instanceCount, firstVertex, firstInstance);
1756 }
1757
1758 void WINAPI wine_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
1759 {
1760     TRACE("%p, %u, %u, %u, %d, %u\n", commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
1761     commandBuffer->device->funcs.p_vkCmdDrawIndexed(commandBuffer->command_buffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
1762 }
1763
1764 void WINAPI wine_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
1765 {
1766     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
1767     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirect(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
1768 }
1769
1770 static void WINAPI wine_vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1771 {
1772     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);
1773     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirectCountAMD(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1774 }
1775
1776 static void WINAPI wine_vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1777 {
1778     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);
1779     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirectCountKHR(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1780 }
1781
1782 void WINAPI wine_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
1783 {
1784     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
1785     commandBuffer->device->funcs.p_vkCmdDrawIndirect(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
1786 }
1787
1788 static void WINAPI wine_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
1789 {
1790     TRACE("%p, %u, %u, 0x%s, 0x%s, %u, %u\n", commandBuffer, instanceCount, firstInstance, wine_dbgstr_longlong(counterBuffer), wine_dbgstr_longlong(counterBufferOffset), counterOffset, vertexStride);
1791     commandBuffer->device->funcs.p_vkCmdDrawIndirectByteCountEXT(commandBuffer->command_buffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
1792 }
1793
1794 static void WINAPI wine_vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1795 {
1796     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);
1797     commandBuffer->device->funcs.p_vkCmdDrawIndirectCountAMD(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1798 }
1799
1800 static void WINAPI wine_vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1801 {
1802     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);
1803     commandBuffer->device->funcs.p_vkCmdDrawIndirectCountKHR(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1804 }
1805
1806 static void WINAPI wine_vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1807 {
1808     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);
1809     commandBuffer->device->funcs.p_vkCmdDrawMeshTasksIndirectCountNV(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1810 }
1811
1812 static void WINAPI wine_vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
1813 {
1814     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
1815     commandBuffer->device->funcs.p_vkCmdDrawMeshTasksIndirectNV(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
1816 }
1817
1818 static void WINAPI wine_vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
1819 {
1820     TRACE("%p, %u, %u\n", commandBuffer, taskCount, firstTask);
1821     commandBuffer->device->funcs.p_vkCmdDrawMeshTasksNV(commandBuffer->command_buffer, taskCount, firstTask);
1822 }
1823
1824 static void WINAPI wine_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
1825 {
1826     TRACE("%p\n", commandBuffer);
1827     commandBuffer->device->funcs.p_vkCmdEndConditionalRenderingEXT(commandBuffer->command_buffer);
1828 }
1829
1830 void WINAPI wine_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
1831 {
1832     TRACE("%p, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query);
1833     commandBuffer->device->funcs.p_vkCmdEndQuery(commandBuffer->command_buffer, queryPool, query);
1834 }
1835
1836 static void WINAPI wine_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
1837 {
1838     TRACE("%p, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, index);
1839     commandBuffer->device->funcs.p_vkCmdEndQueryIndexedEXT(commandBuffer->command_buffer, queryPool, query, index);
1840 }
1841
1842 void WINAPI wine_vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
1843 {
1844     TRACE("%p\n", commandBuffer);
1845     commandBuffer->device->funcs.p_vkCmdEndRenderPass(commandBuffer->command_buffer);
1846 }
1847
1848 static void WINAPI wine_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR *pSubpassEndInfo)
1849 {
1850     TRACE("%p, %p\n", commandBuffer, pSubpassEndInfo);
1851     commandBuffer->device->funcs.p_vkCmdEndRenderPass2KHR(commandBuffer->command_buffer, pSubpassEndInfo);
1852 }
1853
1854 static void WINAPI wine_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
1855 {
1856     TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
1857     commandBuffer->device->funcs.p_vkCmdEndTransformFeedbackEXT(commandBuffer->command_buffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
1858 }
1859
1860 void WINAPI wine_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
1861 {
1862     TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(size), data);
1863     commandBuffer->device->funcs.p_vkCmdFillBuffer(commandBuffer->command_buffer, dstBuffer, dstOffset, size, data);
1864 }
1865
1866 void WINAPI wine_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
1867 {
1868     TRACE("%p, %#x\n", commandBuffer, contents);
1869     commandBuffer->device->funcs.p_vkCmdNextSubpass(commandBuffer->command_buffer, contents);
1870 }
1871
1872 static void WINAPI wine_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR *pSubpassBeginInfo, const VkSubpassEndInfoKHR *pSubpassEndInfo)
1873 {
1874     TRACE("%p, %p, %p\n", commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
1875     commandBuffer->device->funcs.p_vkCmdNextSubpass2KHR(commandBuffer->command_buffer, pSubpassBeginInfo, pSubpassEndInfo);
1876 }
1877
1878 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)
1879 {
1880 #if defined(USE_STRUCT_CONVERSION)
1881     VkBufferMemoryBarrier_host *pBufferMemoryBarriers_host;
1882     VkImageMemoryBarrier_host *pImageMemoryBarriers_host;
1883     TRACE("%p, %#x, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1884
1885     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win_to_host(pBufferMemoryBarriers, bufferMemoryBarrierCount);
1886     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win_to_host(pImageMemoryBarriers, imageMemoryBarrierCount);
1887     commandBuffer->device->funcs.p_vkCmdPipelineBarrier(commandBuffer->command_buffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers_host, imageMemoryBarrierCount, pImageMemoryBarriers_host);
1888
1889     free_VkBufferMemoryBarrier_array(pBufferMemoryBarriers_host, bufferMemoryBarrierCount);
1890     free_VkImageMemoryBarrier_array(pImageMemoryBarriers_host, imageMemoryBarrierCount);
1891 #else
1892     TRACE("%p, %#x, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1893     commandBuffer->device->funcs.p_vkCmdPipelineBarrier(commandBuffer->command_buffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1894 #endif
1895 }
1896
1897 void WINAPI wine_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
1898 {
1899     TRACE("%p, 0x%s, %#x, %u, %u, %p\n", commandBuffer, wine_dbgstr_longlong(layout), stageFlags, offset, size, pValues);
1900     commandBuffer->device->funcs.p_vkCmdPushConstants(commandBuffer->command_buffer, layout, stageFlags, offset, size, pValues);
1901 }
1902
1903 static void WINAPI wine_vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
1904 {
1905 #if defined(USE_STRUCT_CONVERSION)
1906     VkWriteDescriptorSet_host *pDescriptorWrites_host;
1907     TRACE("%p, %#x, 0x%s, %u, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), set, descriptorWriteCount, pDescriptorWrites);
1908
1909     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win_to_host(pDescriptorWrites, descriptorWriteCount);
1910     commandBuffer->device->funcs.p_vkCmdPushDescriptorSetKHR(commandBuffer->command_buffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites_host);
1911
1912     free_VkWriteDescriptorSet_array(pDescriptorWrites_host, descriptorWriteCount);
1913 #else
1914     TRACE("%p, %#x, 0x%s, %u, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), set, descriptorWriteCount, pDescriptorWrites);
1915     commandBuffer->device->funcs.p_vkCmdPushDescriptorSetKHR(commandBuffer->command_buffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
1916 #endif
1917 }
1918
1919 static void WINAPI wine_vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
1920 {
1921     TRACE("%p, 0x%s, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(descriptorUpdateTemplate), wine_dbgstr_longlong(layout), set, pData);
1922     commandBuffer->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer->command_buffer, descriptorUpdateTemplate, layout, set, pData);
1923 }
1924
1925 void WINAPI wine_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
1926 {
1927     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(event), stageMask);
1928     commandBuffer->device->funcs.p_vkCmdResetEvent(commandBuffer->command_buffer, event, stageMask);
1929 }
1930
1931 void WINAPI wine_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
1932 {
1933     TRACE("%p, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), firstQuery, queryCount);
1934     commandBuffer->device->funcs.p_vkCmdResetQueryPool(commandBuffer->command_buffer, queryPool, firstQuery, queryCount);
1935 }
1936
1937 void WINAPI wine_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
1938 {
1939     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
1940     commandBuffer->device->funcs.p_vkCmdResolveImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
1941 }
1942
1943 void WINAPI wine_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
1944 {
1945     TRACE("%p, %p\n", commandBuffer, blendConstants);
1946     commandBuffer->device->funcs.p_vkCmdSetBlendConstants(commandBuffer->command_buffer, blendConstants);
1947 }
1948
1949 static void WINAPI wine_vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
1950 {
1951     TRACE("%p, %p\n", commandBuffer, pCheckpointMarker);
1952     commandBuffer->device->funcs.p_vkCmdSetCheckpointNV(commandBuffer->command_buffer, pCheckpointMarker);
1953 }
1954
1955 static void WINAPI wine_vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
1956 {
1957     TRACE("%p, %#x, %u, %p\n", commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
1958     commandBuffer->device->funcs.p_vkCmdSetCoarseSampleOrderNV(commandBuffer->command_buffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
1959 }
1960
1961 void WINAPI wine_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
1962 {
1963     TRACE("%p, %f, %f, %f\n", commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
1964     commandBuffer->device->funcs.p_vkCmdSetDepthBias(commandBuffer->command_buffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
1965 }
1966
1967 void WINAPI wine_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
1968 {
1969     TRACE("%p, %f, %f\n", commandBuffer, minDepthBounds, maxDepthBounds);
1970     commandBuffer->device->funcs.p_vkCmdSetDepthBounds(commandBuffer->command_buffer, minDepthBounds, maxDepthBounds);
1971 }
1972
1973 void WINAPI wine_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
1974 {
1975     TRACE("%p, %u\n", commandBuffer, deviceMask);
1976     commandBuffer->device->funcs.p_vkCmdSetDeviceMask(commandBuffer->command_buffer, deviceMask);
1977 }
1978
1979 static void WINAPI wine_vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
1980 {
1981     TRACE("%p, %u\n", commandBuffer, deviceMask);
1982     commandBuffer->device->funcs.p_vkCmdSetDeviceMaskKHR(commandBuffer->command_buffer, deviceMask);
1983 }
1984
1985 static void WINAPI wine_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
1986 {
1987     TRACE("%p, %u, %u, %p\n", commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
1988     commandBuffer->device->funcs.p_vkCmdSetDiscardRectangleEXT(commandBuffer->command_buffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
1989 }
1990
1991 void WINAPI wine_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
1992 {
1993     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(event), stageMask);
1994     commandBuffer->device->funcs.p_vkCmdSetEvent(commandBuffer->command_buffer, event, stageMask);
1995 }
1996
1997 static void WINAPI wine_vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
1998 {
1999     TRACE("%p, %u, %u, %p\n", commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
2000     commandBuffer->device->funcs.p_vkCmdSetExclusiveScissorNV(commandBuffer->command_buffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
2001 }
2002
2003 void WINAPI wine_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
2004 {
2005     TRACE("%p, %f\n", commandBuffer, lineWidth);
2006     commandBuffer->device->funcs.p_vkCmdSetLineWidth(commandBuffer->command_buffer, lineWidth);
2007 }
2008
2009 static void WINAPI wine_vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
2010 {
2011     TRACE("%p, %p\n", commandBuffer, pSampleLocationsInfo);
2012     commandBuffer->device->funcs.p_vkCmdSetSampleLocationsEXT(commandBuffer->command_buffer, pSampleLocationsInfo);
2013 }
2014
2015 void WINAPI wine_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
2016 {
2017     TRACE("%p, %u, %u, %p\n", commandBuffer, firstScissor, scissorCount, pScissors);
2018     commandBuffer->device->funcs.p_vkCmdSetScissor(commandBuffer->command_buffer, firstScissor, scissorCount, pScissors);
2019 }
2020
2021 void WINAPI wine_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
2022 {
2023     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, compareMask);
2024     commandBuffer->device->funcs.p_vkCmdSetStencilCompareMask(commandBuffer->command_buffer, faceMask, compareMask);
2025 }
2026
2027 void WINAPI wine_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
2028 {
2029     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, reference);
2030     commandBuffer->device->funcs.p_vkCmdSetStencilReference(commandBuffer->command_buffer, faceMask, reference);
2031 }
2032
2033 void WINAPI wine_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
2034 {
2035     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, writeMask);
2036     commandBuffer->device->funcs.p_vkCmdSetStencilWriteMask(commandBuffer->command_buffer, faceMask, writeMask);
2037 }
2038
2039 void WINAPI wine_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
2040 {
2041     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pViewports);
2042     commandBuffer->device->funcs.p_vkCmdSetViewport(commandBuffer->command_buffer, firstViewport, viewportCount, pViewports);
2043 }
2044
2045 static void WINAPI wine_vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
2046 {
2047     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
2048     commandBuffer->device->funcs.p_vkCmdSetViewportShadingRatePaletteNV(commandBuffer->command_buffer, firstViewport, viewportCount, pShadingRatePalettes);
2049 }
2050
2051 static void WINAPI wine_vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
2052 {
2053     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pViewportWScalings);
2054     commandBuffer->device->funcs.p_vkCmdSetViewportWScalingNV(commandBuffer->command_buffer, firstViewport, viewportCount, pViewportWScalings);
2055 }
2056
2057 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)
2058 {
2059     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);
2060     commandBuffer->device->funcs.p_vkCmdTraceRaysNV(commandBuffer->command_buffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
2061 }
2062
2063 void WINAPI wine_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
2064 {
2065     TRACE("%p, 0x%s, 0x%s, 0x%s, %p\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(dataSize), pData);
2066     commandBuffer->device->funcs.p_vkCmdUpdateBuffer(commandBuffer->command_buffer, dstBuffer, dstOffset, dataSize, pData);
2067 }
2068
2069 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)
2070 {
2071 #if defined(USE_STRUCT_CONVERSION)
2072     VkBufferMemoryBarrier_host *pBufferMemoryBarriers_host;
2073     VkImageMemoryBarrier_host *pImageMemoryBarriers_host;
2074     TRACE("%p, %u, %p, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
2075
2076     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win_to_host(pBufferMemoryBarriers, bufferMemoryBarrierCount);
2077     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win_to_host(pImageMemoryBarriers, imageMemoryBarrierCount);
2078     commandBuffer->device->funcs.p_vkCmdWaitEvents(commandBuffer->command_buffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers_host, imageMemoryBarrierCount, pImageMemoryBarriers_host);
2079
2080     free_VkBufferMemoryBarrier_array(pBufferMemoryBarriers_host, bufferMemoryBarrierCount);
2081     free_VkImageMemoryBarrier_array(pImageMemoryBarriers_host, imageMemoryBarrierCount);
2082 #else
2083     TRACE("%p, %u, %p, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
2084     commandBuffer->device->funcs.p_vkCmdWaitEvents(commandBuffer->command_buffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
2085 #endif
2086 }
2087
2088 static void WINAPI wine_vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
2089 {
2090     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, wine_dbgstr_longlong(queryPool), firstQuery);
2091     commandBuffer->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer->command_buffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
2092 }
2093
2094 static void WINAPI wine_vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
2095 {
2096     TRACE("%p, %#x, 0x%s, 0x%s, %u\n", commandBuffer, pipelineStage, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), marker);
2097     commandBuffer->device->funcs.p_vkCmdWriteBufferMarkerAMD(commandBuffer->command_buffer, pipelineStage, dstBuffer, dstOffset, marker);
2098 }
2099
2100 void WINAPI wine_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
2101 {
2102     TRACE("%p, %#x, 0x%s, %u\n", commandBuffer, pipelineStage, wine_dbgstr_longlong(queryPool), query);
2103     commandBuffer->device->funcs.p_vkCmdWriteTimestamp(commandBuffer->command_buffer, pipelineStage, queryPool, query);
2104 }
2105
2106 static VkResult WINAPI wine_vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
2107 {
2108     TRACE("%p, 0x%s, %u\n", device, wine_dbgstr_longlong(pipeline), shader);
2109     return device->funcs.p_vkCompileDeferredNV(device->device, pipeline, shader);
2110 }
2111
2112 static VkResult WINAPI wine_vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
2113 {
2114 #if defined(USE_STRUCT_CONVERSION)
2115     VkResult result;
2116     VkAccelerationStructureCreateInfoNV_host pCreateInfo_host;
2117     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pAccelerationStructure);
2118
2119     convert_VkAccelerationStructureCreateInfoNV_win_to_host(pCreateInfo, &pCreateInfo_host);
2120     result = device->funcs.p_vkCreateAccelerationStructureNV(device->device, &pCreateInfo_host, NULL, pAccelerationStructure);
2121
2122     return result;
2123 #else
2124     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pAccelerationStructure);
2125     return device->funcs.p_vkCreateAccelerationStructureNV(device->device, pCreateInfo, NULL, pAccelerationStructure);
2126 #endif
2127 }
2128
2129 VkResult WINAPI wine_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
2130 {
2131 #if defined(USE_STRUCT_CONVERSION)
2132     VkResult result;
2133     VkBufferCreateInfo_host pCreateInfo_host;
2134     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pBuffer);
2135
2136     convert_VkBufferCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
2137     result = device->funcs.p_vkCreateBuffer(device->device, &pCreateInfo_host, NULL, pBuffer);
2138
2139     return result;
2140 #else
2141     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pBuffer);
2142     return device->funcs.p_vkCreateBuffer(device->device, pCreateInfo, NULL, pBuffer);
2143 #endif
2144 }
2145
2146 VkResult WINAPI wine_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
2147 {
2148 #if defined(USE_STRUCT_CONVERSION)
2149     VkResult result;
2150     VkBufferViewCreateInfo_host pCreateInfo_host;
2151     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
2152
2153     convert_VkBufferViewCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
2154     result = device->funcs.p_vkCreateBufferView(device->device, &pCreateInfo_host, NULL, pView);
2155
2156     return result;
2157 #else
2158     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
2159     return device->funcs.p_vkCreateBufferView(device->device, pCreateInfo, NULL, pView);
2160 #endif
2161 }
2162
2163 VkResult WINAPI wine_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
2164 {
2165 #if defined(USE_STRUCT_CONVERSION)
2166     VkResult result;
2167     VkComputePipelineCreateInfo_host *pCreateInfos_host;
2168     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
2169
2170     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win_to_host(pCreateInfos, createInfoCount);
2171     result = device->funcs.p_vkCreateComputePipelines(device->device, pipelineCache, createInfoCount, pCreateInfos_host, NULL, pPipelines);
2172
2173     free_VkComputePipelineCreateInfo_array(pCreateInfos_host, createInfoCount);
2174     return result;
2175 #else
2176     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
2177     return device->funcs.p_vkCreateComputePipelines(device->device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines);
2178 #endif
2179 }
2180
2181 VkResult WINAPI wine_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
2182 {
2183     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorPool);
2184     return device->funcs.p_vkCreateDescriptorPool(device->device, pCreateInfo, NULL, pDescriptorPool);
2185 }
2186
2187 VkResult WINAPI wine_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
2188 {
2189     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSetLayout);
2190     return device->funcs.p_vkCreateDescriptorSetLayout(device->device, pCreateInfo, NULL, pSetLayout);
2191 }
2192
2193 VkResult WINAPI wine_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
2194 {
2195 #if defined(USE_STRUCT_CONVERSION)
2196     VkResult result;
2197     VkDescriptorUpdateTemplateCreateInfo_host pCreateInfo_host;
2198     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
2199
2200     convert_VkDescriptorUpdateTemplateCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
2201     result = device->funcs.p_vkCreateDescriptorUpdateTemplate(device->device, &pCreateInfo_host, NULL, pDescriptorUpdateTemplate);
2202
2203     return result;
2204 #else
2205     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
2206     return device->funcs.p_vkCreateDescriptorUpdateTemplate(device->device, pCreateInfo, NULL, pDescriptorUpdateTemplate);
2207 #endif
2208 }
2209
2210 static VkResult WINAPI wine_vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
2211 {
2212 #if defined(USE_STRUCT_CONVERSION)
2213     VkResult result;
2214     VkDescriptorUpdateTemplateCreateInfo_host pCreateInfo_host;
2215     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
2216
2217     convert_VkDescriptorUpdateTemplateCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
2218     result = device->funcs.p_vkCreateDescriptorUpdateTemplateKHR(device->device, &pCreateInfo_host, NULL, pDescriptorUpdateTemplate);
2219
2220     return result;
2221 #else
2222     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
2223     return device->funcs.p_vkCreateDescriptorUpdateTemplateKHR(device->device, pCreateInfo, NULL, pDescriptorUpdateTemplate);
2224 #endif
2225 }
2226
2227 VkResult WINAPI wine_vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
2228 {
2229     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pEvent);
2230     return device->funcs.p_vkCreateEvent(device->device, pCreateInfo, NULL, pEvent);
2231 }
2232
2233 VkResult WINAPI wine_vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
2234 {
2235     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFence);
2236     return device->funcs.p_vkCreateFence(device->device, pCreateInfo, NULL, pFence);
2237 }
2238
2239 VkResult WINAPI wine_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
2240 {
2241 #if defined(USE_STRUCT_CONVERSION)
2242     VkResult result;
2243     VkFramebufferCreateInfo_host pCreateInfo_host;
2244     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFramebuffer);
2245
2246     convert_VkFramebufferCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
2247     result = device->funcs.p_vkCreateFramebuffer(device->device, &pCreateInfo_host, NULL, pFramebuffer);
2248
2249     return result;
2250 #else
2251     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFramebuffer);
2252     return device->funcs.p_vkCreateFramebuffer(device->device, pCreateInfo, NULL, pFramebuffer);
2253 #endif
2254 }
2255
2256 VkResult WINAPI wine_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
2257 {
2258 #if defined(USE_STRUCT_CONVERSION)
2259     VkResult result;
2260     VkGraphicsPipelineCreateInfo_host *pCreateInfos_host;
2261     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
2262
2263     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win_to_host(pCreateInfos, createInfoCount);
2264     result = device->funcs.p_vkCreateGraphicsPipelines(device->device, pipelineCache, createInfoCount, pCreateInfos_host, NULL, pPipelines);
2265
2266     free_VkGraphicsPipelineCreateInfo_array(pCreateInfos_host, createInfoCount);
2267     return result;
2268 #else
2269     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
2270     return device->funcs.p_vkCreateGraphicsPipelines(device->device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines);
2271 #endif
2272 }
2273
2274 VkResult WINAPI wine_vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
2275 {
2276     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pImage);
2277     return device->funcs.p_vkCreateImage(device->device, pCreateInfo, NULL, pImage);
2278 }
2279
2280 VkResult WINAPI wine_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
2281 {
2282 #if defined(USE_STRUCT_CONVERSION)
2283     VkResult result;
2284     VkImageViewCreateInfo_host pCreateInfo_host;
2285     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
2286
2287     convert_VkImageViewCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
2288     result = device->funcs.p_vkCreateImageView(device->device, &pCreateInfo_host, NULL, pView);
2289
2290     return result;
2291 #else
2292     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
2293     return device->funcs.p_vkCreateImageView(device->device, pCreateInfo, NULL, pView);
2294 #endif
2295 }
2296
2297 VkResult WINAPI wine_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
2298 {
2299     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPipelineCache);
2300     return device->funcs.p_vkCreatePipelineCache(device->device, pCreateInfo, NULL, pPipelineCache);
2301 }
2302
2303 VkResult WINAPI wine_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
2304 {
2305     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPipelineLayout);
2306     return device->funcs.p_vkCreatePipelineLayout(device->device, pCreateInfo, NULL, pPipelineLayout);
2307 }
2308
2309 VkResult WINAPI wine_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
2310 {
2311     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pQueryPool);
2312     return device->funcs.p_vkCreateQueryPool(device->device, pCreateInfo, NULL, pQueryPool);
2313 }
2314
2315 static VkResult WINAPI wine_vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
2316 {
2317 #if defined(USE_STRUCT_CONVERSION)
2318     VkResult result;
2319     VkRayTracingPipelineCreateInfoNV_host *pCreateInfos_host;
2320     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
2321
2322     pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win_to_host(pCreateInfos, createInfoCount);
2323     result = device->funcs.p_vkCreateRayTracingPipelinesNV(device->device, pipelineCache, createInfoCount, pCreateInfos_host, NULL, pPipelines);
2324
2325     free_VkRayTracingPipelineCreateInfoNV_array(pCreateInfos_host, createInfoCount);
2326     return result;
2327 #else
2328     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
2329     return device->funcs.p_vkCreateRayTracingPipelinesNV(device->device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines);
2330 #endif
2331 }
2332
2333 VkResult WINAPI wine_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
2334 {
2335     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass);
2336     return device->funcs.p_vkCreateRenderPass(device->device, pCreateInfo, NULL, pRenderPass);
2337 }
2338
2339 static VkResult WINAPI wine_vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
2340 {
2341     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass);
2342     return device->funcs.p_vkCreateRenderPass2KHR(device->device, pCreateInfo, NULL, pRenderPass);
2343 }
2344
2345 VkResult WINAPI wine_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
2346 {
2347     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSampler);
2348     return device->funcs.p_vkCreateSampler(device->device, pCreateInfo, NULL, pSampler);
2349 }
2350
2351 VkResult WINAPI wine_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
2352 {
2353     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pYcbcrConversion);
2354     return device->funcs.p_vkCreateSamplerYcbcrConversion(device->device, pCreateInfo, NULL, pYcbcrConversion);
2355 }
2356
2357 static VkResult WINAPI wine_vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
2358 {
2359     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pYcbcrConversion);
2360     return device->funcs.p_vkCreateSamplerYcbcrConversionKHR(device->device, pCreateInfo, NULL, pYcbcrConversion);
2361 }
2362
2363 VkResult WINAPI wine_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
2364 {
2365     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSemaphore);
2366     return device->funcs.p_vkCreateSemaphore(device->device, pCreateInfo, NULL, pSemaphore);
2367 }
2368
2369 VkResult WINAPI wine_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
2370 {
2371     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pShaderModule);
2372     return device->funcs.p_vkCreateShaderModule(device->device, pCreateInfo, NULL, pShaderModule);
2373 }
2374
2375 VkResult WINAPI wine_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
2376 {
2377 #if defined(USE_STRUCT_CONVERSION)
2378     VkResult result;
2379     VkSwapchainCreateInfoKHR_host pCreateInfo_host;
2380     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSwapchain);
2381
2382     convert_VkSwapchainCreateInfoKHR_win_to_host(pCreateInfo, &pCreateInfo_host);
2383     result = device->funcs.p_vkCreateSwapchainKHR(device->device, &pCreateInfo_host, NULL, pSwapchain);
2384
2385     return result;
2386 #else
2387     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSwapchain);
2388     return device->funcs.p_vkCreateSwapchainKHR(device->device, pCreateInfo, NULL, pSwapchain);
2389 #endif
2390 }
2391
2392 static VkResult WINAPI wine_vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
2393 {
2394     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pValidationCache);
2395     return device->funcs.p_vkCreateValidationCacheEXT(device->device, pCreateInfo, NULL, pValidationCache);
2396 }
2397
2398 VkResult WINAPI wine_vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
2399 {
2400     TRACE("%p, %p, %p, %p\n", instance, pCreateInfo, pAllocator, pSurface);
2401     return instance->funcs.p_vkCreateWin32SurfaceKHR(instance->instance, pCreateInfo, NULL, pSurface);
2402 }
2403
2404 static void WINAPI wine_vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
2405 {
2406     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(accelerationStructure), pAllocator);
2407     device->funcs.p_vkDestroyAccelerationStructureNV(device->device, accelerationStructure, NULL);
2408 }
2409
2410 void WINAPI wine_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
2411 {
2412     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pAllocator);
2413     device->funcs.p_vkDestroyBuffer(device->device, buffer, NULL);
2414 }
2415
2416 void WINAPI wine_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
2417 {
2418     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(bufferView), pAllocator);
2419     device->funcs.p_vkDestroyBufferView(device->device, bufferView, NULL);
2420 }
2421
2422 void WINAPI wine_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
2423 {
2424     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorPool), pAllocator);
2425     device->funcs.p_vkDestroyDescriptorPool(device->device, descriptorPool, NULL);
2426 }
2427
2428 void WINAPI wine_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
2429 {
2430     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSetLayout), pAllocator);
2431     device->funcs.p_vkDestroyDescriptorSetLayout(device->device, descriptorSetLayout, NULL);
2432 }
2433
2434 void WINAPI wine_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
2435 {
2436     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorUpdateTemplate), pAllocator);
2437     device->funcs.p_vkDestroyDescriptorUpdateTemplate(device->device, descriptorUpdateTemplate, NULL);
2438 }
2439
2440 static void WINAPI wine_vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
2441 {
2442     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorUpdateTemplate), pAllocator);
2443     device->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(device->device, descriptorUpdateTemplate, NULL);
2444 }
2445
2446 void WINAPI wine_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
2447 {
2448     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(event), pAllocator);
2449     device->funcs.p_vkDestroyEvent(device->device, event, NULL);
2450 }
2451
2452 void WINAPI wine_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
2453 {
2454     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(fence), pAllocator);
2455     device->funcs.p_vkDestroyFence(device->device, fence, NULL);
2456 }
2457
2458 void WINAPI wine_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
2459 {
2460     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(framebuffer), pAllocator);
2461     device->funcs.p_vkDestroyFramebuffer(device->device, framebuffer, NULL);
2462 }
2463
2464 void WINAPI wine_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
2465 {
2466     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pAllocator);
2467     device->funcs.p_vkDestroyImage(device->device, image, NULL);
2468 }
2469
2470 void WINAPI wine_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
2471 {
2472     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(imageView), pAllocator);
2473     device->funcs.p_vkDestroyImageView(device->device, imageView, NULL);
2474 }
2475
2476 void WINAPI wine_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
2477 {
2478     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), pAllocator);
2479     device->funcs.p_vkDestroyPipeline(device->device, pipeline, NULL);
2480 }
2481
2482 void WINAPI wine_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
2483 {
2484     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipelineCache), pAllocator);
2485     device->funcs.p_vkDestroyPipelineCache(device->device, pipelineCache, NULL);
2486 }
2487
2488 void WINAPI wine_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
2489 {
2490     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipelineLayout), pAllocator);
2491     device->funcs.p_vkDestroyPipelineLayout(device->device, pipelineLayout, NULL);
2492 }
2493
2494 void WINAPI wine_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
2495 {
2496     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(queryPool), pAllocator);
2497     device->funcs.p_vkDestroyQueryPool(device->device, queryPool, NULL);
2498 }
2499
2500 void WINAPI wine_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
2501 {
2502     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pAllocator);
2503     device->funcs.p_vkDestroyRenderPass(device->device, renderPass, NULL);
2504 }
2505
2506 void WINAPI wine_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
2507 {
2508     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(sampler), pAllocator);
2509     device->funcs.p_vkDestroySampler(device->device, sampler, NULL);
2510 }
2511
2512 void WINAPI wine_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
2513 {
2514     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(ycbcrConversion), pAllocator);
2515     device->funcs.p_vkDestroySamplerYcbcrConversion(device->device, ycbcrConversion, NULL);
2516 }
2517
2518 static void WINAPI wine_vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
2519 {
2520     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(ycbcrConversion), pAllocator);
2521     device->funcs.p_vkDestroySamplerYcbcrConversionKHR(device->device, ycbcrConversion, NULL);
2522 }
2523
2524 void WINAPI wine_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
2525 {
2526     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(semaphore), pAllocator);
2527     device->funcs.p_vkDestroySemaphore(device->device, semaphore, NULL);
2528 }
2529
2530 void WINAPI wine_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
2531 {
2532     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(shaderModule), pAllocator);
2533     device->funcs.p_vkDestroyShaderModule(device->device, shaderModule, NULL);
2534 }
2535
2536 void WINAPI wine_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
2537 {
2538     TRACE("%p, 0x%s, %p\n", instance, wine_dbgstr_longlong(surface), pAllocator);
2539     instance->funcs.p_vkDestroySurfaceKHR(instance->instance, surface, NULL);
2540 }
2541
2542 void WINAPI wine_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
2543 {
2544     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(swapchain), pAllocator);
2545     device->funcs.p_vkDestroySwapchainKHR(device->device, swapchain, NULL);
2546 }
2547
2548 static void WINAPI wine_vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
2549 {
2550     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(validationCache), pAllocator);
2551     device->funcs.p_vkDestroyValidationCacheEXT(device->device, validationCache, NULL);
2552 }
2553
2554 VkResult WINAPI wine_vkDeviceWaitIdle(VkDevice device)
2555 {
2556     TRACE("%p\n", device);
2557     return device->funcs.p_vkDeviceWaitIdle(device->device);
2558 }
2559
2560 VkResult WINAPI wine_vkEndCommandBuffer(VkCommandBuffer commandBuffer)
2561 {
2562     TRACE("%p\n", commandBuffer);
2563     return commandBuffer->device->funcs.p_vkEndCommandBuffer(commandBuffer->command_buffer);
2564 }
2565
2566 VkResult WINAPI wine_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
2567 {
2568     TRACE("%p, %p, %p\n", physicalDevice, pPropertyCount, pProperties);
2569     return physicalDevice->instance->funcs.p_vkEnumerateDeviceLayerProperties(physicalDevice->phys_dev, pPropertyCount, pProperties);
2570 }
2571
2572 VkResult WINAPI wine_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
2573 {
2574 #if defined(USE_STRUCT_CONVERSION)
2575     VkResult result;
2576     VkMappedMemoryRange_host *pMemoryRanges_host;
2577     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
2578
2579     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win_to_host(pMemoryRanges, memoryRangeCount);
2580     result = device->funcs.p_vkFlushMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges_host);
2581
2582     free_VkMappedMemoryRange_array(pMemoryRanges_host, memoryRangeCount);
2583     return result;
2584 #else
2585     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
2586     return device->funcs.p_vkFlushMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges);
2587 #endif
2588 }
2589
2590 VkResult WINAPI wine_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
2591 {
2592     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(descriptorPool), descriptorSetCount, pDescriptorSets);
2593     return device->funcs.p_vkFreeDescriptorSets(device->device, descriptorPool, descriptorSetCount, pDescriptorSets);
2594 }
2595
2596 void WINAPI wine_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
2597 {
2598     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(memory), pAllocator);
2599     device->funcs.p_vkFreeMemory(device->device, memory, NULL);
2600 }
2601
2602 static VkResult WINAPI wine_vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
2603 {
2604     TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(accelerationStructure), wine_dbgstr_longlong(dataSize), pData);
2605     return device->funcs.p_vkGetAccelerationStructureHandleNV(device->device, accelerationStructure, dataSize, pData);
2606 }
2607
2608 static void WINAPI wine_vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
2609 {
2610 #if defined(USE_STRUCT_CONVERSION)
2611     VkAccelerationStructureMemoryRequirementsInfoNV_host pInfo_host;
2612     VkMemoryRequirements2KHR_host pMemoryRequirements_host;
2613     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
2614
2615     convert_VkAccelerationStructureMemoryRequirementsInfoNV_win_to_host(pInfo, &pInfo_host);
2616     convert_VkMemoryRequirements2KHR_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
2617     device->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(device->device, &pInfo_host, &pMemoryRequirements_host);
2618
2619     convert_VkMemoryRequirements2KHR_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
2620 #else
2621     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
2622     device->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(device->device, pInfo, pMemoryRequirements);
2623 #endif
2624 }
2625
2626 static VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfoEXT *pInfo)
2627 {
2628 #if defined(USE_STRUCT_CONVERSION)
2629     VkDeviceAddress result;
2630     VkBufferDeviceAddressInfoEXT_host pInfo_host;
2631     TRACE("%p, %p\n", device, pInfo);
2632
2633     convert_VkBufferDeviceAddressInfoEXT_win_to_host(pInfo, &pInfo_host);
2634     result = device->funcs.p_vkGetBufferDeviceAddressEXT(device->device, &pInfo_host);
2635
2636     return result;
2637 #else
2638     TRACE("%p, %p\n", device, pInfo);
2639     return device->funcs.p_vkGetBufferDeviceAddressEXT(device->device, pInfo);
2640 #endif
2641 }
2642
2643 void WINAPI wine_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
2644 {
2645 #if defined(USE_STRUCT_CONVERSION)
2646     VkMemoryRequirements_host pMemoryRequirements_host;
2647     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pMemoryRequirements);
2648
2649     device->funcs.p_vkGetBufferMemoryRequirements(device->device, buffer, &pMemoryRequirements_host);
2650
2651     convert_VkMemoryRequirements_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
2652 #else
2653     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pMemoryRequirements);
2654     device->funcs.p_vkGetBufferMemoryRequirements(device->device, buffer, pMemoryRequirements);
2655 #endif
2656 }
2657
2658 void WINAPI wine_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
2659 {
2660 #if defined(USE_STRUCT_CONVERSION)
2661     VkBufferMemoryRequirementsInfo2_host pInfo_host;
2662     VkMemoryRequirements2_host pMemoryRequirements_host;
2663     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
2664
2665     convert_VkBufferMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
2666     convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
2667     device->funcs.p_vkGetBufferMemoryRequirements2(device->device, &pInfo_host, &pMemoryRequirements_host);
2668
2669     convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
2670 #else
2671     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
2672     device->funcs.p_vkGetBufferMemoryRequirements2(device->device, pInfo, pMemoryRequirements);
2673 #endif
2674 }
2675
2676 static void WINAPI wine_vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
2677 {
2678 #if defined(USE_STRUCT_CONVERSION)
2679     VkBufferMemoryRequirementsInfo2_host pInfo_host;
2680     VkMemoryRequirements2_host pMemoryRequirements_host;
2681     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
2682
2683     convert_VkBufferMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
2684     convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
2685     device->funcs.p_vkGetBufferMemoryRequirements2KHR(device->device, &pInfo_host, &pMemoryRequirements_host);
2686
2687     convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
2688 #else
2689     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
2690     device->funcs.p_vkGetBufferMemoryRequirements2KHR(device->device, pInfo, pMemoryRequirements);
2691 #endif
2692 }
2693
2694 void WINAPI wine_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
2695 {
2696     TRACE("%p, %p, %p\n", device, pCreateInfo, pSupport);
2697     device->funcs.p_vkGetDescriptorSetLayoutSupport(device->device, pCreateInfo, pSupport);
2698 }
2699
2700 static void WINAPI wine_vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
2701 {
2702     TRACE("%p, %p, %p\n", device, pCreateInfo, pSupport);
2703     device->funcs.p_vkGetDescriptorSetLayoutSupportKHR(device->device, pCreateInfo, pSupport);
2704 }
2705
2706 void WINAPI wine_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
2707 {
2708     TRACE("%p, %u, %u, %u, %p\n", device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
2709     device->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(device->device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
2710 }
2711
2712 static void WINAPI wine_vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
2713 {
2714     TRACE("%p, %u, %u, %u, %p\n", device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
2715     device->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(device->device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
2716 }
2717
2718 VkResult WINAPI wine_vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
2719 {
2720     TRACE("%p, %p\n", device, pDeviceGroupPresentCapabilities);
2721     return device->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(device->device, pDeviceGroupPresentCapabilities);
2722 }
2723
2724 VkResult WINAPI wine_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
2725 {
2726     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(surface), pModes);
2727     return device->funcs.p_vkGetDeviceGroupSurfacePresentModesKHR(device->device, surface, pModes);
2728 }
2729
2730 void WINAPI wine_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
2731 {
2732     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(memory), pCommittedMemoryInBytes);
2733     device->funcs.p_vkGetDeviceMemoryCommitment(device->device, memory, pCommittedMemoryInBytes);
2734 }
2735
2736 VkResult WINAPI wine_vkGetEventStatus(VkDevice device, VkEvent event)
2737 {
2738     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
2739     return device->funcs.p_vkGetEventStatus(device->device, event);
2740 }
2741
2742 VkResult WINAPI wine_vkGetFenceStatus(VkDevice device, VkFence fence)
2743 {
2744     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(fence));
2745     return device->funcs.p_vkGetFenceStatus(device->device, fence);
2746 }
2747
2748 void WINAPI wine_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
2749 {
2750 #if defined(USE_STRUCT_CONVERSION)
2751     VkMemoryRequirements_host pMemoryRequirements_host;
2752     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pMemoryRequirements);
2753
2754     device->funcs.p_vkGetImageMemoryRequirements(device->device, image, &pMemoryRequirements_host);
2755
2756     convert_VkMemoryRequirements_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
2757 #else
2758     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pMemoryRequirements);
2759     device->funcs.p_vkGetImageMemoryRequirements(device->device, image, pMemoryRequirements);
2760 #endif
2761 }
2762
2763 void WINAPI wine_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
2764 {
2765 #if defined(USE_STRUCT_CONVERSION)
2766     VkImageMemoryRequirementsInfo2_host pInfo_host;
2767     VkMemoryRequirements2_host pMemoryRequirements_host;
2768     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
2769
2770     convert_VkImageMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
2771     convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
2772     device->funcs.p_vkGetImageMemoryRequirements2(device->device, &pInfo_host, &pMemoryRequirements_host);
2773
2774     convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
2775 #else
2776     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
2777     device->funcs.p_vkGetImageMemoryRequirements2(device->device, pInfo, pMemoryRequirements);
2778 #endif
2779 }
2780
2781 static void WINAPI wine_vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
2782 {
2783 #if defined(USE_STRUCT_CONVERSION)
2784     VkImageMemoryRequirementsInfo2_host pInfo_host;
2785     VkMemoryRequirements2_host pMemoryRequirements_host;
2786     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
2787
2788     convert_VkImageMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
2789     convert_VkMemoryRequirements2_win_to_host(pMemoryRequirements, &pMemoryRequirements_host);
2790     device->funcs.p_vkGetImageMemoryRequirements2KHR(device->device, &pInfo_host, &pMemoryRequirements_host);
2791
2792     convert_VkMemoryRequirements2_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
2793 #else
2794     TRACE("%p, %p, %p\n", device, pInfo, pMemoryRequirements);
2795     device->funcs.p_vkGetImageMemoryRequirements2KHR(device->device, pInfo, pMemoryRequirements);
2796 #endif
2797 }
2798
2799 void WINAPI wine_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
2800 {
2801     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2802     device->funcs.p_vkGetImageSparseMemoryRequirements(device->device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2803 }
2804
2805 void WINAPI wine_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
2806 {
2807 #if defined(USE_STRUCT_CONVERSION)
2808     VkImageSparseMemoryRequirementsInfo2_host pInfo_host;
2809     TRACE("%p, %p, %p, %p\n", device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2810
2811     convert_VkImageSparseMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
2812     device->funcs.p_vkGetImageSparseMemoryRequirements2(device->device, &pInfo_host, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2813
2814 #else
2815     TRACE("%p, %p, %p, %p\n", device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2816     device->funcs.p_vkGetImageSparseMemoryRequirements2(device->device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2817 #endif
2818 }
2819
2820 static void WINAPI wine_vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
2821 {
2822 #if defined(USE_STRUCT_CONVERSION)
2823     VkImageSparseMemoryRequirementsInfo2_host pInfo_host;
2824     TRACE("%p, %p, %p, %p\n", device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2825
2826     convert_VkImageSparseMemoryRequirementsInfo2_win_to_host(pInfo, &pInfo_host);
2827     device->funcs.p_vkGetImageSparseMemoryRequirements2KHR(device->device, &pInfo_host, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2828
2829 #else
2830     TRACE("%p, %p, %p, %p\n", device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2831     device->funcs.p_vkGetImageSparseMemoryRequirements2KHR(device->device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2832 #endif
2833 }
2834
2835 void WINAPI wine_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
2836 {
2837 #if defined(USE_STRUCT_CONVERSION)
2838     VkSubresourceLayout_host pLayout_host;
2839     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSubresource, pLayout);
2840
2841     device->funcs.p_vkGetImageSubresourceLayout(device->device, image, pSubresource, &pLayout_host);
2842
2843     convert_VkSubresourceLayout_host_to_win(&pLayout_host, pLayout);
2844 #else
2845     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSubresource, pLayout);
2846     device->funcs.p_vkGetImageSubresourceLayout(device->device, image, pSubresource, pLayout);
2847 #endif
2848 }
2849
2850 void WINAPI wine_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
2851 {
2852     TRACE("%p, %p\n", physicalDevice, pFeatures);
2853     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures(physicalDevice->phys_dev, pFeatures);
2854 }
2855
2856 void WINAPI wine_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
2857 {
2858     TRACE("%p, %p\n", physicalDevice, pFeatures);
2859     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures2(physicalDevice->phys_dev, pFeatures);
2860 }
2861
2862 static void WINAPI wine_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
2863 {
2864     TRACE("%p, %p\n", physicalDevice, pFeatures);
2865     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(physicalDevice->phys_dev, pFeatures);
2866 }
2867
2868 void WINAPI wine_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
2869 {
2870     TRACE("%p, %#x, %p\n", physicalDevice, format, pFormatProperties);
2871     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(physicalDevice->phys_dev, format, pFormatProperties);
2872 }
2873
2874 void WINAPI wine_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
2875 {
2876     TRACE("%p, %#x, %p\n", physicalDevice, format, pFormatProperties);
2877     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(physicalDevice->phys_dev, format, pFormatProperties);
2878 }
2879
2880 static void WINAPI wine_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
2881 {
2882     TRACE("%p, %#x, %p\n", physicalDevice, format, pFormatProperties);
2883     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice->phys_dev, format, pFormatProperties);
2884 }
2885
2886 VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
2887 {
2888 #if defined(USE_STRUCT_CONVERSION)
2889     VkResult result;
2890     VkImageFormatProperties_host pImageFormatProperties_host;
2891     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
2892
2893     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(physicalDevice->phys_dev, format, type, tiling, usage, flags, &pImageFormatProperties_host);
2894
2895     convert_VkImageFormatProperties_host_to_win(&pImageFormatProperties_host, pImageFormatProperties);
2896     return result;
2897 #else
2898     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
2899     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(physicalDevice->phys_dev, format, type, tiling, usage, flags, pImageFormatProperties);
2900 #endif
2901 }
2902
2903 VkResult thunk_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
2904 {
2905 #if defined(USE_STRUCT_CONVERSION)
2906     VkResult result;
2907     VkImageFormatProperties2_host pImageFormatProperties_host;
2908     convert_VkImageFormatProperties2_win_to_host(pImageFormatProperties, &pImageFormatProperties_host);
2909     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice->phys_dev, pImageFormatInfo, &pImageFormatProperties_host);
2910
2911     convert_VkImageFormatProperties2_host_to_win(&pImageFormatProperties_host, pImageFormatProperties);
2912     return result;
2913 #else
2914     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice->phys_dev, pImageFormatInfo, pImageFormatProperties);
2915 #endif
2916 }
2917
2918 VkResult thunk_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
2919 {
2920 #if defined(USE_STRUCT_CONVERSION)
2921     VkResult result;
2922     VkImageFormatProperties2_host pImageFormatProperties_host;
2923     convert_VkImageFormatProperties2_win_to_host(pImageFormatProperties, &pImageFormatProperties_host);
2924     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice->phys_dev, pImageFormatInfo, &pImageFormatProperties_host);
2925
2926     convert_VkImageFormatProperties2_host_to_win(&pImageFormatProperties_host, pImageFormatProperties);
2927     return result;
2928 #else
2929     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice->phys_dev, pImageFormatInfo, pImageFormatProperties);
2930 #endif
2931 }
2932
2933 void WINAPI wine_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
2934 {
2935 #if defined(USE_STRUCT_CONVERSION)
2936     VkPhysicalDeviceMemoryProperties_host pMemoryProperties_host;
2937     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
2938
2939     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(physicalDevice->phys_dev, &pMemoryProperties_host);
2940
2941     convert_VkPhysicalDeviceMemoryProperties_host_to_win(&pMemoryProperties_host, pMemoryProperties);
2942 #else
2943     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
2944     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(physicalDevice->phys_dev, pMemoryProperties);
2945 #endif
2946 }
2947
2948 void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
2949 {
2950 #if defined(USE_STRUCT_CONVERSION)
2951     VkPhysicalDeviceMemoryProperties2_host pMemoryProperties_host;
2952     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
2953
2954     convert_VkPhysicalDeviceMemoryProperties2_win_to_host(pMemoryProperties, &pMemoryProperties_host);
2955     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(physicalDevice->phys_dev, &pMemoryProperties_host);
2956
2957     convert_VkPhysicalDeviceMemoryProperties2_host_to_win(&pMemoryProperties_host, pMemoryProperties);
2958 #else
2959     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
2960     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(physicalDevice->phys_dev, pMemoryProperties);
2961 #endif
2962 }
2963
2964 static void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
2965 {
2966 #if defined(USE_STRUCT_CONVERSION)
2967     VkPhysicalDeviceMemoryProperties2_host pMemoryProperties_host;
2968     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
2969
2970     convert_VkPhysicalDeviceMemoryProperties2_win_to_host(pMemoryProperties, &pMemoryProperties_host);
2971     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice->phys_dev, &pMemoryProperties_host);
2972
2973     convert_VkPhysicalDeviceMemoryProperties2_host_to_win(&pMemoryProperties_host, pMemoryProperties);
2974 #else
2975     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
2976     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice->phys_dev, pMemoryProperties);
2977 #endif
2978 }
2979
2980 static void WINAPI wine_vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
2981 {
2982     TRACE("%p, %#x, %p\n", physicalDevice, samples, pMultisampleProperties);
2983     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice->phys_dev, samples, pMultisampleProperties);
2984 }
2985
2986 VkResult WINAPI wine_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
2987 {
2988     TRACE("%p, 0x%s, %p, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pRectCount, pRects);
2989     return physicalDevice->instance->funcs.p_vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice->phys_dev, surface, pRectCount, pRects);
2990 }
2991
2992 void WINAPI wine_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
2993 {
2994 #if defined(USE_STRUCT_CONVERSION)
2995     VkPhysicalDeviceProperties_host pProperties_host;
2996     TRACE("%p, %p\n", physicalDevice, pProperties);
2997
2998     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties(physicalDevice->phys_dev, &pProperties_host);
2999
3000     convert_VkPhysicalDeviceProperties_host_to_win(&pProperties_host, pProperties);
3001 #else
3002     TRACE("%p, %p\n", physicalDevice, pProperties);
3003     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties(physicalDevice->phys_dev, pProperties);
3004 #endif
3005 }
3006
3007 void WINAPI wine_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
3008 {
3009 #if defined(USE_STRUCT_CONVERSION)
3010     VkPhysicalDeviceProperties2_host pProperties_host;
3011     TRACE("%p, %p\n", physicalDevice, pProperties);
3012
3013     convert_VkPhysicalDeviceProperties2_win_to_host(pProperties, &pProperties_host);
3014     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2(physicalDevice->phys_dev, &pProperties_host);
3015
3016     convert_VkPhysicalDeviceProperties2_host_to_win(&pProperties_host, pProperties);
3017 #else
3018     TRACE("%p, %p\n", physicalDevice, pProperties);
3019     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2(physicalDevice->phys_dev, pProperties);
3020 #endif
3021 }
3022
3023 static void WINAPI wine_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
3024 {
3025 #if defined(USE_STRUCT_CONVERSION)
3026     VkPhysicalDeviceProperties2_host pProperties_host;
3027     TRACE("%p, %p\n", physicalDevice, pProperties);
3028
3029     convert_VkPhysicalDeviceProperties2_win_to_host(pProperties, &pProperties_host);
3030     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(physicalDevice->phys_dev, &pProperties_host);
3031
3032     convert_VkPhysicalDeviceProperties2_host_to_win(&pProperties_host, pProperties);
3033 #else
3034     TRACE("%p, %p\n", physicalDevice, pProperties);
3035     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(physicalDevice->phys_dev, pProperties);
3036 #endif
3037 }
3038
3039 void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
3040 {
3041     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
3042     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
3043 }
3044
3045 void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
3046 {
3047     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
3048     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
3049 }
3050
3051 static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
3052 {
3053     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
3054     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
3055 }
3056
3057 void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
3058 {
3059     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p, %p\n", physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
3060     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice->phys_dev, format, type, samples, usage, tiling, pPropertyCount, pProperties);
3061 }
3062
3063 void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
3064 {
3065     TRACE("%p, %p, %p, %p\n", physicalDevice, pFormatInfo, pPropertyCount, pProperties);
3066     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice->phys_dev, pFormatInfo, pPropertyCount, pProperties);
3067 }
3068
3069 static void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
3070 {
3071     TRACE("%p, %p, %p, %p\n", physicalDevice, pFormatInfo, pPropertyCount, pProperties);
3072     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice->phys_dev, pFormatInfo, pPropertyCount, pProperties);
3073 }
3074
3075 VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
3076 {
3077     TRACE("%p, 0x%s, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pSurfaceCapabilities);
3078     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice->phys_dev, surface, pSurfaceCapabilities);
3079 }
3080
3081 VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
3082 {
3083     TRACE("%p, 0x%s, %p, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pSurfaceFormatCount, pSurfaceFormats);
3084     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice->phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats);
3085 }
3086
3087 VkResult WINAPI wine_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
3088 {
3089     TRACE("%p, 0x%s, %p, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pPresentModeCount, pPresentModes);
3090     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice->phys_dev, surface, pPresentModeCount, pPresentModes);
3091 }
3092
3093 VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
3094 {
3095     TRACE("%p, %u, 0x%s, %p\n", physicalDevice, queueFamilyIndex, wine_dbgstr_longlong(surface), pSupported);
3096     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice->phys_dev, queueFamilyIndex, surface, pSupported);
3097 }
3098
3099 VkBool32 WINAPI wine_vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
3100 {
3101     TRACE("%p, %u\n", physicalDevice, queueFamilyIndex);
3102     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice->phys_dev, queueFamilyIndex);
3103 }
3104
3105 VkResult WINAPI wine_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
3106 {
3107     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), pDataSize, pData);
3108     return device->funcs.p_vkGetPipelineCacheData(device->device, pipelineCache, pDataSize, pData);
3109 }
3110
3111 VkResult WINAPI wine_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
3112 {
3113     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);
3114     return device->funcs.p_vkGetQueryPoolResults(device->device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
3115 }
3116
3117 static void WINAPI wine_vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
3118 {
3119     TRACE("%p, %p, %p\n", queue, pCheckpointDataCount, pCheckpointData);
3120     queue->device->funcs.p_vkGetQueueCheckpointDataNV(queue->queue, pCheckpointDataCount, pCheckpointData);
3121 }
3122
3123 static VkResult WINAPI wine_vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
3124 {
3125     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), firstGroup, groupCount, wine_dbgstr_longlong(dataSize), pData);
3126     return device->funcs.p_vkGetRayTracingShaderGroupHandlesNV(device->device, pipeline, firstGroup, groupCount, dataSize, pData);
3127 }
3128
3129 void WINAPI wine_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
3130 {
3131     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pGranularity);
3132     device->funcs.p_vkGetRenderAreaGranularity(device->device, renderPass, pGranularity);
3133 }
3134
3135 static VkResult WINAPI wine_vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
3136 {
3137     TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", device, wine_dbgstr_longlong(pipeline), shaderStage, infoType, pInfoSize, pInfo);
3138     return device->funcs.p_vkGetShaderInfoAMD(device->device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
3139 }
3140
3141 VkResult WINAPI wine_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
3142 {
3143     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(swapchain), pSwapchainImageCount, pSwapchainImages);
3144     return device->funcs.p_vkGetSwapchainImagesKHR(device->device, swapchain, pSwapchainImageCount, pSwapchainImages);
3145 }
3146
3147 static VkResult WINAPI wine_vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
3148 {
3149     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(validationCache), pDataSize, pData);
3150     return device->funcs.p_vkGetValidationCacheDataEXT(device->device, validationCache, pDataSize, pData);
3151 }
3152
3153 VkResult WINAPI wine_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
3154 {
3155 #if defined(USE_STRUCT_CONVERSION)
3156     VkResult result;
3157     VkMappedMemoryRange_host *pMemoryRanges_host;
3158     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
3159
3160     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win_to_host(pMemoryRanges, memoryRangeCount);
3161     result = device->funcs.p_vkInvalidateMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges_host);
3162
3163     free_VkMappedMemoryRange_array(pMemoryRanges_host, memoryRangeCount);
3164     return result;
3165 #else
3166     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
3167     return device->funcs.p_vkInvalidateMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges);
3168 #endif
3169 }
3170
3171 VkResult WINAPI wine_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
3172 {
3173     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);
3174     return device->funcs.p_vkMapMemory(device->device, memory, offset, size, flags, ppData);
3175 }
3176
3177 VkResult WINAPI wine_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
3178 {
3179     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(dstCache), srcCacheCount, pSrcCaches);
3180     return device->funcs.p_vkMergePipelineCaches(device->device, dstCache, srcCacheCount, pSrcCaches);
3181 }
3182
3183 static VkResult WINAPI wine_vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
3184 {
3185     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(dstCache), srcCacheCount, pSrcCaches);
3186     return device->funcs.p_vkMergeValidationCachesEXT(device->device, dstCache, srcCacheCount, pSrcCaches);
3187 }
3188
3189 VkResult WINAPI wine_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
3190 {
3191 #if defined(USE_STRUCT_CONVERSION)
3192     VkResult result;
3193     VkBindSparseInfo_host *pBindInfo_host;
3194     TRACE("%p, %u, %p, 0x%s\n", queue, bindInfoCount, pBindInfo, wine_dbgstr_longlong(fence));
3195
3196     pBindInfo_host = convert_VkBindSparseInfo_array_win_to_host(pBindInfo, bindInfoCount);
3197     result = queue->device->funcs.p_vkQueueBindSparse(queue->queue, bindInfoCount, pBindInfo_host, fence);
3198
3199     free_VkBindSparseInfo_array(pBindInfo_host, bindInfoCount);
3200     return result;
3201 #else
3202     TRACE("%p, %u, %p, 0x%s\n", queue, bindInfoCount, pBindInfo, wine_dbgstr_longlong(fence));
3203     return queue->device->funcs.p_vkQueueBindSparse(queue->queue, bindInfoCount, pBindInfo, fence);
3204 #endif
3205 }
3206
3207 VkResult WINAPI wine_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
3208 {
3209     TRACE("%p, %p\n", queue, pPresentInfo);
3210     return queue->device->funcs.p_vkQueuePresentKHR(queue->queue, pPresentInfo);
3211 }
3212
3213 VkResult WINAPI wine_vkQueueWaitIdle(VkQueue queue)
3214 {
3215     TRACE("%p\n", queue);
3216     return queue->device->funcs.p_vkQueueWaitIdle(queue->queue);
3217 }
3218
3219 VkResult WINAPI wine_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
3220 {
3221     TRACE("%p, %#x\n", commandBuffer, flags);
3222     return commandBuffer->device->funcs.p_vkResetCommandBuffer(commandBuffer->command_buffer, flags);
3223 }
3224
3225 VkResult WINAPI wine_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
3226 {
3227     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
3228     return device->funcs.p_vkResetCommandPool(device->device, wine_cmd_pool_from_handle(commandPool)->command_pool, flags);
3229 }
3230
3231 VkResult WINAPI wine_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
3232 {
3233     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(descriptorPool), flags);
3234     return device->funcs.p_vkResetDescriptorPool(device->device, descriptorPool, flags);
3235 }
3236
3237 VkResult WINAPI wine_vkResetEvent(VkDevice device, VkEvent event)
3238 {
3239     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
3240     return device->funcs.p_vkResetEvent(device->device, event);
3241 }
3242
3243 VkResult WINAPI wine_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
3244 {
3245     TRACE("%p, %u, %p\n", device, fenceCount, pFences);
3246     return device->funcs.p_vkResetFences(device->device, fenceCount, pFences);
3247 }
3248
3249 static void WINAPI wine_vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
3250 {
3251     TRACE("%p, 0x%s, %u, %u\n", device, wine_dbgstr_longlong(queryPool), firstQuery, queryCount);
3252     device->funcs.p_vkResetQueryPoolEXT(device->device, queryPool, firstQuery, queryCount);
3253 }
3254
3255 VkResult WINAPI wine_vkSetEvent(VkDevice device, VkEvent event)
3256 {
3257     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
3258     return device->funcs.p_vkSetEvent(device->device, event);
3259 }
3260
3261 void WINAPI wine_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
3262 {
3263     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
3264     device->funcs.p_vkTrimCommandPool(device->device, wine_cmd_pool_from_handle(commandPool)->command_pool, flags);
3265 }
3266
3267 static void WINAPI wine_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
3268 {
3269     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
3270     device->funcs.p_vkTrimCommandPoolKHR(device->device, wine_cmd_pool_from_handle(commandPool)->command_pool, flags);
3271 }
3272
3273 void WINAPI wine_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
3274 {
3275     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(memory));
3276     device->funcs.p_vkUnmapMemory(device->device, memory);
3277 }
3278
3279 void WINAPI wine_vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
3280 {
3281     TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSet), wine_dbgstr_longlong(descriptorUpdateTemplate), pData);
3282     device->funcs.p_vkUpdateDescriptorSetWithTemplate(device->device, descriptorSet, descriptorUpdateTemplate, pData);
3283 }
3284
3285 static void WINAPI wine_vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
3286 {
3287     TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSet), wine_dbgstr_longlong(descriptorUpdateTemplate), pData);
3288     device->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(device->device, descriptorSet, descriptorUpdateTemplate, pData);
3289 }
3290
3291 void WINAPI wine_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
3292 {
3293 #if defined(USE_STRUCT_CONVERSION)
3294     VkWriteDescriptorSet_host *pDescriptorWrites_host;
3295     VkCopyDescriptorSet_host *pDescriptorCopies_host;
3296     TRACE("%p, %u, %p, %u, %p\n", device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
3297
3298     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win_to_host(pDescriptorWrites, descriptorWriteCount);
3299     pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win_to_host(pDescriptorCopies, descriptorCopyCount);
3300     device->funcs.p_vkUpdateDescriptorSets(device->device, descriptorWriteCount, pDescriptorWrites_host, descriptorCopyCount, pDescriptorCopies_host);
3301
3302     free_VkWriteDescriptorSet_array(pDescriptorWrites_host, descriptorWriteCount);
3303     free_VkCopyDescriptorSet_array(pDescriptorCopies_host, descriptorCopyCount);
3304 #else
3305     TRACE("%p, %u, %p, %u, %p\n", device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
3306     device->funcs.p_vkUpdateDescriptorSets(device->device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
3307 #endif
3308 }
3309
3310 VkResult WINAPI wine_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
3311 {
3312     TRACE("%p, %u, %p, %u, 0x%s\n", device, fenceCount, pFences, waitAll, wine_dbgstr_longlong(timeout));
3313     return device->funcs.p_vkWaitForFences(device->device, fenceCount, pFences, waitAll, timeout);
3314 }
3315
3316 static const struct vulkan_func vk_device_dispatch_table[] =
3317 {
3318     {"vkAcquireNextImage2KHR", &wine_vkAcquireNextImage2KHR},
3319     {"vkAcquireNextImageKHR", &wine_vkAcquireNextImageKHR},
3320     {"vkAllocateCommandBuffers", &wine_vkAllocateCommandBuffers},
3321     {"vkAllocateDescriptorSets", &wine_vkAllocateDescriptorSets},
3322     {"vkAllocateMemory", &wine_vkAllocateMemory},
3323     {"vkBeginCommandBuffer", &wine_vkBeginCommandBuffer},
3324     {"vkBindAccelerationStructureMemoryNV", &wine_vkBindAccelerationStructureMemoryNV},
3325     {"vkBindBufferMemory", &wine_vkBindBufferMemory},
3326     {"vkBindBufferMemory2", &wine_vkBindBufferMemory2},
3327     {"vkBindBufferMemory2KHR", &wine_vkBindBufferMemory2KHR},
3328     {"vkBindImageMemory", &wine_vkBindImageMemory},
3329     {"vkBindImageMemory2", &wine_vkBindImageMemory2},
3330     {"vkBindImageMemory2KHR", &wine_vkBindImageMemory2KHR},
3331     {"vkCmdBeginConditionalRenderingEXT", &wine_vkCmdBeginConditionalRenderingEXT},
3332     {"vkCmdBeginQuery", &wine_vkCmdBeginQuery},
3333     {"vkCmdBeginQueryIndexedEXT", &wine_vkCmdBeginQueryIndexedEXT},
3334     {"vkCmdBeginRenderPass", &wine_vkCmdBeginRenderPass},
3335     {"vkCmdBeginRenderPass2KHR", &wine_vkCmdBeginRenderPass2KHR},
3336     {"vkCmdBeginTransformFeedbackEXT", &wine_vkCmdBeginTransformFeedbackEXT},
3337     {"vkCmdBindDescriptorSets", &wine_vkCmdBindDescriptorSets},
3338     {"vkCmdBindIndexBuffer", &wine_vkCmdBindIndexBuffer},
3339     {"vkCmdBindPipeline", &wine_vkCmdBindPipeline},
3340     {"vkCmdBindShadingRateImageNV", &wine_vkCmdBindShadingRateImageNV},
3341     {"vkCmdBindTransformFeedbackBuffersEXT", &wine_vkCmdBindTransformFeedbackBuffersEXT},
3342     {"vkCmdBindVertexBuffers", &wine_vkCmdBindVertexBuffers},
3343     {"vkCmdBlitImage", &wine_vkCmdBlitImage},
3344     {"vkCmdBuildAccelerationStructureNV", &wine_vkCmdBuildAccelerationStructureNV},
3345     {"vkCmdClearAttachments", &wine_vkCmdClearAttachments},
3346     {"vkCmdClearColorImage", &wine_vkCmdClearColorImage},
3347     {"vkCmdClearDepthStencilImage", &wine_vkCmdClearDepthStencilImage},
3348     {"vkCmdCopyAccelerationStructureNV", &wine_vkCmdCopyAccelerationStructureNV},
3349     {"vkCmdCopyBuffer", &wine_vkCmdCopyBuffer},
3350     {"vkCmdCopyBufferToImage", &wine_vkCmdCopyBufferToImage},
3351     {"vkCmdCopyImage", &wine_vkCmdCopyImage},
3352     {"vkCmdCopyImageToBuffer", &wine_vkCmdCopyImageToBuffer},
3353     {"vkCmdCopyQueryPoolResults", &wine_vkCmdCopyQueryPoolResults},
3354     {"vkCmdDispatch", &wine_vkCmdDispatch},
3355     {"vkCmdDispatchBase", &wine_vkCmdDispatchBase},
3356     {"vkCmdDispatchBaseKHR", &wine_vkCmdDispatchBaseKHR},
3357     {"vkCmdDispatchIndirect", &wine_vkCmdDispatchIndirect},
3358     {"vkCmdDraw", &wine_vkCmdDraw},
3359     {"vkCmdDrawIndexed", &wine_vkCmdDrawIndexed},
3360     {"vkCmdDrawIndexedIndirect", &wine_vkCmdDrawIndexedIndirect},
3361     {"vkCmdDrawIndexedIndirectCountAMD", &wine_vkCmdDrawIndexedIndirectCountAMD},
3362     {"vkCmdDrawIndexedIndirectCountKHR", &wine_vkCmdDrawIndexedIndirectCountKHR},
3363     {"vkCmdDrawIndirect", &wine_vkCmdDrawIndirect},
3364     {"vkCmdDrawIndirectByteCountEXT", &wine_vkCmdDrawIndirectByteCountEXT},
3365     {"vkCmdDrawIndirectCountAMD", &wine_vkCmdDrawIndirectCountAMD},
3366     {"vkCmdDrawIndirectCountKHR", &wine_vkCmdDrawIndirectCountKHR},
3367     {"vkCmdDrawMeshTasksIndirectCountNV", &wine_vkCmdDrawMeshTasksIndirectCountNV},
3368     {"vkCmdDrawMeshTasksIndirectNV", &wine_vkCmdDrawMeshTasksIndirectNV},
3369     {"vkCmdDrawMeshTasksNV", &wine_vkCmdDrawMeshTasksNV},
3370     {"vkCmdEndConditionalRenderingEXT", &wine_vkCmdEndConditionalRenderingEXT},
3371     {"vkCmdEndQuery", &wine_vkCmdEndQuery},
3372     {"vkCmdEndQueryIndexedEXT", &wine_vkCmdEndQueryIndexedEXT},
3373     {"vkCmdEndRenderPass", &wine_vkCmdEndRenderPass},
3374     {"vkCmdEndRenderPass2KHR", &wine_vkCmdEndRenderPass2KHR},
3375     {"vkCmdEndTransformFeedbackEXT", &wine_vkCmdEndTransformFeedbackEXT},
3376     {"vkCmdExecuteCommands", &wine_vkCmdExecuteCommands},
3377     {"vkCmdFillBuffer", &wine_vkCmdFillBuffer},
3378     {"vkCmdNextSubpass", &wine_vkCmdNextSubpass},
3379     {"vkCmdNextSubpass2KHR", &wine_vkCmdNextSubpass2KHR},
3380     {"vkCmdPipelineBarrier", &wine_vkCmdPipelineBarrier},
3381     {"vkCmdPushConstants", &wine_vkCmdPushConstants},
3382     {"vkCmdPushDescriptorSetKHR", &wine_vkCmdPushDescriptorSetKHR},
3383     {"vkCmdPushDescriptorSetWithTemplateKHR", &wine_vkCmdPushDescriptorSetWithTemplateKHR},
3384     {"vkCmdResetEvent", &wine_vkCmdResetEvent},
3385     {"vkCmdResetQueryPool", &wine_vkCmdResetQueryPool},
3386     {"vkCmdResolveImage", &wine_vkCmdResolveImage},
3387     {"vkCmdSetBlendConstants", &wine_vkCmdSetBlendConstants},
3388     {"vkCmdSetCheckpointNV", &wine_vkCmdSetCheckpointNV},
3389     {"vkCmdSetCoarseSampleOrderNV", &wine_vkCmdSetCoarseSampleOrderNV},
3390     {"vkCmdSetDepthBias", &wine_vkCmdSetDepthBias},
3391     {"vkCmdSetDepthBounds", &wine_vkCmdSetDepthBounds},
3392     {"vkCmdSetDeviceMask", &wine_vkCmdSetDeviceMask},
3393     {"vkCmdSetDeviceMaskKHR", &wine_vkCmdSetDeviceMaskKHR},
3394     {"vkCmdSetDiscardRectangleEXT", &wine_vkCmdSetDiscardRectangleEXT},
3395     {"vkCmdSetEvent", &wine_vkCmdSetEvent},
3396     {"vkCmdSetExclusiveScissorNV", &wine_vkCmdSetExclusiveScissorNV},
3397     {"vkCmdSetLineWidth", &wine_vkCmdSetLineWidth},
3398     {"vkCmdSetSampleLocationsEXT", &wine_vkCmdSetSampleLocationsEXT},
3399     {"vkCmdSetScissor", &wine_vkCmdSetScissor},
3400     {"vkCmdSetStencilCompareMask", &wine_vkCmdSetStencilCompareMask},
3401     {"vkCmdSetStencilReference", &wine_vkCmdSetStencilReference},
3402     {"vkCmdSetStencilWriteMask", &wine_vkCmdSetStencilWriteMask},
3403     {"vkCmdSetViewport", &wine_vkCmdSetViewport},
3404     {"vkCmdSetViewportShadingRatePaletteNV", &wine_vkCmdSetViewportShadingRatePaletteNV},
3405     {"vkCmdSetViewportWScalingNV", &wine_vkCmdSetViewportWScalingNV},
3406     {"vkCmdTraceRaysNV", &wine_vkCmdTraceRaysNV},
3407     {"vkCmdUpdateBuffer", &wine_vkCmdUpdateBuffer},
3408     {"vkCmdWaitEvents", &wine_vkCmdWaitEvents},
3409     {"vkCmdWriteAccelerationStructuresPropertiesNV", &wine_vkCmdWriteAccelerationStructuresPropertiesNV},
3410     {"vkCmdWriteBufferMarkerAMD", &wine_vkCmdWriteBufferMarkerAMD},
3411     {"vkCmdWriteTimestamp", &wine_vkCmdWriteTimestamp},
3412     {"vkCompileDeferredNV", &wine_vkCompileDeferredNV},
3413     {"vkCreateAccelerationStructureNV", &wine_vkCreateAccelerationStructureNV},
3414     {"vkCreateBuffer", &wine_vkCreateBuffer},
3415     {"vkCreateBufferView", &wine_vkCreateBufferView},
3416     {"vkCreateCommandPool", &wine_vkCreateCommandPool},
3417     {"vkCreateComputePipelines", &wine_vkCreateComputePipelines},
3418     {"vkCreateDescriptorPool", &wine_vkCreateDescriptorPool},
3419     {"vkCreateDescriptorSetLayout", &wine_vkCreateDescriptorSetLayout},
3420     {"vkCreateDescriptorUpdateTemplate", &wine_vkCreateDescriptorUpdateTemplate},
3421     {"vkCreateDescriptorUpdateTemplateKHR", &wine_vkCreateDescriptorUpdateTemplateKHR},
3422     {"vkCreateEvent", &wine_vkCreateEvent},
3423     {"vkCreateFence", &wine_vkCreateFence},
3424     {"vkCreateFramebuffer", &wine_vkCreateFramebuffer},
3425     {"vkCreateGraphicsPipelines", &wine_vkCreateGraphicsPipelines},
3426     {"vkCreateImage", &wine_vkCreateImage},
3427     {"vkCreateImageView", &wine_vkCreateImageView},
3428     {"vkCreatePipelineCache", &wine_vkCreatePipelineCache},
3429     {"vkCreatePipelineLayout", &wine_vkCreatePipelineLayout},
3430     {"vkCreateQueryPool", &wine_vkCreateQueryPool},
3431     {"vkCreateRayTracingPipelinesNV", &wine_vkCreateRayTracingPipelinesNV},
3432     {"vkCreateRenderPass", &wine_vkCreateRenderPass},
3433     {"vkCreateRenderPass2KHR", &wine_vkCreateRenderPass2KHR},
3434     {"vkCreateSampler", &wine_vkCreateSampler},
3435     {"vkCreateSamplerYcbcrConversion", &wine_vkCreateSamplerYcbcrConversion},
3436     {"vkCreateSamplerYcbcrConversionKHR", &wine_vkCreateSamplerYcbcrConversionKHR},
3437     {"vkCreateSemaphore", &wine_vkCreateSemaphore},
3438     {"vkCreateShaderModule", &wine_vkCreateShaderModule},
3439     {"vkCreateSwapchainKHR", &wine_vkCreateSwapchainKHR},
3440     {"vkCreateValidationCacheEXT", &wine_vkCreateValidationCacheEXT},
3441     {"vkDestroyAccelerationStructureNV", &wine_vkDestroyAccelerationStructureNV},
3442     {"vkDestroyBuffer", &wine_vkDestroyBuffer},
3443     {"vkDestroyBufferView", &wine_vkDestroyBufferView},
3444     {"vkDestroyCommandPool", &wine_vkDestroyCommandPool},
3445     {"vkDestroyDescriptorPool", &wine_vkDestroyDescriptorPool},
3446     {"vkDestroyDescriptorSetLayout", &wine_vkDestroyDescriptorSetLayout},
3447     {"vkDestroyDescriptorUpdateTemplate", &wine_vkDestroyDescriptorUpdateTemplate},
3448     {"vkDestroyDescriptorUpdateTemplateKHR", &wine_vkDestroyDescriptorUpdateTemplateKHR},
3449     {"vkDestroyDevice", &wine_vkDestroyDevice},
3450     {"vkDestroyEvent", &wine_vkDestroyEvent},
3451     {"vkDestroyFence", &wine_vkDestroyFence},
3452     {"vkDestroyFramebuffer", &wine_vkDestroyFramebuffer},
3453     {"vkDestroyImage", &wine_vkDestroyImage},
3454     {"vkDestroyImageView", &wine_vkDestroyImageView},
3455     {"vkDestroyPipeline", &wine_vkDestroyPipeline},
3456     {"vkDestroyPipelineCache", &wine_vkDestroyPipelineCache},
3457     {"vkDestroyPipelineLayout", &wine_vkDestroyPipelineLayout},
3458     {"vkDestroyQueryPool", &wine_vkDestroyQueryPool},
3459     {"vkDestroyRenderPass", &wine_vkDestroyRenderPass},
3460     {"vkDestroySampler", &wine_vkDestroySampler},
3461     {"vkDestroySamplerYcbcrConversion", &wine_vkDestroySamplerYcbcrConversion},
3462     {"vkDestroySamplerYcbcrConversionKHR", &wine_vkDestroySamplerYcbcrConversionKHR},
3463     {"vkDestroySemaphore", &wine_vkDestroySemaphore},
3464     {"vkDestroyShaderModule", &wine_vkDestroyShaderModule},
3465     {"vkDestroySwapchainKHR", &wine_vkDestroySwapchainKHR},
3466     {"vkDestroyValidationCacheEXT", &wine_vkDestroyValidationCacheEXT},
3467     {"vkDeviceWaitIdle", &wine_vkDeviceWaitIdle},
3468     {"vkEndCommandBuffer", &wine_vkEndCommandBuffer},
3469     {"vkFlushMappedMemoryRanges", &wine_vkFlushMappedMemoryRanges},
3470     {"vkFreeCommandBuffers", &wine_vkFreeCommandBuffers},
3471     {"vkFreeDescriptorSets", &wine_vkFreeDescriptorSets},
3472     {"vkFreeMemory", &wine_vkFreeMemory},
3473     {"vkGetAccelerationStructureHandleNV", &wine_vkGetAccelerationStructureHandleNV},
3474     {"vkGetAccelerationStructureMemoryRequirementsNV", &wine_vkGetAccelerationStructureMemoryRequirementsNV},
3475     {"vkGetBufferDeviceAddressEXT", &wine_vkGetBufferDeviceAddressEXT},
3476     {"vkGetBufferMemoryRequirements", &wine_vkGetBufferMemoryRequirements},
3477     {"vkGetBufferMemoryRequirements2", &wine_vkGetBufferMemoryRequirements2},
3478     {"vkGetBufferMemoryRequirements2KHR", &wine_vkGetBufferMemoryRequirements2KHR},
3479     {"vkGetDescriptorSetLayoutSupport", &wine_vkGetDescriptorSetLayoutSupport},
3480     {"vkGetDescriptorSetLayoutSupportKHR", &wine_vkGetDescriptorSetLayoutSupportKHR},
3481     {"vkGetDeviceGroupPeerMemoryFeatures", &wine_vkGetDeviceGroupPeerMemoryFeatures},
3482     {"vkGetDeviceGroupPeerMemoryFeaturesKHR", &wine_vkGetDeviceGroupPeerMemoryFeaturesKHR},
3483     {"vkGetDeviceGroupPresentCapabilitiesKHR", &wine_vkGetDeviceGroupPresentCapabilitiesKHR},
3484     {"vkGetDeviceGroupSurfacePresentModesKHR", &wine_vkGetDeviceGroupSurfacePresentModesKHR},
3485     {"vkGetDeviceMemoryCommitment", &wine_vkGetDeviceMemoryCommitment},
3486     {"vkGetDeviceProcAddr", &wine_vkGetDeviceProcAddr},
3487     {"vkGetDeviceQueue", &wine_vkGetDeviceQueue},
3488     {"vkGetDeviceQueue2", &wine_vkGetDeviceQueue2},
3489     {"vkGetEventStatus", &wine_vkGetEventStatus},
3490     {"vkGetFenceStatus", &wine_vkGetFenceStatus},
3491     {"vkGetImageMemoryRequirements", &wine_vkGetImageMemoryRequirements},
3492     {"vkGetImageMemoryRequirements2", &wine_vkGetImageMemoryRequirements2},
3493     {"vkGetImageMemoryRequirements2KHR", &wine_vkGetImageMemoryRequirements2KHR},
3494     {"vkGetImageSparseMemoryRequirements", &wine_vkGetImageSparseMemoryRequirements},
3495     {"vkGetImageSparseMemoryRequirements2", &wine_vkGetImageSparseMemoryRequirements2},
3496     {"vkGetImageSparseMemoryRequirements2KHR", &wine_vkGetImageSparseMemoryRequirements2KHR},
3497     {"vkGetImageSubresourceLayout", &wine_vkGetImageSubresourceLayout},
3498     {"vkGetPipelineCacheData", &wine_vkGetPipelineCacheData},
3499     {"vkGetQueryPoolResults", &wine_vkGetQueryPoolResults},
3500     {"vkGetQueueCheckpointDataNV", &wine_vkGetQueueCheckpointDataNV},
3501     {"vkGetRayTracingShaderGroupHandlesNV", &wine_vkGetRayTracingShaderGroupHandlesNV},
3502     {"vkGetRenderAreaGranularity", &wine_vkGetRenderAreaGranularity},
3503     {"vkGetShaderInfoAMD", &wine_vkGetShaderInfoAMD},
3504     {"vkGetSwapchainImagesKHR", &wine_vkGetSwapchainImagesKHR},
3505     {"vkGetValidationCacheDataEXT", &wine_vkGetValidationCacheDataEXT},
3506     {"vkInvalidateMappedMemoryRanges", &wine_vkInvalidateMappedMemoryRanges},
3507     {"vkMapMemory", &wine_vkMapMemory},
3508     {"vkMergePipelineCaches", &wine_vkMergePipelineCaches},
3509     {"vkMergeValidationCachesEXT", &wine_vkMergeValidationCachesEXT},
3510     {"vkQueueBindSparse", &wine_vkQueueBindSparse},
3511     {"vkQueuePresentKHR", &wine_vkQueuePresentKHR},
3512     {"vkQueueSubmit", &wine_vkQueueSubmit},
3513     {"vkQueueWaitIdle", &wine_vkQueueWaitIdle},
3514     {"vkResetCommandBuffer", &wine_vkResetCommandBuffer},
3515     {"vkResetCommandPool", &wine_vkResetCommandPool},
3516     {"vkResetDescriptorPool", &wine_vkResetDescriptorPool},
3517     {"vkResetEvent", &wine_vkResetEvent},
3518     {"vkResetFences", &wine_vkResetFences},
3519     {"vkResetQueryPoolEXT", &wine_vkResetQueryPoolEXT},
3520     {"vkSetEvent", &wine_vkSetEvent},
3521     {"vkTrimCommandPool", &wine_vkTrimCommandPool},
3522     {"vkTrimCommandPoolKHR", &wine_vkTrimCommandPoolKHR},
3523     {"vkUnmapMemory", &wine_vkUnmapMemory},
3524     {"vkUpdateDescriptorSetWithTemplate", &wine_vkUpdateDescriptorSetWithTemplate},
3525     {"vkUpdateDescriptorSetWithTemplateKHR", &wine_vkUpdateDescriptorSetWithTemplateKHR},
3526     {"vkUpdateDescriptorSets", &wine_vkUpdateDescriptorSets},
3527     {"vkWaitForFences", &wine_vkWaitForFences},
3528 };
3529
3530 static const struct vulkan_func vk_instance_dispatch_table[] =
3531 {
3532     {"vkCreateDevice", &wine_vkCreateDevice},
3533     {"vkCreateWin32SurfaceKHR", &wine_vkCreateWin32SurfaceKHR},
3534     {"vkDestroyInstance", &wine_vkDestroyInstance},
3535     {"vkDestroySurfaceKHR", &wine_vkDestroySurfaceKHR},
3536     {"vkEnumerateDeviceExtensionProperties", &wine_vkEnumerateDeviceExtensionProperties},
3537     {"vkEnumerateDeviceLayerProperties", &wine_vkEnumerateDeviceLayerProperties},
3538     {"vkEnumeratePhysicalDeviceGroups", &wine_vkEnumeratePhysicalDeviceGroups},
3539     {"vkEnumeratePhysicalDeviceGroupsKHR", &wine_vkEnumeratePhysicalDeviceGroupsKHR},
3540     {"vkEnumeratePhysicalDevices", &wine_vkEnumeratePhysicalDevices},
3541     {"vkGetPhysicalDeviceExternalBufferProperties", &wine_vkGetPhysicalDeviceExternalBufferProperties},
3542     {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", &wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR},
3543     {"vkGetPhysicalDeviceExternalFenceProperties", &wine_vkGetPhysicalDeviceExternalFenceProperties},
3544     {"vkGetPhysicalDeviceExternalFencePropertiesKHR", &wine_vkGetPhysicalDeviceExternalFencePropertiesKHR},
3545     {"vkGetPhysicalDeviceFeatures", &wine_vkGetPhysicalDeviceFeatures},
3546     {"vkGetPhysicalDeviceFeatures2", &wine_vkGetPhysicalDeviceFeatures2},
3547     {"vkGetPhysicalDeviceFeatures2KHR", &wine_vkGetPhysicalDeviceFeatures2KHR},
3548     {"vkGetPhysicalDeviceFormatProperties", &wine_vkGetPhysicalDeviceFormatProperties},
3549     {"vkGetPhysicalDeviceFormatProperties2", &wine_vkGetPhysicalDeviceFormatProperties2},
3550     {"vkGetPhysicalDeviceFormatProperties2KHR", &wine_vkGetPhysicalDeviceFormatProperties2KHR},
3551     {"vkGetPhysicalDeviceImageFormatProperties", &wine_vkGetPhysicalDeviceImageFormatProperties},
3552     {"vkGetPhysicalDeviceImageFormatProperties2", &wine_vkGetPhysicalDeviceImageFormatProperties2},
3553     {"vkGetPhysicalDeviceImageFormatProperties2KHR", &wine_vkGetPhysicalDeviceImageFormatProperties2KHR},
3554     {"vkGetPhysicalDeviceMemoryProperties", &wine_vkGetPhysicalDeviceMemoryProperties},
3555     {"vkGetPhysicalDeviceMemoryProperties2", &wine_vkGetPhysicalDeviceMemoryProperties2},
3556     {"vkGetPhysicalDeviceMemoryProperties2KHR", &wine_vkGetPhysicalDeviceMemoryProperties2KHR},
3557     {"vkGetPhysicalDeviceMultisamplePropertiesEXT", &wine_vkGetPhysicalDeviceMultisamplePropertiesEXT},
3558     {"vkGetPhysicalDevicePresentRectanglesKHR", &wine_vkGetPhysicalDevicePresentRectanglesKHR},
3559     {"vkGetPhysicalDeviceProperties", &wine_vkGetPhysicalDeviceProperties},
3560     {"vkGetPhysicalDeviceProperties2", &wine_vkGetPhysicalDeviceProperties2},
3561     {"vkGetPhysicalDeviceProperties2KHR", &wine_vkGetPhysicalDeviceProperties2KHR},
3562     {"vkGetPhysicalDeviceQueueFamilyProperties", &wine_vkGetPhysicalDeviceQueueFamilyProperties},
3563     {"vkGetPhysicalDeviceQueueFamilyProperties2", &wine_vkGetPhysicalDeviceQueueFamilyProperties2},
3564     {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", &wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR},
3565     {"vkGetPhysicalDeviceSparseImageFormatProperties", &wine_vkGetPhysicalDeviceSparseImageFormatProperties},
3566     {"vkGetPhysicalDeviceSparseImageFormatProperties2", &wine_vkGetPhysicalDeviceSparseImageFormatProperties2},
3567     {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", &wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR},
3568     {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", &wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR},
3569     {"vkGetPhysicalDeviceSurfaceFormatsKHR", &wine_vkGetPhysicalDeviceSurfaceFormatsKHR},
3570     {"vkGetPhysicalDeviceSurfacePresentModesKHR", &wine_vkGetPhysicalDeviceSurfacePresentModesKHR},
3571     {"vkGetPhysicalDeviceSurfaceSupportKHR", &wine_vkGetPhysicalDeviceSurfaceSupportKHR},
3572     {"vkGetPhysicalDeviceWin32PresentationSupportKHR", &wine_vkGetPhysicalDeviceWin32PresentationSupportKHR},
3573 };
3574
3575 void *wine_vk_get_device_proc_addr(const char *name)
3576 {
3577     unsigned int i;
3578     for (i = 0; i < ARRAY_SIZE(vk_device_dispatch_table); i++)
3579     {
3580         if (strcmp(vk_device_dispatch_table[i].name, name) == 0)
3581         {
3582             TRACE("Found name=%s in device table\n", debugstr_a(name));
3583             return vk_device_dispatch_table[i].func;
3584         }
3585     }
3586     return NULL;
3587 }
3588
3589 void *wine_vk_get_instance_proc_addr(const char *name)
3590 {
3591     unsigned int i;
3592     for (i = 0; i < ARRAY_SIZE(vk_instance_dispatch_table); i++)
3593     {
3594         if (strcmp(vk_instance_dispatch_table[i].name, name) == 0)
3595         {
3596             TRACE("Found name=%s in instance table\n", debugstr_a(name));
3597             return vk_instance_dispatch_table[i].func;
3598         }
3599     }
3600     return NULL;
3601 }
3602
3603 static const char * const vk_device_extensions[] =
3604 {
3605     "VK_AMD_buffer_marker",
3606     "VK_AMD_draw_indirect_count",
3607     "VK_AMD_gcn_shader",
3608     "VK_AMD_gpu_shader_half_float",
3609     "VK_AMD_gpu_shader_int16",
3610     "VK_AMD_mixed_attachment_samples",
3611     "VK_AMD_negative_viewport_height",
3612     "VK_AMD_rasterization_order",
3613     "VK_AMD_shader_ballot",
3614     "VK_AMD_shader_core_properties",
3615     "VK_AMD_shader_explicit_vertex_parameter",
3616     "VK_AMD_shader_fragment_mask",
3617     "VK_AMD_shader_image_load_store_lod",
3618     "VK_AMD_shader_info",
3619     "VK_AMD_shader_trinary_minmax",
3620     "VK_AMD_texture_gather_bias_lod",
3621     "VK_EXT_astc_decode_mode",
3622     "VK_EXT_blend_operation_advanced",
3623     "VK_EXT_buffer_device_address",
3624     "VK_EXT_conditional_rendering",
3625     "VK_EXT_conservative_rasterization",
3626     "VK_EXT_depth_clip_enable",
3627     "VK_EXT_depth_range_unrestricted",
3628     "VK_EXT_descriptor_indexing",
3629     "VK_EXT_discard_rectangles",
3630     "VK_EXT_filter_cubic",
3631     "VK_EXT_fragment_density_map",
3632     "VK_EXT_global_priority",
3633     "VK_EXT_host_query_reset",
3634     "VK_EXT_inline_uniform_block",
3635     "VK_EXT_memory_budget",
3636     "VK_EXT_pci_bus_info",
3637     "VK_EXT_post_depth_coverage",
3638     "VK_EXT_sample_locations",
3639     "VK_EXT_sampler_filter_minmax",
3640     "VK_EXT_scalar_block_layout",
3641     "VK_EXT_separate_stencil_usage",
3642     "VK_EXT_shader_stencil_export",
3643     "VK_EXT_shader_subgroup_ballot",
3644     "VK_EXT_shader_subgroup_vote",
3645     "VK_EXT_shader_viewport_index_layer",
3646     "VK_EXT_transform_feedback",
3647     "VK_EXT_validation_cache",
3648     "VK_EXT_vertex_attribute_divisor",
3649     "VK_GOOGLE_decorate_string",
3650     "VK_GOOGLE_hlsl_functionality1",
3651     "VK_IMG_filter_cubic",
3652     "VK_IMG_format_pvrtc",
3653     "VK_KHR_16bit_storage",
3654     "VK_KHR_8bit_storage",
3655     "VK_KHR_bind_memory2",
3656     "VK_KHR_create_renderpass2",
3657     "VK_KHR_dedicated_allocation",
3658     "VK_KHR_depth_stencil_resolve",
3659     "VK_KHR_descriptor_update_template",
3660     "VK_KHR_device_group",
3661     "VK_KHR_draw_indirect_count",
3662     "VK_KHR_driver_properties",
3663     "VK_KHR_get_memory_requirements2",
3664     "VK_KHR_image_format_list",
3665     "VK_KHR_incremental_present",
3666     "VK_KHR_maintenance1",
3667     "VK_KHR_maintenance2",
3668     "VK_KHR_maintenance3",
3669     "VK_KHR_multiview",
3670     "VK_KHR_push_descriptor",
3671     "VK_KHR_relaxed_block_layout",
3672     "VK_KHR_sampler_mirror_clamp_to_edge",
3673     "VK_KHR_sampler_ycbcr_conversion",
3674     "VK_KHR_shader_atomic_int64",
3675     "VK_KHR_shader_draw_parameters",
3676     "VK_KHR_shader_float_controls",
3677     "VK_KHR_storage_buffer_storage_class",
3678     "VK_KHR_swapchain",
3679     "VK_KHR_swapchain_mutable_format",
3680     "VK_KHR_variable_pointers",
3681     "VK_KHR_vulkan_memory_model",
3682     "VK_NV_clip_space_w_scaling",
3683     "VK_NV_compute_shader_derivatives",
3684     "VK_NV_corner_sampled_image",
3685     "VK_NV_dedicated_allocation",
3686     "VK_NV_device_diagnostic_checkpoints",
3687     "VK_NV_fill_rectangle",
3688     "VK_NV_fragment_coverage_to_color",
3689     "VK_NV_fragment_shader_barycentric",
3690     "VK_NV_framebuffer_mixed_samples",
3691     "VK_NV_geometry_shader_passthrough",
3692     "VK_NV_glsl_shader",
3693     "VK_NV_mesh_shader",
3694     "VK_NV_ray_tracing",
3695     "VK_NV_representative_fragment_test",
3696     "VK_NV_sample_mask_override_coverage",
3697     "VK_NV_scissor_exclusive",
3698     "VK_NV_shader_image_footprint",
3699     "VK_NV_shader_subgroup_partitioned",
3700     "VK_NV_shading_rate_image",
3701     "VK_NV_viewport_array2",
3702     "VK_NV_viewport_swizzle",
3703 };
3704
3705 static const char * const vk_instance_extensions[] =
3706 {
3707     "VK_EXT_swapchain_colorspace",
3708     "VK_KHR_device_group_creation",
3709     "VK_KHR_external_fence_capabilities",
3710     "VK_KHR_external_memory_capabilities",
3711     "VK_KHR_get_physical_device_properties2",
3712     "VK_KHR_surface",
3713     "VK_KHR_win32_surface",
3714 };
3715
3716 BOOL wine_vk_device_extension_supported(const char *name)
3717 {
3718     unsigned int i;
3719     for (i = 0; i < ARRAY_SIZE(vk_device_extensions); i++)
3720     {
3721         if (strcmp(vk_device_extensions[i], name) == 0)
3722             return TRUE;
3723     }
3724     return FALSE;
3725 }
3726
3727 BOOL wine_vk_instance_extension_supported(const char *name)
3728 {
3729     unsigned int i;
3730     for (i = 0; i < ARRAY_SIZE(vk_instance_extensions); i++)
3731     {
3732         if (strcmp(vk_instance_extensions[i], name) == 0)
3733             return TRUE;
3734     }
3735     return FALSE;
3736 }