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_VkDescriptorSetAllocateInfo_win_to_host(const VkDescriptorSetAllocateInfo *in, VkDescriptorSetAllocateInfo_host *out)
  16 {
  17     if (!in) return;
  18
  19     out->sType = in->sType;
  20     out->pNext = in->pNext;
  21     out->descriptorPool = in->descriptorPool;
  22     out->descriptorSetCount = in->descriptorSetCount;
  23     out->pSetLayouts = in->pSetLayouts;
  24 }
  25
  26 static inline void convert_VkMemoryAllocateInfo_win_to_host(const VkMemoryAllocateInfo *in, VkMemoryAllocateInfo_host *out)
  27 {
  28     if (!in) return;
  29
  30     out->sType = in->sType;
  31     out->pNext = in->pNext;
  32     out->allocationSize = in->allocationSize;
  33     out->memoryTypeIndex = in->memoryTypeIndex;
  34 }
  35
  36 static inline void convert_VkBufferCreateInfo_win_to_host(const VkBufferCreateInfo *in, VkBufferCreateInfo_host *out)
  37 {
  38     if (!in) return;
  39
  40     out->sType = in->sType;
  41     out->pNext = in->pNext;
  42     out->flags = in->flags;
  43     out->size = in->size;
  44     out->usage = in->usage;
  45     out->sharingMode = in->sharingMode;
  46     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
  47     out->pQueueFamilyIndices = in->pQueueFamilyIndices;
  48 }
  49
  50 static inline void convert_VkBufferViewCreateInfo_win_to_host(const VkBufferViewCreateInfo *in, VkBufferViewCreateInfo_host *out)
  51 {
  52     if (!in) return;
  53
  54     out->sType = in->sType;
  55     out->pNext = in->pNext;
  56     out->flags = in->flags;
  57     out->buffer = in->buffer;
  58     out->format = in->format;
  59     out->offset = in->offset;
  60     out->range = in->range;
  61 }
  62
  63 static inline void convert_VkPipelineShaderStageCreateInfo_win_to_host(const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo_host *out)
  64 {
  65     if (!in) return;
  66
  67     out->sType = in->sType;
  68     out->pNext = in->pNext;
  69     out->flags = in->flags;
  70     out->stage = in->stage;
  71     out->module = in->module;
  72     out->pName = in->pName;
  73     out->pSpecializationInfo = in->pSpecializationInfo;
  74 }
  75
  76 static inline VkComputePipelineCreateInfo_host *convert_VkComputePipelineCreateInfo_array_win_to_host(const VkComputePipelineCreateInfo *in, uint32_t count)
  77 {
  78     VkComputePipelineCreateInfo_host *out;
  79     unsigned int i;
  80
  81     if (!in) return NULL;
  82
  83     out = heap_alloc(count * sizeof(*out));
  84     for (i = 0; i < count; i++)
  85     {
  86         out[i].sType = in[i].sType;
  87         out[i].pNext = in[i].pNext;
  88         out[i].flags = in[i].flags;
  89         convert_VkPipelineShaderStageCreateInfo_win_to_host(&in[i].stage, &out[i].stage);
  90         out[i].layout = in[i].layout;
  91         out[i].basePipelineHandle = in[i].basePipelineHandle;
  92         out[i].basePipelineIndex = in[i].basePipelineIndex;
  93     }
  94
  95     return out;
  96 }
  97
  98 static inline void free_VkComputePipelineCreateInfo_array(VkComputePipelineCreateInfo_host *in, uint32_t count)
  99 {
 100     if (!in) return;
 101
 102     heap_free(in);
 103 }
 104
 105 static inline void convert_VkFramebufferCreateInfo_win_to_host(const VkFramebufferCreateInfo *in, VkFramebufferCreateInfo_host *out)
 106 {
 107     if (!in) return;
 108
 109     out->sType = in->sType;
 110     out->pNext = in->pNext;
 111     out->flags = in->flags;
 112     out->renderPass = in->renderPass;
 113     out->attachmentCount = in->attachmentCount;
 114     out->pAttachments = in->pAttachments;
 115     out->width = in->width;
 116     out->height = in->height;
 117     out->layers = in->layers;
 118 }
 119
 120 static inline VkPipelineShaderStageCreateInfo_host *convert_VkPipelineShaderStageCreateInfo_array_win_to_host(const VkPipelineShaderStageCreateInfo *in, uint32_t count)
 121 {
 122     VkPipelineShaderStageCreateInfo_host *out;
 123     unsigned int i;
 124
 125     if (!in) return NULL;
 126
 127     out = heap_alloc(count * sizeof(*out));
 128     for (i = 0; i < count; i++)
 129     {
 130         out[i].sType = in[i].sType;
 131         out[i].pNext = in[i].pNext;
 132         out[i].flags = in[i].flags;
 133         out[i].stage = in[i].stage;
 134         out[i].module = in[i].module;
 135         out[i].pName = in[i].pName;
 136         out[i].pSpecializationInfo = in[i].pSpecializationInfo;
 137     }
 138
 139     return out;
 140 }
 141
 142 static inline void free_VkPipelineShaderStageCreateInfo_array(VkPipelineShaderStageCreateInfo_host *in, uint32_t count)
 143 {
 144     if (!in) return;
 145
 146     heap_free(in);
 147 }
 148
 149 static inline VkGraphicsPipelineCreateInfo_host *convert_VkGraphicsPipelineCreateInfo_array_win_to_host(const VkGraphicsPipelineCreateInfo *in, uint32_t count)
 150 {
 151     VkGraphicsPipelineCreateInfo_host *out;
 152     unsigned int i;
 153
 154     if (!in) return NULL;
 155
 156     out = heap_alloc(count * sizeof(*out));
 157     for (i = 0; i < count; i++)
 158     {
 159         out[i].sType = in[i].sType;
 160         out[i].pNext = in[i].pNext;
 161         out[i].flags = in[i].flags;
 162         out[i].stageCount = in[i].stageCount;
 163         out[i].pStages = convert_VkPipelineShaderStageCreateInfo_array_win_to_host(in[i].pStages, in[i].stageCount);
 164         out[i].pVertexInputState = in[i].pVertexInputState;
 165         out[i].pInputAssemblyState = in[i].pInputAssemblyState;
 166         out[i].pTessellationState = in[i].pTessellationState;
 167         out[i].pViewportState = in[i].pViewportState;
 168         out[i].pRasterizationState = in[i].pRasterizationState;
 169         out[i].pMultisampleState = in[i].pMultisampleState;
 170         out[i].pDepthStencilState = in[i].pDepthStencilState;
 171         out[i].pColorBlendState = in[i].pColorBlendState;
 172         out[i].pDynamicState = in[i].pDynamicState;
 173         out[i].layout = in[i].layout;
 174         out[i].renderPass = in[i].renderPass;
 175         out[i].subpass = in[i].subpass;
 176         out[i].basePipelineHandle = in[i].basePipelineHandle;
 177         out[i].basePipelineIndex = in[i].basePipelineIndex;
 178     }
 179
 180     return out;
 181 }
 182
 183 static inline void free_VkGraphicsPipelineCreateInfo_array(VkGraphicsPipelineCreateInfo_host *in, uint32_t count)
 184 {
 185     unsigned int i;
 186
 187     if (!in) return;
 188
 189     for (i = 0; i < count; i++)
 190     {
 191         free_VkPipelineShaderStageCreateInfo_array((VkPipelineShaderStageCreateInfo_host *)in[i].pStages, in[i].stageCount);
 192     }
 193     heap_free(in);
 194 }
 195
 196 static inline void convert_VkImageViewCreateInfo_win_to_host(const VkImageViewCreateInfo *in, VkImageViewCreateInfo_host *out)
 197 {
 198     if (!in) return;
 199
 200     out->sType = in->sType;
 201     out->pNext = in->pNext;
 202     out->flags = in->flags;
 203     out->image = in->image;
 204     out->viewType = in->viewType;
 205     out->format = in->format;
 206     out->components = in->components;
 207     out->subresourceRange = in->subresourceRange;
 208 }
 209
 210 static inline VkMappedMemoryRange_host *convert_VkMappedMemoryRange_array_win_to_host(const VkMappedMemoryRange *in, uint32_t count)
 211 {
 212     VkMappedMemoryRange_host *out;
 213     unsigned int i;
 214
 215     if (!in) return NULL;
 216
 217     out = heap_alloc(count * sizeof(*out));
 218     for (i = 0; i < count; i++)
 219     {
 220         out[i].sType = in[i].sType;
 221         out[i].pNext = in[i].pNext;
 222         out[i].memory = in[i].memory;
 223         out[i].offset = in[i].offset;
 224         out[i].size = in[i].size;
 225     }
 226
 227     return out;
 228 }
 229
 230 static inline void free_VkMappedMemoryRange_array(VkMappedMemoryRange_host *in, uint32_t count)
 231 {
 232     if (!in) return;
 233
 234     heap_free(in);
 235 }
 236
 237 static inline void convert_VkMemoryRequirements_host_to_win(const VkMemoryRequirements_host *in, VkMemoryRequirements *out)
 238 {
 239     if (!in) return;
 240
 241     out->size = in->size;
 242     out->alignment = in->alignment;
 243     out->memoryTypeBits = in->memoryTypeBits;
 244 }
 245
 246 static inline void convert_VkSubresourceLayout_host_to_win(const VkSubresourceLayout_host *in, VkSubresourceLayout *out)
 247 {
 248     if (!in) return;
 249
 250     out->offset = in->offset;
 251     out->size = in->size;
 252     out->rowPitch = in->rowPitch;
 253     out->arrayPitch = in->arrayPitch;
 254     out->depthPitch = in->depthPitch;
 255 }
 256
 257 static inline void convert_VkImageFormatProperties_host_to_win(const VkImageFormatProperties_host *in, VkImageFormatProperties *out)
 258 {
 259     if (!in) return;
 260
 261     out->maxExtent = in->maxExtent;
 262     out->maxMipLevels = in->maxMipLevels;
 263     out->maxArrayLayers = in->maxArrayLayers;
 264     out->sampleCounts = in->sampleCounts;
 265     out->maxResourceSize = in->maxResourceSize;
 266 }
 267
 268 static inline void convert_VkMemoryHeap_static_array_host_to_win(const VkMemoryHeap_host *in, VkMemoryHeap *out, uint32_t count)
 269 {
 270     unsigned int i;
 271
 272     if (!in) return;
 273
 274     for (i = 0; i < count; i++)
 275     {
 276         out[i].size = in[i].size;
 277         out[i].flags = in[i].flags;
 278     }
 279 }
 280
 281 static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win(const VkPhysicalDeviceMemoryProperties_host *in, VkPhysicalDeviceMemoryProperties *out)
 282 {
 283     if (!in) return;
 284
 285     out->memoryTypeCount = in->memoryTypeCount;
 286     memcpy(out->memoryTypes, in->memoryTypes, VK_MAX_MEMORY_TYPES * sizeof(VkMemoryType));
 287     out->memoryHeapCount = in->memoryHeapCount;
 288     convert_VkMemoryHeap_static_array_host_to_win(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
 289 }
 290
 291 static inline void convert_VkPhysicalDeviceLimits_host_to_win(const VkPhysicalDeviceLimits_host *in, VkPhysicalDeviceLimits *out)
 292 {
 293     if (!in) return;
 294
 295     out->maxImageDimension1D = in->maxImageDimension1D;
 296     out->maxImageDimension2D = in->maxImageDimension2D;
 297     out->maxImageDimension3D = in->maxImageDimension3D;
 298     out->maxImageDimensionCube = in->maxImageDimensionCube;
 299     out->maxImageArrayLayers = in->maxImageArrayLayers;
 300     out->maxTexelBufferElements = in->maxTexelBufferElements;
 301     out->maxUniformBufferRange = in->maxUniformBufferRange;
 302     out->maxStorageBufferRange = in->maxStorageBufferRange;
 303     out->maxPushConstantsSize = in->maxPushConstantsSize;
 304     out->maxMemoryAllocationCount = in->maxMemoryAllocationCount;
 305     out->maxSamplerAllocationCount = in->maxSamplerAllocationCount;
 306     out->bufferImageGranularity = in->bufferImageGranularity;
 307     out->sparseAddressSpaceSize = in->sparseAddressSpaceSize;
 308     out->maxBoundDescriptorSets = in->maxBoundDescriptorSets;
 309     out->maxPerStageDescriptorSamplers = in->maxPerStageDescriptorSamplers;
 310     out->maxPerStageDescriptorUniformBuffers = in->maxPerStageDescriptorUniformBuffers;
 311     out->maxPerStageDescriptorStorageBuffers = in->maxPerStageDescriptorStorageBuffers;
 312     out->maxPerStageDescriptorSampledImages = in->maxPerStageDescriptorSampledImages;
 313     out->maxPerStageDescriptorStorageImages = in->maxPerStageDescriptorStorageImages;
 314     out->maxPerStageDescriptorInputAttachments = in->maxPerStageDescriptorInputAttachments;
 315     out->maxPerStageResources = in->maxPerStageResources;
 316     out->maxDescriptorSetSamplers = in->maxDescriptorSetSamplers;
 317     out->maxDescriptorSetUniformBuffers = in->maxDescriptorSetUniformBuffers;
 318     out->maxDescriptorSetUniformBuffersDynamic = in->maxDescriptorSetUniformBuffersDynamic;
 319     out->maxDescriptorSetStorageBuffers = in->maxDescriptorSetStorageBuffers;
 320     out->maxDescriptorSetStorageBuffersDynamic = in->maxDescriptorSetStorageBuffersDynamic;
 321     out->maxDescriptorSetSampledImages = in->maxDescriptorSetSampledImages;
 322     out->maxDescriptorSetStorageImages = in->maxDescriptorSetStorageImages;
 323     out->maxDescriptorSetInputAttachments = in->maxDescriptorSetInputAttachments;
 324     out->maxVertexInputAttributes = in->maxVertexInputAttributes;
 325     out->maxVertexInputBindings = in->maxVertexInputBindings;
 326     out->maxVertexInputAttributeOffset = in->maxVertexInputAttributeOffset;
 327     out->maxVertexInputBindingStride = in->maxVertexInputBindingStride;
 328     out->maxVertexOutputComponents = in->maxVertexOutputComponents;
 329     out->maxTessellationGenerationLevel = in->maxTessellationGenerationLevel;
 330     out->maxTessellationPatchSize = in->maxTessellationPatchSize;
 331     out->maxTessellationControlPerVertexInputComponents = in->maxTessellationControlPerVertexInputComponents;
 332     out->maxTessellationControlPerVertexOutputComponents = in->maxTessellationControlPerVertexOutputComponents;
 333     out->maxTessellationControlPerPatchOutputComponents = in->maxTessellationControlPerPatchOutputComponents;
 334     out->maxTessellationControlTotalOutputComponents = in->maxTessellationControlTotalOutputComponents;
 335     out->maxTessellationEvaluationInputComponents = in->maxTessellationEvaluationInputComponents;
 336     out->maxTessellationEvaluationOutputComponents = in->maxTessellationEvaluationOutputComponents;
 337     out->maxGeometryShaderInvocations = in->maxGeometryShaderInvocations;
 338     out->maxGeometryInputComponents = in->maxGeometryInputComponents;
 339     out->maxGeometryOutputComponents = in->maxGeometryOutputComponents;
 340     out->maxGeometryOutputVertices = in->maxGeometryOutputVertices;
 341     out->maxGeometryTotalOutputComponents = in->maxGeometryTotalOutputComponents;
 342     out->maxFragmentInputComponents = in->maxFragmentInputComponents;
 343     out->maxFragmentOutputAttachments = in->maxFragmentOutputAttachments;
 344     out->maxFragmentDualSrcAttachments = in->maxFragmentDualSrcAttachments;
 345     out->maxFragmentCombinedOutputResources = in->maxFragmentCombinedOutputResources;
 346     out->maxComputeSharedMemorySize = in->maxComputeSharedMemorySize;
 347     memcpy(out->maxComputeWorkGroupCount, in->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
 348     out->maxComputeWorkGroupInvocations = in->maxComputeWorkGroupInvocations;
 349     memcpy(out->maxComputeWorkGroupSize, in->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
 350     out->subPixelPrecisionBits = in->subPixelPrecisionBits;
 351     out->subTexelPrecisionBits = in->subTexelPrecisionBits;
 352     out->mipmapPrecisionBits = in->mipmapPrecisionBits;
 353     out->maxDrawIndexedIndexValue = in->maxDrawIndexedIndexValue;
 354     out->maxDrawIndirectCount = in->maxDrawIndirectCount;
 355     out->maxSamplerLodBias = in->maxSamplerLodBias;
 356     out->maxSamplerAnisotropy = in->maxSamplerAnisotropy;
 357     out->maxViewports = in->maxViewports;
 358     memcpy(out->maxViewportDimensions, in->maxViewportDimensions, 2 * sizeof(uint32_t));
 359     memcpy(out->viewportBoundsRange, in->viewportBoundsRange, 2 * sizeof(float));
 360     out->viewportSubPixelBits = in->viewportSubPixelBits;
 361     out->minMemoryMapAlignment = in->minMemoryMapAlignment;
 362     out->minTexelBufferOffsetAlignment = in->minTexelBufferOffsetAlignment;
 363     out->minUniformBufferOffsetAlignment = in->minUniformBufferOffsetAlignment;
 364     out->minStorageBufferOffsetAlignment = in->minStorageBufferOffsetAlignment;
 365     out->minTexelOffset = in->minTexelOffset;
 366     out->maxTexelOffset = in->maxTexelOffset;
 367     out->minTexelGatherOffset = in->minTexelGatherOffset;
 368     out->maxTexelGatherOffset = in->maxTexelGatherOffset;
 369     out->minInterpolationOffset = in->minInterpolationOffset;
 370     out->maxInterpolationOffset = in->maxInterpolationOffset;
 371     out->subPixelInterpolationOffsetBits = in->subPixelInterpolationOffsetBits;
 372     out->maxFramebufferWidth = in->maxFramebufferWidth;
 373     out->maxFramebufferHeight = in->maxFramebufferHeight;
 374     out->maxFramebufferLayers = in->maxFramebufferLayers;
 375     out->framebufferColorSampleCounts = in->framebufferColorSampleCounts;
 376     out->framebufferDepthSampleCounts = in->framebufferDepthSampleCounts;
 377     out->framebufferStencilSampleCounts = in->framebufferStencilSampleCounts;
 378     out->framebufferNoAttachmentsSampleCounts = in->framebufferNoAttachmentsSampleCounts;
 379     out->maxColorAttachments = in->maxColorAttachments;
 380     out->sampledImageColorSampleCounts = in->sampledImageColorSampleCounts;
 381     out->sampledImageIntegerSampleCounts = in->sampledImageIntegerSampleCounts;
 382     out->sampledImageDepthSampleCounts = in->sampledImageDepthSampleCounts;
 383     out->sampledImageStencilSampleCounts = in->sampledImageStencilSampleCounts;
 384     out->storageImageSampleCounts = in->storageImageSampleCounts;
 385     out->maxSampleMaskWords = in->maxSampleMaskWords;
 386     out->timestampComputeAndGraphics = in->timestampComputeAndGraphics;
 387     out->timestampPeriod = in->timestampPeriod;
 388     out->maxClipDistances = in->maxClipDistances;
 389     out->maxCullDistances = in->maxCullDistances;
 390     out->maxCombinedClipAndCullDistances = in->maxCombinedClipAndCullDistances;
 391     out->discreteQueuePriorities = in->discreteQueuePriorities;
 392     memcpy(out->pointSizeRange, in->pointSizeRange, 2 * sizeof(float));
 393     memcpy(out->lineWidthRange, in->lineWidthRange, 2 * sizeof(float));
 394     out->pointSizeGranularity = in->pointSizeGranularity;
 395     out->lineWidthGranularity = in->lineWidthGranularity;
 396     out->strictLines = in->strictLines;
 397     out->standardSampleLocations = in->standardSampleLocations;
 398     out->optimalBufferCopyOffsetAlignment = in->optimalBufferCopyOffsetAlignment;
 399     out->optimalBufferCopyRowPitchAlignment = in->optimalBufferCopyRowPitchAlignment;
 400     out->nonCoherentAtomSize = in->nonCoherentAtomSize;
 401 }
 402
 403 static inline void convert_VkPhysicalDeviceProperties_host_to_win(const VkPhysicalDeviceProperties_host *in, VkPhysicalDeviceProperties *out)
 404 {
 405     if (!in) return;
 406
 407     out->apiVersion = in->apiVersion;
 408     out->driverVersion = in->driverVersion;
 409     out->vendorID = in->vendorID;
 410     out->deviceID = in->deviceID;
 411     out->deviceType = in->deviceType;
 412     memcpy(out->deviceName, in->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
 413     memcpy(out->pipelineCacheUUID, in->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
 414     convert_VkPhysicalDeviceLimits_host_to_win(&in->limits, &out->limits);
 415     out->sparseProperties = in->sparseProperties;
 416 }
 417
 418 static inline VkDescriptorImageInfo_host *convert_VkDescriptorImageInfo_array_win_to_host(const VkDescriptorImageInfo *in, uint32_t count)
 419 {
 420     VkDescriptorImageInfo_host *out;
 421     unsigned int i;
 422
 423     if (!in) return NULL;
 424
 425     out = heap_alloc(count * sizeof(*out));
 426     for (i = 0; i < count; i++)
 427     {
 428         out[i].sampler = in[i].sampler;
 429         out[i].imageView = in[i].imageView;
 430         out[i].imageLayout = in[i].imageLayout;
 431     }
 432
 433     return out;
 434 }
 435
 436 static inline void free_VkDescriptorImageInfo_array(VkDescriptorImageInfo_host *in, uint32_t count)
 437 {
 438     if (!in) return;
 439
 440     heap_free(in);
 441 }
 442
 443 static inline VkDescriptorBufferInfo_host *convert_VkDescriptorBufferInfo_array_win_to_host(const VkDescriptorBufferInfo *in, uint32_t count)
 444 {
 445     VkDescriptorBufferInfo_host *out;
 446     unsigned int i;
 447
 448     if (!in) return NULL;
 449
 450     out = heap_alloc(count * sizeof(*out));
 451     for (i = 0; i < count; i++)
 452     {
 453         out[i].buffer = in[i].buffer;
 454         out[i].offset = in[i].offset;
 455         out[i].range = in[i].range;
 456     }
 457
 458     return out;
 459 }
 460
 461 static inline void free_VkDescriptorBufferInfo_array(VkDescriptorBufferInfo_host *in, uint32_t count)
 462 {
 463     if (!in) return;
 464
 465     heap_free(in);
 466 }
 467
 468 static inline VkWriteDescriptorSet_host *convert_VkWriteDescriptorSet_array_win_to_host(const VkWriteDescriptorSet *in, uint32_t count)
 469 {
 470     VkWriteDescriptorSet_host *out;
 471     unsigned int i;
 472
 473     if (!in) return NULL;
 474
 475     out = heap_alloc(count * sizeof(*out));
 476     for (i = 0; i < count; i++)
 477     {
 478         out[i].sType = in[i].sType;
 479         out[i].pNext = in[i].pNext;
 480         out[i].dstSet = in[i].dstSet;
 481         out[i].dstBinding = in[i].dstBinding;
 482         out[i].dstArrayElement = in[i].dstArrayElement;
 483         out[i].descriptorCount = in[i].descriptorCount;
 484         out[i].descriptorType = in[i].descriptorType;
 485         out[i].pImageInfo = convert_VkDescriptorImageInfo_array_win_to_host(in[i].pImageInfo, in[i].descriptorCount);
 486         out[i].pBufferInfo = convert_VkDescriptorBufferInfo_array_win_to_host(in[i].pBufferInfo, in[i].descriptorCount);
 487         out[i].pTexelBufferView = in[i].pTexelBufferView;
 488     }
 489
 490     return out;
 491 }
 492
 493 static inline void free_VkWriteDescriptorSet_array(VkWriteDescriptorSet_host *in, uint32_t count)
 494 {
 495     unsigned int i;
 496
 497     if (!in) return;
 498
 499     for (i = 0; i < count; i++)
 500     {
 501         free_VkDescriptorImageInfo_array((VkDescriptorImageInfo_host *)in[i].pImageInfo, in[i].descriptorCount);
 502         free_VkDescriptorBufferInfo_array((VkDescriptorBufferInfo_host *)in[i].pBufferInfo, in[i].descriptorCount);
 503     }
 504     heap_free(in);
 505 }
 506
 507 static inline VkCopyDescriptorSet_host *convert_VkCopyDescriptorSet_array_win_to_host(const VkCopyDescriptorSet *in, uint32_t count)
 508 {
 509     VkCopyDescriptorSet_host *out;
 510     unsigned int i;
 511
 512     if (!in) return NULL;
 513
 514     out = heap_alloc(count * sizeof(*out));
 515     for (i = 0; i < count; i++)
 516     {
 517         out[i].sType = in[i].sType;
 518         out[i].pNext = in[i].pNext;
 519         out[i].srcSet = in[i].srcSet;
 520         out[i].srcBinding = in[i].srcBinding;
 521         out[i].srcArrayElement = in[i].srcArrayElement;
 522         out[i].dstSet = in[i].dstSet;
 523         out[i].dstBinding = in[i].dstBinding;
 524         out[i].dstArrayElement = in[i].dstArrayElement;
 525         out[i].descriptorCount = in[i].descriptorCount;
 526     }
 527
 528     return out;
 529 }
 530
 531 static inline void free_VkCopyDescriptorSet_array(VkCopyDescriptorSet_host *in, uint32_t count)
 532 {
 533     if (!in) return;
 534
 535     heap_free(in);
 536 }
 537
 538 #endif /* USE_STRUCT_CONVERSION */
 539
 540 static VkResult WINAPI wine_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
 541 {
 542     FIXME("stub: %p, %p, %p\n", device, pAllocateInfo, pCommandBuffers);
 543     return VK_ERROR_OUT_OF_HOST_MEMORY;
 544 }
 545
 546 static VkResult WINAPI wine_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
 547 {
 548 #if defined(USE_STRUCT_CONVERSION)
 549     VkResult result;
 550     VkDescriptorSetAllocateInfo_host pAllocateInfo_host;
 551     TRACE("%p, %p, %p\n", device, pAllocateInfo, pDescriptorSets);
 552
 553     convert_VkDescriptorSetAllocateInfo_win_to_host(pAllocateInfo, &pAllocateInfo_host);
 554     result = device->funcs.p_vkAllocateDescriptorSets(device->device, &pAllocateInfo_host, pDescriptorSets);
 555
 556     return result;
 557 #else
 558     TRACE("%p, %p, %p\n", device, pAllocateInfo, pDescriptorSets);
 559     return device->funcs.p_vkAllocateDescriptorSets(device->device, pAllocateInfo, pDescriptorSets);
 560 #endif
 561 }
 562
 563 static VkResult WINAPI wine_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
 564 {
 565 #if defined(USE_STRUCT_CONVERSION)
 566     VkResult result;
 567     VkMemoryAllocateInfo_host pAllocateInfo_host;
 568     TRACE("%p, %p, %p, %p\n", device, pAllocateInfo, pAllocator, pMemory);
 569
 570     convert_VkMemoryAllocateInfo_win_to_host(pAllocateInfo, &pAllocateInfo_host);
 571     result = device->funcs.p_vkAllocateMemory(device->device, &pAllocateInfo_host, NULL, pMemory);
 572
 573     return result;
 574 #else
 575     TRACE("%p, %p, %p, %p\n", device, pAllocateInfo, pAllocator, pMemory);
 576     return device->funcs.p_vkAllocateMemory(device->device, pAllocateInfo, NULL, pMemory);
 577 #endif
 578 }
 579
 580 static VkResult WINAPI wine_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
 581 {
 582     FIXME("stub: %p, %p\n", commandBuffer, pBeginInfo);
 583     return VK_ERROR_OUT_OF_HOST_MEMORY;
 584 }
 585
 586 static VkResult WINAPI wine_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 587 {
 588     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset));
 589     return device->funcs.p_vkBindBufferMemory(device->device, buffer, memory, memoryOffset);
 590 }
 591
 592 static VkResult WINAPI wine_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 593 {
 594     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(image), wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset));
 595     return device->funcs.p_vkBindImageMemory(device->device, image, memory, memoryOffset);
 596 }
 597
 598 static void WINAPI wine_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
 599 {
 600     FIXME("stub: %p, 0x%s, %u, %#x\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, flags);
 601 }
 602
 603 static void WINAPI wine_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
 604 {
 605     FIXME("stub: %p, %p, %d\n", commandBuffer, pRenderPassBegin, contents);
 606 }
 607
 608 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)
 609 {
 610     FIXME("stub: %p, %d, 0x%s, %u, %u, %p, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 611 }
 612
 613 static void WINAPI wine_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 614 {
 615     FIXME("stub: %p, 0x%s, 0x%s, %d\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), indexType);
 616 }
 617
 618 static void WINAPI wine_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 619 {
 620     FIXME("stub: %p, %d, 0x%s\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(pipeline));
 621 }
 622
 623 static void WINAPI wine_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
 624 {
 625     FIXME("stub: %p, %u, %u, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
 626 }
 627
 628 static void WINAPI wine_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
 629 {
 630     FIXME("stub: %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);
 631 }
 632
 633 static void WINAPI wine_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
 634 {
 635     FIXME("stub: %p, %u, %p, %u, %p\n", commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
 636 }
 637
 638 static void WINAPI wine_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
 639 {
 640     FIXME("stub: %p, 0x%s, %d, %p, %u, %p\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, pColor, rangeCount, pRanges);
 641 }
 642
 643 static void WINAPI wine_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
 644 {
 645     FIXME("stub: %p, 0x%s, %d, %p, %u, %p\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, pDepthStencil, rangeCount, pRanges);
 646 }
 647
 648 static void WINAPI wine_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
 649 {
 650     FIXME("stub: %p, 0x%s, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
 651 }
 652
 653 static void WINAPI wine_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
 654 {
 655     FIXME("stub: %p, 0x%s, 0x%s, %d, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcBuffer), wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
 656 }
 657
 658 static void WINAPI wine_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
 659 {
 660     FIXME("stub: %p, 0x%s, %d, 0x%s, %d, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
 661 }
 662
 663 static void WINAPI wine_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
 664 {
 665     FIXME("stub: %p, 0x%s, %d, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstBuffer), regionCount, pRegions);
 666 }
 667
 668 static void WINAPI wine_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
 669 {
 670     FIXME("stub: %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);
 671 }
 672
 673 static void WINAPI wine_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 674 {
 675     FIXME("stub: %p, %u, %u, %u\n", commandBuffer, groupCountX, groupCountY, groupCountZ);
 676 }
 677
 678 static void WINAPI wine_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 679 {
 680     FIXME("stub: %p, 0x%s, 0x%s\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset));
 681 }
 682
 683 static void WINAPI wine_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
 684 {
 685     FIXME("stub: %p, %u, %u, %u, %u\n", commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
 686 }
 687
 688 static void WINAPI wine_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
 689 {
 690     FIXME("stub: %p, %u, %u, %u, %d, %u\n", commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
 691 }
 692
 693 static void WINAPI wine_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 694 {
 695     FIXME("stub: %p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
 696 }
 697
 698 static void WINAPI wine_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 699 {
 700     FIXME("stub: %p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
 701 }
 702
 703 static void WINAPI wine_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
 704 {
 705     FIXME("stub: %p, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query);
 706 }
 707
 708 static void WINAPI wine_vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
 709 {
 710     FIXME("stub: %p\n", commandBuffer);
 711 }
 712
 713 static void WINAPI wine_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
 714 {
 715     FIXME("stub: %p, %u, %p\n", commandBuffer, commandBufferCount, pCommandBuffers);
 716 }
 717
 718 static void WINAPI wine_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
 719 {
 720     FIXME("stub: %p, 0x%s, 0x%s, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(size), data);
 721 }
 722
 723 static void WINAPI wine_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
 724 {
 725     FIXME("stub: %p, %d\n", commandBuffer, contents);
 726 }
 727
 728 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)
 729 {
 730     FIXME("stub: %p, %#x, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 731 }
 732
 733 static void WINAPI wine_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
 734 {
 735     FIXME("stub: %p, 0x%s, %#x, %u, %u, %p\n", commandBuffer, wine_dbgstr_longlong(layout), stageFlags, offset, size, pValues);
 736 }
 737
 738 static void WINAPI wine_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 739 {
 740     FIXME("stub: %p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(event), stageMask);
 741 }
 742
 743 static void WINAPI wine_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
 744 {
 745     FIXME("stub: %p, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), firstQuery, queryCount);
 746 }
 747
 748 static void WINAPI wine_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
 749 {
 750     FIXME("stub: %p, 0x%s, %d, 0x%s, %d, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
 751 }
 752
 753 static void WINAPI wine_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
 754 {
 755     FIXME("stub: %p, %p\n", commandBuffer, blendConstants);
 756 }
 757
 758 static void WINAPI wine_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
 759 {
 760     FIXME("stub: %p, %f, %f, %f\n", commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
 761 }
 762
 763 static void WINAPI wine_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
 764 {
 765     FIXME("stub: %p, %f, %f\n", commandBuffer, minDepthBounds, maxDepthBounds);
 766 }
 767
 768 static void WINAPI wine_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 769 {
 770     FIXME("stub: %p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(event), stageMask);
 771 }
 772
 773 static void WINAPI wine_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
 774 {
 775     FIXME("stub: %p, %f\n", commandBuffer, lineWidth);
 776 }
 777
 778 static void WINAPI wine_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
 779 {
 780     FIXME("stub: %p, %u, %u, %p\n", commandBuffer, firstScissor, scissorCount, pScissors);
 781 }
 782
 783 static void WINAPI wine_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
 784 {
 785     FIXME("stub: %p, %#x, %u\n", commandBuffer, faceMask, compareMask);
 786 }
 787
 788 static void WINAPI wine_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
 789 {
 790     FIXME("stub: %p, %#x, %u\n", commandBuffer, faceMask, reference);
 791 }
 792
 793 static void WINAPI wine_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
 794 {
 795     FIXME("stub: %p, %#x, %u\n", commandBuffer, faceMask, writeMask);
 796 }
 797
 798 static void WINAPI wine_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
 799 {
 800     FIXME("stub: %p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pViewports);
 801 }
 802
 803 static void WINAPI wine_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
 804 {
 805     FIXME("stub: %p, 0x%s, 0x%s, 0x%s, %p\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(dataSize), pData);
 806 }
 807
 808 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)
 809 {
 810     FIXME("stub: %p, %u, %p, %#x, %#x, %u, %p, %u, %p, %u, %p\n", commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 811 }
 812
 813 static void WINAPI wine_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
 814 {
 815     FIXME("stub: %p, %d, 0x%s, %u\n", commandBuffer, pipelineStage, wine_dbgstr_longlong(queryPool), query);
 816 }
 817
 818 static VkResult WINAPI wine_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
 819 {
 820 #if defined(USE_STRUCT_CONVERSION)
 821     VkResult result;
 822     VkBufferCreateInfo_host pCreateInfo_host;
 823     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pBuffer);
 824
 825     convert_VkBufferCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
 826     result = device->funcs.p_vkCreateBuffer(device->device, &pCreateInfo_host, NULL, pBuffer);
 827
 828     return result;
 829 #else
 830     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pBuffer);
 831     return device->funcs.p_vkCreateBuffer(device->device, pCreateInfo, NULL, pBuffer);
 832 #endif
 833 }
 834
 835 static VkResult WINAPI wine_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
 836 {
 837 #if defined(USE_STRUCT_CONVERSION)
 838     VkResult result;
 839     VkBufferViewCreateInfo_host pCreateInfo_host;
 840     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
 841
 842     convert_VkBufferViewCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
 843     result = device->funcs.p_vkCreateBufferView(device->device, &pCreateInfo_host, NULL, pView);
 844
 845     return result;
 846 #else
 847     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
 848     return device->funcs.p_vkCreateBufferView(device->device, pCreateInfo, NULL, pView);
 849 #endif
 850 }
 851
 852 static VkResult WINAPI wine_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
 853 {
 854     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pCommandPool);
 855     return device->funcs.p_vkCreateCommandPool(device->device, pCreateInfo, NULL, pCommandPool);
 856 }
 857
 858 static VkResult WINAPI wine_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 859 {
 860 #if defined(USE_STRUCT_CONVERSION)
 861     VkResult result;
 862     VkComputePipelineCreateInfo_host *pCreateInfos_host;
 863     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
 864
 865     pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win_to_host(pCreateInfos, createInfoCount);
 866     result = device->funcs.p_vkCreateComputePipelines(device->device, pipelineCache, createInfoCount, pCreateInfos_host, NULL, pPipelines);
 867
 868     free_VkComputePipelineCreateInfo_array(pCreateInfos_host, createInfoCount);
 869     return result;
 870 #else
 871     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
 872     return device->funcs.p_vkCreateComputePipelines(device->device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines);
 873 #endif
 874 }
 875
 876 static VkResult WINAPI wine_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
 877 {
 878     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorPool);
 879     return device->funcs.p_vkCreateDescriptorPool(device->device, pCreateInfo, NULL, pDescriptorPool);
 880 }
 881
 882 static VkResult WINAPI wine_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
 883 {
 884     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSetLayout);
 885     return device->funcs.p_vkCreateDescriptorSetLayout(device->device, pCreateInfo, NULL, pSetLayout);
 886 }
 887
 888 static VkResult WINAPI wine_vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
 889 {
 890     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pEvent);
 891     return device->funcs.p_vkCreateEvent(device->device, pCreateInfo, NULL, pEvent);
 892 }
 893
 894 static VkResult WINAPI wine_vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
 895 {
 896     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFence);
 897     return device->funcs.p_vkCreateFence(device->device, pCreateInfo, NULL, pFence);
 898 }
 899
 900 static VkResult WINAPI wine_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
 901 {
 902 #if defined(USE_STRUCT_CONVERSION)
 903     VkResult result;
 904     VkFramebufferCreateInfo_host pCreateInfo_host;
 905     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFramebuffer);
 906
 907     convert_VkFramebufferCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
 908     result = device->funcs.p_vkCreateFramebuffer(device->device, &pCreateInfo_host, NULL, pFramebuffer);
 909
 910     return result;
 911 #else
 912     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFramebuffer);
 913     return device->funcs.p_vkCreateFramebuffer(device->device, pCreateInfo, NULL, pFramebuffer);
 914 #endif
 915 }
 916
 917 static VkResult WINAPI wine_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 918 {
 919 #if defined(USE_STRUCT_CONVERSION)
 920     VkResult result;
 921     VkGraphicsPipelineCreateInfo_host *pCreateInfos_host;
 922     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
 923
 924     pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win_to_host(pCreateInfos, createInfoCount);
 925     result = device->funcs.p_vkCreateGraphicsPipelines(device->device, pipelineCache, createInfoCount, pCreateInfos_host, NULL, pPipelines);
 926
 927     free_VkGraphicsPipelineCreateInfo_array(pCreateInfos_host, createInfoCount);
 928     return result;
 929 #else
 930     TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), createInfoCount, pCreateInfos, pAllocator, pPipelines);
 931     return device->funcs.p_vkCreateGraphicsPipelines(device->device, pipelineCache, createInfoCount, pCreateInfos, NULL, pPipelines);
 932 #endif
 933 }
 934
 935 static VkResult WINAPI wine_vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
 936 {
 937     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pImage);
 938     return device->funcs.p_vkCreateImage(device->device, pCreateInfo, NULL, pImage);
 939 }
 940
 941 static VkResult WINAPI wine_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
 942 {
 943 #if defined(USE_STRUCT_CONVERSION)
 944     VkResult result;
 945     VkImageViewCreateInfo_host pCreateInfo_host;
 946     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
 947
 948     convert_VkImageViewCreateInfo_win_to_host(pCreateInfo, &pCreateInfo_host);
 949     result = device->funcs.p_vkCreateImageView(device->device, &pCreateInfo_host, NULL, pView);
 950
 951     return result;
 952 #else
 953     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pView);
 954     return device->funcs.p_vkCreateImageView(device->device, pCreateInfo, NULL, pView);
 955 #endif
 956 }
 957
 958 static VkResult WINAPI wine_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
 959 {
 960     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPipelineCache);
 961     return device->funcs.p_vkCreatePipelineCache(device->device, pCreateInfo, NULL, pPipelineCache);
 962 }
 963
 964 static VkResult WINAPI wine_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
 965 {
 966     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPipelineLayout);
 967     return device->funcs.p_vkCreatePipelineLayout(device->device, pCreateInfo, NULL, pPipelineLayout);
 968 }
 969
 970 static VkResult WINAPI wine_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
 971 {
 972     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pQueryPool);
 973     return device->funcs.p_vkCreateQueryPool(device->device, pCreateInfo, NULL, pQueryPool);
 974 }
 975
 976 static VkResult WINAPI wine_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
 977 {
 978     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass);
 979     return device->funcs.p_vkCreateRenderPass(device->device, pCreateInfo, NULL, pRenderPass);
 980 }
 981
 982 static VkResult WINAPI wine_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
 983 {
 984     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSampler);
 985     return device->funcs.p_vkCreateSampler(device->device, pCreateInfo, NULL, pSampler);
 986 }
 987
 988 static VkResult WINAPI wine_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
 989 {
 990     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSemaphore);
 991     return device->funcs.p_vkCreateSemaphore(device->device, pCreateInfo, NULL, pSemaphore);
 992 }
 993
 994 static VkResult WINAPI wine_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
 995 {
 996     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pShaderModule);
 997     return device->funcs.p_vkCreateShaderModule(device->device, pCreateInfo, NULL, pShaderModule);
 998 }
 999
1000 static void WINAPI wine_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
1001 {
1002     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pAllocator);
1003     device->funcs.p_vkDestroyBuffer(device->device, buffer, NULL);
1004 }
1005
1006 static void WINAPI wine_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
1007 {
1008     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(bufferView), pAllocator);
1009     device->funcs.p_vkDestroyBufferView(device->device, bufferView, NULL);
1010 }
1011
1012 static void WINAPI wine_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
1013 {
1014     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(commandPool), pAllocator);
1015     device->funcs.p_vkDestroyCommandPool(device->device, commandPool, NULL);
1016 }
1017
1018 static void WINAPI wine_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
1019 {
1020     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorPool), pAllocator);
1021     device->funcs.p_vkDestroyDescriptorPool(device->device, descriptorPool, NULL);
1022 }
1023
1024 static void WINAPI wine_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
1025 {
1026     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSetLayout), pAllocator);
1027     device->funcs.p_vkDestroyDescriptorSetLayout(device->device, descriptorSetLayout, NULL);
1028 }
1029
1030 static void WINAPI wine_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
1031 {
1032     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(event), pAllocator);
1033     device->funcs.p_vkDestroyEvent(device->device, event, NULL);
1034 }
1035
1036 static void WINAPI wine_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
1037 {
1038     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(fence), pAllocator);
1039     device->funcs.p_vkDestroyFence(device->device, fence, NULL);
1040 }
1041
1042 static void WINAPI wine_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
1043 {
1044     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(framebuffer), pAllocator);
1045     device->funcs.p_vkDestroyFramebuffer(device->device, framebuffer, NULL);
1046 }
1047
1048 static void WINAPI wine_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
1049 {
1050     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pAllocator);
1051     device->funcs.p_vkDestroyImage(device->device, image, NULL);
1052 }
1053
1054 static void WINAPI wine_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
1055 {
1056     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(imageView), pAllocator);
1057     device->funcs.p_vkDestroyImageView(device->device, imageView, NULL);
1058 }
1059
1060 static void WINAPI wine_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
1061 {
1062     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), pAllocator);
1063     device->funcs.p_vkDestroyPipeline(device->device, pipeline, NULL);
1064 }
1065
1066 static void WINAPI wine_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
1067 {
1068     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipelineCache), pAllocator);
1069     device->funcs.p_vkDestroyPipelineCache(device->device, pipelineCache, NULL);
1070 }
1071
1072 static void WINAPI wine_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
1073 {
1074     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipelineLayout), pAllocator);
1075     device->funcs.p_vkDestroyPipelineLayout(device->device, pipelineLayout, NULL);
1076 }
1077
1078 static void WINAPI wine_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
1079 {
1080     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(queryPool), pAllocator);
1081     device->funcs.p_vkDestroyQueryPool(device->device, queryPool, NULL);
1082 }
1083
1084 static void WINAPI wine_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
1085 {
1086     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pAllocator);
1087     device->funcs.p_vkDestroyRenderPass(device->device, renderPass, NULL);
1088 }
1089
1090 static void WINAPI wine_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
1091 {
1092     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(sampler), pAllocator);
1093     device->funcs.p_vkDestroySampler(device->device, sampler, NULL);
1094 }
1095
1096 static void WINAPI wine_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
1097 {
1098     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(semaphore), pAllocator);
1099     device->funcs.p_vkDestroySemaphore(device->device, semaphore, NULL);
1100 }
1101
1102 static void WINAPI wine_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
1103 {
1104     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(shaderModule), pAllocator);
1105     device->funcs.p_vkDestroyShaderModule(device->device, shaderModule, NULL);
1106 }
1107
1108 static VkResult WINAPI wine_vkDeviceWaitIdle(VkDevice device)
1109 {
1110     TRACE("%p\n", device);
1111     return device->funcs.p_vkDeviceWaitIdle(device->device);
1112 }
1113
1114 static VkResult WINAPI wine_vkEndCommandBuffer(VkCommandBuffer commandBuffer)
1115 {
1116     FIXME("stub: %p\n", commandBuffer);
1117     return VK_ERROR_OUT_OF_HOST_MEMORY;
1118 }
1119
1120 static VkResult WINAPI wine_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
1121 {
1122     TRACE("%p, %p, %p\n", physicalDevice, pPropertyCount, pProperties);
1123     return physicalDevice->instance->funcs.p_vkEnumerateDeviceLayerProperties(physicalDevice->phys_dev, pPropertyCount, pProperties);
1124 }
1125
1126 static VkResult WINAPI wine_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
1127 {
1128 #if defined(USE_STRUCT_CONVERSION)
1129     VkResult result;
1130     VkMappedMemoryRange_host *pMemoryRanges_host;
1131     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
1132
1133     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win_to_host(pMemoryRanges, memoryRangeCount);
1134     result = device->funcs.p_vkFlushMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges_host);
1135
1136     free_VkMappedMemoryRange_array(pMemoryRanges_host, memoryRangeCount);
1137     return result;
1138 #else
1139     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
1140     return device->funcs.p_vkFlushMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges);
1141 #endif
1142 }
1143
1144 static void WINAPI wine_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
1145 {
1146     FIXME("stub: %p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(commandPool), commandBufferCount, pCommandBuffers);
1147 }
1148
1149 static VkResult WINAPI wine_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
1150 {
1151     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(descriptorPool), descriptorSetCount, pDescriptorSets);
1152     return device->funcs.p_vkFreeDescriptorSets(device->device, descriptorPool, descriptorSetCount, pDescriptorSets);
1153 }
1154
1155 static void WINAPI wine_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
1156 {
1157     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(memory), pAllocator);
1158     device->funcs.p_vkFreeMemory(device->device, memory, NULL);
1159 }
1160
1161 static void WINAPI wine_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
1162 {
1163 #if defined(USE_STRUCT_CONVERSION)
1164     VkMemoryRequirements_host pMemoryRequirements_host;
1165     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pMemoryRequirements);
1166
1167     device->funcs.p_vkGetBufferMemoryRequirements(device->device, buffer, &pMemoryRequirements_host);
1168
1169     convert_VkMemoryRequirements_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
1170 #else
1171     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pMemoryRequirements);
1172     device->funcs.p_vkGetBufferMemoryRequirements(device->device, buffer, pMemoryRequirements);
1173 #endif
1174 }
1175
1176 static void WINAPI wine_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
1177 {
1178     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(memory), pCommittedMemoryInBytes);
1179     device->funcs.p_vkGetDeviceMemoryCommitment(device->device, memory, pCommittedMemoryInBytes);
1180 }
1181
1182 static VkResult WINAPI wine_vkGetEventStatus(VkDevice device, VkEvent event)
1183 {
1184     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
1185     return device->funcs.p_vkGetEventStatus(device->device, event);
1186 }
1187
1188 static VkResult WINAPI wine_vkGetFenceStatus(VkDevice device, VkFence fence)
1189 {
1190     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(fence));
1191     return device->funcs.p_vkGetFenceStatus(device->device, fence);
1192 }
1193
1194 static void WINAPI wine_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
1195 {
1196 #if defined(USE_STRUCT_CONVERSION)
1197     VkMemoryRequirements_host pMemoryRequirements_host;
1198     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pMemoryRequirements);
1199
1200     device->funcs.p_vkGetImageMemoryRequirements(device->device, image, &pMemoryRequirements_host);
1201
1202     convert_VkMemoryRequirements_host_to_win(&pMemoryRequirements_host, pMemoryRequirements);
1203 #else
1204     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pMemoryRequirements);
1205     device->funcs.p_vkGetImageMemoryRequirements(device->device, image, pMemoryRequirements);
1206 #endif
1207 }
1208
1209 static void WINAPI wine_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
1210 {
1211     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSparseMemoryRequirementCount, pSparseMemoryRequirements);
1212     device->funcs.p_vkGetImageSparseMemoryRequirements(device->device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
1213 }
1214
1215 static void WINAPI wine_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
1216 {
1217 #if defined(USE_STRUCT_CONVERSION)
1218     VkSubresourceLayout_host pLayout_host;
1219     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSubresource, pLayout);
1220
1221     device->funcs.p_vkGetImageSubresourceLayout(device->device, image, pSubresource, &pLayout_host);
1222
1223     convert_VkSubresourceLayout_host_to_win(&pLayout_host, pLayout);
1224 #else
1225     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSubresource, pLayout);
1226     device->funcs.p_vkGetImageSubresourceLayout(device->device, image, pSubresource, pLayout);
1227 #endif
1228 }
1229
1230 static void WINAPI wine_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
1231 {
1232     TRACE("%p, %p\n", physicalDevice, pFeatures);
1233     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures(physicalDevice->phys_dev, pFeatures);
1234 }
1235
1236 static void WINAPI wine_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
1237 {
1238     TRACE("%p, %d, %p\n", physicalDevice, format, pFormatProperties);
1239     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(physicalDevice->phys_dev, format, pFormatProperties);
1240 }
1241
1242 static VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
1243 {
1244 #if defined(USE_STRUCT_CONVERSION)
1245     VkResult result;
1246     VkImageFormatProperties_host pImageFormatProperties_host;
1247     TRACE("%p, %d, %d, %d, %#x, %#x, %p\n", physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
1248
1249     result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(physicalDevice->phys_dev, format, type, tiling, usage, flags, &pImageFormatProperties_host);
1250
1251     convert_VkImageFormatProperties_host_to_win(&pImageFormatProperties_host, pImageFormatProperties);
1252     return result;
1253 #else
1254     TRACE("%p, %d, %d, %d, %#x, %#x, %p\n", physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
1255     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(physicalDevice->phys_dev, format, type, tiling, usage, flags, pImageFormatProperties);
1256 #endif
1257 }
1258
1259 static void WINAPI wine_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
1260 {
1261 #if defined(USE_STRUCT_CONVERSION)
1262     VkPhysicalDeviceMemoryProperties_host pMemoryProperties_host;
1263     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
1264
1265     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(physicalDevice->phys_dev, &pMemoryProperties_host);
1266
1267     convert_VkPhysicalDeviceMemoryProperties_host_to_win(&pMemoryProperties_host, pMemoryProperties);
1268 #else
1269     TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
1270     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(physicalDevice->phys_dev, pMemoryProperties);
1271 #endif
1272 }
1273
1274 static void WINAPI wine_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
1275 {
1276 #if defined(USE_STRUCT_CONVERSION)
1277     VkPhysicalDeviceProperties_host pProperties_host;
1278     TRACE("%p, %p\n", physicalDevice, pProperties);
1279
1280     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties(physicalDevice->phys_dev, &pProperties_host);
1281
1282     convert_VkPhysicalDeviceProperties_host_to_win(&pProperties_host, pProperties);
1283 #else
1284     TRACE("%p, %p\n", physicalDevice, pProperties);
1285     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties(physicalDevice->phys_dev, pProperties);
1286 #endif
1287 }
1288
1289 static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
1290 {
1291     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
1292     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
1293 }
1294
1295 static void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
1296 {
1297     TRACE("%p, %d, %d, %d, %#x, %d, %p, %p\n", physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
1298     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice->phys_dev, format, type, samples, usage, tiling, pPropertyCount, pProperties);
1299 }
1300
1301 static VkResult WINAPI wine_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
1302 {
1303     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), pDataSize, pData);
1304     return device->funcs.p_vkGetPipelineCacheData(device->device, pipelineCache, pDataSize, pData);
1305 }
1306
1307 static VkResult WINAPI wine_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
1308 {
1309     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);
1310     return device->funcs.p_vkGetQueryPoolResults(device->device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
1311 }
1312
1313 static void WINAPI wine_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
1314 {
1315     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pGranularity);
1316     device->funcs.p_vkGetRenderAreaGranularity(device->device, renderPass, pGranularity);
1317 }
1318
1319 static VkResult WINAPI wine_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
1320 {
1321 #if defined(USE_STRUCT_CONVERSION)
1322     VkResult result;
1323     VkMappedMemoryRange_host *pMemoryRanges_host;
1324     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
1325
1326     pMemoryRanges_host = convert_VkMappedMemoryRange_array_win_to_host(pMemoryRanges, memoryRangeCount);
1327     result = device->funcs.p_vkInvalidateMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges_host);
1328
1329     free_VkMappedMemoryRange_array(pMemoryRanges_host, memoryRangeCount);
1330     return result;
1331 #else
1332     TRACE("%p, %u, %p\n", device, memoryRangeCount, pMemoryRanges);
1333     return device->funcs.p_vkInvalidateMappedMemoryRanges(device->device, memoryRangeCount, pMemoryRanges);
1334 #endif
1335 }
1336
1337 static VkResult WINAPI wine_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
1338 {
1339     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);
1340     return device->funcs.p_vkMapMemory(device->device, memory, offset, size, flags, ppData);
1341 }
1342
1343 static VkResult WINAPI wine_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
1344 {
1345     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(dstCache), srcCacheCount, pSrcCaches);
1346     return device->funcs.p_vkMergePipelineCaches(device->device, dstCache, srcCacheCount, pSrcCaches);
1347 }
1348
1349 static VkResult WINAPI wine_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
1350 {
1351     FIXME("stub: %p, %u, %p, 0x%s\n", queue, bindInfoCount, pBindInfo, wine_dbgstr_longlong(fence));
1352     return VK_ERROR_OUT_OF_HOST_MEMORY;
1353 }
1354
1355 static VkResult WINAPI wine_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
1356 {
1357     FIXME("stub: %p, %u, %p, 0x%s\n", queue, submitCount, pSubmits, wine_dbgstr_longlong(fence));
1358     return VK_ERROR_OUT_OF_HOST_MEMORY;
1359 }
1360
1361 static VkResult WINAPI wine_vkQueueWaitIdle(VkQueue queue)
1362 {
1363     FIXME("stub: %p\n", queue);
1364     return VK_ERROR_OUT_OF_HOST_MEMORY;
1365 }
1366
1367 static VkResult WINAPI wine_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
1368 {
1369     FIXME("stub: %p, %#x\n", commandBuffer, flags);
1370     return VK_ERROR_OUT_OF_HOST_MEMORY;
1371 }
1372
1373 static VkResult WINAPI wine_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
1374 {
1375     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
1376     return device->funcs.p_vkResetCommandPool(device->device, commandPool, flags);
1377 }
1378
1379 static VkResult WINAPI wine_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
1380 {
1381     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(descriptorPool), flags);
1382     return device->funcs.p_vkResetDescriptorPool(device->device, descriptorPool, flags);
1383 }
1384
1385 static VkResult WINAPI wine_vkResetEvent(VkDevice device, VkEvent event)
1386 {
1387     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
1388     return device->funcs.p_vkResetEvent(device->device, event);
1389 }
1390
1391 static VkResult WINAPI wine_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
1392 {
1393     TRACE("%p, %u, %p\n", device, fenceCount, pFences);
1394     return device->funcs.p_vkResetFences(device->device, fenceCount, pFences);
1395 }
1396
1397 static VkResult WINAPI wine_vkSetEvent(VkDevice device, VkEvent event)
1398 {
1399     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
1400     return device->funcs.p_vkSetEvent(device->device, event);
1401 }
1402
1403 static void WINAPI wine_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
1404 {
1405     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(memory));
1406     device->funcs.p_vkUnmapMemory(device->device, memory);
1407 }
1408
1409 static void WINAPI wine_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
1410 {
1411 #if defined(USE_STRUCT_CONVERSION)
1412     VkWriteDescriptorSet_host *pDescriptorWrites_host;
1413     VkCopyDescriptorSet_host *pDescriptorCopies_host;
1414     TRACE("%p, %u, %p, %u, %p\n", device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
1415
1416     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win_to_host(pDescriptorWrites, descriptorWriteCount);
1417     pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win_to_host(pDescriptorCopies, descriptorCopyCount);
1418     device->funcs.p_vkUpdateDescriptorSets(device->device, descriptorWriteCount, pDescriptorWrites_host, descriptorCopyCount, pDescriptorCopies_host);
1419
1420     free_VkWriteDescriptorSet_array(pDescriptorWrites_host, descriptorWriteCount);
1421     free_VkCopyDescriptorSet_array(pDescriptorCopies_host, descriptorCopyCount);
1422 #else
1423     TRACE("%p, %u, %p, %u, %p\n", device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
1424     device->funcs.p_vkUpdateDescriptorSets(device->device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
1425 #endif
1426 }
1427
1428 static VkResult WINAPI wine_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
1429 {
1430     TRACE("%p, %u, %p, %u, 0x%s\n", device, fenceCount, pFences, waitAll, wine_dbgstr_longlong(timeout));
1431     return device->funcs.p_vkWaitForFences(device->device, fenceCount, pFences, waitAll, timeout);
1432 }
1433
1434 static const struct vulkan_func vk_device_dispatch_table[] =
1435 {
1436     {"vkAcquireNextImageKHR", &wine_vkAcquireNextImageKHR},
1437     {"vkAllocateCommandBuffers", &wine_vkAllocateCommandBuffers},
1438     {"vkAllocateDescriptorSets", &wine_vkAllocateDescriptorSets},
1439     {"vkAllocateMemory", &wine_vkAllocateMemory},
1440     {"vkBeginCommandBuffer", &wine_vkBeginCommandBuffer},
1441     {"vkBindBufferMemory", &wine_vkBindBufferMemory},
1442     {"vkBindImageMemory", &wine_vkBindImageMemory},
1443     {"vkCmdBeginQuery", &wine_vkCmdBeginQuery},
1444     {"vkCmdBeginRenderPass", &wine_vkCmdBeginRenderPass},
1445     {"vkCmdBindDescriptorSets", &wine_vkCmdBindDescriptorSets},
1446     {"vkCmdBindIndexBuffer", &wine_vkCmdBindIndexBuffer},
1447     {"vkCmdBindPipeline", &wine_vkCmdBindPipeline},
1448     {"vkCmdBindVertexBuffers", &wine_vkCmdBindVertexBuffers},
1449     {"vkCmdBlitImage", &wine_vkCmdBlitImage},
1450     {"vkCmdClearAttachments", &wine_vkCmdClearAttachments},
1451     {"vkCmdClearColorImage", &wine_vkCmdClearColorImage},
1452     {"vkCmdClearDepthStencilImage", &wine_vkCmdClearDepthStencilImage},
1453     {"vkCmdCopyBuffer", &wine_vkCmdCopyBuffer},
1454     {"vkCmdCopyBufferToImage", &wine_vkCmdCopyBufferToImage},
1455     {"vkCmdCopyImage", &wine_vkCmdCopyImage},
1456     {"vkCmdCopyImageToBuffer", &wine_vkCmdCopyImageToBuffer},
1457     {"vkCmdCopyQueryPoolResults", &wine_vkCmdCopyQueryPoolResults},
1458     {"vkCmdDispatch", &wine_vkCmdDispatch},
1459     {"vkCmdDispatchIndirect", &wine_vkCmdDispatchIndirect},
1460     {"vkCmdDraw", &wine_vkCmdDraw},
1461     {"vkCmdDrawIndexed", &wine_vkCmdDrawIndexed},
1462     {"vkCmdDrawIndexedIndirect", &wine_vkCmdDrawIndexedIndirect},
1463     {"vkCmdDrawIndirect", &wine_vkCmdDrawIndirect},
1464     {"vkCmdEndQuery", &wine_vkCmdEndQuery},
1465     {"vkCmdEndRenderPass", &wine_vkCmdEndRenderPass},
1466     {"vkCmdExecuteCommands", &wine_vkCmdExecuteCommands},
1467     {"vkCmdFillBuffer", &wine_vkCmdFillBuffer},
1468     {"vkCmdNextSubpass", &wine_vkCmdNextSubpass},
1469     {"vkCmdPipelineBarrier", &wine_vkCmdPipelineBarrier},
1470     {"vkCmdPushConstants", &wine_vkCmdPushConstants},
1471     {"vkCmdResetEvent", &wine_vkCmdResetEvent},
1472     {"vkCmdResetQueryPool", &wine_vkCmdResetQueryPool},
1473     {"vkCmdResolveImage", &wine_vkCmdResolveImage},
1474     {"vkCmdSetBlendConstants", &wine_vkCmdSetBlendConstants},
1475     {"vkCmdSetDepthBias", &wine_vkCmdSetDepthBias},
1476     {"vkCmdSetDepthBounds", &wine_vkCmdSetDepthBounds},
1477     {"vkCmdSetEvent", &wine_vkCmdSetEvent},
1478     {"vkCmdSetLineWidth", &wine_vkCmdSetLineWidth},
1479     {"vkCmdSetScissor", &wine_vkCmdSetScissor},
1480     {"vkCmdSetStencilCompareMask", &wine_vkCmdSetStencilCompareMask},
1481     {"vkCmdSetStencilReference", &wine_vkCmdSetStencilReference},
1482     {"vkCmdSetStencilWriteMask", &wine_vkCmdSetStencilWriteMask},
1483     {"vkCmdSetViewport", &wine_vkCmdSetViewport},
1484     {"vkCmdUpdateBuffer", &wine_vkCmdUpdateBuffer},
1485     {"vkCmdWaitEvents", &wine_vkCmdWaitEvents},
1486     {"vkCmdWriteTimestamp", &wine_vkCmdWriteTimestamp},
1487     {"vkCreateBuffer", &wine_vkCreateBuffer},
1488     {"vkCreateBufferView", &wine_vkCreateBufferView},
1489     {"vkCreateCommandPool", &wine_vkCreateCommandPool},
1490     {"vkCreateComputePipelines", &wine_vkCreateComputePipelines},
1491     {"vkCreateDescriptorPool", &wine_vkCreateDescriptorPool},
1492     {"vkCreateDescriptorSetLayout", &wine_vkCreateDescriptorSetLayout},
1493     {"vkCreateEvent", &wine_vkCreateEvent},
1494     {"vkCreateFence", &wine_vkCreateFence},
1495     {"vkCreateFramebuffer", &wine_vkCreateFramebuffer},
1496     {"vkCreateGraphicsPipelines", &wine_vkCreateGraphicsPipelines},
1497     {"vkCreateImage", &wine_vkCreateImage},
1498     {"vkCreateImageView", &wine_vkCreateImageView},
1499     {"vkCreatePipelineCache", &wine_vkCreatePipelineCache},
1500     {"vkCreatePipelineLayout", &wine_vkCreatePipelineLayout},
1501     {"vkCreateQueryPool", &wine_vkCreateQueryPool},
1502     {"vkCreateRenderPass", &wine_vkCreateRenderPass},
1503     {"vkCreateSampler", &wine_vkCreateSampler},
1504     {"vkCreateSemaphore", &wine_vkCreateSemaphore},
1505     {"vkCreateShaderModule", &wine_vkCreateShaderModule},
1506     {"vkCreateSwapchainKHR", &wine_vkCreateSwapchainKHR},
1507     {"vkDestroyBuffer", &wine_vkDestroyBuffer},
1508     {"vkDestroyBufferView", &wine_vkDestroyBufferView},
1509     {"vkDestroyCommandPool", &wine_vkDestroyCommandPool},
1510     {"vkDestroyDescriptorPool", &wine_vkDestroyDescriptorPool},
1511     {"vkDestroyDescriptorSetLayout", &wine_vkDestroyDescriptorSetLayout},
1512     {"vkDestroyDevice", &wine_vkDestroyDevice},
1513     {"vkDestroyEvent", &wine_vkDestroyEvent},
1514     {"vkDestroyFence", &wine_vkDestroyFence},
1515     {"vkDestroyFramebuffer", &wine_vkDestroyFramebuffer},
1516     {"vkDestroyImage", &wine_vkDestroyImage},
1517     {"vkDestroyImageView", &wine_vkDestroyImageView},
1518     {"vkDestroyPipeline", &wine_vkDestroyPipeline},
1519     {"vkDestroyPipelineCache", &wine_vkDestroyPipelineCache},
1520     {"vkDestroyPipelineLayout", &wine_vkDestroyPipelineLayout},
1521     {"vkDestroyQueryPool", &wine_vkDestroyQueryPool},
1522     {"vkDestroyRenderPass", &wine_vkDestroyRenderPass},
1523     {"vkDestroySampler", &wine_vkDestroySampler},
1524     {"vkDestroySemaphore", &wine_vkDestroySemaphore},
1525     {"vkDestroyShaderModule", &wine_vkDestroyShaderModule},
1526     {"vkDestroySwapchainKHR", &wine_vkDestroySwapchainKHR},
1527     {"vkDeviceWaitIdle", &wine_vkDeviceWaitIdle},
1528     {"vkEndCommandBuffer", &wine_vkEndCommandBuffer},
1529     {"vkFlushMappedMemoryRanges", &wine_vkFlushMappedMemoryRanges},
1530     {"vkFreeCommandBuffers", &wine_vkFreeCommandBuffers},
1531     {"vkFreeDescriptorSets", &wine_vkFreeDescriptorSets},
1532     {"vkFreeMemory", &wine_vkFreeMemory},
1533     {"vkGetBufferMemoryRequirements", &wine_vkGetBufferMemoryRequirements},
1534     {"vkGetDeviceMemoryCommitment", &wine_vkGetDeviceMemoryCommitment},
1535     {"vkGetDeviceProcAddr", &wine_vkGetDeviceProcAddr},
1536     {"vkGetDeviceQueue", &wine_vkGetDeviceQueue},
1537     {"vkGetEventStatus", &wine_vkGetEventStatus},
1538     {"vkGetFenceStatus", &wine_vkGetFenceStatus},
1539     {"vkGetImageMemoryRequirements", &wine_vkGetImageMemoryRequirements},
1540     {"vkGetImageSparseMemoryRequirements", &wine_vkGetImageSparseMemoryRequirements},
1541     {"vkGetImageSubresourceLayout", &wine_vkGetImageSubresourceLayout},
1542     {"vkGetPipelineCacheData", &wine_vkGetPipelineCacheData},
1543     {"vkGetQueryPoolResults", &wine_vkGetQueryPoolResults},
1544     {"vkGetRenderAreaGranularity", &wine_vkGetRenderAreaGranularity},
1545     {"vkGetSwapchainImagesKHR", &wine_vkGetSwapchainImagesKHR},
1546     {"vkInvalidateMappedMemoryRanges", &wine_vkInvalidateMappedMemoryRanges},
1547     {"vkMapMemory", &wine_vkMapMemory},
1548     {"vkMergePipelineCaches", &wine_vkMergePipelineCaches},
1549     {"vkQueueBindSparse", &wine_vkQueueBindSparse},
1550     {"vkQueuePresentKHR", &wine_vkQueuePresentKHR},
1551     {"vkQueueSubmit", &wine_vkQueueSubmit},
1552     {"vkQueueWaitIdle", &wine_vkQueueWaitIdle},
1553     {"vkResetCommandBuffer", &wine_vkResetCommandBuffer},
1554     {"vkResetCommandPool", &wine_vkResetCommandPool},
1555     {"vkResetDescriptorPool", &wine_vkResetDescriptorPool},
1556     {"vkResetEvent", &wine_vkResetEvent},
1557     {"vkResetFences", &wine_vkResetFences},
1558     {"vkSetEvent", &wine_vkSetEvent},
1559     {"vkUnmapMemory", &wine_vkUnmapMemory},
1560     {"vkUpdateDescriptorSets", &wine_vkUpdateDescriptorSets},
1561     {"vkWaitForFences", &wine_vkWaitForFences},
1562 };
1563
1564 static const struct vulkan_func vk_instance_dispatch_table[] =
1565 {
1566     {"vkCreateDevice", &wine_vkCreateDevice},
1567     {"vkCreateWin32SurfaceKHR", &wine_vkCreateWin32SurfaceKHR},
1568     {"vkDestroyInstance", &wine_vkDestroyInstance},
1569     {"vkDestroySurfaceKHR", &wine_vkDestroySurfaceKHR},
1570     {"vkEnumerateDeviceExtensionProperties", &wine_vkEnumerateDeviceExtensionProperties},
1571     {"vkEnumerateDeviceLayerProperties", &wine_vkEnumerateDeviceLayerProperties},
1572     {"vkEnumeratePhysicalDevices", &wine_vkEnumeratePhysicalDevices},
1573     {"vkGetPhysicalDeviceFeatures", &wine_vkGetPhysicalDeviceFeatures},
1574     {"vkGetPhysicalDeviceFormatProperties", &wine_vkGetPhysicalDeviceFormatProperties},
1575     {"vkGetPhysicalDeviceImageFormatProperties", &wine_vkGetPhysicalDeviceImageFormatProperties},
1576     {"vkGetPhysicalDeviceMemoryProperties", &wine_vkGetPhysicalDeviceMemoryProperties},
1577     {"vkGetPhysicalDeviceProperties", &wine_vkGetPhysicalDeviceProperties},
1578     {"vkGetPhysicalDeviceQueueFamilyProperties", &wine_vkGetPhysicalDeviceQueueFamilyProperties},
1579     {"vkGetPhysicalDeviceSparseImageFormatProperties", &wine_vkGetPhysicalDeviceSparseImageFormatProperties},
1580     {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", &wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR},
1581     {"vkGetPhysicalDeviceSurfaceFormatsKHR", &wine_vkGetPhysicalDeviceSurfaceFormatsKHR},
1582     {"vkGetPhysicalDeviceSurfacePresentModesKHR", &wine_vkGetPhysicalDeviceSurfacePresentModesKHR},
1583     {"vkGetPhysicalDeviceSurfaceSupportKHR", &wine_vkGetPhysicalDeviceSurfaceSupportKHR},
1584     {"vkGetPhysicalDeviceWin32PresentationSupportKHR", &wine_vkGetPhysicalDeviceWin32PresentationSupportKHR},
1585 };
1586
1587 void *wine_vk_get_device_proc_addr(const char *name)
1588 {
1589     unsigned int i;
1590     for (i = 0; i < ARRAY_SIZE(vk_device_dispatch_table); i++)
1591     {
1592         if (strcmp(vk_device_dispatch_table[i].name, name) == 0)
1593         {
1594             TRACE("Found name=%s in device table\n", name);
1595             return vk_device_dispatch_table[i].func;
1596         }
1597     }
1598     return NULL;
1599 }
1600
1601 void *wine_vk_get_instance_proc_addr(const char *name)
1602 {
1603     unsigned int i;
1604     for (i = 0; i < ARRAY_SIZE(vk_instance_dispatch_table); i++)
1605     {
1606         if (strcmp(vk_instance_dispatch_table[i].name, name) == 0)
1607         {
1608             TRACE("Found name=%s in instance table\n", name);
1609             return vk_instance_dispatch_table[i].func;
1610         }
1611     }
1612     return NULL;
1613 }
1614
1615 static const char * const vk_device_extensions[] =
1616 {
1617     "VK_KHR_swapchain",
1618 };
1619
1620 BOOL wine_vk_device_extension_supported(const char *name)
1621 {
1622     unsigned int i;
1623     for (i = 0; i < ARRAY_SIZE(vk_device_extensions); i++)
1624     {
1625         if (strcmp(vk_device_extensions[i], name) == 0)
1626             return TRUE;
1627     }
1628     return FALSE;
1629 }