dlls/winevulkan/vulkan_thunks.c

   1 /* Automatically generated from Vulkan vk.xml; DO NOT EDIT! */
   2
   3 #include "config.h"
   4 #include "wine/port.h"
   5
   6 #include "wine/debug.h"
   7 #include "wine/heap.h"
   8 #include "wine/vulkan.h"
   9 #include "wine/vulkan_driver.h"
  10 #include "vulkan_private.h"
  11
  12 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
  13
  14 #if defined(USE_STRUCT_CONVERSION)
  15 static inline void convert_VkCommandBufferAllocateInfo_win_to_host(const VkCommandBufferAllocateInfo *in, VkCommandBufferAllocateInfo_host *out)
  16 {
  17     if (!in) return;
  18
  19     out->sType = in->sType;
  20     out->pNext = in->pNext;
  21     out->commandPool = in->commandPool;
  22     out->level = in->level;
  23     out->commandBufferCount = in->commandBufferCount;
  24 }
  25
  26 static inline void convert_VkDescriptorSetAllocateInfo_win_to_host(const VkDescriptorSetAllocateInfo *in, VkDescriptorSetAllocateInfo_host *out)
  27 {
  28     if (!in) return;
  29
  30     out->sType = in->sType;
  31     out->pNext = in->pNext;
  32     out->descriptorPool = in->descriptorPool;
  33     out->descriptorSetCount = in->descriptorSetCount;
  34     out->pSetLayouts = in->pSetLayouts;
  35 }
  36
  37 static inline void convert_VkMemoryAllocateInfo_win_to_host(const VkMemoryAllocateInfo *in, VkMemoryAllocateInfo_host *out)
  38 {
  39     if (!in) return;
  40
  41     out->sType = in->sType;
  42     out->pNext = in->pNext;
  43     out->allocationSize = in->allocationSize;
  44     out->memoryTypeIndex = in->memoryTypeIndex;
  45 }
  46
  47 static inline VkCommandBufferInheritanceInfo_host *convert_VkCommandBufferInheritanceInfo_array_win_to_host(const VkCommandBufferInheritanceInfo *in, uint32_t count)
  48 {
  49     VkCommandBufferInheritanceInfo_host *out;
  50     unsigned int i;
  51
  52     if (!in) return NULL;
  53
  54     out = heap_alloc(count * sizeof(*out));
  55     for (i = 0; i < count; i++)
  56     {
  57         out[i].sType = in[i].sType;
  58         out[i].pNext = in[i].pNext;
  59         out[i].renderPass = in[i].renderPass;
  60         out[i].subpass = in[i].subpass;
  61         out[i].framebuffer = in[i].framebuffer;
  62         out[i].occlusionQueryEnable = in[i].occlusionQueryEnable;
  63         out[i].queryFlags = in[i].queryFlags;
  64         out[i].pipelineStatistics = in[i].pipelineStatistics;
  65     }
  66
  67     return out;
  68 }
  69
  70 static inline void free_VkCommandBufferInheritanceInfo_array(VkCommandBufferInheritanceInfo_host *in, uint32_t count)
  71 {
  72     if (!in) return;
  73
  74     heap_free(in);
  75 }
  76
  77 static inline void convert_VkCommandBufferBeginInfo_win_to_host(const VkCommandBufferBeginInfo *in, VkCommandBufferBeginInfo_host *out)
  78 {
  79     if (!in) return;
  80
  81     out->sType = in->sType;
  82     out->pNext = in->pNext;
  83     out->flags = in->flags;
  84     out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win_to_host(in->pInheritanceInfo, 1);
  85 }
  86
  87 static inline void free_VkCommandBufferBeginInfo(VkCommandBufferBeginInfo_host *in)
  88 {
  89     free_VkCommandBufferInheritanceInfo_array((VkCommandBufferInheritanceInfo_host *)in->pInheritanceInfo, 1);
  90 }
  91
  92 static inline void convert_VkRenderPassBeginInfo_win_to_host(const VkRenderPassBeginInfo *in, VkRenderPassBeginInfo_host *out)
  93 {
  94     if (!in) return;
  95
  96     out->sType = in->sType;
  97     out->pNext = in->pNext;
  98     out->renderPass = in->renderPass;
  99     out->framebuffer = in->framebuffer;
 100     out->renderArea = in->renderArea;
 101     out->clearValueCount = in->clearValueCount;
 102     out->pClearValues = in->pClearValues;
 103 }
 104
 105 static inline VkBufferCopy_host *convert_VkBufferCopy_array_win_to_host(const VkBufferCopy *in, uint32_t count)
 106 {
 107     VkBufferCopy_host *out;
 108     unsigned int i;
 109
 110     if (!in) return NULL;
 111
 112     out = heap_alloc(count * sizeof(*out));
 113     for (i = 0; i < count; i++)
 114     {
 115         out[i].srcOffset = in[i].srcOffset;
 116         out[i].dstOffset = in[i].dstOffset;
 117         out[i].size = in[i].size;
 118     }
 119
 120     return out;
 121 }
 122
 123 static inline void free_VkBufferCopy_array(VkBufferCopy_host *in, uint32_t count)
 124 {
 125     if (!in) return;
 126
 127     heap_free(in);
 128 }
 129
 130 static inline VkBufferImageCopy_host *convert_VkBufferImageCopy_array_win_to_host(const VkBufferImageCopy *in, uint32_t count)
 131 {
 132     VkBufferImageCopy_host *out;
 133     unsigned int i;
 134
 135     if (!in) return NULL;
 136
 137     out = heap_alloc(count * sizeof(*out));
 138     for (i = 0; i < count; i++)
 139     {
 140         out[i].bufferOffset = in[i].bufferOffset;
 141         out[i].bufferRowLength = in[i].bufferRowLength;
 142         out[i].bufferImageHeight = in[i].bufferImageHeight;
 143         out[i].imageSubresource = in[i].imageSubresource;
 144         out[i].imageOffset = in[i].imageOffset;
 145         out[i].imageExtent = in[i].imageExtent;
 146     }
 147
 148     return out;
 149 }
 150
 151 static inline void free_VkBufferImageCopy_array(VkBufferImageCopy_host *in, uint32_t count)
 152 {
 153     if (!in) return;
 154
 155     heap_free(in);
 156 }
 157
 158 static inline VkBufferMemoryBarrier_host *convert_VkBufferMemoryBarrier_array_win_to_host(const VkBufferMemoryBarrier *in, uint32_t count)
 159 {
 160     VkBufferMemoryBarrier_host *out;
 161     unsigned int i;
 162
 163     if (!in) return NULL;
 164
 165     out = heap_alloc(count * sizeof(*out));
 166     for (i = 0; i < count; i++)
 167     {
 168         out[i].sType = in[i].sType;
 169         out[i].pNext = in[i].pNext;
 170         out[i].srcAccessMask = in[i].srcAccessMask;
 171         out[i].dstAccessMask = in[i].dstAccessMask;
 172         out[i].srcQueueFamilyIndex = in[i].srcQueueFamilyIndex;
 173         out[i].dstQueueFamilyIndex = in[i].dstQueueFamilyIndex;
 174         out[i].buffer = in[i].buffer;
 175         out[i].offset = in[i].offset;
 176         out[i].size = in[i].size;
 177     }
 178
 179     return out;
 180 }
 181
 182 static inline void free_VkBufferMemoryBarrier_array(VkBufferMemoryBarrier_host *in, uint32_t count)
 183 {
 184     if (!in) return;
 185
 186     heap_free(in);
 187 }
 188
 189 static inline VkImageMemoryBarrier_host *convert_VkImageMemoryBarrier_array_win_to_host(const VkImageMemoryBarrier *in, uint32_t count)
 190 {
 191     VkImageMemoryBarrier_host *out;
 192     unsigned int i;
 193
 194     if (!in) return NULL;
 195
 196     out = heap_alloc(count * sizeof(*out));
 197     for (i = 0; i < count; i++)
 198     {
 199         out[i].sType = in[i].sType;
 200         out[i].pNext = in[i].pNext;
 201         out[i].srcAccessMask = in[i].srcAccessMask;
 202         out[i].dstAccessMask = in[i].dstAccessMask;
 203         out[i].oldLayout = in[i].oldLayout;
 204         out[i].newLayout = in[i].newLayout;
 205         out[i].srcQueueFamilyIndex = in[i].srcQueueFamilyIndex;
 206         out[i].dstQueueFamilyIndex = in[i].dstQueueFamilyIndex;
 207         out[i].image = in[i].image;
 208         out[i].subresourceRange = in[i].subresourceRange;
 209     }
 210
 211     return out;
 212 }
 213
 214 static inline void free_VkImageMemoryBarrier_array(VkImageMemoryBarrier_host *in, uint32_t count)
 215 {
 216     if (!in) return;
 217
 218     heap_free(in);
 219 }
 220
 221 static inline VkDescriptorImageInfo_host *convert_VkDescriptorImageInfo_array_win_to_host(const VkDescriptorImageInfo *in, uint32_t count)
 222 {
 223     VkDescriptorImageInfo_host *out;
 224     unsigned int i;
 225
 226     if (!in) return NULL;
 227
 228     out = heap_alloc(count * sizeof(*out));
 229     for (i = 0; i < count; i++)
 230     {
 231         out[i].sampler = in[i].sampler;
 232         out[i].imageView = in[i].imageView;
 233         out[i].imageLayout = in[i].imageLayout;
 234     }
 235
 236     return out;
 237 }
 238
 239 static inline void free_VkDescriptorImageInfo_array(VkDescriptorImageInfo_host *in, uint32_t count)
 240 {
 241     if (!in) return;
 242
 243     heap_free(in);
 244 }
 245
 246 static inline VkDescriptorBufferInfo_host *convert_VkDescriptorBufferInfo_array_win_to_host(const VkDescriptorBufferInfo *in, uint32_t count)
 247 {
 248     VkDescriptorBufferInfo_host *out;
 249     unsigned int i;
 250
 251     if (!in) return NULL;
 252
 253     out = heap_alloc(count * sizeof(*out));
 254     for (i = 0; i < count; i++)
 255     {
 256         out[i].buffer = in[i].buffer;
 257         out[i].offset = in[i].offset;
 258         out[i].range = in[i].range;
 259     }
 260
 261     return out;
 262 }
 263
 264 static inline void free_VkDescriptorBufferInfo_array(VkDescriptorBufferInfo_host *in, uint32_t count)
 265 {
 266     if (!in) return;
 267
 268     heap_free(in);
 269 }
 270
 271 static inline VkWriteDescriptorSet_host *convert_VkWriteDescriptorSet_array_win_to_host(const VkWriteDescriptorSet *in, uint32_t count)
 272 {
 273     VkWriteDescriptorSet_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].dstSet = in[i].dstSet;
 284         out[i].dstBinding = in[i].dstBinding;
 285         out[i].dstArrayElement = in[i].dstArrayElement;
 286         out[i].descriptorCount = in[i].descriptorCount;
 287         out[i].descriptorType = in[i].descriptorType;
 288         out[i].pImageInfo = convert_VkDescriptorImageInfo_array_win_to_host(in[i].pImageInfo, in[i].descriptorCount);
 289         out[i].pBufferInfo = convert_VkDescriptorBufferInfo_array_win_to_host(in[i].pBufferInfo, in[i].descriptorCount);
 290         out[i].pTexelBufferView = in[i].pTexelBufferView;
 291     }
 292
 293     return out;
 294 }
 295
 296 static inline void free_VkWriteDescriptorSet_array(VkWriteDescriptorSet_host *in, uint32_t count)
 297 {
 298     unsigned int i;
 299
 300     if (!in) return;
 301
 302     for (i = 0; i < count; i++)
 303     {
 304         free_VkDescriptorImageInfo_array((VkDescriptorImageInfo_host *)in[i].pImageInfo, in[i].descriptorCount);
 305         free_VkDescriptorBufferInfo_array((VkDescriptorBufferInfo_host *)in[i].pBufferInfo, in[i].descriptorCount);
 306     }
 307     heap_free(in);
 308 }
 309
 310 static inline void convert_VkBufferCreateInfo_win_to_host(const VkBufferCreateInfo *in, VkBufferCreateInfo_host *out)
 311 {
 312     if (!in) return;
 313
 314     out->sType = in->sType;
 315     out->pNext = in->pNext;
 316     out->flags = in->flags;
 317     out->size = in->size;
 318     out->usage = in->usage;
 319     out->sharingMode = in->sharingMode;
 320     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
 321     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
 322 }
 323
 324 static inline void convert_VkBufferViewCreateInfo_win_to_host(const VkBufferViewCreateInfo *in, VkBufferViewCreateInfo_host *out)
 325 {
 326     if (!in) return;
 327
 328     out->sType = in->sType;
 329     out->pNext = in->pNext;
 330     out->flags = in->flags;
 331     out->buffer = in->buffer;
 332     out->format = in->format;
 333     out->offset = in->offset;
 334     out->range = in->range;
 335 }
 336
 337 static inline void convert_VkPipelineShaderStageCreateInfo_win_to_host(const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo_host *out)
 338 {
 339     if (!in) return;
 340
 341     out->sType = in->sType;
 342     out->pNext = in->pNext;
 343     out->flags = in->flags;
 344     out->stage = in->stage;
 345     out->module = in->module;
 346     out->pName = in->pName;
 347     out->pSpecializationInfo = in->pSpecializationInfo;
 348 }
 349
 350 static inline VkComputePipelineCreateInfo_host *convert_VkComputePipelineCreateInfo_array_win_to_host(const VkComputePipelineCreateInfo *in, uint32_t count)
 351 {
 352     VkComputePipelineCreateInfo_host *out;
 353     unsigned int i;
 354
 355     if (!in) return NULL;
 356
 357     out = heap_alloc(count * sizeof(*out));
 358     for (i = 0; i < count; i++)
 359     {
 360         out[i].sType = in[i].sType;
 361         out[i].pNext = in[i].pNext;
 362         out[i].flags = in[i].flags;
 363         convert_VkPipelineShaderStageCreateInfo_win_to_host(&in[i].stage, &out[i].stage);
 364         out[i].layout = in[i].layout;
 365         out[i].basePipelineHandle = in[i].basePipelineHandle;
 366         out[i].basePipelineIndex = in[i].basePipelineIndex;
 367     }
 368
 369     return out;
 370 }
 371
 372 static inline void free_VkComputePipelineCreateInfo_array(VkComputePipelineCreateInfo_host *in, uint32_t count)
 373 {
 374     if (!in) return;
 375
 376     heap_free(in);
 377 }
 378
 379 static inline void convert_VkDescriptorUpdateTemplateCreateInfoKHR_win_to_host(const VkDescriptorUpdateTemplateCreateInfoKHR *in, VkDescriptorUpdateTemplateCreateInfoKHR_host *out)
 380 {
 381     if (!in) return;
 382
 383     out->sType = in->sType;
 384     out->pNext = in->pNext;
 385     out->flags = in->flags;
 386     out->descriptorUpdateEntryCount = in->descriptorUpdateEntryCount;
 387     out->pDescriptorUpdateEntries = in->pDescriptorUpdateEntries;
 388     out->templateType = in->templateType;
 389     out->descriptorSetLayout = in->descriptorSetLayout;
 390     out->pipelineBindPoint = in->pipelineBindPoint;
 391     out->pipelineLayout = in->pipelineLayout;
 392     out->set = in->set;
 393 }
 394
 395 static inline void convert_VkFramebufferCreateInfo_win_to_host(const VkFramebufferCreateInfo *in, VkFramebufferCreateInfo_host *out)
 396 {
 397     if (!in) return;
 398
 399     out->sType = in->sType;
 400     out->pNext = in->pNext;
 401     out->flags = in->flags;
 402     out->renderPass = in->renderPass;
 403     out->attachmentCount = in->attachmentCount;
 404     out->pAttachments = in->pAttachments;
 405     out->width = in->width;
 406     out->height = in->height;
 407     out->layers = in->layers;
 408 }
 409
 410 static inline VkPipelineShaderStageCreateInfo_host *convert_VkPipelineShaderStageCreateInfo_array_win_to_host(const VkPipelineShaderStageCreateInfo *in, uint32_t count)
 411 {
 412     VkPipelineShaderStageCreateInfo_host *out;
 413     unsigned int i;
 414
 415     if (!in) return NULL;
 416
 417     out = heap_alloc(count * sizeof(*out));
 418     for (i = 0; i < count; i++)
 419     {
 420         out[i].sType = in[i].sType;
 421         out[i].pNext = in[i].pNext;
 422         out[i].flags = in[i].flags;
 423         out[i].stage = in[i].stage;
 424         out[i].module = in[i].module;
 425         out[i].pName = in[i].pName;
 426         out[i].pSpecializationInfo = in[i].pSpecializationInfo;
 427     }
 428
 429     return out;
 430 }
 431
 432 static inline void free_VkPipelineShaderStageCreateInfo_array(VkPipelineShaderStageCreateInfo_host *in, uint32_t count)
 433 {
 434     if (!in) return;
 435
 436     heap_free(in);
 437 }
 438
 439 static inline VkGraphicsPipelineCreateInfo_host *convert_VkGraphicsPipelineCreateInfo_array_win_to_host(const VkGraphicsPipelineCreateInfo *in, uint32_t count)
 440 {
 441     VkGraphicsPipelineCreateInfo_host *out;
 442     unsigned int i;
 443
 444     if (!in) return NULL;
 445
 446     out = heap_alloc(count * sizeof(*out));
 447     for (i = 0; i < count; i++)
 448     {
 449         out[i].sType = in[i].sType;
 450         out[i].pNext = in[i].pNext;
 451         out[i].flags = in[i].flags;
 452         out[i].stageCount = in[i].stageCount;
 453         out[i].pStages = convert_VkPipelineShaderStageCreateInfo_array_win_to_host(in[i].pStages, in[i].stageCount);
 454         out[i].pVertexInputState = in[i].pVertexInputState;
 455         out[i].pInputAssemblyState = in[i].pInputAssemblyState;
 456         out[i].pTessellationState = in[i].pTessellationState;
 457         out[i].pViewportState = in[i].pViewportState;
 458         out[i].pRasterizationState = in[i].pRasterizationState;
 459         out[i].pMultisampleState = in[i].pMultisampleState;
 460         out[i].pDepthStencilState = in[i].pDepthStencilState;
 461         out[i].pColorBlendState = in[i].pColorBlendState;
 462         out[i].pDynamicState = in[i].pDynamicState;
 463         out[i].layout = in[i].layout;
 464         out[i].renderPass = in[i].renderPass;
 465         out[i].subpass = in[i].subpass;
 466         out[i].basePipelineHandle = in[i].basePipelineHandle;
 467         out[i].basePipelineIndex = in[i].basePipelineIndex;
 468     }
 469
 470     return out;
 471 }
 472
 473 static inline void free_VkGraphicsPipelineCreateInfo_array(VkGraphicsPipelineCreateInfo_host *in, uint32_t count)
 474 {
 475     unsigned int i;
 476
 477     if (!in) return;
 478
 479     for (i = 0; i < count; i++)
 480     {
 481         free_VkPipelineShaderStageCreateInfo_array((VkPipelineShaderStageCreateInfo_host *)in[i].pStages, in[i].stageCount);
 482     }
 483     heap_free(in);
 484 }
 485
 486 static inline void convert_VkImageViewCreateInfo_win_to_host(const VkImageViewCreateInfo *in, VkImageViewCreateInfo_host *out)
 487 {
 488     if (!in) return;
 489
 490     out->sType = in->sType;
 491     out->pNext = in->pNext;
 492     out->flags = in->flags;
 493     out->image = in->image;
 494     out->viewType = in->viewType;
 495     out->format = in->format;
 496     out->components = in->components;
 497     out->subresourceRange = in->subresourceRange;
 498 }
 499
 500 static inline VkMappedMemoryRange_host *convert_VkMappedMemoryRange_array_win_to_host(const VkMappedMemoryRange *in, uint32_t count)
 501 {
 502     VkMappedMemoryRange_host *out;
 503     unsigned int i;
 504
 505     if (!in) return NULL;
 506
 507     out = heap_alloc(count * sizeof(*out));
 508     for (i = 0; i < count; i++)
 509     {
 510         out[i].sType = in[i].sType;
 511         out[i].pNext = in[i].pNext;
 512         out[i].memory = in[i].memory;
 513         out[i].offset = in[i].offset;
 514         out[i].size = in[i].size;
 515     }
 516
 517     return out;
 518 }
 519
 520 static inline void free_VkMappedMemoryRange_array(VkMappedMemoryRange_host *in, uint32_t count)
 521 {
 522     if (!in) return;
 523
 524     heap_free(in);
 525 }
 526
 527 static inline void convert_VkMemoryRequirements_host_to_win(const VkMemoryRequirements_host *in, VkMemoryRequirements *out)
 528 {
 529     if (!in) return;
 530
 531     out->size = in->size;
 532     out->alignment = in->alignment;
 533     out->memoryTypeBits = in->memoryTypeBits;
 534 }
 535
 536 static inline void convert_VkSubresourceLayout_host_to_win(const VkSubresourceLayout_host *in, VkSubresourceLayout *out)
 537 {
 538     if (!in) return;
 539
 540     out->offset = in->offset;
 541     out->size = in->size;
 542     out->rowPitch = in->rowPitch;
 543     out->arrayPitch = in->arrayPitch;
 544     out->depthPitch = in->depthPitch;
 545 }
 546
 547 static inline void convert_VkImageFormatProperties_host_to_win(const VkImageFormatProperties_host *in, VkImageFormatProperties *out)
 548 {
 549     if (!in) return;
 550
 551     out->maxExtent = in->maxExtent;
 552     out->maxMipLevels = in->maxMipLevels;
 553     out->maxArrayLayers = in->maxArrayLayers;
 554     out->sampleCounts = in->sampleCounts;
 555     out->maxResourceSize = in->maxResourceSize;
 556 }
 557
 558 static inline void convert_VkImageFormatProperties2KHR_win_to_host(const VkImageFormatProperties2KHR *in, VkImageFormatProperties2KHR_host *out)
 559 {
 560     if (!in) return;
 561
 562     out->pNext = in->pNext;
 563     out->sType = in->sType;
 564 }
 565
 566 static inline void convert_VkImageFormatProperties2KHR_host_to_win(const VkImageFormatProperties2KHR_host *in, VkImageFormatProperties2KHR *out)
 567 {
 568     if (!in) return;
 569
 570     out->sType = in->sType;
 571     out->pNext = in->pNext;
 572     convert_VkImageFormatProperties_host_to_win(&in->imageFormatProperties, &out->imageFormatProperties);
 573 }
 574
 575 static inline void convert_VkMemoryHeap_static_array_host_to_win(const VkMemoryHeap_host *in, VkMemoryHeap *out, uint32_t count)
 576 {
 577     unsigned int i;
 578
 579     if (!in) return;
 580
 581     for (i = 0; i < count; i++)
 582     {
 583         out[i].size = in[i].size;
 584         out[i].flags = in[i].flags;
 585     }
 586 }
 587
 588 static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win(const VkPhysicalDeviceMemoryProperties_host *in, VkPhysicalDeviceMemoryProperties *out)
 589 {
 590     if (!in) return;
 591
 592     out->memoryTypeCount = in->memoryTypeCount;
 593     memcpy(out->memoryTypes, in->memoryTypes, VK_MAX_MEMORY_TYPES * sizeof(VkMemoryType));
 594     out->memoryHeapCount = in->memoryHeapCount;
 595     convert_VkMemoryHeap_static_array_host_to_win(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
 596 }
 597
 598 static inline void convert_VkPhysicalDeviceMemoryProperties2KHR_win_to_host(const VkPhysicalDeviceMemoryProperties2KHR *in, VkPhysicalDeviceMemoryProperties2KHR_host *out)
 599 {
 600     if (!in) return;
 601
 602     out->pNext = in->pNext;
 603     out->sType = in->sType;
 604 }
 605
 606 static inline void convert_VkPhysicalDeviceMemoryProperties2KHR_host_to_win(const VkPhysicalDeviceMemoryProperties2KHR_host *in, VkPhysicalDeviceMemoryProperties2KHR *out)
 607 {
 608     if (!in) return;
 609
 610     out->sType = in->sType;
 611     out->pNext = in->pNext;
 612     convert_VkPhysicalDeviceMemoryProperties_host_to_win(&in->memoryProperties, &out->memoryProperties);
 613 }
 614
 615 static inline void convert_VkPhysicalDeviceLimits_host_to_win(const VkPhysicalDeviceLimits_host *in, VkPhysicalDeviceLimits *out)
 616 {
 617     if (!in) return;
 618
 619     out->maxImageDimension1D = in->maxImageDimension1D;
 620     out->maxImageDimension2D = in->maxImageDimension2D;
 621     out->maxImageDimension3D = in->maxImageDimension3D;
 622     out->maxImageDimensionCube = in->maxImageDimensionCube;
 623     out->maxImageArrayLayers = in->maxImageArrayLayers;
 624     out->maxTexelBufferElements = in->maxTexelBufferElements;
 625     out->maxUniformBufferRange = in->maxUniformBufferRange;
 626     out->maxStorageBufferRange = in->maxStorageBufferRange;
 627     out->maxPushConstantsSize = in->maxPushConstantsSize;
 628     out->maxMemoryAllocationCount = in->maxMemoryAllocationCount;
 629     out->maxSamplerAllocationCount = in->maxSamplerAllocationCount;
 630     out->bufferImageGranularity = in->bufferImageGranularity;
 631     out->sparseAddressSpaceSize = in->sparseAddressSpaceSize;
 632     out->maxBoundDescriptorSets = in->maxBoundDescriptorSets;
 633     out->maxPerStageDescriptorSamplers = in->maxPerStageDescriptorSamplers;
 634     out->maxPerStageDescriptorUniformBuffers = in->maxPerStageDescriptorUniformBuffers;
 635     out->maxPerStageDescriptorStorageBuffers = in->maxPerStageDescriptorStorageBuffers;
 636     out->maxPerStageDescriptorSampledImages = in->maxPerStageDescriptorSampledImages;
 637     out->maxPerStageDescriptorStorageImages = in->maxPerStageDescriptorStorageImages;
 638     out->maxPerStageDescriptorInputAttachments = in->maxPerStageDescriptorInputAttachments;
 639     out->maxPerStageResources = in->maxPerStageResources;
 640     out->maxDescriptorSetSamplers = in->maxDescriptorSetSamplers;
 641     out->maxDescriptorSetUniformBuffers = in->maxDescriptorSetUniformBuffers;
 642     out->maxDescriptorSetUniformBuffersDynamic = in->maxDescriptorSetUniformBuffersDynamic;
 643     out->maxDescriptorSetStorageBuffers = in->maxDescriptorSetStorageBuffers;
 644     out->maxDescriptorSetStorageBuffersDynamic = in->maxDescriptorSetStorageBuffersDynamic;
 645     out->maxDescriptorSetSampledImages = in->maxDescriptorSetSampledImages;
 646     out->maxDescriptorSetStorageImages = in->maxDescriptorSetStorageImages;
 647     out->maxDescriptorSetInputAttachments = in->maxDescriptorSetInputAttachments;
 648     out->maxVertexInputAttributes = in->maxVertexInputAttributes;
 649     out->maxVertexInputBindings = in->maxVertexInputBindings;
 650     out->maxVertexInputAttributeOffset = in->maxVertexInputAttributeOffset;
 651     out->maxVertexInputBindingStride = in->maxVertexInputBindingStride;
 652     out->maxVertexOutputComponents = in->maxVertexOutputComponents;
 653     out->maxTessellationGenerationLevel = in->maxTessellationGenerationLevel;
 654     out->maxTessellationPatchSize = in->maxTessellationPatchSize;
 655     out->maxTessellationControlPerVertexInputComponents = in->maxTessellationControlPerVertexInputComponents;
 656     out->maxTessellationControlPerVertexOutputComponents = in->maxTessellationControlPerVertexOutputComponents;
 657     out->maxTessellationControlPerPatchOutputComponents = in->maxTessellationControlPerPatchOutputComponents;
 658     out->maxTessellationControlTotalOutputComponents = in->maxTessellationControlTotalOutputComponents;
 659     out->maxTessellationEvaluationInputComponents = in->maxTessellationEvaluationInputComponents;
 660     out->maxTessellationEvaluationOutputComponents = in->maxTessellationEvaluationOutputComponents;
 661     out->maxGeometryShaderInvocations = in->maxGeometryShaderInvocations;
 662     out->maxGeometryInputComponents = in->maxGeometryInputComponents;
 663     out->maxGeometryOutputComponents = in->maxGeometryOutputComponents;
 664     out->maxGeometryOutputVertices = in->maxGeometryOutputVertices;
 665     out->maxGeometryTotalOutputComponents = in->maxGeometryTotalOutputComponents;
 666     out->maxFragmentInputComponents = in->maxFragmentInputComponents;
 667     out->maxFragmentOutputAttachments = in->maxFragmentOutputAttachments;
 668     out->maxFragmentDualSrcAttachments = in->maxFragmentDualSrcAttachments;
 669     out->maxFragmentCombinedOutputResources = in->maxFragmentCombinedOutputResources;
 670     out->maxComputeSharedMemorySize = in->maxComputeSharedMemorySize;
 671     memcpy(out->maxComputeWorkGroupCount, in->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
 672     out->maxComputeWorkGroupInvocations = in->maxComputeWorkGroupInvocations;
 673     memcpy(out->maxComputeWorkGroupSize, in->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
 674     out->subPixelPrecisionBits = in->subPixelPrecisionBits;
 675     out->subTexelPrecisionBits = in->subTexelPrecisionBits;
 676     out->mipmapPrecisionBits = in->mipmapPrecisionBits;
 677     out->maxDrawIndexedIndexValue = in->maxDrawIndexedIndexValue;
 678     out->maxDrawIndirectCount = in->maxDrawIndirectCount;
 679     out->maxSamplerLodBias = in->maxSamplerLodBias;
 680     out->maxSamplerAnisotropy = in->maxSamplerAnisotropy;
 681     out->maxViewports = in->maxViewports;
 682     memcpy(out->maxViewportDimensions, in->maxViewportDimensions, 2 * sizeof(uint32_t));
 683     memcpy(out->viewportBoundsRange, in->viewportBoundsRange, 2 * sizeof(float));
 684     out->viewportSubPixelBits = in->viewportSubPixelBits;
 685     out->minMemoryMapAlignment = in->minMemoryMapAlignment;
 686     out->minTexelBufferOffsetAlignment = in->minTexelBufferOffsetAlignment;
 687     out->minUniformBufferOffsetAlignment = in->minUniformBufferOffsetAlignment;
 688     out->minStorageBufferOffsetAlignment = in->minStorageBufferOffsetAlignment;
 689     out->minTexelOffset = in->minTexelOffset;
 690     out->maxTexelOffset = in->maxTexelOffset;
 691     out->minTexelGatherOffset = in->minTexelGatherOffset;
 692     out->maxTexelGatherOffset = in->maxTexelGatherOffset;
 693     out->minInterpolationOffset = in->minInterpolationOffset;
 694     out->maxInterpolationOffset = in->maxInterpolationOffset;
 695     out->subPixelInterpolationOffsetBits = in->subPixelInterpolationOffsetBits;
 696     out->maxFramebufferWidth = in->maxFramebufferWidth;
 697     out->maxFramebufferHeight = in->maxFramebufferHeight;
 698     out->maxFramebufferLayers = in->maxFramebufferLayers;
 699     out->framebufferColorSampleCounts = in->framebufferColorSampleCounts;
 700     out->framebufferDepthSampleCounts = in->framebufferDepthSampleCounts;
 701     out->framebufferStencilSampleCounts = in->framebufferStencilSampleCounts;
 702     out->framebufferNoAttachmentsSampleCounts = in->framebufferNoAttachmentsSampleCounts;
 703     out->maxColorAttachments = in->maxColorAttachments;
 704     out->sampledImageColorSampleCounts = in->sampledImageColorSampleCounts;
 705     out->sampledImageIntegerSampleCounts = in->sampledImageIntegerSampleCounts;
 706     out->sampledImageDepthSampleCounts = in->sampledImageDepthSampleCounts;
 707     out->sampledImageStencilSampleCounts = in->sampledImageStencilSampleCounts;
 708     out->storageImageSampleCounts = in->storageImageSampleCounts;
 709     out->maxSampleMaskWords = in->maxSampleMaskWords;
 710     out->timestampComputeAndGraphics = in->timestampComputeAndGraphics;
 711     out->timestampPeriod = in->timestampPeriod;
 712     out->maxClipDistances = in->maxClipDistances;
 713     out->maxCullDistances = in->maxCullDistances;
 714     out->maxCombinedClipAndCullDistances = in->maxCombinedClipAndCullDistances;
 715     out->discreteQueuePriorities = in->discreteQueuePriorities;
 716     memcpy(out->pointSizeRange, in->pointSizeRange, 2 * sizeof(float));
 717     memcpy(out->lineWidthRange, in->lineWidthRange, 2 * sizeof(float));
 718     out->pointSizeGranularity = in->pointSizeGranularity;
 719     out->lineWidthGranularity = in->lineWidthGranularity;
 720     out->strictLines = in->strictLines;
 721     out->standardSampleLocations = in->standardSampleLocations;
 722     out->optimalBufferCopyOffsetAlignment = in->optimalBufferCopyOffsetAlignment;
 723     out->optimalBufferCopyRowPitchAlignment = in->optimalBufferCopyRowPitchAlignment;
 724     out->nonCoherentAtomSize = in->nonCoherentAtomSize;
 725 }
 726
 727 static inline void convert_VkPhysicalDeviceProperties_host_to_win(const VkPhysicalDeviceProperties_host *in, VkPhysicalDeviceProperties *out)
 728 {
 729     if (!in) return;
 730
 731     out->apiVersion = in->apiVersion;
 732     out->driverVersion = in->driverVersion;
 733     out->vendorID = in->vendorID;
 734     out->deviceID = in->deviceID;
 735     out->deviceType = in->deviceType;
 736     memcpy(out->deviceName, in->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
 737     memcpy(out->pipelineCacheUUID, in->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
 738     convert_VkPhysicalDeviceLimits_host_to_win(&in->limits, &out->limits);
 739     out->sparseProperties = in->sparseProperties;
 740 }
 741
 742 static inline void convert_VkPhysicalDeviceProperties2KHR_win_to_host(const VkPhysicalDeviceProperties2KHR *in, VkPhysicalDeviceProperties2KHR_host *out)
 743 {
 744     if (!in) return;
 745
 746     out->pNext = in->pNext;
 747     out->sType = in->sType;
 748 }
 749
 750 static inline void convert_VkPhysicalDeviceProperties2KHR_host_to_win(const VkPhysicalDeviceProperties2KHR_host *in, VkPhysicalDeviceProperties2KHR *out)
 751 {
 752     if (!in) return;
 753
 754     out->sType = in->sType;
 755     out->pNext = in->pNext;
 756     convert_VkPhysicalDeviceProperties_host_to_win(&in->properties, &out->properties);
 757 }
 758
 759 static inline VkSparseMemoryBind_host *convert_VkSparseMemoryBind_array_win_to_host(const VkSparseMemoryBind *in, uint32_t count)
 760 {
 761     VkSparseMemoryBind_host *out;
 762     unsigned int i;
 763
 764     if (!in) return NULL;
 765
 766     out = heap_alloc(count * sizeof(*out));
 767     for (i = 0; i < count; i++)
 768     {
 769         out[i].resourceOffset = in[i].resourceOffset;
 770         out[i].size = in[i].size;
 771         out[i].memory = in[i].memory;
 772         out[i].memoryOffset = in[i].memoryOffset;
 773         out[i].flags = in[i].flags;
 774     }
 775
 776     return out;
 777 }
 778
 779 static inline void free_VkSparseMemoryBind_array(VkSparseMemoryBind_host *in, uint32_t count)
 780 {
 781     if (!in) return;
 782
 783     heap_free(in);
 784 }
 785
 786 static inline VkSparseBufferMemoryBindInfo_host *convert_VkSparseBufferMemoryBindInfo_array_win_to_host(const VkSparseBufferMemoryBindInfo *in, uint32_t count)
 787 {
 788     VkSparseBufferMemoryBindInfo_host *out;
 789     unsigned int i;
 790
 791     if (!in) return NULL;
 792
 793     out = heap_alloc(count * sizeof(*out));
 794     for (i = 0; i < count; i++)
 795     {
 796         out[i].buffer = in[i].buffer;
 797         out[i].bindCount = in[i].bindCount;
 798         out[i].pBinds = convert_VkSparseMemoryBind_array_win_to_host(in[i].pBinds, in[i].bindCount);
 799     }
 800
 801     return out;
 802 }
 803
 804 static inline void free_VkSparseBufferMemoryBindInfo_array(VkSparseBufferMemoryBindInfo_host *in, uint32_t count)
 805 {
 806     unsigned int i;
 807
 808     if (!in) return;
 809
 810     for (i = 0; i < count; i++)
 811     {
 812         free_VkSparseMemoryBind_array((VkSparseMemoryBind_host *)in[i].pBinds, in[i].bindCount);
 813     }
 814     heap_free(in);
 815 }
 816
 817 static inline VkSparseImageOpaqueMemoryBindInfo_host *convert_VkSparseImageOpaqueMemoryBindInfo_array_win_to_host(const VkSparseImageOpaqueMemoryBindInfo *in, uint32_t count)
 818 {
 819     VkSparseImageOpaqueMemoryBindInfo_host *out;
 820     unsigned int i;
 821
 822     if (!in) return NULL;
 823
 824     out = heap_alloc(count * sizeof(*out));
 825     for (i = 0; i < count; i++)
 826     {
 827         out[i].image = in[i].image;
 828         out[i].bindCount = in[i].bindCount;
 829         out[i].pBinds = convert_VkSparseMemoryBind_array_win_to_host(in[i].pBinds, in[i].bindCount);
 830     }
 831
 832     return out;
 833 }
 834
 835 static inline void free_VkSparseImageOpaqueMemoryBindInfo_array(VkSparseImageOpaqueMemoryBindInfo_host *in, uint32_t count)
 836 {
 837     unsigned int i;
 838
 839     if (!in) return;
 840
 841     for (i = 0; i < count; i++)
 842     {
 843         free_VkSparseMemoryBind_array((VkSparseMemoryBind_host *)in[i].pBinds, in[i].bindCount);
 844     }
 845     heap_free(in);
 846 }
 847
 848 static inline VkSparseImageMemoryBind_host *convert_VkSparseImageMemoryBind_array_win_to_host(const VkSparseImageMemoryBind *in, uint32_t count)
 849 {
 850     VkSparseImageMemoryBind_host *out;
 851     unsigned int i;
 852
 853     if (!in) return NULL;
 854
 855     out = heap_alloc(count * sizeof(*out));
 856     for (i = 0; i < count; i++)
 857     {
 858         out[i].subresource = in[i].subresource;
 859         out[i].offset = in[i].offset;
 860         out[i].extent = in[i].extent;
 861         out[i].memory = in[i].memory;
 862         out[i].memoryOffset = in[i].memoryOffset;
 863         out[i].flags = in[i].flags;
 864     }
 865
 866     return out;
 867 }
 868
 869 static inline void free_VkSparseImageMemoryBind_array(VkSparseImageMemoryBind_host *in, uint32_t count)
 870 {
 871     if (!in) return;
 872
 873     heap_free(in);
 874 }
 875
 876 static inline VkSparseImageMemoryBindInfo_host *convert_VkSparseImageMemoryBindInfo_array_win_to_host(const VkSparseImageMemoryBindInfo *in, uint32_t count)
 877 {
 878     VkSparseImageMemoryBindInfo_host *out;
 879     unsigned int i;
 880
 881     if (!in) return NULL;
 882
 883     out = heap_alloc(count * sizeof(*out));
 884     for (i = 0; i < count; i++)
 885     {
 886         out[i].image = in[i].image;
 887         out[i].bindCount = in[i].bindCount;
 888         out[i].pBinds = convert_VkSparseImageMemoryBind_array_win_to_host(in[i].pBinds, in[i].bindCount);
 889     }
 890
 891     return out;
 892 }
 893
 894 static inline void free_VkSparseImageMemoryBindInfo_array(VkSparseImageMemoryBindInfo_host *in, uint32_t count)
 895 {
 896     unsigned int i;
 897
 898     if (!in) return;
 899
 900     for (i = 0; i < count; i++)
 901     {
 902         free_VkSparseImageMemoryBind_array((VkSparseImageMemoryBind_host *)in[i].pBinds, in[i].bindCount);
 903     }
 904     heap_free(in);
 905 }
 906
 907 static inline VkBindSparseInfo_host *convert_VkBindSparseInfo_array_win_to_host(const VkBindSparseInfo *in, uint32_t count)
 908 {
 909     VkBindSparseInfo_host *out;
 910     unsigned int i;
 911
 912     if (!in) return NULL;
 913
 914     out = heap_alloc(count * sizeof(*out));
 915     for (i = 0; i < count; i++)
 916     {
 917         out[i].sType = in[i].sType;
 918         out[i].pNext = in[i].pNext;
 919         out[i].waitSemaphoreCount = in[i].waitSemaphoreCount;
 920         out[i].pWaitSemaphores = in[i].pWaitSemaphores;
 921         out[i].bufferBindCount = in[i].bufferBindCount;
 922         out[i].pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win_to_host(in[i].pBufferBinds, in[i].bufferBindCount);
 923         out[i].imageOpaqueBindCount = in[i].imageOpaqueBindCount;
 924         out[i].pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win_to_host(in[i].pImageOpaqueBinds, in[i].imageOpaqueBindCount);
 925         out[i].imageBindCount = in[i].imageBindCount;
 926         out[i].pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win_to_host(in[i].pImageBinds, in[i].imageBindCount);
 927         out[i].signalSemaphoreCount = in[i].signalSemaphoreCount;
 928         out[i].pSignalSemaphores = in[i].pSignalSemaphores;
 929     }
 930
 931     return out;
 932 }
 933
 934 static inline void free_VkBindSparseInfo_array(VkBindSparseInfo_host *in, uint32_t count)
 935 {
 936     unsigned int i;
 937
 938     if (!in) return;
 939
 940     for (i = 0; i < count; i++)
 941     {
 942         free_VkSparseBufferMemoryBindInfo_array((VkSparseBufferMemoryBindInfo_host *)in[i].pBufferBinds, in[i].bufferBindCount);
 943         free_VkSparseImageOpaqueMemoryBindInfo_array((VkSparseImageOpaqueMemoryBindInfo_host *)in[i].pImageOpaqueBinds, in[i].imageOpaqueBindCount);
 944         free_VkSparseImageMemoryBindInfo_array((VkSparseImageMemoryBindInfo_host *)in[i].pImageBinds, in[i].imageBindCount);
 945     }
 946     heap_free(in);
 947 }
 948
 949 static inline VkCopyDescriptorSet_host *convert_VkCopyDescriptorSet_array_win_to_host(const VkCopyDescriptorSet *in, uint32_t count)
 950 {
 951     VkCopyDescriptorSet_host *out;
 952     unsigned int i;
 953
 954     if (!in) return NULL;
 955
 956     out = heap_alloc(count * sizeof(*out));
 957     for (i = 0; i < count; i++)
 958     {
 959         out[i].sType = in[i].sType;
 960         out[i].pNext = in[i].pNext;
 961         out[i].srcSet = in[i].srcSet;
 962         out[i].srcBinding = in[i].srcBinding;
 963         out[i].srcArrayElement = in[i].srcArrayElement;
 964         out[i].dstSet = in[i].dstSet;
 965         out[i].dstBinding = in[i].dstBinding;
 966         out[i].dstArrayElement = in[i].dstArrayElement;
 967         out[i].descriptorCount = in[i].descriptorCount;
 968     }
 969
 970     return out;
 971 }
 972
 973 static inline void free_VkCopyDescriptorSet_array(VkCopyDescriptorSet_host *in, uint32_t count)
 974 {
 975     if (!in) return;
 976
 977     heap_free(in);
 978 }
 979
 980 #endif /* USE_STRUCT_CONVERSION */
 981
 982 static VkResult WINAPI wine_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
 983 {
 984 #if defined(USE_STRUCT_CONVERSION)
 985     VkResult result;
 986     VkDescriptorSetAllocateInfo_host pAllocateInfo_host;
 987     TRACE("%p, %p, %p\n", device, pAllocateInfo, pDescriptorSets);
 988
 989     convert_VkDescriptorSetAllocateInfo_win_to_host(pAllocateInfo, &pAllocateInfo_host);
 990     result = device->funcs.p_vkAllocateDescriptorSets(device->device, &pAllocateInfo_host, pDescriptorSets);
 991
 992     return result;
 993 #else
 994     TRACE("%p, %p, %p\n", device, pAllocateInfo, pDescriptorSets);
 995     return device->funcs.p_vkAllocateDescriptorSets(device->device, pAllocateInfo, pDescriptorSets);
 996 #endif
 997 }
 998
 999 static VkResult WINAPI wine_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
1000 {
1001 #if defined(USE_STRUCT_CONVERSION)
1002     VkResult result;
1003     VkMemoryAllocateInfo_host pAllocateInfo_host;
1004     TRACE("%p, %p, %p, %p\n", device, pAllocateInfo, pAllocator, pMemory);
1005
1006     convert_VkMemoryAllocateInfo_win_to_host(pAllocateInfo, &pAllocateInfo_host);
1007     result = device->funcs.p_vkAllocateMemory(device->device, &pAllocateInfo_host, NULL, pMemory);
1008
1009     return result;
1010 #else
1011     TRACE("%p, %p, %p, %p\n", device, pAllocateInfo, pAllocator, pMemory);
1012     return device->funcs.p_vkAllocateMemory(device->device, pAllocateInfo, NULL, pMemory);
1013 #endif
1014 }
1015
1016 static VkResult WINAPI wine_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
1017 {
1018 #if defined(USE_STRUCT_CONVERSION)
1019     VkResult result;
1020     VkCommandBufferBeginInfo_host pBeginInfo_host;
1021     TRACE("%p, %p\n", commandBuffer, pBeginInfo);
1022
1023     convert_VkCommandBufferBeginInfo_win_to_host(pBeginInfo, &pBeginInfo_host);
1024     result = commandBuffer->device->funcs.p_vkBeginCommandBuffer(commandBuffer->command_buffer, &pBeginInfo_host);
1025
1026     free_VkCommandBufferBeginInfo(&pBeginInfo_host);
1027     return result;
1028 #else
1029     TRACE("%p, %p\n", commandBuffer, pBeginInfo);
1030     return commandBuffer->device->funcs.p_vkBeginCommandBuffer(commandBuffer->command_buffer, pBeginInfo);
1031 #endif
1032 }
1033
1034 static VkResult WINAPI wine_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1035 {
1036     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset));
1037     return device->funcs.p_vkBindBufferMemory(device->device, buffer, memory, memoryOffset);
1038 }
1039
1040 static VkResult WINAPI wine_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
1041 {
1042     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(image), wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset));
1043     return device->funcs.p_vkBindImageMemory(device->device, image, memory, memoryOffset);
1044 }
1045
1046 static void WINAPI wine_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
1047 {
1048     TRACE("%p, 0x%s, %u, %#x\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, flags);
1049     commandBuffer->device->funcs.p_vkCmdBeginQuery(commandBuffer->command_buffer, queryPool, query, flags);
1050 }
1051
1052 static void WINAPI wine_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
1053 {
1054 #if defined(USE_STRUCT_CONVERSION)
1055     VkRenderPassBeginInfo_host pRenderPassBegin_host;
1056     TRACE("%p, %p, %d\n", commandBuffer, pRenderPassBegin, contents);
1057
1058     convert_VkRenderPassBeginInfo_win_to_host(pRenderPassBegin, &pRenderPassBegin_host);
1059     commandBuffer->device->funcs.p_vkCmdBeginRenderPass(commandBuffer->command_buffer, &pRenderPassBegin_host, contents);
1060
1061 #else
1062     TRACE("%p, %p, %d\n", commandBuffer, pRenderPassBegin, contents);
1063     commandBuffer->device->funcs.p_vkCmdBeginRenderPass(commandBuffer->command_buffer, pRenderPassBegin, contents);
1064 #endif
1065 }
1066
1067 static 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)
1068 {
1069     TRACE("%p, %d, 0x%s, %u, %u, %p, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
1070     commandBuffer->device->funcs.p_vkCmdBindDescriptorSets(commandBuffer->command_buffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
1071 }
1072
1073 static void WINAPI wine_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
1074 {
1075     TRACE("%p, 0x%s, 0x%s, %d\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), indexType);
1076     commandBuffer->device->funcs.p_vkCmdBindIndexBuffer(commandBuffer->command_buffer, buffer, offset, indexType);
1077 }
1078
1079 static void WINAPI wine_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
1080 {
1081     TRACE("%p, %d, 0x%s\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(pipeline));
1082     commandBuffer->device->funcs.p_vkCmdBindPipeline(commandBuffer->command_buffer, pipelineBindPoint, pipeline);
1083 }
1084
1085 static void WINAPI wine_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
1086 {
1087     TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
1088     commandBuffer->device->funcs.p_vkCmdBindVertexBuffers(commandBuffer->command_buffer, firstBinding, bindingCount, pBuffers, pOffsets);
1089 }
1090
1091 static void WINAPI wine_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
1092 {
1093     TRACE("%p, 0x%s, %d, 0x%s, %d, %u, %p, %d\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions, filter);
1094     commandBuffer->device->funcs.p_vkCmdBlitImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
1095 }
1096
1097 static void WINAPI wine_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
1098 {
1099     TRACE("%p, %u, %p, %u, %p\n", commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
1100     commandBuffer->device->funcs.p_vkCmdClearAttachments(commandBuffer->command_buffer, attachmentCount, pAttachments, rectCount, pRects);
1101 }
1102
1103 static void WINAPI wine_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
1104 {
1105     TRACE("%p, 0x%s, %d, %p, %u, %p\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, pColor, rangeCount, pRanges);
1106     commandBuffer->device->funcs.p_vkCmdClearColorImage(commandBuffer->command_buffer, image, imageLayout, pColor, rangeCount, pRanges);
1107 }
1108
1109 static void WINAPI wine_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
1110 {
1111     TRACE("%p, 0x%s, %d, %p, %u, %p\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, pDepthStencil, rangeCount, pRanges);
1112     commandBuffer->device->funcs.p_vkCmdClearDepthStencilImage(commandBuffer->command_buffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
1113 }
1114
1115 static void WINAPI wine_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
1116 {
1117 #if defined(USE_STRUCT_CONVERSION)
1118     VkBufferCopy_host *pRegions_host;
1119     TRACE("%p, 0x%s, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
1120
1121     pRegions_host = convert_VkBufferCopy_array_win_to_host(pRegions, regionCount);
1122     commandBuffer->device->funcs.p_vkCmdCopyBuffer(commandBuffer->command_buffer, srcBuffer, dstBuffer, regionCount, pRegions_host);
1123
1124     free_VkBufferCopy_array(pRegions_host, regionCount);
1125 #else
1126     TRACE("%p, 0x%s, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
1127     commandBuffer->device->funcs.p_vkCmdCopyBuffer(commandBuffer->command_buffer, srcBuffer, dstBuffer, regionCount, pRegions);
1128 #endif
1129 }
1130
1131 static void WINAPI wine_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
1132 {
1133 #if defined(USE_STRUCT_CONVERSION)
1134     VkBufferImageCopy_host *pRegions_host;
1135     TRACE("%p, 0x%s, 0x%s, %d, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
1136
1137     pRegions_host = convert_VkBufferImageCopy_array_win_to_host(pRegions, regionCount);
1138     commandBuffer->device->funcs.p_vkCmdCopyBufferToImage(commandBuffer->command_buffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions_host);
1139
1140     free_VkBufferImageCopy_array(pRegions_host, regionCount);
1141 #else
1142     TRACE("%p, 0x%s, 0x%s, %d, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
1143     commandBuffer->device->funcs.p_vkCmdCopyBufferToImage(commandBuffer->command_buffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
1144 #endif
1145 }
1146
1147 static void WINAPI wine_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
1148 {
1149     TRACE("%p, 0x%s, %d, 0x%s, %d, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
1150     commandBuffer->device->funcs.p_vkCmdCopyImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
1151 }
1152
1153 static void WINAPI wine_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
1154 {
1155 #if defined(USE_STRUCT_CONVERSION)
1156     VkBufferImageCopy_host *pRegions_host;
1157     TRACE("%p, 0x%s, %d, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
1158
1159     pRegions_host = convert_VkBufferImageCopy_array_win_to_host(pRegions, regionCount);
1160     commandBuffer->device->funcs.p_vkCmdCopyImageToBuffer(commandBuffer->command_buffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions_host);
1161
1162     free_VkBufferImageCopy_array(pRegions_host, regionCount);
1163 #else
1164     TRACE("%p, 0x%s, %d, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
1165     commandBuffer->device->funcs.p_vkCmdCopyImageToBuffer(commandBuffer->command_buffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
1166 #endif
1167 }
1168
1169 static void WINAPI wine_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
1170 {
1171     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);
1172     commandBuffer->device->funcs.p_vkCmdCopyQueryPoolResults(commandBuffer->command_buffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
1173 }
1174
1175 static void WINAPI wine_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
1176 {
1177     TRACE("%p, %u, %u, %u\n", commandBuffer, groupCountX, groupCountY, groupCountZ);
1178     commandBuffer->device->funcs.p_vkCmdDispatch(commandBuffer->command_buffer, groupCountX, groupCountY, groupCountZ);
1179 }
1180
1181 static void WINAPI wine_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
1182 {
1183     TRACE("%p, 0x%s, 0x%s\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset));
1184     commandBuffer->device->funcs.p_vkCmdDispatchIndirect(commandBuffer->command_buffer, buffer, offset);
1185 }
1186
1187 static void WINAPI wine_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
1188 {
1189     TRACE("%p, %u, %u, %u, %u\n", commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
1190     commandBuffer->device->funcs.p_vkCmdDraw(commandBuffer->command_buffer, vertexCount, instanceCount, firstVertex, firstInstance);
1191 }
1192
1193 static void WINAPI wine_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
1194 {
1195     TRACE("%p, %u, %u, %u, %d, %u\n", commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
1196     commandBuffer->device->funcs.p_vkCmdDrawIndexed(commandBuffer->command_buffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
1197 }
1198
1199 static void WINAPI wine_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
1200 {
1201     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
1202     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirect(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
1203 }
1204
1205 static void WINAPI wine_vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1206 {
1207     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);
1208     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirectCountAMD(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1209 }
1210
1211 static void WINAPI wine_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
1212 {
1213     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
1214     commandBuffer->device->funcs.p_vkCmdDrawIndirect(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
1215 }
1216
1217 static void WINAPI wine_vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
1218 {
1219     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);
1220     commandBuffer->device->funcs.p_vkCmdDrawIndirectCountAMD(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1221 }
1222
1223 static void WINAPI wine_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
1224 {
1225     TRACE("%p, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query);
1226     commandBuffer->device->funcs.p_vkCmdEndQuery(commandBuffer->command_buffer, queryPool, query);
1227 }
1228
1229 static void WINAPI wine_vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
1230 {
1231     TRACE("%p\n", commandBuffer);
1232     commandBuffer->device->funcs.p_vkCmdEndRenderPass(commandBuffer->command_buffer);
1233 }
1234
1235 static void WINAPI wine_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
1236 {
1237     TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(size), data);
1238     commandBuffer->device->funcs.p_vkCmdFillBuffer(commandBuffer->command_buffer, dstBuffer, dstOffset, size, data);
1239 }
1240
1241 static void WINAPI wine_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
1242 {
1243     TRACE("%p, %d\n", commandBuffer, contents);
1244     commandBuffer->device->funcs.p_vkCmdNextSubpass(commandBuffer->command_buffer, contents);
1245 }
1246
1247 static 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)
1248 {
1249 #if defined(USE_STRUCT_CONVERSION)
1250     VkBufferMemoryBarrier_host *pBufferMemoryBarriers_host;
1251     VkImageMemoryBarrier_host *pImageMemoryBarriers_host;
1252     TRACE("%p, %#x, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1253
1254     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win_to_host(pBufferMemoryBarriers, bufferMemoryBarrierCount);
1255     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win_to_host(pImageMemoryBarriers, imageMemoryBarrierCount);
1256     commandBuffer->device->funcs.p_vkCmdPipelineBarrier(commandBuffer->command_buffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers_host, imageMemoryBarrierCount, pImageMemoryBarriers_host);
1257
1258     free_VkBufferMemoryBarrier_array(pBufferMemoryBarriers_host, bufferMemoryBarrierCount);
1259     free_VkImageMemoryBarrier_array(pImageMemoryBarriers_host, imageMemoryBarrierCount);
1260 #else
1261     TRACE("%p, %#x, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1262     commandBuffer->device->funcs.p_vkCmdPipelineBarrier(commandBuffer->command_buffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1263 #endif
1264 }
1265
1266 static void WINAPI wine_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
1267 {
1268     TRACE("%p, 0x%s, %#x, %u, %u, %p\n", commandBuffer, wine_dbgstr_longlong(layout), stageFlags, offset, size, pValues);
1269     commandBuffer->device->funcs.p_vkCmdPushConstants(commandBuffer->command_buffer, layout, stageFlags, offset, size, pValues);
1270 }
1271
1272 static void WINAPI wine_vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
1273 {
1274 #if defined(USE_STRUCT_CONVERSION)
1275     VkWriteDescriptorSet_host *pDescriptorWrites_host;
1276     TRACE("%p, %d, 0x%s, %u, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), set, descriptorWriteCount, pDescriptorWrites);
1277
1278     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win_to_host(pDescriptorWrites, descriptorWriteCount);
1279     commandBuffer->device->funcs.p_vkCmdPushDescriptorSetKHR(commandBuffer->command_buffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites_host);
1280
1281     free_VkWriteDescriptorSet_array(pDescriptorWrites_host, descriptorWriteCount);
1282 #else
1283     TRACE("%p, %d, 0x%s, %u, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), set, descriptorWriteCount, pDescriptorWrites);
1284     commandBuffer->device->funcs.p_vkCmdPushDescriptorSetKHR(commandBuffer->command_buffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
1285 #endif
1286 }
1287
1288 static void WINAPI wine_vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
1289 {
1290     TRACE("%p, 0x%s, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(descriptorUpdateTemplate), wine_dbgstr_longlong(layout), set, pData);
1291     commandBuffer->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer->command_buffer, descriptorUpdateTemplate, layout, set, pData);
1292 }
1293
1294 static void WINAPI wine_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
1295 {
1296     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(event), stageMask);
1297     commandBuffer->device->funcs.p_vkCmdResetEvent(commandBuffer->command_buffer, event, stageMask);
1298 }
1299
1300 static void WINAPI wine_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
1301 {
1302     TRACE("%p, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), firstQuery, queryCount);
1303     commandBuffer->device->funcs.p_vkCmdResetQueryPool(commandBuffer->command_buffer, queryPool, firstQuery, queryCount);
1304 }
1305
1306 static void WINAPI wine_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
1307 {
1308     TRACE("%p, 0x%s, %d, 0x%s, %d, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
1309     commandBuffer->device->funcs.p_vkCmdResolveImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
1310 }
1311
1312 static void WINAPI wine_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
1313 {
1314     TRACE("%p, %p\n", commandBuffer, blendConstants);
1315     commandBuffer->device->funcs.p_vkCmdSetBlendConstants(commandBuffer->command_buffer, blendConstants);
1316 }
1317
1318 static void WINAPI wine_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
1319 {
1320     TRACE("%p, %f, %f, %f\n", commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
1321     commandBuffer->device->funcs.p_vkCmdSetDepthBias(commandBuffer->command_buffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
1322 }
1323
1324 static void WINAPI wine_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
1325 {
1326     TRACE("%p, %f, %f\n", commandBuffer, minDepthBounds, maxDepthBounds);
1327     commandBuffer->device->funcs.p_vkCmdSetDepthBounds(commandBuffer->command_buffer, minDepthBounds, maxDepthBounds);
1328 }
1329
1330 static void WINAPI wine_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
1331 {
1332     TRACE("%p, %u, %u, %p\n", commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
1333     commandBuffer->device->funcs.p_vkCmdSetDiscardRectangleEXT(commandBuffer->command_buffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
1334 }
1335
1336 static void WINAPI wine_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
1337 {
1338     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(event), stageMask);
1339     commandBuffer->device->funcs.p_vkCmdSetEvent(commandBuffer->command_buffer, event, stageMask);
1340 }
1341
1342 static void WINAPI wine_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
1343 {
1344     TRACE("%p, %f\n", commandBuffer, lineWidth);
1345     commandBuffer->device->funcs.p_vkCmdSetLineWidth(commandBuffer->command_buffer, lineWidth);
1346 }
1347
1348 static void WINAPI wine_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
1349 {
1350     TRACE("%p, %u, %u, %p\n", commandBuffer, firstScissor, scissorCount, pScissors);
1351     commandBuffer->device->funcs.p_vkCmdSetScissor(commandBuffer->command_buffer, firstScissor, scissorCount, pScissors);
1352 }
1353
1354 static void WINAPI wine_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
1355 {
1356     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, compareMask);
1357     commandBuffer->device->funcs.p_vkCmdSetStencilCompareMask(commandBuffer->command_buffer, faceMask, compareMask);
1358 }
1359
1360 static void WINAPI wine_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
1361 {
1362     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, reference);
1363     commandBuffer->device->funcs.p_vkCmdSetStencilReference(commandBuffer->command_buffer, faceMask, reference);
1364 }
1365
1366 static void WINAPI wine_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
1367 {
1368     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, writeMask);
1369     commandBuffer->device->funcs.p_vkCmdSetStencilWriteMask(commandBuffer->command_buffer, faceMask, writeMask);
1370 }
1371
1372 static void WINAPI wine_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
1373 {
1374     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pViewports);
1375     commandBuffer->device->funcs.p_vkCmdSetViewport(commandBuffer->command_buffer, firstViewport, viewportCount, pViewports);
1376 }
1377
1378 static void WINAPI wine_vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
1379 {
1380     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pViewportWScalings);
1381     commandBuffer->device->funcs.p_vkCmdSetViewportWScalingNV(commandBuffer->command_buffer, firstViewport, viewportCount, pViewportWScalings);
1382 }
1383
1384 static void WINAPI wine_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
1385 {
1386     TRACE("%p, 0x%s, 0x%s, 0x%s, %p\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(dataSize), pData);
1387     commandBuffer->device->funcs.p_vkCmdUpdateBuffer(commandBuffer->command_buffer, dstBuffer, dstOffset, dataSize, pData);
1388 }
1389
1390 static 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)
1391 {
1392 #if defined(USE_STRUCT_CONVERSION)
1393     VkBufferMemoryBarrier_host *pBufferMemoryBarriers_host;
1394     VkImageMemoryBarrier_host *pImageMemoryBarriers_host;
1395     TRACE("%p, %u, %p, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1396
1397     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win_to_host(pBufferMemoryBarriers, bufferMemoryBarrierCount);
1398     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win_to_host(pImageMemoryBarriers, imageMemoryBarrierCount);
1399     commandBuffer->device->funcs.p_vkCmdWaitEvents(commandBuffer->command_buffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers_host, imageMemoryBarrierCount, pImageMemoryBarriers_host);
1400
1401     free_VkBufferMemoryBarrier_array(pBufferMemoryBarriers_host, bufferMemoryBarrierCount);
1402     free_VkImageMemoryBarrier_array(pImageMemoryBarriers_host, imageMemoryBarrierCount);
1403 #else
1404     TRACE("%p, %u, %p, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1405     commandBuffer->device->funcs.p_vkCmdWaitEvents(commandBuffer->command_buffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1406 #endif
1407 }
1408
1409 static void WINAPI wine_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
1410 {
1411     TRACE("%p, %d, 0x%s, %u\n", commandBuffer, pipelineStage, wine_dbgstr_longlong(queryPool), query);
1412     commandBuffer->device->funcs.p_vkCmdWriteTimestamp(commandBuffer->command_buffer, pipelineStage, queryPool, query);
1413 }
1414
1415 static VkResult WINAPI wine_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
1416 {
1417 #if defined(USE_STRUCT_CONVERSION)
1418     VkResult result;
1419     VkBufferCreateInfo_host pCreateInfo_host;
1420     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pBuffer);
1421
1422     convert_VkBufferCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
1423     result = device->funcs.p_vkCreateBuffer(device->device, &pCreateInfo_host, NULL, pBuffer);
1424
1425     return result;
1426 #else
1427     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pBuffer);
1428     return device->funcs.p_vkCreateBuffer(device->device, pCreateInfo, NULL, pBuffer);
1429 #endif
1430 }
1431
1432 static VkResult WINAPI wine_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
1433 {
1434 #if defined(USE_STRUCT_CONVERSION)
1435     VkResult result;
1436     VkBufferViewCreateInfo_host pCreateInfo_host;
1437     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
1438
1439     convert_VkBufferViewCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
1440     result = device->funcs.p_vkCreateBufferView(device->device, &pCreateInfo_host, NULL, pView);
1441
1442     return result;
1443 #else
1444     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
1445     return device->funcs.p_vkCreateBufferView(device->device, pCreateInfo, NULL, pView);
1446 #endif
1447 }
1448
1449 static VkResult WINAPI wine_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
1450 {
1451     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pCommandPool);
1452     return device->funcs.p_vkCreateCommandPool(device->device, pCreateInfo, NULL, pCommandPool);
1453 }
1454
1455 static VkResult WINAPI wine_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
1456 {
1457 #if defined(USE_STRUCT_CONVERSION)
1458     VkResult result;
1459     VkComputePipelineCreateInfo_host *pCreateInfos_host;
1460     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
1461
1462     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win_to_host(pCreateInfos, createInfoCount);
1463     result = device->funcs.p_vkCreateComputePipelines(device->device, pipelineCache, createInfoCount, pCreateInfos_host, NULL, pPipelines);
1464
1465     free_VkComputePipelineCreateInfo_array(pCreateInfos_host, createInfoCount);
1466     return result;
1467 #else
1468     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
1469     return device->funcs.p_vkCreateComputePipelines(device->device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines);
1470 #endif
1471 }
1472
1473 static VkResult WINAPI wine_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
1474 {
1475     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorPool);
1476     return device->funcs.p_vkCreateDescriptorPool(device->device, pCreateInfo, NULL, pDescriptorPool);
1477 }
1478
1479 static VkResult WINAPI wine_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
1480 {
1481     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSetLayout);
1482     return device->funcs.p_vkCreateDescriptorSetLayout(device->device, pCreateInfo, NULL, pSetLayout);
1483 }
1484
1485 static VkResult WINAPI wine_vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate)
1486 {
1487 #if defined(USE_STRUCT_CONVERSION)
1488     VkResult result;
1489     VkDescriptorUpdateTemplateCreateInfoKHR_host pCreateInfo_host;
1490     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
1491
1492     convert_VkDescriptorUpdateTemplateCreateInfoKHR_win_to_host(pCreateInfo, &pCreateInfo_host);
1493     result = device->funcs.p_vkCreateDescriptorUpdateTemplateKHR(device->device, &pCreateInfo_host, NULL, pDescriptorUpdateTemplate);
1494
1495     return result;
1496 #else
1497     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
1498     return device->funcs.p_vkCreateDescriptorUpdateTemplateKHR(device->device, pCreateInfo, NULL, pDescriptorUpdateTemplate);
1499 #endif
1500 }
1501
1502 static VkResult WINAPI wine_vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
1503 {
1504     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pEvent);
1505     return device->funcs.p_vkCreateEvent(device->device, pCreateInfo, NULL, pEvent);
1506 }
1507
1508 static VkResult WINAPI wine_vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
1509 {
1510     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFence);
1511     return device->funcs.p_vkCreateFence(device->device, pCreateInfo, NULL, pFence);
1512 }
1513
1514 static VkResult WINAPI wine_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
1515 {
1516 #if defined(USE_STRUCT_CONVERSION)
1517     VkResult result;
1518     VkFramebufferCreateInfo_host pCreateInfo_host;
1519     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFramebuffer);
1520
1521     convert_VkFramebufferCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
1522     result = device->funcs.p_vkCreateFramebuffer(device->device, &pCreateInfo_host, NULL, pFramebuffer);
1523
1524     return result;
1525 #else
1526     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFramebuffer);
1527     return device->funcs.p_vkCreateFramebuffer(device->device, pCreateInfo, NULL, pFramebuffer);
1528 #endif
1529 }
1530
1531 static VkResult WINAPI wine_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
1532 {
1533 #if defined(USE_STRUCT_CONVERSION)
1534     VkResult result;
1535     VkGraphicsPipelineCreateInfo_host *pCreateInfos_host;
1536     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
1537
1538     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win_to_host(pCreateInfos, createInfoCount);
1539     result = device->funcs.p_vkCreateGraphicsPipelines(device->device, pipelineCache, createInfoCount, pCreateInfos_host, NULL, pPipelines);
1540
1541     free_VkGraphicsPipelineCreateInfo_array(pCreateInfos_host, createInfoCount);
1542     return result;
1543 #else
1544     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
1545     return device->funcs.p_vkCreateGraphicsPipelines(device->device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines);
1546 #endif
1547 }
1548
1549 static VkResult WINAPI wine_vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
1550 {
1551     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pImage);
1552     return device->funcs.p_vkCreateImage(device->device, pCreateInfo, NULL, pImage);
1553 }
1554
1555 static VkResult WINAPI wine_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
1556 {
1557 #if defined(USE_STRUCT_CONVERSION)
1558     VkResult result;
1559     VkImageViewCreateInfo_host pCreateInfo_host;
1560     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
1561
1562     convert_VkImageViewCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
1563     result = device->funcs.p_vkCreateImageView(device->device, &pCreateInfo_host, NULL, pView);
1564
1565     return result;
1566 #else
1567     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
1568     return device->funcs.p_vkCreateImageView(device->device, pCreateInfo, NULL, pView);
1569 #endif
1570 }
1571
1572 static VkResult WINAPI wine_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
1573 {
1574     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPipelineCache);
1575     return device->funcs.p_vkCreatePipelineCache(device->device, pCreateInfo, NULL, pPipelineCache);
1576 }
1577
1578 static VkResult WINAPI wine_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
1579 {
1580     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPipelineLayout);
1581     return device->funcs.p_vkCreatePipelineLayout(device->device, pCreateInfo, NULL, pPipelineLayout);
1582 }
1583
1584 static VkResult WINAPI wine_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
1585 {
1586     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pQueryPool);
1587     return device->funcs.p_vkCreateQueryPool(device->device, pCreateInfo, NULL, pQueryPool);
1588 }
1589
1590 static VkResult WINAPI wine_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
1591 {
1592     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass);
1593     return device->funcs.p_vkCreateRenderPass(device->device, pCreateInfo, NULL, pRenderPass);
1594 }
1595
1596 static VkResult WINAPI wine_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
1597 {
1598     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSampler);
1599     return device->funcs.p_vkCreateSampler(device->device, pCreateInfo, NULL, pSampler);
1600 }
1601
1602 static VkResult WINAPI wine_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
1603 {
1604     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSemaphore);
1605     return device->funcs.p_vkCreateSemaphore(device->device, pCreateInfo, NULL, pSemaphore);
1606 }
1607
1608 static VkResult WINAPI wine_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
1609 {
1610     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pShaderModule);
1611     return device->funcs.p_vkCreateShaderModule(device->device, pCreateInfo, NULL, pShaderModule);
1612 }
1613
1614 static void WINAPI wine_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
1615 {
1616     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pAllocator);
1617     device->funcs.p_vkDestroyBuffer(device->device, buffer, NULL);
1618 }
1619
1620 static void WINAPI wine_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
1621 {
1622     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(bufferView), pAllocator);
1623     device->funcs.p_vkDestroyBufferView(device->device, bufferView, NULL);
1624 }
1625
1626 static void WINAPI wine_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
1627 {
1628     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(commandPool), pAllocator);
1629     device->funcs.p_vkDestroyCommandPool(device->device, commandPool, NULL);
1630 }
1631
1632 static void WINAPI wine_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
1633 {
1634     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorPool), pAllocator);
1635     device->funcs.p_vkDestroyDescriptorPool(device->device, descriptorPool, NULL);
1636 }
1637
1638 static void WINAPI wine_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
1639 {
1640     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSetLayout), pAllocator);
1641     device->funcs.p_vkDestroyDescriptorSetLayout(device->device, descriptorSetLayout, NULL);
1642 }
1643
1644 static void WINAPI wine_vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
1645 {
1646     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorUpdateTemplate), pAllocator);
1647     device->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(device->device, descriptorUpdateTemplate, NULL);
1648 }
1649
1650 static void WINAPI wine_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
1651 {
1652     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(event), pAllocator);
1653     device->funcs.p_vkDestroyEvent(device->device, event, NULL);
1654 }
1655
1656 static void WINAPI wine_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
1657 {
1658     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(fence), pAllocator);
1659     device->funcs.p_vkDestroyFence(device->device, fence, NULL);
1660 }
1661
1662 static void WINAPI wine_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
1663 {
1664     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(framebuffer), pAllocator);
1665     device->funcs.p_vkDestroyFramebuffer(device->device, framebuffer, NULL);
1666 }
1667
1668 static void WINAPI wine_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
1669 {
1670     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pAllocator);
1671     device->funcs.p_vkDestroyImage(device->device, image, NULL);
1672 }
1673
1674 static void WINAPI wine_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
1675 {
1676     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(imageView), pAllocator);
1677     device->funcs.p_vkDestroyImageView(device->device, imageView, NULL);
1678 }
1679
1680 static void WINAPI wine_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
1681 {
1682     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), pAllocator);
1683     device->funcs.p_vkDestroyPipeline(device->device, pipeline, NULL);
1684 }
1685
1686 static void WINAPI wine_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
1687 {
1688     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipelineCache), pAllocator);
1689     device->funcs.p_vkDestroyPipelineCache(device->device, pipelineCache, NULL);
1690 }
1691
1692 static void WINAPI wine_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
1693 {
1694     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipelineLayout), pAllocator);
1695     device->funcs.p_vkDestroyPipelineLayout(device->device, pipelineLayout, NULL);
1696 }
1697
1698 static void WINAPI wine_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
1699 {
1700     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(queryPool), pAllocator);
1701     device->funcs.p_vkDestroyQueryPool(device->device, queryPool, NULL);
1702 }
1703
1704 static void WINAPI wine_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
1705 {
1706     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pAllocator);
1707     device->funcs.p_vkDestroyRenderPass(device->device, renderPass, NULL);
1708 }
1709
1710 static void WINAPI wine_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
1711 {
1712     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(sampler), pAllocator);
1713     device->funcs.p_vkDestroySampler(device->device, sampler, NULL);
1714 }
1715
1716 static void WINAPI wine_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
1717 {
1718     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(semaphore), pAllocator);
1719     device->funcs.p_vkDestroySemaphore(device->device, semaphore, NULL);
1720 }
1721
1722 static void WINAPI wine_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
1723 {
1724     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(shaderModule), pAllocator);
1725     device->funcs.p_vkDestroyShaderModule(device->device, shaderModule, NULL);
1726 }
1727
1728 static VkResult WINAPI wine_vkDeviceWaitIdle(VkDevice device)
1729 {
1730     TRACE("%p\n", device);
1731     return device->funcs.p_vkDeviceWaitIdle(device->device);
1732 }
1733
1734 static VkResult WINAPI wine_vkEndCommandBuffer(VkCommandBuffer commandBuffer)
1735 {
1736     TRACE("%p\n", commandBuffer);
1737     return commandBuffer->device->funcs.p_vkEndCommandBuffer(commandBuffer->command_buffer);
1738 }
1739
1740 static VkResult WINAPI wine_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
1741 {
1742     TRACE("%p, %p, %p\n", physicalDevice, pPropertyCount, pProperties);
1743     return physicalDevice->instance->funcs.p_vkEnumerateDeviceLayerProperties(physicalDevice->phys_dev, pPropertyCount, pProperties);
1744 }
1745
1746 static VkResult WINAPI wine_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
1747 {
1748 #if defined(USE_STRUCT_CONVERSION)
1749     VkResult result;
1750     VkMappedMemoryRange_host *pMemoryRanges_host;
1751     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
1752
1753     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win_to_host(pMemoryRanges, memoryRangeCount);
1754     result = device->funcs.p_vkFlushMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges_host);
1755
1756     free_VkMappedMemoryRange_array(pMemoryRanges_host, memoryRangeCount);
1757     return result;
1758 #else
1759     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
1760     return device->funcs.p_vkFlushMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges);
1761 #endif
1762 }
1763
1764 static VkResult WINAPI wine_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
1765 {
1766     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(descriptorPool), descriptorSetCount, pDescriptorSets);
1767     return device->funcs.p_vkFreeDescriptorSets(device->device, descriptorPool, descriptorSetCount, pDescriptorSets);
1768 }
1769
1770 static void WINAPI wine_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
1771 {
1772     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(memory), pAllocator);
1773     device->funcs.p_vkFreeMemory(device->device, memory, NULL);
1774 }
1775
1776 static void WINAPI wine_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
1777 {
1778 #if defined(USE_STRUCT_CONVERSION)
1779     VkMemoryRequirements_host pMemoryRequirements_host;
1780     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pMemoryRequirements);
1781
1782     device->funcs.p_vkGetBufferMemoryRequirements(device->device, buffer, &pMemoryRequirements_host);
1783
1784     convert_VkMemoryRequirements_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
1785 #else
1786     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pMemoryRequirements);
1787     device->funcs.p_vkGetBufferMemoryRequirements(device->device, buffer, pMemoryRequirements);
1788 #endif
1789 }
1790
1791 static void WINAPI wine_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
1792 {
1793     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(memory), pCommittedMemoryInBytes);
1794     device->funcs.p_vkGetDeviceMemoryCommitment(device->device, memory, pCommittedMemoryInBytes);
1795 }
1796
1797 static VkResult WINAPI wine_vkGetEventStatus(VkDevice device, VkEvent event)
1798 {
1799     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
1800     return device->funcs.p_vkGetEventStatus(device->device, event);
1801 }
1802
1803 static VkResult WINAPI wine_vkGetFenceStatus(VkDevice device, VkFence fence)
1804 {
1805     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(fence));
1806     return device->funcs.p_vkGetFenceStatus(device->device, fence);
1807 }
1808
1809 static void WINAPI wine_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
1810 {
1811 #if defined(USE_STRUCT_CONVERSION)
1812     VkMemoryRequirements_host pMemoryRequirements_host;
1813     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pMemoryRequirements);
1814
1815     device->funcs.p_vkGetImageMemoryRequirements(device->device, image, &pMemoryRequirements_host);
1816
1817     convert_VkMemoryRequirements_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
1818 #else
1819     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pMemoryRequirements);
1820     device->funcs.p_vkGetImageMemoryRequirements(device->device, image, pMemoryRequirements);
1821 #endif
1822 }
1823
1824 static void WINAPI wine_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
1825 {
1826     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSparseMemoryRequirementCount, pSparseMemoryRequirements);
1827     device->funcs.p_vkGetImageSparseMemoryRequirements(device->device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
1828 }
1829
1830 static void WINAPI wine_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
1831 {
1832 #if defined(USE_STRUCT_CONVERSION)
1833     VkSubresourceLayout_host pLayout_host;
1834     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSubresource, pLayout);
1835
1836     device->funcs.p_vkGetImageSubresourceLayout(device->device, image, pSubresource, &pLayout_host);
1837
1838     convert_VkSubresourceLayout_host_to_win(&pLayout_host, pLayout);
1839 #else
1840     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSubresource, pLayout);
1841     device->funcs.p_vkGetImageSubresourceLayout(device->device, image, pSubresource, pLayout);
1842 #endif
1843 }
1844
1845 static void WINAPI wine_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
1846 {
1847     TRACE("%p, %p\n", physicalDevice, pFeatures);
1848     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures(physicalDevice->phys_dev, pFeatures);
1849 }
1850
1851 static void WINAPI wine_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR *pFeatures)
1852 {
1853     TRACE("%p, %p\n", physicalDevice, pFeatures);
1854     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(physicalDevice->phys_dev, pFeatures);
1855 }
1856
1857 static void WINAPI wine_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
1858 {
1859     TRACE("%p, %d, %p\n", physicalDevice, format, pFormatProperties);
1860     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(physicalDevice->phys_dev, format, pFormatProperties);
1861 }
1862
1863 static void WINAPI wine_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR *pFormatProperties)
1864 {
1865     TRACE("%p, %d, %p\n", physicalDevice, format, pFormatProperties);
1866     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice->phys_dev, format, pFormatProperties);
1867 }
1868
1869 static VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
1870 {
1871 #if defined(USE_STRUCT_CONVERSION)
1872     VkResult result;
1873     VkImageFormatProperties_host pImageFormatProperties_host;
1874     TRACE("%p, %d, %d, %d, %#x, %#x, %p\n", physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
1875
1876     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(physicalDevice->phys_dev, format, type, tiling, usage, flags, &pImageFormatProperties_host);
1877
1878     convert_VkImageFormatProperties_host_to_win(&pImageFormatProperties_host, pImageFormatProperties);
1879     return result;
1880 #else
1881     TRACE("%p, %d, %d, %d, %#x, %#x, %p\n", physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
1882     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(physicalDevice->phys_dev, format, type, tiling, usage, flags, pImageFormatProperties);
1883 #endif
1884 }
1885
1886 static VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo, VkImageFormatProperties2KHR *pImageFormatProperties)
1887 {
1888 #if defined(USE_STRUCT_CONVERSION)
1889     VkResult result;
1890     VkImageFormatProperties2KHR_host pImageFormatProperties_host;
1891     TRACE("%p, %p, %p\n", physicalDevice, pImageFormatInfo, pImageFormatProperties);
1892
1893     convert_VkImageFormatProperties2KHR_win_to_host(pImageFormatProperties, &pImageFormatProperties_host);
1894     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice->phys_dev, pImageFormatInfo, &pImageFormatProperties_host);
1895
1896     convert_VkImageFormatProperties2KHR_host_to_win(&pImageFormatProperties_host, pImageFormatProperties);
1897     return result;
1898 #else
1899     TRACE("%p, %p, %p\n", physicalDevice, pImageFormatInfo, pImageFormatProperties);
1900     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice->phys_dev, pImageFormatInfo, pImageFormatProperties);
1901 #endif
1902 }
1903
1904 static void WINAPI wine_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
1905 {
1906 #if defined(USE_STRUCT_CONVERSION)
1907     VkPhysicalDeviceMemoryProperties_host pMemoryProperties_host;
1908     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
1909
1910     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(physicalDevice->phys_dev, &pMemoryProperties_host);
1911
1912     convert_VkPhysicalDeviceMemoryProperties_host_to_win(&pMemoryProperties_host, pMemoryProperties);
1913 #else
1914     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
1915     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(physicalDevice->phys_dev, pMemoryProperties);
1916 #endif
1917 }
1918
1919 static void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties)
1920 {
1921 #if defined(USE_STRUCT_CONVERSION)
1922     VkPhysicalDeviceMemoryProperties2KHR_host pMemoryProperties_host;
1923     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
1924
1925     convert_VkPhysicalDeviceMemoryProperties2KHR_win_to_host(pMemoryProperties, &pMemoryProperties_host);
1926     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice->phys_dev, &pMemoryProperties_host);
1927
1928     convert_VkPhysicalDeviceMemoryProperties2KHR_host_to_win(&pMemoryProperties_host, pMemoryProperties);
1929 #else
1930     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
1931     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice->phys_dev, pMemoryProperties);
1932 #endif
1933 }
1934
1935 static void WINAPI wine_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
1936 {
1937 #if defined(USE_STRUCT_CONVERSION)
1938     VkPhysicalDeviceProperties_host pProperties_host;
1939     TRACE("%p, %p\n", physicalDevice, pProperties);
1940
1941     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties(physicalDevice->phys_dev, &pProperties_host);
1942
1943     convert_VkPhysicalDeviceProperties_host_to_win(&pProperties_host, pProperties);
1944 #else
1945     TRACE("%p, %p\n", physicalDevice, pProperties);
1946     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties(physicalDevice->phys_dev, pProperties);
1947 #endif
1948 }
1949
1950 static void WINAPI wine_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR *pProperties)
1951 {
1952 #if defined(USE_STRUCT_CONVERSION)
1953     VkPhysicalDeviceProperties2KHR_host pProperties_host;
1954     TRACE("%p, %p\n", physicalDevice, pProperties);
1955
1956     convert_VkPhysicalDeviceProperties2KHR_win_to_host(pProperties, &pProperties_host);
1957     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(physicalDevice->phys_dev, &pProperties_host);
1958
1959     convert_VkPhysicalDeviceProperties2KHR_host_to_win(&pProperties_host, pProperties);
1960 #else
1961     TRACE("%p, %p\n", physicalDevice, pProperties);
1962     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(physicalDevice->phys_dev, pProperties);
1963 #endif
1964 }
1965
1966 static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
1967 {
1968     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
1969     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
1970 }
1971
1972 static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties)
1973 {
1974     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
1975     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
1976 }
1977
1978 static void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
1979 {
1980     TRACE("%p, %d, %d, %d, %#x, %d, %p, %p\n", physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
1981     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice->phys_dev, format, type, samples, usage, tiling, pPropertyCount, pProperties);
1982 }
1983
1984 static void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2KHR *pProperties)
1985 {
1986     TRACE("%p, %p, %p, %p\n", physicalDevice, pFormatInfo, pPropertyCount, pProperties);
1987     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice->phys_dev, pFormatInfo, pPropertyCount, pProperties);
1988 }
1989
1990 static VkResult WINAPI wine_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
1991 {
1992     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), pDataSize, pData);
1993     return device->funcs.p_vkGetPipelineCacheData(device->device, pipelineCache, pDataSize, pData);
1994 }
1995
1996 static VkResult WINAPI wine_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
1997 {
1998     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);
1999     return device->funcs.p_vkGetQueryPoolResults(device->device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
2000 }
2001
2002 static void WINAPI wine_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
2003 {
2004     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pGranularity);
2005     device->funcs.p_vkGetRenderAreaGranularity(device->device, renderPass, pGranularity);
2006 }
2007
2008 static VkResult WINAPI wine_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
2009 {
2010 #if defined(USE_STRUCT_CONVERSION)
2011     VkResult result;
2012     VkMappedMemoryRange_host *pMemoryRanges_host;
2013     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
2014
2015     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win_to_host(pMemoryRanges, memoryRangeCount);
2016     result = device->funcs.p_vkInvalidateMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges_host);
2017
2018     free_VkMappedMemoryRange_array(pMemoryRanges_host, memoryRangeCount);
2019     return result;
2020 #else
2021     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
2022     return device->funcs.p_vkInvalidateMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges);
2023 #endif
2024 }
2025
2026 static VkResult WINAPI wine_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
2027 {
2028     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);
2029     return device->funcs.p_vkMapMemory(device->device, memory, offset, size, flags, ppData);
2030 }
2031
2032 static VkResult WINAPI wine_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
2033 {
2034     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(dstCache), srcCacheCount, pSrcCaches);
2035     return device->funcs.p_vkMergePipelineCaches(device->device, dstCache, srcCacheCount, pSrcCaches);
2036 }
2037
2038 static VkResult WINAPI wine_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
2039 {
2040 #if defined(USE_STRUCT_CONVERSION)
2041     VkResult result;
2042     VkBindSparseInfo_host *pBindInfo_host;
2043     TRACE("%p, %u, %p, 0x%s\n", queue, bindInfoCount, pBindInfo, wine_dbgstr_longlong(fence));
2044
2045     pBindInfo_host = convert_VkBindSparseInfo_array_win_to_host(pBindInfo, bindInfoCount);
2046     result = queue->device->funcs.p_vkQueueBindSparse(queue->queue, bindInfoCount, pBindInfo_host, fence);
2047
2048     free_VkBindSparseInfo_array(pBindInfo_host, bindInfoCount);
2049     return result;
2050 #else
2051     TRACE("%p, %u, %p, 0x%s\n", queue, bindInfoCount, pBindInfo, wine_dbgstr_longlong(fence));
2052     return queue->device->funcs.p_vkQueueBindSparse(queue->queue, bindInfoCount, pBindInfo, fence);
2053 #endif
2054 }
2055
2056 static VkResult WINAPI wine_vkQueueWaitIdle(VkQueue queue)
2057 {
2058     TRACE("%p\n", queue);
2059     return queue->device->funcs.p_vkQueueWaitIdle(queue->queue);
2060 }
2061
2062 static VkResult WINAPI wine_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
2063 {
2064     TRACE("%p, %#x\n", commandBuffer, flags);
2065     return commandBuffer->device->funcs.p_vkResetCommandBuffer(commandBuffer->command_buffer, flags);
2066 }
2067
2068 static VkResult WINAPI wine_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
2069 {
2070     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
2071     return device->funcs.p_vkResetCommandPool(device->device, commandPool, flags);
2072 }
2073
2074 static VkResult WINAPI wine_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
2075 {
2076     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(descriptorPool), flags);
2077     return device->funcs.p_vkResetDescriptorPool(device->device, descriptorPool, flags);
2078 }
2079
2080 static VkResult WINAPI wine_vkResetEvent(VkDevice device, VkEvent event)
2081 {
2082     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
2083     return device->funcs.p_vkResetEvent(device->device, event);
2084 }
2085
2086 static VkResult WINAPI wine_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
2087 {
2088     TRACE("%p, %u, %p\n", device, fenceCount, pFences);
2089     return device->funcs.p_vkResetFences(device->device, fenceCount, pFences);
2090 }
2091
2092 static VkResult WINAPI wine_vkSetEvent(VkDevice device, VkEvent event)
2093 {
2094     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
2095     return device->funcs.p_vkSetEvent(device->device, event);
2096 }
2097
2098 static void WINAPI wine_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags)
2099 {
2100     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
2101     device->funcs.p_vkTrimCommandPoolKHR(device->device, commandPool, flags);
2102 }
2103
2104 static void WINAPI wine_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
2105 {
2106     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(memory));
2107     device->funcs.p_vkUnmapMemory(device->device, memory);
2108 }
2109
2110 static void WINAPI wine_vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void *pData)
2111 {
2112     TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSet), wine_dbgstr_longlong(descriptorUpdateTemplate), pData);
2113     device->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(device->device, descriptorSet, descriptorUpdateTemplate, pData);
2114 }
2115
2116 static void WINAPI wine_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
2117 {
2118 #if defined(USE_STRUCT_CONVERSION)
2119     VkWriteDescriptorSet_host *pDescriptorWrites_host;
2120     VkCopyDescriptorSet_host *pDescriptorCopies_host;
2121     TRACE("%p, %u, %p, %u, %p\n", device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
2122
2123     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win_to_host(pDescriptorWrites, descriptorWriteCount);
2124     pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win_to_host(pDescriptorCopies, descriptorCopyCount);
2125     device->funcs.p_vkUpdateDescriptorSets(device->device, descriptorWriteCount, pDescriptorWrites_host, descriptorCopyCount, pDescriptorCopies_host);
2126
2127     free_VkWriteDescriptorSet_array(pDescriptorWrites_host, descriptorWriteCount);
2128     free_VkCopyDescriptorSet_array(pDescriptorCopies_host, descriptorCopyCount);
2129 #else
2130     TRACE("%p, %u, %p, %u, %p\n", device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
2131     device->funcs.p_vkUpdateDescriptorSets(device->device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
2132 #endif
2133 }
2134
2135 static VkResult WINAPI wine_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
2136 {
2137     TRACE("%p, %u, %p, %u, 0x%s\n", device, fenceCount, pFences, waitAll, wine_dbgstr_longlong(timeout));
2138     return device->funcs.p_vkWaitForFences(device->device, fenceCount, pFences, waitAll, timeout);
2139 }
2140
2141 static const struct vulkan_func vk_device_dispatch_table[] =
2142 {
2143     {"vkAcquireNextImageKHR", &wine_vkAcquireNextImageKHR},
2144     {"vkAllocateCommandBuffers", &wine_vkAllocateCommandBuffers},
2145     {"vkAllocateDescriptorSets", &wine_vkAllocateDescriptorSets},
2146     {"vkAllocateMemory", &wine_vkAllocateMemory},
2147     {"vkBeginCommandBuffer", &wine_vkBeginCommandBuffer},
2148     {"vkBindBufferMemory", &wine_vkBindBufferMemory},
2149     {"vkBindImageMemory", &wine_vkBindImageMemory},
2150     {"vkCmdBeginQuery", &wine_vkCmdBeginQuery},
2151     {"vkCmdBeginRenderPass", &wine_vkCmdBeginRenderPass},
2152     {"vkCmdBindDescriptorSets", &wine_vkCmdBindDescriptorSets},
2153     {"vkCmdBindIndexBuffer", &wine_vkCmdBindIndexBuffer},
2154     {"vkCmdBindPipeline", &wine_vkCmdBindPipeline},
2155     {"vkCmdBindVertexBuffers", &wine_vkCmdBindVertexBuffers},
2156     {"vkCmdBlitImage", &wine_vkCmdBlitImage},
2157     {"vkCmdClearAttachments", &wine_vkCmdClearAttachments},
2158     {"vkCmdClearColorImage", &wine_vkCmdClearColorImage},
2159     {"vkCmdClearDepthStencilImage", &wine_vkCmdClearDepthStencilImage},
2160     {"vkCmdCopyBuffer", &wine_vkCmdCopyBuffer},
2161     {"vkCmdCopyBufferToImage", &wine_vkCmdCopyBufferToImage},
2162     {"vkCmdCopyImage", &wine_vkCmdCopyImage},
2163     {"vkCmdCopyImageToBuffer", &wine_vkCmdCopyImageToBuffer},
2164     {"vkCmdCopyQueryPoolResults", &wine_vkCmdCopyQueryPoolResults},
2165     {"vkCmdDispatch", &wine_vkCmdDispatch},
2166     {"vkCmdDispatchIndirect", &wine_vkCmdDispatchIndirect},
2167     {"vkCmdDraw", &wine_vkCmdDraw},
2168     {"vkCmdDrawIndexed", &wine_vkCmdDrawIndexed},
2169     {"vkCmdDrawIndexedIndirect", &wine_vkCmdDrawIndexedIndirect},
2170     {"vkCmdDrawIndexedIndirectCountAMD", &wine_vkCmdDrawIndexedIndirectCountAMD},
2171     {"vkCmdDrawIndirect", &wine_vkCmdDrawIndirect},
2172     {"vkCmdDrawIndirectCountAMD", &wine_vkCmdDrawIndirectCountAMD},
2173     {"vkCmdEndQuery", &wine_vkCmdEndQuery},
2174     {"vkCmdEndRenderPass", &wine_vkCmdEndRenderPass},
2175     {"vkCmdExecuteCommands", &wine_vkCmdExecuteCommands},
2176     {"vkCmdFillBuffer", &wine_vkCmdFillBuffer},
2177     {"vkCmdNextSubpass", &wine_vkCmdNextSubpass},
2178     {"vkCmdPipelineBarrier", &wine_vkCmdPipelineBarrier},
2179     {"vkCmdPushConstants", &wine_vkCmdPushConstants},
2180     {"vkCmdPushDescriptorSetKHR", &wine_vkCmdPushDescriptorSetKHR},
2181     {"vkCmdPushDescriptorSetWithTemplateKHR", &wine_vkCmdPushDescriptorSetWithTemplateKHR},
2182     {"vkCmdResetEvent", &wine_vkCmdResetEvent},
2183     {"vkCmdResetQueryPool", &wine_vkCmdResetQueryPool},
2184     {"vkCmdResolveImage", &wine_vkCmdResolveImage},
2185     {"vkCmdSetBlendConstants", &wine_vkCmdSetBlendConstants},
2186     {"vkCmdSetDepthBias", &wine_vkCmdSetDepthBias},
2187     {"vkCmdSetDepthBounds", &wine_vkCmdSetDepthBounds},
2188     {"vkCmdSetDiscardRectangleEXT", &wine_vkCmdSetDiscardRectangleEXT},
2189     {"vkCmdSetEvent", &wine_vkCmdSetEvent},
2190     {"vkCmdSetLineWidth", &wine_vkCmdSetLineWidth},
2191     {"vkCmdSetScissor", &wine_vkCmdSetScissor},
2192     {"vkCmdSetStencilCompareMask", &wine_vkCmdSetStencilCompareMask},
2193     {"vkCmdSetStencilReference", &wine_vkCmdSetStencilReference},
2194     {"vkCmdSetStencilWriteMask", &wine_vkCmdSetStencilWriteMask},
2195     {"vkCmdSetViewport", &wine_vkCmdSetViewport},
2196     {"vkCmdSetViewportWScalingNV", &wine_vkCmdSetViewportWScalingNV},
2197     {"vkCmdUpdateBuffer", &wine_vkCmdUpdateBuffer},
2198     {"vkCmdWaitEvents", &wine_vkCmdWaitEvents},
2199     {"vkCmdWriteTimestamp", &wine_vkCmdWriteTimestamp},
2200     {"vkCreateBuffer", &wine_vkCreateBuffer},
2201     {"vkCreateBufferView", &wine_vkCreateBufferView},
2202     {"vkCreateCommandPool", &wine_vkCreateCommandPool},
2203     {"vkCreateComputePipelines", &wine_vkCreateComputePipelines},
2204     {"vkCreateDescriptorPool", &wine_vkCreateDescriptorPool},
2205     {"vkCreateDescriptorSetLayout", &wine_vkCreateDescriptorSetLayout},
2206     {"vkCreateDescriptorUpdateTemplateKHR", &wine_vkCreateDescriptorUpdateTemplateKHR},
2207     {"vkCreateEvent", &wine_vkCreateEvent},
2208     {"vkCreateFence", &wine_vkCreateFence},
2209     {"vkCreateFramebuffer", &wine_vkCreateFramebuffer},
2210     {"vkCreateGraphicsPipelines", &wine_vkCreateGraphicsPipelines},
2211     {"vkCreateImage", &wine_vkCreateImage},
2212     {"vkCreateImageView", &wine_vkCreateImageView},
2213     {"vkCreatePipelineCache", &wine_vkCreatePipelineCache},
2214     {"vkCreatePipelineLayout", &wine_vkCreatePipelineLayout},
2215     {"vkCreateQueryPool", &wine_vkCreateQueryPool},
2216     {"vkCreateRenderPass", &wine_vkCreateRenderPass},
2217     {"vkCreateSampler", &wine_vkCreateSampler},
2218     {"vkCreateSemaphore", &wine_vkCreateSemaphore},
2219     {"vkCreateShaderModule", &wine_vkCreateShaderModule},
2220     {"vkCreateSwapchainKHR", &wine_vkCreateSwapchainKHR},
2221     {"vkDestroyBuffer", &wine_vkDestroyBuffer},
2222     {"vkDestroyBufferView", &wine_vkDestroyBufferView},
2223     {"vkDestroyCommandPool", &wine_vkDestroyCommandPool},
2224     {"vkDestroyDescriptorPool", &wine_vkDestroyDescriptorPool},
2225     {"vkDestroyDescriptorSetLayout", &wine_vkDestroyDescriptorSetLayout},
2226     {"vkDestroyDescriptorUpdateTemplateKHR", &wine_vkDestroyDescriptorUpdateTemplateKHR},
2227     {"vkDestroyDevice", &wine_vkDestroyDevice},
2228     {"vkDestroyEvent", &wine_vkDestroyEvent},
2229     {"vkDestroyFence", &wine_vkDestroyFence},
2230     {"vkDestroyFramebuffer", &wine_vkDestroyFramebuffer},
2231     {"vkDestroyImage", &wine_vkDestroyImage},
2232     {"vkDestroyImageView", &wine_vkDestroyImageView},
2233     {"vkDestroyPipeline", &wine_vkDestroyPipeline},
2234     {"vkDestroyPipelineCache", &wine_vkDestroyPipelineCache},
2235     {"vkDestroyPipelineLayout", &wine_vkDestroyPipelineLayout},
2236     {"vkDestroyQueryPool", &wine_vkDestroyQueryPool},
2237     {"vkDestroyRenderPass", &wine_vkDestroyRenderPass},
2238     {"vkDestroySampler", &wine_vkDestroySampler},
2239     {"vkDestroySemaphore", &wine_vkDestroySemaphore},
2240     {"vkDestroyShaderModule", &wine_vkDestroyShaderModule},
2241     {"vkDestroySwapchainKHR", &wine_vkDestroySwapchainKHR},
2242     {"vkDeviceWaitIdle", &wine_vkDeviceWaitIdle},
2243     {"vkEndCommandBuffer", &wine_vkEndCommandBuffer},
2244     {"vkFlushMappedMemoryRanges", &wine_vkFlushMappedMemoryRanges},
2245     {"vkFreeCommandBuffers", &wine_vkFreeCommandBuffers},
2246     {"vkFreeDescriptorSets", &wine_vkFreeDescriptorSets},
2247     {"vkFreeMemory", &wine_vkFreeMemory},
2248     {"vkGetBufferMemoryRequirements", &wine_vkGetBufferMemoryRequirements},
2249     {"vkGetDeviceMemoryCommitment", &wine_vkGetDeviceMemoryCommitment},
2250     {"vkGetDeviceProcAddr", &wine_vkGetDeviceProcAddr},
2251     {"vkGetDeviceQueue", &wine_vkGetDeviceQueue},
2252     {"vkGetEventStatus", &wine_vkGetEventStatus},
2253     {"vkGetFenceStatus", &wine_vkGetFenceStatus},
2254     {"vkGetImageMemoryRequirements", &wine_vkGetImageMemoryRequirements},
2255     {"vkGetImageSparseMemoryRequirements", &wine_vkGetImageSparseMemoryRequirements},
2256     {"vkGetImageSubresourceLayout", &wine_vkGetImageSubresourceLayout},
2257     {"vkGetPipelineCacheData", &wine_vkGetPipelineCacheData},
2258     {"vkGetQueryPoolResults", &wine_vkGetQueryPoolResults},
2259     {"vkGetRenderAreaGranularity", &wine_vkGetRenderAreaGranularity},
2260     {"vkGetSwapchainImagesKHR", &wine_vkGetSwapchainImagesKHR},
2261     {"vkInvalidateMappedMemoryRanges", &wine_vkInvalidateMappedMemoryRanges},
2262     {"vkMapMemory", &wine_vkMapMemory},
2263     {"vkMergePipelineCaches", &wine_vkMergePipelineCaches},
2264     {"vkQueueBindSparse", &wine_vkQueueBindSparse},
2265     {"vkQueuePresentKHR", &wine_vkQueuePresentKHR},
2266     {"vkQueueSubmit", &wine_vkQueueSubmit},
2267     {"vkQueueWaitIdle", &wine_vkQueueWaitIdle},
2268     {"vkResetCommandBuffer", &wine_vkResetCommandBuffer},
2269     {"vkResetCommandPool", &wine_vkResetCommandPool},
2270     {"vkResetDescriptorPool", &wine_vkResetDescriptorPool},
2271     {"vkResetEvent", &wine_vkResetEvent},
2272     {"vkResetFences", &wine_vkResetFences},
2273     {"vkSetEvent", &wine_vkSetEvent},
2274     {"vkTrimCommandPoolKHR", &wine_vkTrimCommandPoolKHR},
2275     {"vkUnmapMemory", &wine_vkUnmapMemory},
2276     {"vkUpdateDescriptorSetWithTemplateKHR", &wine_vkUpdateDescriptorSetWithTemplateKHR},
2277     {"vkUpdateDescriptorSets", &wine_vkUpdateDescriptorSets},
2278     {"vkWaitForFences", &wine_vkWaitForFences},
2279 };
2280
2281 static const struct vulkan_func vk_instance_dispatch_table[] =
2282 {
2283     {"vkCreateDevice", &wine_vkCreateDevice},
2284     {"vkCreateWin32SurfaceKHR", &wine_vkCreateWin32SurfaceKHR},
2285     {"vkDestroyInstance", &wine_vkDestroyInstance},
2286     {"vkDestroySurfaceKHR", &wine_vkDestroySurfaceKHR},
2287     {"vkEnumerateDeviceExtensionProperties", &wine_vkEnumerateDeviceExtensionProperties},
2288     {"vkEnumerateDeviceLayerProperties", &wine_vkEnumerateDeviceLayerProperties},
2289     {"vkEnumeratePhysicalDevices", &wine_vkEnumeratePhysicalDevices},
2290     {"vkGetPhysicalDeviceFeatures", &wine_vkGetPhysicalDeviceFeatures},
2291     {"vkGetPhysicalDeviceFeatures2KHR", &wine_vkGetPhysicalDeviceFeatures2KHR},
2292     {"vkGetPhysicalDeviceFormatProperties", &wine_vkGetPhysicalDeviceFormatProperties},
2293     {"vkGetPhysicalDeviceFormatProperties2KHR", &wine_vkGetPhysicalDeviceFormatProperties2KHR},
2294     {"vkGetPhysicalDeviceImageFormatProperties", &wine_vkGetPhysicalDeviceImageFormatProperties},
2295     {"vkGetPhysicalDeviceImageFormatProperties2KHR", &wine_vkGetPhysicalDeviceImageFormatProperties2KHR},
2296     {"vkGetPhysicalDeviceMemoryProperties", &wine_vkGetPhysicalDeviceMemoryProperties},
2297     {"vkGetPhysicalDeviceMemoryProperties2KHR", &wine_vkGetPhysicalDeviceMemoryProperties2KHR},
2298     {"vkGetPhysicalDeviceProperties", &wine_vkGetPhysicalDeviceProperties},
2299     {"vkGetPhysicalDeviceProperties2KHR", &wine_vkGetPhysicalDeviceProperties2KHR},
2300     {"vkGetPhysicalDeviceQueueFamilyProperties", &wine_vkGetPhysicalDeviceQueueFamilyProperties},
2301     {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", &wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR},
2302     {"vkGetPhysicalDeviceSparseImageFormatProperties", &wine_vkGetPhysicalDeviceSparseImageFormatProperties},
2303     {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", &wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR},
2304     {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", &wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR},
2305     {"vkGetPhysicalDeviceSurfaceFormatsKHR", &wine_vkGetPhysicalDeviceSurfaceFormatsKHR},
2306     {"vkGetPhysicalDeviceSurfacePresentModesKHR", &wine_vkGetPhysicalDeviceSurfacePresentModesKHR},
2307     {"vkGetPhysicalDeviceSurfaceSupportKHR", &wine_vkGetPhysicalDeviceSurfaceSupportKHR},
2308     {"vkGetPhysicalDeviceWin32PresentationSupportKHR", &wine_vkGetPhysicalDeviceWin32PresentationSupportKHR},
2309 };
2310
2311 void *wine_vk_get_device_proc_addr(const char *name)
2312 {
2313     unsigned int i;
2314     for (i = 0; i < ARRAY_SIZE(vk_device_dispatch_table); i++)
2315     {
2316         if (strcmp(vk_device_dispatch_table[i].name, name) == 0)
2317         {
2318             TRACE("Found name=%s in device table\n", name);
2319             return vk_device_dispatch_table[i].func;
2320         }
2321     }
2322     return NULL;
2323 }
2324
2325 void *wine_vk_get_instance_proc_addr(const char *name)
2326 {
2327     unsigned int i;
2328     for (i = 0; i < ARRAY_SIZE(vk_instance_dispatch_table); i++)
2329     {
2330         if (strcmp(vk_instance_dispatch_table[i].name, name) == 0)
2331         {
2332             TRACE("Found name=%s in instance table\n", name);
2333             return vk_instance_dispatch_table[i].func;
2334         }
2335     }
2336     return NULL;
2337 }
2338
2339 static const char * const vk_device_extensions[] =
2340 {
2341     "VK_AMD_draw_indirect_count",
2342     "VK_AMD_gcn_shader",
2343     "VK_AMD_gpu_shader_half_float",
2344     "VK_AMD_negative_viewport_height",
2345     "VK_AMD_rasterization_order",
2346     "VK_AMD_shader_ballot",
2347     "VK_AMD_shader_explicit_vertex_parameter",
2348     "VK_AMD_shader_trinary_minmax",
2349     "VK_AMD_texture_gather_bias_lod",
2350     "VK_EXT_discard_rectangles",
2351     "VK_EXT_shader_subgroup_ballot",
2352     "VK_EXT_shader_subgroup_vote",
2353     "VK_IMG_filter_cubic",
2354     "VK_IMG_format_pvrtc",
2355     "VK_KHR_descriptor_update_template",
2356     "VK_KHR_incremental_present",
2357     "VK_KHR_maintenance1",
2358     "VK_KHR_push_descriptor",
2359     "VK_KHR_sampler_mirror_clamp_to_edge",
2360     "VK_KHR_shader_draw_parameters",
2361     "VK_KHR_swapchain",
2362     "VK_NV_clip_space_w_scaling",
2363     "VK_NV_dedicated_allocation",
2364     "VK_NV_external_memory",
2365     "VK_NV_geometry_shader_passthrough",
2366     "VK_NV_glsl_shader",
2367     "VK_NV_sample_mask_override_coverage",
2368     "VK_NV_viewport_array2",
2369     "VK_NV_viewport_swizzle",
2370 };
2371
2372 static const char *vk_instance_extensions[] =
2373 {
2374     "VK_KHR_get_physical_device_properties2",
2375     "VK_KHR_surface",
2376     "VK_KHR_win32_surface",
2377 };
2378
2379 BOOL wine_vk_device_extension_supported(const char *name)
2380 {
2381     unsigned int i;
2382     for (i = 0; i < ARRAY_SIZE(vk_device_extensions); i++)
2383     {
2384         if (strcmp(vk_device_extensions[i], name) == 0)
2385             return TRUE;
2386     }
2387     return FALSE;
2388 }
2389
2390 BOOL wine_vk_instance_extension_supported(const char *name)
2391 {
2392     unsigned int i;
2393     for (i = 0; i < ARRAY_SIZE(vk_instance_extensions); i++)
2394     {
2395         if (strcmp(vk_instance_extensions[i], name) == 0)
2396             return TRUE;
2397     }
2398     return FALSE;
2399 }