dlls/winevulkan/loader_thunks.c

   1 /* Automatically generated from Vulkan vk.xml; DO NOT EDIT!
   2  *
   3  * This file is generated from Vulkan vk.xml file covered
   4  * by the following copyright and permission notice:
   5  *
   6  * Copyright 2015-2021 The Khronos Group Inc.
   7  *
   8  * SPDX-License-Identifier: Apache-2.0 OR MIT
   9  *
  10  */
  11
  12 #include "vulkan_loader.h"
  13
  14 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
  15
  16 VkResult WINAPI wine_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
  17 {
  18     return unix_funcs->p_vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
  19 }
  20
  21 VkResult WINAPI wine_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
  22 {
  23     return unix_funcs->p_vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
  24 }
  25
  26 VkResult WINAPI wine_vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
  27 {
  28     return unix_funcs->p_vkAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration);
  29 }
  30
  31 VkResult WINAPI wine_vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
  32 {
  33     return unix_funcs->p_vkAcquireProfilingLockKHR(device, pInfo);
  34 }
  35
  36 VkResult WINAPI wine_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
  37 {
  38     return unix_funcs->p_vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
  39 }
  40
  41 VkResult WINAPI wine_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
  42 {
  43     return unix_funcs->p_vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
  44 }
  45
  46 VkResult WINAPI wine_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
  47 {
  48     return unix_funcs->p_vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
  49 }
  50
  51 VkResult WINAPI wine_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
  52 {
  53     return unix_funcs->p_vkBeginCommandBuffer(commandBuffer, pBeginInfo);
  54 }
  55
  56 VkResult WINAPI wine_vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
  57 {
  58     return unix_funcs->p_vkBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos);
  59 }
  60
  61 VkResult WINAPI wine_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
  62 {
  63     return unix_funcs->p_vkBindBufferMemory(device, buffer, memory, memoryOffset);
  64 }
  65
  66 VkResult WINAPI wine_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
  67 {
  68     return unix_funcs->p_vkBindBufferMemory2(device, bindInfoCount, pBindInfos);
  69 }
  70
  71 VkResult WINAPI wine_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
  72 {
  73     return unix_funcs->p_vkBindBufferMemory2KHR(device, bindInfoCount, pBindInfos);
  74 }
  75
  76 VkResult WINAPI wine_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
  77 {
  78     return unix_funcs->p_vkBindImageMemory(device, image, memory, memoryOffset);
  79 }
  80
  81 VkResult WINAPI wine_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
  82 {
  83     return unix_funcs->p_vkBindImageMemory2(device, bindInfoCount, pBindInfos);
  84 }
  85
  86 VkResult WINAPI wine_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
  87 {
  88     return unix_funcs->p_vkBindImageMemory2KHR(device, bindInfoCount, pBindInfos);
  89 }
  90
  91 VkResult WINAPI wine_vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
  92 {
  93     return unix_funcs->p_vkBuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos);
  94 }
  95
  96 void WINAPI wine_vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
  97 {
  98     unix_funcs->p_vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin);
  99 }
 100
 101 void WINAPI wine_vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
 102 {
 103     unix_funcs->p_vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
 104 }
 105
 106 void WINAPI wine_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
 107 {
 108     unix_funcs->p_vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
 109 }
 110
 111 void WINAPI wine_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
 112 {
 113     unix_funcs->p_vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index);
 114 }
 115
 116 void WINAPI wine_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
 117 {
 118     unix_funcs->p_vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
 119 }
 120
 121 void WINAPI wine_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
 122 {
 123     unix_funcs->p_vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
 124 }
 125
 126 void WINAPI wine_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
 127 {
 128     unix_funcs->p_vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
 129 }
 130
 131 void WINAPI wine_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
 132 {
 133     unix_funcs->p_vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
 134 }
 135
 136 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)
 137 {
 138     unix_funcs->p_vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 139 }
 140
 141 void WINAPI wine_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 142 {
 143     unix_funcs->p_vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
 144 }
 145
 146 void WINAPI wine_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 147 {
 148     unix_funcs->p_vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
 149 }
 150
 151 void WINAPI wine_vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
 152 {
 153     unix_funcs->p_vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex);
 154 }
 155
 156 void WINAPI wine_vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
 157 {
 158     unix_funcs->p_vkCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout);
 159 }
 160
 161 void WINAPI wine_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
 162 {
 163     unix_funcs->p_vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
 164 }
 165
 166 void WINAPI wine_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
 167 {
 168     unix_funcs->p_vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
 169 }
 170
 171 void WINAPI wine_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
 172 {
 173     unix_funcs->p_vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
 174 }
 175
 176 void WINAPI wine_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
 177 {
 178     unix_funcs->p_vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
 179 }
 180
 181 void WINAPI wine_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo)
 182 {
 183     unix_funcs->p_vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo);
 184 }
 185
 186 void WINAPI wine_vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
 187 {
 188     unix_funcs->p_vkCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
 189 }
 190
 191 void WINAPI wine_vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t * const*ppMaxPrimitiveCounts)
 192 {
 193     unix_funcs->p_vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
 194 }
 195
 196 void WINAPI wine_vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
 197 {
 198     unix_funcs->p_vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
 199 }
 200
 201 void WINAPI wine_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
 202 {
 203     unix_funcs->p_vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
 204 }
 205
 206 void WINAPI wine_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
 207 {
 208     unix_funcs->p_vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
 209 }
 210
 211 void WINAPI wine_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
 212 {
 213     unix_funcs->p_vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
 214 }
 215
 216 void WINAPI wine_vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
 217 {
 218     unix_funcs->p_vkCmdCopyAccelerationStructureKHR(commandBuffer, pInfo);
 219 }
 220
 221 void WINAPI wine_vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
 222 {
 223     unix_funcs->p_vkCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode);
 224 }
 225
 226 void WINAPI wine_vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
 227 {
 228     unix_funcs->p_vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo);
 229 }
 230
 231 void WINAPI wine_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
 232 {
 233     unix_funcs->p_vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
 234 }
 235
 236 void WINAPI wine_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR *pCopyBufferInfo)
 237 {
 238     unix_funcs->p_vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo);
 239 }
 240
 241 void WINAPI wine_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
 242 {
 243     unix_funcs->p_vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
 244 }
 245
 246 void WINAPI wine_vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo)
 247 {
 248     unix_funcs->p_vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo);
 249 }
 250
 251 void WINAPI wine_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
 252 {
 253     unix_funcs->p_vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 254 }
 255
 256 void WINAPI wine_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR *pCopyImageInfo)
 257 {
 258     unix_funcs->p_vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo);
 259 }
 260
 261 void WINAPI wine_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
 262 {
 263     unix_funcs->p_vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
 264 }
 265
 266 void WINAPI wine_vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo)
 267 {
 268     unix_funcs->p_vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo);
 269 }
 270
 271 void WINAPI wine_vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
 272 {
 273     unix_funcs->p_vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo);
 274 }
 275
 276 void WINAPI wine_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
 277 {
 278     unix_funcs->p_vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
 279 }
 280
 281 void WINAPI wine_vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
 282 {
 283     unix_funcs->p_vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
 284 }
 285
 286 void WINAPI wine_vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
 287 {
 288     unix_funcs->p_vkCmdDebugMarkerEndEXT(commandBuffer);
 289 }
 290
 291 void WINAPI wine_vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
 292 {
 293     unix_funcs->p_vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
 294 }
 295
 296 void WINAPI wine_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 297 {
 298     unix_funcs->p_vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
 299 }
 300
 301 void WINAPI wine_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 302 {
 303     unix_funcs->p_vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
 304 }
 305
 306 void WINAPI wine_vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 307 {
 308     unix_funcs->p_vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
 309 }
 310
 311 void WINAPI wine_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 312 {
 313     unix_funcs->p_vkCmdDispatchIndirect(commandBuffer, buffer, offset);
 314 }
 315
 316 void WINAPI wine_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
 317 {
 318     unix_funcs->p_vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
 319 }
 320
 321 void WINAPI wine_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
 322 {
 323     unix_funcs->p_vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
 324 }
 325
 326 void WINAPI wine_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 327 {
 328     unix_funcs->p_vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
 329 }
 330
 331 void WINAPI wine_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 332 {
 333     unix_funcs->p_vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 334 }
 335
 336 void WINAPI wine_vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 337 {
 338     unix_funcs->p_vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 339 }
 340
 341 void WINAPI wine_vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 342 {
 343     unix_funcs->p_vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 344 }
 345
 346 void WINAPI wine_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 347 {
 348     unix_funcs->p_vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
 349 }
 350
 351 void WINAPI wine_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
 352 {
 353     unix_funcs->p_vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
 354 }
 355
 356 void WINAPI wine_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 357 {
 358     unix_funcs->p_vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 359 }
 360
 361 void WINAPI wine_vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 362 {
 363     unix_funcs->p_vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 364 }
 365
 366 void WINAPI wine_vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 367 {
 368     unix_funcs->p_vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 369 }
 370
 371 void WINAPI wine_vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 372 {
 373     unix_funcs->p_vkCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 374 }
 375
 376 void WINAPI wine_vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 377 {
 378     unix_funcs->p_vkCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride);
 379 }
 380
 381 void WINAPI wine_vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
 382 {
 383     unix_funcs->p_vkCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask);
 384 }
 385
 386 void WINAPI wine_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
 387 {
 388     unix_funcs->p_vkCmdEndConditionalRenderingEXT(commandBuffer);
 389 }
 390
 391 void WINAPI wine_vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
 392 {
 393     unix_funcs->p_vkCmdEndDebugUtilsLabelEXT(commandBuffer);
 394 }
 395
 396 void WINAPI wine_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
 397 {
 398     unix_funcs->p_vkCmdEndQuery(commandBuffer, queryPool, query);
 399 }
 400
 401 void WINAPI wine_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
 402 {
 403     unix_funcs->p_vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
 404 }
 405
 406 void WINAPI wine_vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
 407 {
 408     unix_funcs->p_vkCmdEndRenderPass(commandBuffer);
 409 }
 410
 411 void WINAPI wine_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
 412 {
 413     unix_funcs->p_vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo);
 414 }
 415
 416 void WINAPI wine_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
 417 {
 418     unix_funcs->p_vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo);
 419 }
 420
 421 void WINAPI wine_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
 422 {
 423     unix_funcs->p_vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
 424 }
 425
 426 void WINAPI wine_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
 427 {
 428     unix_funcs->p_vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
 429 }
 430
 431 void WINAPI wine_vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
 432 {
 433     unix_funcs->p_vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
 434 }
 435
 436 void WINAPI wine_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
 437 {
 438     unix_funcs->p_vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
 439 }
 440
 441 void WINAPI wine_vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
 442 {
 443     unix_funcs->p_vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
 444 }
 445
 446 void WINAPI wine_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
 447 {
 448     unix_funcs->p_vkCmdNextSubpass(commandBuffer, contents);
 449 }
 450
 451 void WINAPI wine_vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
 452 {
 453     unix_funcs->p_vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
 454 }
 455
 456 void WINAPI wine_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
 457 {
 458     unix_funcs->p_vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
 459 }
 460
 461 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)
 462 {
 463     unix_funcs->p_vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 464 }
 465
 466 void WINAPI wine_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR *pDependencyInfo)
 467 {
 468     unix_funcs->p_vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo);
 469 }
 470
 471 void WINAPI wine_vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
 472 {
 473     unix_funcs->p_vkCmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo);
 474 }
 475
 476 void WINAPI wine_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
 477 {
 478     unix_funcs->p_vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
 479 }
 480
 481 void WINAPI wine_vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
 482 {
 483     unix_funcs->p_vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
 484 }
 485
 486 void WINAPI wine_vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
 487 {
 488     unix_funcs->p_vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
 489 }
 490
 491 void WINAPI wine_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 492 {
 493     unix_funcs->p_vkCmdResetEvent(commandBuffer, event, stageMask);
 494 }
 495
 496 void WINAPI wine_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask)
 497 {
 498     unix_funcs->p_vkCmdResetEvent2KHR(commandBuffer, event, stageMask);
 499 }
 500
 501 void WINAPI wine_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
 502 {
 503     unix_funcs->p_vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
 504 }
 505
 506 void WINAPI wine_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
 507 {
 508     unix_funcs->p_vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 509 }
 510
 511 void WINAPI wine_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR *pResolveImageInfo)
 512 {
 513     unix_funcs->p_vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo);
 514 }
 515
 516 void WINAPI wine_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
 517 {
 518     unix_funcs->p_vkCmdSetBlendConstants(commandBuffer, blendConstants);
 519 }
 520
 521 void WINAPI wine_vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
 522 {
 523     unix_funcs->p_vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker);
 524 }
 525
 526 void WINAPI wine_vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
 527 {
 528     unix_funcs->p_vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
 529 }
 530
 531 void WINAPI wine_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
 532 {
 533     unix_funcs->p_vkCmdSetCullModeEXT(commandBuffer, cullMode);
 534 }
 535
 536 void WINAPI wine_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
 537 {
 538     unix_funcs->p_vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
 539 }
 540
 541 void WINAPI wine_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
 542 {
 543     unix_funcs->p_vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
 544 }
 545
 546 void WINAPI wine_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
 547 {
 548     unix_funcs->p_vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable);
 549 }
 550
 551 void WINAPI wine_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
 552 {
 553     unix_funcs->p_vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp);
 554 }
 555
 556 void WINAPI wine_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
 557 {
 558     unix_funcs->p_vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable);
 559 }
 560
 561 void WINAPI wine_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
 562 {
 563     unix_funcs->p_vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable);
 564 }
 565
 566 void WINAPI wine_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
 567 {
 568     unix_funcs->p_vkCmdSetDeviceMask(commandBuffer, deviceMask);
 569 }
 570
 571 void WINAPI wine_vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
 572 {
 573     unix_funcs->p_vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask);
 574 }
 575
 576 void WINAPI wine_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
 577 {
 578     unix_funcs->p_vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
 579 }
 580
 581 void WINAPI wine_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 582 {
 583     unix_funcs->p_vkCmdSetEvent(commandBuffer, event, stageMask);
 584 }
 585
 586 void WINAPI wine_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR *pDependencyInfo)
 587 {
 588     unix_funcs->p_vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo);
 589 }
 590
 591 void WINAPI wine_vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
 592 {
 593     unix_funcs->p_vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
 594 }
 595
 596 void WINAPI wine_vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
 597 {
 598     unix_funcs->p_vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps);
 599 }
 600
 601 void WINAPI wine_vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
 602 {
 603     unix_funcs->p_vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps);
 604 }
 605
 606 void WINAPI wine_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
 607 {
 608     unix_funcs->p_vkCmdSetFrontFaceEXT(commandBuffer, frontFace);
 609 }
 610
 611 void WINAPI wine_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
 612 {
 613     unix_funcs->p_vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern);
 614 }
 615
 616 void WINAPI wine_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
 617 {
 618     unix_funcs->p_vkCmdSetLineWidth(commandBuffer, lineWidth);
 619 }
 620
 621 VkResult WINAPI wine_vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
 622 {
 623     return unix_funcs->p_vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo);
 624 }
 625
 626 VkResult WINAPI wine_vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
 627 {
 628     return unix_funcs->p_vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo);
 629 }
 630
 631 VkResult WINAPI wine_vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
 632 {
 633     return unix_funcs->p_vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo);
 634 }
 635
 636 void WINAPI wine_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
 637 {
 638     unix_funcs->p_vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology);
 639 }
 640
 641 void WINAPI wine_vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
 642 {
 643     unix_funcs->p_vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize);
 644 }
 645
 646 void WINAPI wine_vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
 647 {
 648     unix_funcs->p_vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
 649 }
 650
 651 void WINAPI wine_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
 652 {
 653     unix_funcs->p_vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
 654 }
 655
 656 void WINAPI wine_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
 657 {
 658     unix_funcs->p_vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors);
 659 }
 660
 661 void WINAPI wine_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
 662 {
 663     unix_funcs->p_vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
 664 }
 665
 666 void WINAPI wine_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
 667 {
 668     unix_funcs->p_vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
 669 }
 670
 671 void WINAPI wine_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
 672 {
 673     unix_funcs->p_vkCmdSetStencilReference(commandBuffer, faceMask, reference);
 674 }
 675
 676 void WINAPI wine_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
 677 {
 678     unix_funcs->p_vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable);
 679 }
 680
 681 void WINAPI wine_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
 682 {
 683     unix_funcs->p_vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
 684 }
 685
 686 void WINAPI wine_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
 687 {
 688     unix_funcs->p_vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
 689 }
 690
 691 void WINAPI wine_vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
 692 {
 693     unix_funcs->p_vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
 694 }
 695
 696 void WINAPI wine_vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
 697 {
 698     unix_funcs->p_vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
 699 }
 700
 701 void WINAPI wine_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
 702 {
 703     unix_funcs->p_vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports);
 704 }
 705
 706 void WINAPI wine_vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
 707 {
 708     unix_funcs->p_vkCmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
 709 }
 710
 711 void WINAPI wine_vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
 712 {
 713     unix_funcs->p_vkCmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
 714 }
 715
 716 void WINAPI wine_vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
 717 {
 718     unix_funcs->p_vkCmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
 719 }
 720
 721 void WINAPI wine_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
 722 {
 723     unix_funcs->p_vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
 724 }
 725
 726 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)
 727 {
 728     unix_funcs->p_vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 729 }
 730
 731 void WINAPI wine_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfoKHR *pDependencyInfos)
 732 {
 733     unix_funcs->p_vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos);
 734 }
 735
 736 void WINAPI wine_vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
 737 {
 738     unix_funcs->p_vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
 739 }
 740
 741 void WINAPI wine_vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
 742 {
 743     unix_funcs->p_vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
 744 }
 745
 746 void WINAPI wine_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
 747 {
 748     unix_funcs->p_vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker);
 749 }
 750
 751 void WINAPI wine_vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
 752 {
 753     unix_funcs->p_vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
 754 }
 755
 756 void WINAPI wine_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
 757 {
 758     unix_funcs->p_vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
 759 }
 760
 761 void WINAPI wine_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query)
 762 {
 763     unix_funcs->p_vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query);
 764 }
 765
 766 VkResult WINAPI wine_vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
 767 {
 768     return unix_funcs->p_vkCompileDeferredNV(device, pipeline, shader);
 769 }
 770
 771 VkResult WINAPI wine_vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
 772 {
 773     return unix_funcs->p_vkCopyAccelerationStructureKHR(device, deferredOperation, pInfo);
 774 }
 775
 776 VkResult WINAPI wine_vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
 777 {
 778     return unix_funcs->p_vkCopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo);
 779 }
 780
 781 VkResult WINAPI wine_vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
 782 {
 783     return unix_funcs->p_vkCopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo);
 784 }
 785
 786 VkResult WINAPI wine_vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
 787 {
 788     return unix_funcs->p_vkCreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure);
 789 }
 790
 791 VkResult WINAPI wine_vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
 792 {
 793     return unix_funcs->p_vkCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure);
 794 }
 795
 796 VkResult WINAPI wine_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
 797 {
 798     return unix_funcs->p_vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
 799 }
 800
 801 VkResult WINAPI wine_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
 802 {
 803     return unix_funcs->p_vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
 804 }
 805
 806 VkResult WINAPI wine_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
 807 {
 808     return unix_funcs->p_vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
 809 }
 810
 811 VkResult WINAPI wine_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 812 {
 813     return unix_funcs->p_vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 814 }
 815
 816 VkResult WINAPI wine_vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
 817 {
 818     return unix_funcs->p_vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
 819 }
 820
 821 VkResult WINAPI wine_vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
 822 {
 823     return unix_funcs->p_vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
 824 }
 825
 826 VkResult WINAPI wine_vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
 827 {
 828     return unix_funcs->p_vkCreateDeferredOperationKHR(device, pAllocator, pDeferredOperation);
 829 }
 830
 831 VkResult WINAPI wine_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
 832 {
 833     return unix_funcs->p_vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
 834 }
 835
 836 VkResult WINAPI wine_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
 837 {
 838     return unix_funcs->p_vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
 839 }
 840
 841 VkResult WINAPI wine_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
 842 {
 843     return unix_funcs->p_vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
 844 }
 845
 846 VkResult WINAPI wine_vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
 847 {
 848     return unix_funcs->p_vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
 849 }
 850
 851 VkResult WINAPI wine_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
 852 {
 853     return unix_funcs->p_vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
 854 }
 855
 856 VkResult WINAPI wine_vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
 857 {
 858     return unix_funcs->p_vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
 859 }
 860
 861 VkResult WINAPI wine_vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
 862 {
 863     return unix_funcs->p_vkCreateFence(device, pCreateInfo, pAllocator, pFence);
 864 }
 865
 866 VkResult WINAPI wine_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
 867 {
 868     return unix_funcs->p_vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
 869 }
 870
 871 VkResult WINAPI wine_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 872 {
 873     return unix_funcs->p_vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 874 }
 875
 876 VkResult WINAPI wine_vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
 877 {
 878     return unix_funcs->p_vkCreateImage(device, pCreateInfo, pAllocator, pImage);
 879 }
 880
 881 VkResult WINAPI wine_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
 882 {
 883     return unix_funcs->p_vkCreateImageView(device, pCreateInfo, pAllocator, pView);
 884 }
 885
 886 VkResult WINAPI wine_vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
 887 {
 888     return unix_funcs->p_vkCreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
 889 }
 890
 891 VkResult WINAPI wine_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
 892 {
 893     return unix_funcs->p_vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
 894 }
 895
 896 VkResult WINAPI wine_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
 897 {
 898     return unix_funcs->p_vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
 899 }
 900
 901 VkResult WINAPI wine_vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlotEXT *pPrivateDataSlot)
 902 {
 903     return unix_funcs->p_vkCreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot);
 904 }
 905
 906 VkResult WINAPI wine_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
 907 {
 908     return unix_funcs->p_vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
 909 }
 910
 911 VkResult WINAPI wine_vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 912 {
 913     return unix_funcs->p_vkCreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 914 }
 915
 916 VkResult WINAPI wine_vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 917 {
 918     return unix_funcs->p_vkCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 919 }
 920
 921 VkResult WINAPI wine_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
 922 {
 923     return unix_funcs->p_vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
 924 }
 925
 926 VkResult WINAPI wine_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
 927 {
 928     return unix_funcs->p_vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
 929 }
 930
 931 VkResult WINAPI wine_vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
 932 {
 933     return unix_funcs->p_vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
 934 }
 935
 936 VkResult WINAPI wine_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
 937 {
 938     return unix_funcs->p_vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
 939 }
 940
 941 VkResult WINAPI wine_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
 942 {
 943     return unix_funcs->p_vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
 944 }
 945
 946 VkResult WINAPI wine_vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
 947 {
 948     return unix_funcs->p_vkCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion);
 949 }
 950
 951 VkResult WINAPI wine_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
 952 {
 953     return unix_funcs->p_vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
 954 }
 955
 956 VkResult WINAPI wine_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
 957 {
 958     return unix_funcs->p_vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
 959 }
 960
 961 VkResult WINAPI wine_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
 962 {
 963     return unix_funcs->p_vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
 964 }
 965
 966 VkResult WINAPI wine_vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
 967 {
 968     return unix_funcs->p_vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
 969 }
 970
 971 VkResult WINAPI wine_vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
 972 {
 973     return unix_funcs->p_vkCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
 974 }
 975
 976 VkResult WINAPI wine_vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
 977 {
 978     return unix_funcs->p_vkDebugMarkerSetObjectNameEXT(device, pNameInfo);
 979 }
 980
 981 VkResult WINAPI wine_vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
 982 {
 983     return unix_funcs->p_vkDebugMarkerSetObjectTagEXT(device, pTagInfo);
 984 }
 985
 986 void WINAPI wine_vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
 987 {
 988     unix_funcs->p_vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
 989 }
 990
 991 VkResult WINAPI wine_vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation)
 992 {
 993     return unix_funcs->p_vkDeferredOperationJoinKHR(device, operation);
 994 }
 995
 996 void WINAPI wine_vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
 997 {
 998     unix_funcs->p_vkDestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator);
 999 }
1000
1001 void WINAPI wine_vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
1002 {
1003     unix_funcs->p_vkDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator);
1004 }
1005
1006 void WINAPI wine_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
1007 {
1008     unix_funcs->p_vkDestroyBuffer(device, buffer, pAllocator);
1009 }
1010
1011 void WINAPI wine_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
1012 {
1013     unix_funcs->p_vkDestroyBufferView(device, bufferView, pAllocator);
1014 }
1015
1016 void WINAPI wine_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
1017 {
1018     unix_funcs->p_vkDestroyCommandPool(device, commandPool, pAllocator);
1019 }
1020
1021 void WINAPI wine_vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
1022 {
1023     unix_funcs->p_vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator);
1024 }
1025
1026 void WINAPI wine_vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
1027 {
1028     unix_funcs->p_vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
1029 }
1030
1031 void WINAPI wine_vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
1032 {
1033     unix_funcs->p_vkDestroyDeferredOperationKHR(device, operation, pAllocator);
1034 }
1035
1036 void WINAPI wine_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
1037 {
1038     unix_funcs->p_vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
1039 }
1040
1041 void WINAPI wine_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
1042 {
1043     unix_funcs->p_vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
1044 }
1045
1046 void WINAPI wine_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
1047 {
1048     unix_funcs->p_vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
1049 }
1050
1051 void WINAPI wine_vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
1052 {
1053     unix_funcs->p_vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
1054 }
1055
1056 void WINAPI wine_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator)
1057 {
1058     unix_funcs->p_vkDestroyDevice(device, pAllocator);
1059 }
1060
1061 void WINAPI wine_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
1062 {
1063     unix_funcs->p_vkDestroyEvent(device, event, pAllocator);
1064 }
1065
1066 void WINAPI wine_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
1067 {
1068     unix_funcs->p_vkDestroyFence(device, fence, pAllocator);
1069 }
1070
1071 void WINAPI wine_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
1072 {
1073     unix_funcs->p_vkDestroyFramebuffer(device, framebuffer, pAllocator);
1074 }
1075
1076 void WINAPI wine_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
1077 {
1078     unix_funcs->p_vkDestroyImage(device, image, pAllocator);
1079 }
1080
1081 void WINAPI wine_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
1082 {
1083     unix_funcs->p_vkDestroyImageView(device, imageView, pAllocator);
1084 }
1085
1086 void WINAPI wine_vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
1087 {
1088     unix_funcs->p_vkDestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator);
1089 }
1090
1091 void WINAPI wine_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
1092 {
1093     unix_funcs->p_vkDestroyInstance(instance, pAllocator);
1094 }
1095
1096 void WINAPI wine_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
1097 {
1098     unix_funcs->p_vkDestroyPipeline(device, pipeline, pAllocator);
1099 }
1100
1101 void WINAPI wine_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
1102 {
1103     unix_funcs->p_vkDestroyPipelineCache(device, pipelineCache, pAllocator);
1104 }
1105
1106 void WINAPI wine_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
1107 {
1108     unix_funcs->p_vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
1109 }
1110
1111 void WINAPI wine_vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks *pAllocator)
1112 {
1113     unix_funcs->p_vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator);
1114 }
1115
1116 void WINAPI wine_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
1117 {
1118     unix_funcs->p_vkDestroyQueryPool(device, queryPool, pAllocator);
1119 }
1120
1121 void WINAPI wine_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
1122 {
1123     unix_funcs->p_vkDestroyRenderPass(device, renderPass, pAllocator);
1124 }
1125
1126 void WINAPI wine_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
1127 {
1128     unix_funcs->p_vkDestroySampler(device, sampler, pAllocator);
1129 }
1130
1131 void WINAPI wine_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
1132 {
1133     unix_funcs->p_vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
1134 }
1135
1136 void WINAPI wine_vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
1137 {
1138     unix_funcs->p_vkDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator);
1139 }
1140
1141 void WINAPI wine_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
1142 {
1143     unix_funcs->p_vkDestroySemaphore(device, semaphore, pAllocator);
1144 }
1145
1146 void WINAPI wine_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
1147 {
1148     unix_funcs->p_vkDestroyShaderModule(device, shaderModule, pAllocator);
1149 }
1150
1151 void WINAPI wine_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
1152 {
1153     unix_funcs->p_vkDestroySurfaceKHR(instance, surface, pAllocator);
1154 }
1155
1156 void WINAPI wine_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
1157 {
1158     unix_funcs->p_vkDestroySwapchainKHR(device, swapchain, pAllocator);
1159 }
1160
1161 void WINAPI wine_vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
1162 {
1163     unix_funcs->p_vkDestroyValidationCacheEXT(device, validationCache, pAllocator);
1164 }
1165
1166 VkResult WINAPI wine_vkDeviceWaitIdle(VkDevice device)
1167 {
1168     return unix_funcs->p_vkDeviceWaitIdle(device);
1169 }
1170
1171 VkResult WINAPI wine_vkEndCommandBuffer(VkCommandBuffer commandBuffer)
1172 {
1173     return unix_funcs->p_vkEndCommandBuffer(commandBuffer);
1174 }
1175
1176 VkResult WINAPI wine_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
1177 {
1178     return unix_funcs->p_vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
1179 }
1180
1181 VkResult WINAPI wine_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
1182 {
1183     return unix_funcs->p_vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
1184 }
1185
1186 VkResult WINAPI wine_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
1187 {
1188     return unix_funcs->p_vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
1189 }
1190
1191 VkResult WINAPI wine_vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
1192 {
1193     return unix_funcs->p_vkEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
1194 }
1195
1196 VkResult WINAPI wine_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
1197 {
1198     return unix_funcs->p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
1199 }
1200
1201 VkResult WINAPI wine_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
1202 {
1203     return unix_funcs->p_vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
1204 }
1205
1206 VkResult WINAPI wine_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
1207 {
1208     return unix_funcs->p_vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
1209 }
1210
1211 void WINAPI wine_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
1212 {
1213     unix_funcs->p_vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
1214 }
1215
1216 VkResult WINAPI wine_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
1217 {
1218     return unix_funcs->p_vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
1219 }
1220
1221 void WINAPI wine_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
1222 {
1223     unix_funcs->p_vkFreeMemory(device, memory, pAllocator);
1224 }
1225
1226 void WINAPI wine_vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
1227 {
1228     unix_funcs->p_vkGetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
1229 }
1230
1231 VkDeviceAddress WINAPI wine_vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
1232 {
1233     return unix_funcs->p_vkGetAccelerationStructureDeviceAddressKHR(device, pInfo);
1234 }
1235
1236 VkResult WINAPI wine_vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
1237 {
1238     return unix_funcs->p_vkGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData);
1239 }
1240
1241 void WINAPI wine_vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
1242 {
1243     unix_funcs->p_vkGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
1244 }
1245
1246 VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
1247 {
1248     return unix_funcs->p_vkGetBufferDeviceAddress(device, pInfo);
1249 }
1250
1251 VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
1252 {
1253     return unix_funcs->p_vkGetBufferDeviceAddressEXT(device, pInfo);
1254 }
1255
1256 VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
1257 {
1258     return unix_funcs->p_vkGetBufferDeviceAddressKHR(device, pInfo);
1259 }
1260
1261 void WINAPI wine_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
1262 {
1263     unix_funcs->p_vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
1264 }
1265
1266 void WINAPI wine_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
1267 {
1268     unix_funcs->p_vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
1269 }
1270
1271 void WINAPI wine_vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
1272 {
1273     unix_funcs->p_vkGetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
1274 }
1275
1276 uint64_t WINAPI wine_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
1277 {
1278     return unix_funcs->p_vkGetBufferOpaqueCaptureAddress(device, pInfo);
1279 }
1280
1281 uint64_t WINAPI wine_vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
1282 {
1283     return unix_funcs->p_vkGetBufferOpaqueCaptureAddressKHR(device, pInfo);
1284 }
1285
1286 VkResult WINAPI wine_vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
1287 {
1288     return unix_funcs->p_vkGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
1289 }
1290
1291 uint32_t WINAPI wine_vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
1292 {
1293     return unix_funcs->p_vkGetDeferredOperationMaxConcurrencyKHR(device, operation);
1294 }
1295
1296 VkResult WINAPI wine_vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
1297 {
1298     return unix_funcs->p_vkGetDeferredOperationResultKHR(device, operation);
1299 }
1300
1301 void WINAPI wine_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
1302 {
1303     unix_funcs->p_vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
1304 }
1305
1306 void WINAPI wine_vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
1307 {
1308     unix_funcs->p_vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport);
1309 }
1310
1311 void WINAPI wine_vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
1312 {
1313     unix_funcs->p_vkGetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility);
1314 }
1315
1316 void WINAPI wine_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
1317 {
1318     unix_funcs->p_vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
1319 }
1320
1321 void WINAPI wine_vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
1322 {
1323     unix_funcs->p_vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
1324 }
1325
1326 VkResult WINAPI wine_vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
1327 {
1328     return unix_funcs->p_vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
1329 }
1330
1331 VkResult WINAPI wine_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
1332 {
1333     return unix_funcs->p_vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
1334 }
1335
1336 void WINAPI wine_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
1337 {
1338     unix_funcs->p_vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
1339 }
1340
1341 uint64_t WINAPI wine_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
1342 {
1343     return unix_funcs->p_vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo);
1344 }
1345
1346 uint64_t WINAPI wine_vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
1347 {
1348     return unix_funcs->p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo);
1349 }
1350
1351 void WINAPI wine_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
1352 {
1353     unix_funcs->p_vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
1354 }
1355
1356 void WINAPI wine_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
1357 {
1358     unix_funcs->p_vkGetDeviceQueue2(device, pQueueInfo, pQueue);
1359 }
1360
1361 VkResult WINAPI wine_vkGetEventStatus(VkDevice device, VkEvent event)
1362 {
1363     return unix_funcs->p_vkGetEventStatus(device, event);
1364 }
1365
1366 VkResult WINAPI wine_vkGetFenceStatus(VkDevice device, VkFence fence)
1367 {
1368     return unix_funcs->p_vkGetFenceStatus(device, fence);
1369 }
1370
1371 void WINAPI wine_vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
1372 {
1373     unix_funcs->p_vkGetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
1374 }
1375
1376 void WINAPI wine_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
1377 {
1378     unix_funcs->p_vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
1379 }
1380
1381 void WINAPI wine_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
1382 {
1383     unix_funcs->p_vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
1384 }
1385
1386 void WINAPI wine_vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
1387 {
1388     unix_funcs->p_vkGetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
1389 }
1390
1391 void WINAPI wine_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
1392 {
1393     unix_funcs->p_vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
1394 }
1395
1396 void WINAPI wine_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
1397 {
1398     unix_funcs->p_vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
1399 }
1400
1401 void WINAPI wine_vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
1402 {
1403     unix_funcs->p_vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
1404 }
1405
1406 void WINAPI wine_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
1407 {
1408     unix_funcs->p_vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
1409 }
1410
1411 VkResult WINAPI wine_vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
1412 {
1413     return unix_funcs->p_vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
1414 }
1415
1416 VkResult WINAPI wine_vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
1417 {
1418     return unix_funcs->p_vkGetPerformanceParameterINTEL(device, parameter, pValue);
1419 }
1420
1421 VkResult WINAPI wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
1422 {
1423     return unix_funcs->p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains);
1424 }
1425
1426 VkResult WINAPI wine_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
1427 {
1428     return unix_funcs->p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties);
1429 }
1430
1431 void WINAPI wine_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
1432 {
1433     unix_funcs->p_vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
1434 }
1435
1436 void WINAPI wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
1437 {
1438     unix_funcs->p_vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
1439 }
1440
1441 void WINAPI wine_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
1442 {
1443     unix_funcs->p_vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
1444 }
1445
1446 void WINAPI wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
1447 {
1448     unix_funcs->p_vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
1449 }
1450
1451 void WINAPI wine_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
1452 {
1453     unix_funcs->p_vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
1454 }
1455
1456 void WINAPI wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
1457 {
1458     unix_funcs->p_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
1459 }
1460
1461 void WINAPI wine_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
1462 {
1463     unix_funcs->p_vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
1464 }
1465
1466 void WINAPI wine_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
1467 {
1468     unix_funcs->p_vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
1469 }
1470
1471 void WINAPI wine_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
1472 {
1473     unix_funcs->p_vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
1474 }
1475
1476 void WINAPI wine_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
1477 {
1478     unix_funcs->p_vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
1479 }
1480
1481 void WINAPI wine_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
1482 {
1483     unix_funcs->p_vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
1484 }
1485
1486 void WINAPI wine_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
1487 {
1488     unix_funcs->p_vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties);
1489 }
1490
1491 VkResult WINAPI wine_vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
1492 {
1493     return unix_funcs->p_vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
1494 }
1495
1496 VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
1497 {
1498     return unix_funcs->p_vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
1499 }
1500
1501 VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
1502 {
1503     return unix_funcs->p_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
1504 }
1505
1506 VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
1507 {
1508     return unix_funcs->p_vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties);
1509 }
1510
1511 void WINAPI wine_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
1512 {
1513     unix_funcs->p_vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
1514 }
1515
1516 void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
1517 {
1518     unix_funcs->p_vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
1519 }
1520
1521 void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
1522 {
1523     unix_funcs->p_vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties);
1524 }
1525
1526 void WINAPI wine_vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
1527 {
1528     unix_funcs->p_vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties);
1529 }
1530
1531 VkResult WINAPI wine_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
1532 {
1533     return unix_funcs->p_vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
1534 }
1535
1536 void WINAPI wine_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
1537 {
1538     unix_funcs->p_vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
1539 }
1540
1541 void WINAPI wine_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
1542 {
1543     unix_funcs->p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
1544 }
1545
1546 void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
1547 {
1548     unix_funcs->p_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
1549 }
1550
1551 void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
1552 {
1553     unix_funcs->p_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
1554 }
1555
1556 void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
1557 {
1558     unix_funcs->p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
1559 }
1560
1561 void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
1562 {
1563     unix_funcs->p_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
1564 }
1565
1566 void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
1567 {
1568     unix_funcs->p_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
1569 }
1570
1571 void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
1572 {
1573     unix_funcs->p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
1574 }
1575
1576 VkResult WINAPI wine_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
1577 {
1578     return unix_funcs->p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations);
1579 }
1580
1581 VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
1582 {
1583     return unix_funcs->p_vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
1584 }
1585
1586 VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
1587 {
1588     return unix_funcs->p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
1589 }
1590
1591 VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
1592 {
1593     return unix_funcs->p_vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
1594 }
1595
1596 VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
1597 {
1598     return unix_funcs->p_vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
1599 }
1600
1601 VkResult WINAPI wine_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
1602 {
1603     return unix_funcs->p_vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
1604 }
1605
1606 VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
1607 {
1608     return unix_funcs->p_vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
1609 }
1610
1611 VkResult WINAPI wine_vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolPropertiesEXT *pToolProperties)
1612 {
1613     return unix_funcs->p_vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties);
1614 }
1615
1616 VkBool32 WINAPI wine_vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
1617 {
1618     return unix_funcs->p_vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
1619 }
1620
1621 VkResult WINAPI wine_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
1622 {
1623     return unix_funcs->p_vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
1624 }
1625
1626 VkResult WINAPI wine_vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
1627 {
1628     return unix_funcs->p_vkGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
1629 }
1630
1631 VkResult WINAPI wine_vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
1632 {
1633     return unix_funcs->p_vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties);
1634 }
1635
1636 VkResult WINAPI wine_vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
1637 {
1638     return unix_funcs->p_vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics);
1639 }
1640
1641 void WINAPI wine_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t *pData)
1642 {
1643     unix_funcs->p_vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData);
1644 }
1645
1646 VkResult WINAPI wine_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
1647 {
1648     return unix_funcs->p_vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
1649 }
1650
1651 void WINAPI wine_vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
1652 {
1653     unix_funcs->p_vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData);
1654 }
1655
1656 void WINAPI wine_vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
1657 {
1658     unix_funcs->p_vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData);
1659 }
1660
1661 VkResult WINAPI wine_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
1662 {
1663     return unix_funcs->p_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
1664 }
1665
1666 VkResult WINAPI wine_vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
1667 {
1668     return unix_funcs->p_vkGetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
1669 }
1670
1671 VkResult WINAPI wine_vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
1672 {
1673     return unix_funcs->p_vkGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData);
1674 }
1675
1676 VkDeviceSize WINAPI wine_vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
1677 {
1678     return unix_funcs->p_vkGetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader);
1679 }
1680
1681 void WINAPI wine_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
1682 {
1683     unix_funcs->p_vkGetRenderAreaGranularity(device, renderPass, pGranularity);
1684 }
1685
1686 VkResult WINAPI wine_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
1687 {
1688     return unix_funcs->p_vkGetSemaphoreCounterValue(device, semaphore, pValue);
1689 }
1690
1691 VkResult WINAPI wine_vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
1692 {
1693     return unix_funcs->p_vkGetSemaphoreCounterValueKHR(device, semaphore, pValue);
1694 }
1695
1696 VkResult WINAPI wine_vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
1697 {
1698     return unix_funcs->p_vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
1699 }
1700
1701 VkResult WINAPI wine_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
1702 {
1703     return unix_funcs->p_vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
1704 }
1705
1706 VkResult WINAPI wine_vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
1707 {
1708     return unix_funcs->p_vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
1709 }
1710
1711 VkResult WINAPI wine_vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
1712 {
1713     return unix_funcs->p_vkInitializePerformanceApiINTEL(device, pInitializeInfo);
1714 }
1715
1716 VkResult WINAPI wine_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
1717 {
1718     return unix_funcs->p_vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
1719 }
1720
1721 VkResult WINAPI wine_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
1722 {
1723     return unix_funcs->p_vkMapMemory(device, memory, offset, size, flags, ppData);
1724 }
1725
1726 VkResult WINAPI wine_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
1727 {
1728     return unix_funcs->p_vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
1729 }
1730
1731 VkResult WINAPI wine_vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
1732 {
1733     return unix_funcs->p_vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
1734 }
1735
1736 void WINAPI wine_vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
1737 {
1738     unix_funcs->p_vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo);
1739 }
1740
1741 VkResult WINAPI wine_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
1742 {
1743     return unix_funcs->p_vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
1744 }
1745
1746 void WINAPI wine_vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
1747 {
1748     unix_funcs->p_vkQueueEndDebugUtilsLabelEXT(queue);
1749 }
1750
1751 void WINAPI wine_vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
1752 {
1753     unix_funcs->p_vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo);
1754 }
1755
1756 VkResult WINAPI wine_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
1757 {
1758     return unix_funcs->p_vkQueuePresentKHR(queue, pPresentInfo);
1759 }
1760
1761 VkResult WINAPI wine_vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
1762 {
1763     return unix_funcs->p_vkQueueSetPerformanceConfigurationINTEL(queue, configuration);
1764 }
1765
1766 VkResult WINAPI wine_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
1767 {
1768     return unix_funcs->p_vkQueueSubmit(queue, submitCount, pSubmits, fence);
1769 }
1770
1771 VkResult WINAPI wine_vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR *pSubmits, VkFence fence)
1772 {
1773     return unix_funcs->p_vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence);
1774 }
1775
1776 VkResult WINAPI wine_vkQueueWaitIdle(VkQueue queue)
1777 {
1778     return unix_funcs->p_vkQueueWaitIdle(queue);
1779 }
1780
1781 VkResult WINAPI wine_vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
1782 {
1783     return unix_funcs->p_vkReleasePerformanceConfigurationINTEL(device, configuration);
1784 }
1785
1786 void WINAPI wine_vkReleaseProfilingLockKHR(VkDevice device)
1787 {
1788     unix_funcs->p_vkReleaseProfilingLockKHR(device);
1789 }
1790
1791 VkResult WINAPI wine_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
1792 {
1793     return unix_funcs->p_vkResetCommandBuffer(commandBuffer, flags);
1794 }
1795
1796 VkResult WINAPI wine_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
1797 {
1798     return unix_funcs->p_vkResetCommandPool(device, commandPool, flags);
1799 }
1800
1801 VkResult WINAPI wine_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
1802 {
1803     return unix_funcs->p_vkResetDescriptorPool(device, descriptorPool, flags);
1804 }
1805
1806 VkResult WINAPI wine_vkResetEvent(VkDevice device, VkEvent event)
1807 {
1808     return unix_funcs->p_vkResetEvent(device, event);
1809 }
1810
1811 VkResult WINAPI wine_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
1812 {
1813     return unix_funcs->p_vkResetFences(device, fenceCount, pFences);
1814 }
1815
1816 void WINAPI wine_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
1817 {
1818     unix_funcs->p_vkResetQueryPool(device, queryPool, firstQuery, queryCount);
1819 }
1820
1821 void WINAPI wine_vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
1822 {
1823     unix_funcs->p_vkResetQueryPoolEXT(device, queryPool, firstQuery, queryCount);
1824 }
1825
1826 VkResult WINAPI wine_vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
1827 {
1828     return unix_funcs->p_vkSetDebugUtilsObjectNameEXT(device, pNameInfo);
1829 }
1830
1831 VkResult WINAPI wine_vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
1832 {
1833     return unix_funcs->p_vkSetDebugUtilsObjectTagEXT(device, pTagInfo);
1834 }
1835
1836 VkResult WINAPI wine_vkSetEvent(VkDevice device, VkEvent event)
1837 {
1838     return unix_funcs->p_vkSetEvent(device, event);
1839 }
1840
1841 VkResult WINAPI wine_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data)
1842 {
1843     return unix_funcs->p_vkSetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data);
1844 }
1845
1846 VkResult WINAPI wine_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
1847 {
1848     return unix_funcs->p_vkSignalSemaphore(device, pSignalInfo);
1849 }
1850
1851 VkResult WINAPI wine_vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
1852 {
1853     return unix_funcs->p_vkSignalSemaphoreKHR(device, pSignalInfo);
1854 }
1855
1856 void WINAPI wine_vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
1857 {
1858     unix_funcs->p_vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData);
1859 }
1860
1861 void WINAPI wine_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
1862 {
1863     unix_funcs->p_vkTrimCommandPool(device, commandPool, flags);
1864 }
1865
1866 void WINAPI wine_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
1867 {
1868     unix_funcs->p_vkTrimCommandPoolKHR(device, commandPool, flags);
1869 }
1870
1871 void WINAPI wine_vkUninitializePerformanceApiINTEL(VkDevice device)
1872 {
1873     unix_funcs->p_vkUninitializePerformanceApiINTEL(device);
1874 }
1875
1876 void WINAPI wine_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
1877 {
1878     unix_funcs->p_vkUnmapMemory(device, memory);
1879 }
1880
1881 void WINAPI wine_vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
1882 {
1883     unix_funcs->p_vkUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
1884 }
1885
1886 void WINAPI wine_vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
1887 {
1888     unix_funcs->p_vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
1889 }
1890
1891 void WINAPI wine_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
1892 {
1893     unix_funcs->p_vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
1894 }
1895
1896 VkResult WINAPI wine_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
1897 {
1898     return unix_funcs->p_vkWaitForFences(device, fenceCount, pFences, waitAll, timeout);
1899 }
1900
1901 VkResult WINAPI wine_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
1902 {
1903     return unix_funcs->p_vkWaitSemaphores(device, pWaitInfo, timeout);
1904 }
1905
1906 VkResult WINAPI wine_vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
1907 {
1908     return unix_funcs->p_vkWaitSemaphoresKHR(device, pWaitInfo, timeout);
1909 }
1910
1911 VkResult WINAPI wine_vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
1912 {
1913     return unix_funcs->p_vkWriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
1914 }
1915
1916 static const struct vulkan_func vk_device_dispatch_table[] =
1917 {
1918     {"vkAcquireNextImage2KHR", &wine_vkAcquireNextImage2KHR},
1919     {"vkAcquireNextImageKHR", &wine_vkAcquireNextImageKHR},
1920     {"vkAcquirePerformanceConfigurationINTEL", &wine_vkAcquirePerformanceConfigurationINTEL},
1921     {"vkAcquireProfilingLockKHR", &wine_vkAcquireProfilingLockKHR},
1922     {"vkAllocateCommandBuffers", &wine_vkAllocateCommandBuffers},
1923     {"vkAllocateDescriptorSets", &wine_vkAllocateDescriptorSets},
1924     {"vkAllocateMemory", &wine_vkAllocateMemory},
1925     {"vkBeginCommandBuffer", &wine_vkBeginCommandBuffer},
1926     {"vkBindAccelerationStructureMemoryNV", &wine_vkBindAccelerationStructureMemoryNV},
1927     {"vkBindBufferMemory", &wine_vkBindBufferMemory},
1928     {"vkBindBufferMemory2", &wine_vkBindBufferMemory2},
1929     {"vkBindBufferMemory2KHR", &wine_vkBindBufferMemory2KHR},
1930     {"vkBindImageMemory", &wine_vkBindImageMemory},
1931     {"vkBindImageMemory2", &wine_vkBindImageMemory2},
1932     {"vkBindImageMemory2KHR", &wine_vkBindImageMemory2KHR},
1933     {"vkBuildAccelerationStructuresKHR", &wine_vkBuildAccelerationStructuresKHR},
1934     {"vkCmdBeginConditionalRenderingEXT", &wine_vkCmdBeginConditionalRenderingEXT},
1935     {"vkCmdBeginDebugUtilsLabelEXT", &wine_vkCmdBeginDebugUtilsLabelEXT},
1936     {"vkCmdBeginQuery", &wine_vkCmdBeginQuery},
1937     {"vkCmdBeginQueryIndexedEXT", &wine_vkCmdBeginQueryIndexedEXT},
1938     {"vkCmdBeginRenderPass", &wine_vkCmdBeginRenderPass},
1939     {"vkCmdBeginRenderPass2", &wine_vkCmdBeginRenderPass2},
1940     {"vkCmdBeginRenderPass2KHR", &wine_vkCmdBeginRenderPass2KHR},
1941     {"vkCmdBeginTransformFeedbackEXT", &wine_vkCmdBeginTransformFeedbackEXT},
1942     {"vkCmdBindDescriptorSets", &wine_vkCmdBindDescriptorSets},
1943     {"vkCmdBindIndexBuffer", &wine_vkCmdBindIndexBuffer},
1944     {"vkCmdBindPipeline", &wine_vkCmdBindPipeline},
1945     {"vkCmdBindPipelineShaderGroupNV", &wine_vkCmdBindPipelineShaderGroupNV},
1946     {"vkCmdBindShadingRateImageNV", &wine_vkCmdBindShadingRateImageNV},
1947     {"vkCmdBindTransformFeedbackBuffersEXT", &wine_vkCmdBindTransformFeedbackBuffersEXT},
1948     {"vkCmdBindVertexBuffers", &wine_vkCmdBindVertexBuffers},
1949     {"vkCmdBindVertexBuffers2EXT", &wine_vkCmdBindVertexBuffers2EXT},
1950     {"vkCmdBlitImage", &wine_vkCmdBlitImage},
1951     {"vkCmdBlitImage2KHR", &wine_vkCmdBlitImage2KHR},
1952     {"vkCmdBuildAccelerationStructureNV", &wine_vkCmdBuildAccelerationStructureNV},
1953     {"vkCmdBuildAccelerationStructuresIndirectKHR", &wine_vkCmdBuildAccelerationStructuresIndirectKHR},
1954     {"vkCmdBuildAccelerationStructuresKHR", &wine_vkCmdBuildAccelerationStructuresKHR},
1955     {"vkCmdClearAttachments", &wine_vkCmdClearAttachments},
1956     {"vkCmdClearColorImage", &wine_vkCmdClearColorImage},
1957     {"vkCmdClearDepthStencilImage", &wine_vkCmdClearDepthStencilImage},
1958     {"vkCmdCopyAccelerationStructureKHR", &wine_vkCmdCopyAccelerationStructureKHR},
1959     {"vkCmdCopyAccelerationStructureNV", &wine_vkCmdCopyAccelerationStructureNV},
1960     {"vkCmdCopyAccelerationStructureToMemoryKHR", &wine_vkCmdCopyAccelerationStructureToMemoryKHR},
1961     {"vkCmdCopyBuffer", &wine_vkCmdCopyBuffer},
1962     {"vkCmdCopyBuffer2KHR", &wine_vkCmdCopyBuffer2KHR},
1963     {"vkCmdCopyBufferToImage", &wine_vkCmdCopyBufferToImage},
1964     {"vkCmdCopyBufferToImage2KHR", &wine_vkCmdCopyBufferToImage2KHR},
1965     {"vkCmdCopyImage", &wine_vkCmdCopyImage},
1966     {"vkCmdCopyImage2KHR", &wine_vkCmdCopyImage2KHR},
1967     {"vkCmdCopyImageToBuffer", &wine_vkCmdCopyImageToBuffer},
1968     {"vkCmdCopyImageToBuffer2KHR", &wine_vkCmdCopyImageToBuffer2KHR},
1969     {"vkCmdCopyMemoryToAccelerationStructureKHR", &wine_vkCmdCopyMemoryToAccelerationStructureKHR},
1970     {"vkCmdCopyQueryPoolResults", &wine_vkCmdCopyQueryPoolResults},
1971     {"vkCmdDebugMarkerBeginEXT", &wine_vkCmdDebugMarkerBeginEXT},
1972     {"vkCmdDebugMarkerEndEXT", &wine_vkCmdDebugMarkerEndEXT},
1973     {"vkCmdDebugMarkerInsertEXT", &wine_vkCmdDebugMarkerInsertEXT},
1974     {"vkCmdDispatch", &wine_vkCmdDispatch},
1975     {"vkCmdDispatchBase", &wine_vkCmdDispatchBase},
1976     {"vkCmdDispatchBaseKHR", &wine_vkCmdDispatchBaseKHR},
1977     {"vkCmdDispatchIndirect", &wine_vkCmdDispatchIndirect},
1978     {"vkCmdDraw", &wine_vkCmdDraw},
1979     {"vkCmdDrawIndexed", &wine_vkCmdDrawIndexed},
1980     {"vkCmdDrawIndexedIndirect", &wine_vkCmdDrawIndexedIndirect},
1981     {"vkCmdDrawIndexedIndirectCount", &wine_vkCmdDrawIndexedIndirectCount},
1982     {"vkCmdDrawIndexedIndirectCountAMD", &wine_vkCmdDrawIndexedIndirectCountAMD},
1983     {"vkCmdDrawIndexedIndirectCountKHR", &wine_vkCmdDrawIndexedIndirectCountKHR},
1984     {"vkCmdDrawIndirect", &wine_vkCmdDrawIndirect},
1985     {"vkCmdDrawIndirectByteCountEXT", &wine_vkCmdDrawIndirectByteCountEXT},
1986     {"vkCmdDrawIndirectCount", &wine_vkCmdDrawIndirectCount},
1987     {"vkCmdDrawIndirectCountAMD", &wine_vkCmdDrawIndirectCountAMD},
1988     {"vkCmdDrawIndirectCountKHR", &wine_vkCmdDrawIndirectCountKHR},
1989     {"vkCmdDrawMeshTasksIndirectCountNV", &wine_vkCmdDrawMeshTasksIndirectCountNV},
1990     {"vkCmdDrawMeshTasksIndirectNV", &wine_vkCmdDrawMeshTasksIndirectNV},
1991     {"vkCmdDrawMeshTasksNV", &wine_vkCmdDrawMeshTasksNV},
1992     {"vkCmdEndConditionalRenderingEXT", &wine_vkCmdEndConditionalRenderingEXT},
1993     {"vkCmdEndDebugUtilsLabelEXT", &wine_vkCmdEndDebugUtilsLabelEXT},
1994     {"vkCmdEndQuery", &wine_vkCmdEndQuery},
1995     {"vkCmdEndQueryIndexedEXT", &wine_vkCmdEndQueryIndexedEXT},
1996     {"vkCmdEndRenderPass", &wine_vkCmdEndRenderPass},
1997     {"vkCmdEndRenderPass2", &wine_vkCmdEndRenderPass2},
1998     {"vkCmdEndRenderPass2KHR", &wine_vkCmdEndRenderPass2KHR},
1999     {"vkCmdEndTransformFeedbackEXT", &wine_vkCmdEndTransformFeedbackEXT},
2000     {"vkCmdExecuteCommands", &wine_vkCmdExecuteCommands},
2001     {"vkCmdExecuteGeneratedCommandsNV", &wine_vkCmdExecuteGeneratedCommandsNV},
2002     {"vkCmdFillBuffer", &wine_vkCmdFillBuffer},
2003     {"vkCmdInsertDebugUtilsLabelEXT", &wine_vkCmdInsertDebugUtilsLabelEXT},
2004     {"vkCmdNextSubpass", &wine_vkCmdNextSubpass},
2005     {"vkCmdNextSubpass2", &wine_vkCmdNextSubpass2},
2006     {"vkCmdNextSubpass2KHR", &wine_vkCmdNextSubpass2KHR},
2007     {"vkCmdPipelineBarrier", &wine_vkCmdPipelineBarrier},
2008     {"vkCmdPipelineBarrier2KHR", &wine_vkCmdPipelineBarrier2KHR},
2009     {"vkCmdPreprocessGeneratedCommandsNV", &wine_vkCmdPreprocessGeneratedCommandsNV},
2010     {"vkCmdPushConstants", &wine_vkCmdPushConstants},
2011     {"vkCmdPushDescriptorSetKHR", &wine_vkCmdPushDescriptorSetKHR},
2012     {"vkCmdPushDescriptorSetWithTemplateKHR", &wine_vkCmdPushDescriptorSetWithTemplateKHR},
2013     {"vkCmdResetEvent", &wine_vkCmdResetEvent},
2014     {"vkCmdResetEvent2KHR", &wine_vkCmdResetEvent2KHR},
2015     {"vkCmdResetQueryPool", &wine_vkCmdResetQueryPool},
2016     {"vkCmdResolveImage", &wine_vkCmdResolveImage},
2017     {"vkCmdResolveImage2KHR", &wine_vkCmdResolveImage2KHR},
2018     {"vkCmdSetBlendConstants", &wine_vkCmdSetBlendConstants},
2019     {"vkCmdSetCheckpointNV", &wine_vkCmdSetCheckpointNV},
2020     {"vkCmdSetCoarseSampleOrderNV", &wine_vkCmdSetCoarseSampleOrderNV},
2021     {"vkCmdSetCullModeEXT", &wine_vkCmdSetCullModeEXT},
2022     {"vkCmdSetDepthBias", &wine_vkCmdSetDepthBias},
2023     {"vkCmdSetDepthBounds", &wine_vkCmdSetDepthBounds},
2024     {"vkCmdSetDepthBoundsTestEnableEXT", &wine_vkCmdSetDepthBoundsTestEnableEXT},
2025     {"vkCmdSetDepthCompareOpEXT", &wine_vkCmdSetDepthCompareOpEXT},
2026     {"vkCmdSetDepthTestEnableEXT", &wine_vkCmdSetDepthTestEnableEXT},
2027     {"vkCmdSetDepthWriteEnableEXT", &wine_vkCmdSetDepthWriteEnableEXT},
2028     {"vkCmdSetDeviceMask", &wine_vkCmdSetDeviceMask},
2029     {"vkCmdSetDeviceMaskKHR", &wine_vkCmdSetDeviceMaskKHR},
2030     {"vkCmdSetDiscardRectangleEXT", &wine_vkCmdSetDiscardRectangleEXT},
2031     {"vkCmdSetEvent", &wine_vkCmdSetEvent},
2032     {"vkCmdSetEvent2KHR", &wine_vkCmdSetEvent2KHR},
2033     {"vkCmdSetExclusiveScissorNV", &wine_vkCmdSetExclusiveScissorNV},
2034     {"vkCmdSetFragmentShadingRateEnumNV", &wine_vkCmdSetFragmentShadingRateEnumNV},
2035     {"vkCmdSetFragmentShadingRateKHR", &wine_vkCmdSetFragmentShadingRateKHR},
2036     {"vkCmdSetFrontFaceEXT", &wine_vkCmdSetFrontFaceEXT},
2037     {"vkCmdSetLineStippleEXT", &wine_vkCmdSetLineStippleEXT},
2038     {"vkCmdSetLineWidth", &wine_vkCmdSetLineWidth},
2039     {"vkCmdSetPerformanceMarkerINTEL", &wine_vkCmdSetPerformanceMarkerINTEL},
2040     {"vkCmdSetPerformanceOverrideINTEL", &wine_vkCmdSetPerformanceOverrideINTEL},
2041     {"vkCmdSetPerformanceStreamMarkerINTEL", &wine_vkCmdSetPerformanceStreamMarkerINTEL},
2042     {"vkCmdSetPrimitiveTopologyEXT", &wine_vkCmdSetPrimitiveTopologyEXT},
2043     {"vkCmdSetRayTracingPipelineStackSizeKHR", &wine_vkCmdSetRayTracingPipelineStackSizeKHR},
2044     {"vkCmdSetSampleLocationsEXT", &wine_vkCmdSetSampleLocationsEXT},
2045     {"vkCmdSetScissor", &wine_vkCmdSetScissor},
2046     {"vkCmdSetScissorWithCountEXT", &wine_vkCmdSetScissorWithCountEXT},
2047     {"vkCmdSetStencilCompareMask", &wine_vkCmdSetStencilCompareMask},
2048     {"vkCmdSetStencilOpEXT", &wine_vkCmdSetStencilOpEXT},
2049     {"vkCmdSetStencilReference", &wine_vkCmdSetStencilReference},
2050     {"vkCmdSetStencilTestEnableEXT", &wine_vkCmdSetStencilTestEnableEXT},
2051     {"vkCmdSetStencilWriteMask", &wine_vkCmdSetStencilWriteMask},
2052     {"vkCmdSetViewport", &wine_vkCmdSetViewport},
2053     {"vkCmdSetViewportShadingRatePaletteNV", &wine_vkCmdSetViewportShadingRatePaletteNV},
2054     {"vkCmdSetViewportWScalingNV", &wine_vkCmdSetViewportWScalingNV},
2055     {"vkCmdSetViewportWithCountEXT", &wine_vkCmdSetViewportWithCountEXT},
2056     {"vkCmdTraceRaysIndirectKHR", &wine_vkCmdTraceRaysIndirectKHR},
2057     {"vkCmdTraceRaysKHR", &wine_vkCmdTraceRaysKHR},
2058     {"vkCmdTraceRaysNV", &wine_vkCmdTraceRaysNV},
2059     {"vkCmdUpdateBuffer", &wine_vkCmdUpdateBuffer},
2060     {"vkCmdWaitEvents", &wine_vkCmdWaitEvents},
2061     {"vkCmdWaitEvents2KHR", &wine_vkCmdWaitEvents2KHR},
2062     {"vkCmdWriteAccelerationStructuresPropertiesKHR", &wine_vkCmdWriteAccelerationStructuresPropertiesKHR},
2063     {"vkCmdWriteAccelerationStructuresPropertiesNV", &wine_vkCmdWriteAccelerationStructuresPropertiesNV},
2064     {"vkCmdWriteBufferMarker2AMD", &wine_vkCmdWriteBufferMarker2AMD},
2065     {"vkCmdWriteBufferMarkerAMD", &wine_vkCmdWriteBufferMarkerAMD},
2066     {"vkCmdWriteTimestamp", &wine_vkCmdWriteTimestamp},
2067     {"vkCmdWriteTimestamp2KHR", &wine_vkCmdWriteTimestamp2KHR},
2068     {"vkCompileDeferredNV", &wine_vkCompileDeferredNV},
2069     {"vkCopyAccelerationStructureKHR", &wine_vkCopyAccelerationStructureKHR},
2070     {"vkCopyAccelerationStructureToMemoryKHR", &wine_vkCopyAccelerationStructureToMemoryKHR},
2071     {"vkCopyMemoryToAccelerationStructureKHR", &wine_vkCopyMemoryToAccelerationStructureKHR},
2072     {"vkCreateAccelerationStructureKHR", &wine_vkCreateAccelerationStructureKHR},
2073     {"vkCreateAccelerationStructureNV", &wine_vkCreateAccelerationStructureNV},
2074     {"vkCreateBuffer", &wine_vkCreateBuffer},
2075     {"vkCreateBufferView", &wine_vkCreateBufferView},
2076     {"vkCreateCommandPool", &wine_vkCreateCommandPool},
2077     {"vkCreateComputePipelines", &wine_vkCreateComputePipelines},
2078     {"vkCreateDeferredOperationKHR", &wine_vkCreateDeferredOperationKHR},
2079     {"vkCreateDescriptorPool", &wine_vkCreateDescriptorPool},
2080     {"vkCreateDescriptorSetLayout", &wine_vkCreateDescriptorSetLayout},
2081     {"vkCreateDescriptorUpdateTemplate", &wine_vkCreateDescriptorUpdateTemplate},
2082     {"vkCreateDescriptorUpdateTemplateKHR", &wine_vkCreateDescriptorUpdateTemplateKHR},
2083     {"vkCreateEvent", &wine_vkCreateEvent},
2084     {"vkCreateFence", &wine_vkCreateFence},
2085     {"vkCreateFramebuffer", &wine_vkCreateFramebuffer},
2086     {"vkCreateGraphicsPipelines", &wine_vkCreateGraphicsPipelines},
2087     {"vkCreateImage", &wine_vkCreateImage},
2088     {"vkCreateImageView", &wine_vkCreateImageView},
2089     {"vkCreateIndirectCommandsLayoutNV", &wine_vkCreateIndirectCommandsLayoutNV},
2090     {"vkCreatePipelineCache", &wine_vkCreatePipelineCache},
2091     {"vkCreatePipelineLayout", &wine_vkCreatePipelineLayout},
2092     {"vkCreatePrivateDataSlotEXT", &wine_vkCreatePrivateDataSlotEXT},
2093     {"vkCreateQueryPool", &wine_vkCreateQueryPool},
2094     {"vkCreateRayTracingPipelinesKHR", &wine_vkCreateRayTracingPipelinesKHR},
2095     {"vkCreateRayTracingPipelinesNV", &wine_vkCreateRayTracingPipelinesNV},
2096     {"vkCreateRenderPass", &wine_vkCreateRenderPass},
2097     {"vkCreateRenderPass2", &wine_vkCreateRenderPass2},
2098     {"vkCreateRenderPass2KHR", &wine_vkCreateRenderPass2KHR},
2099     {"vkCreateSampler", &wine_vkCreateSampler},
2100     {"vkCreateSamplerYcbcrConversion", &wine_vkCreateSamplerYcbcrConversion},
2101     {"vkCreateSamplerYcbcrConversionKHR", &wine_vkCreateSamplerYcbcrConversionKHR},
2102     {"vkCreateSemaphore", &wine_vkCreateSemaphore},
2103     {"vkCreateShaderModule", &wine_vkCreateShaderModule},
2104     {"vkCreateSwapchainKHR", &wine_vkCreateSwapchainKHR},
2105     {"vkCreateValidationCacheEXT", &wine_vkCreateValidationCacheEXT},
2106     {"vkDebugMarkerSetObjectNameEXT", &wine_vkDebugMarkerSetObjectNameEXT},
2107     {"vkDebugMarkerSetObjectTagEXT", &wine_vkDebugMarkerSetObjectTagEXT},
2108     {"vkDeferredOperationJoinKHR", &wine_vkDeferredOperationJoinKHR},
2109     {"vkDestroyAccelerationStructureKHR", &wine_vkDestroyAccelerationStructureKHR},
2110     {"vkDestroyAccelerationStructureNV", &wine_vkDestroyAccelerationStructureNV},
2111     {"vkDestroyBuffer", &wine_vkDestroyBuffer},
2112     {"vkDestroyBufferView", &wine_vkDestroyBufferView},
2113     {"vkDestroyCommandPool", &wine_vkDestroyCommandPool},
2114     {"vkDestroyDeferredOperationKHR", &wine_vkDestroyDeferredOperationKHR},
2115     {"vkDestroyDescriptorPool", &wine_vkDestroyDescriptorPool},
2116     {"vkDestroyDescriptorSetLayout", &wine_vkDestroyDescriptorSetLayout},
2117     {"vkDestroyDescriptorUpdateTemplate", &wine_vkDestroyDescriptorUpdateTemplate},
2118     {"vkDestroyDescriptorUpdateTemplateKHR", &wine_vkDestroyDescriptorUpdateTemplateKHR},
2119     {"vkDestroyDevice", &wine_vkDestroyDevice},
2120     {"vkDestroyEvent", &wine_vkDestroyEvent},
2121     {"vkDestroyFence", &wine_vkDestroyFence},
2122     {"vkDestroyFramebuffer", &wine_vkDestroyFramebuffer},
2123     {"vkDestroyImage", &wine_vkDestroyImage},
2124     {"vkDestroyImageView", &wine_vkDestroyImageView},
2125     {"vkDestroyIndirectCommandsLayoutNV", &wine_vkDestroyIndirectCommandsLayoutNV},
2126     {"vkDestroyPipeline", &wine_vkDestroyPipeline},
2127     {"vkDestroyPipelineCache", &wine_vkDestroyPipelineCache},
2128     {"vkDestroyPipelineLayout", &wine_vkDestroyPipelineLayout},
2129     {"vkDestroyPrivateDataSlotEXT", &wine_vkDestroyPrivateDataSlotEXT},
2130     {"vkDestroyQueryPool", &wine_vkDestroyQueryPool},
2131     {"vkDestroyRenderPass", &wine_vkDestroyRenderPass},
2132     {"vkDestroySampler", &wine_vkDestroySampler},
2133     {"vkDestroySamplerYcbcrConversion", &wine_vkDestroySamplerYcbcrConversion},
2134     {"vkDestroySamplerYcbcrConversionKHR", &wine_vkDestroySamplerYcbcrConversionKHR},
2135     {"vkDestroySemaphore", &wine_vkDestroySemaphore},
2136     {"vkDestroyShaderModule", &wine_vkDestroyShaderModule},
2137     {"vkDestroySwapchainKHR", &wine_vkDestroySwapchainKHR},
2138     {"vkDestroyValidationCacheEXT", &wine_vkDestroyValidationCacheEXT},
2139     {"vkDeviceWaitIdle", &wine_vkDeviceWaitIdle},
2140     {"vkEndCommandBuffer", &wine_vkEndCommandBuffer},
2141     {"vkFlushMappedMemoryRanges", &wine_vkFlushMappedMemoryRanges},
2142     {"vkFreeCommandBuffers", &wine_vkFreeCommandBuffers},
2143     {"vkFreeDescriptorSets", &wine_vkFreeDescriptorSets},
2144     {"vkFreeMemory", &wine_vkFreeMemory},
2145     {"vkGetAccelerationStructureBuildSizesKHR", &wine_vkGetAccelerationStructureBuildSizesKHR},
2146     {"vkGetAccelerationStructureDeviceAddressKHR", &wine_vkGetAccelerationStructureDeviceAddressKHR},
2147     {"vkGetAccelerationStructureHandleNV", &wine_vkGetAccelerationStructureHandleNV},
2148     {"vkGetAccelerationStructureMemoryRequirementsNV", &wine_vkGetAccelerationStructureMemoryRequirementsNV},
2149     {"vkGetBufferDeviceAddress", &wine_vkGetBufferDeviceAddress},
2150     {"vkGetBufferDeviceAddressEXT", &wine_vkGetBufferDeviceAddressEXT},
2151     {"vkGetBufferDeviceAddressKHR", &wine_vkGetBufferDeviceAddressKHR},
2152     {"vkGetBufferMemoryRequirements", &wine_vkGetBufferMemoryRequirements},
2153     {"vkGetBufferMemoryRequirements2", &wine_vkGetBufferMemoryRequirements2},
2154     {"vkGetBufferMemoryRequirements2KHR", &wine_vkGetBufferMemoryRequirements2KHR},
2155     {"vkGetBufferOpaqueCaptureAddress", &wine_vkGetBufferOpaqueCaptureAddress},
2156     {"vkGetBufferOpaqueCaptureAddressKHR", &wine_vkGetBufferOpaqueCaptureAddressKHR},
2157     {"vkGetCalibratedTimestampsEXT", &wine_vkGetCalibratedTimestampsEXT},
2158     {"vkGetDeferredOperationMaxConcurrencyKHR", &wine_vkGetDeferredOperationMaxConcurrencyKHR},
2159     {"vkGetDeferredOperationResultKHR", &wine_vkGetDeferredOperationResultKHR},
2160     {"vkGetDescriptorSetLayoutSupport", &wine_vkGetDescriptorSetLayoutSupport},
2161     {"vkGetDescriptorSetLayoutSupportKHR", &wine_vkGetDescriptorSetLayoutSupportKHR},
2162     {"vkGetDeviceAccelerationStructureCompatibilityKHR", &wine_vkGetDeviceAccelerationStructureCompatibilityKHR},
2163     {"vkGetDeviceGroupPeerMemoryFeatures", &wine_vkGetDeviceGroupPeerMemoryFeatures},
2164     {"vkGetDeviceGroupPeerMemoryFeaturesKHR", &wine_vkGetDeviceGroupPeerMemoryFeaturesKHR},
2165     {"vkGetDeviceGroupPresentCapabilitiesKHR", &wine_vkGetDeviceGroupPresentCapabilitiesKHR},
2166     {"vkGetDeviceGroupSurfacePresentModesKHR", &wine_vkGetDeviceGroupSurfacePresentModesKHR},
2167     {"vkGetDeviceMemoryCommitment", &wine_vkGetDeviceMemoryCommitment},
2168     {"vkGetDeviceMemoryOpaqueCaptureAddress", &wine_vkGetDeviceMemoryOpaqueCaptureAddress},
2169     {"vkGetDeviceMemoryOpaqueCaptureAddressKHR", &wine_vkGetDeviceMemoryOpaqueCaptureAddressKHR},
2170     {"vkGetDeviceProcAddr", &wine_vkGetDeviceProcAddr},
2171     {"vkGetDeviceQueue", &wine_vkGetDeviceQueue},
2172     {"vkGetDeviceQueue2", &wine_vkGetDeviceQueue2},
2173     {"vkGetEventStatus", &wine_vkGetEventStatus},
2174     {"vkGetFenceStatus", &wine_vkGetFenceStatus},
2175     {"vkGetGeneratedCommandsMemoryRequirementsNV", &wine_vkGetGeneratedCommandsMemoryRequirementsNV},
2176     {"vkGetImageMemoryRequirements", &wine_vkGetImageMemoryRequirements},
2177     {"vkGetImageMemoryRequirements2", &wine_vkGetImageMemoryRequirements2},
2178     {"vkGetImageMemoryRequirements2KHR", &wine_vkGetImageMemoryRequirements2KHR},
2179     {"vkGetImageSparseMemoryRequirements", &wine_vkGetImageSparseMemoryRequirements},
2180     {"vkGetImageSparseMemoryRequirements2", &wine_vkGetImageSparseMemoryRequirements2},
2181     {"vkGetImageSparseMemoryRequirements2KHR", &wine_vkGetImageSparseMemoryRequirements2KHR},
2182     {"vkGetImageSubresourceLayout", &wine_vkGetImageSubresourceLayout},
2183     {"vkGetMemoryHostPointerPropertiesEXT", &wine_vkGetMemoryHostPointerPropertiesEXT},
2184     {"vkGetPerformanceParameterINTEL", &wine_vkGetPerformanceParameterINTEL},
2185     {"vkGetPipelineCacheData", &wine_vkGetPipelineCacheData},
2186     {"vkGetPipelineExecutableInternalRepresentationsKHR", &wine_vkGetPipelineExecutableInternalRepresentationsKHR},
2187     {"vkGetPipelineExecutablePropertiesKHR", &wine_vkGetPipelineExecutablePropertiesKHR},
2188     {"vkGetPipelineExecutableStatisticsKHR", &wine_vkGetPipelineExecutableStatisticsKHR},
2189     {"vkGetPrivateDataEXT", &wine_vkGetPrivateDataEXT},
2190     {"vkGetQueryPoolResults", &wine_vkGetQueryPoolResults},
2191     {"vkGetQueueCheckpointData2NV", &wine_vkGetQueueCheckpointData2NV},
2192     {"vkGetQueueCheckpointDataNV", &wine_vkGetQueueCheckpointDataNV},
2193     {"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", &wine_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR},
2194     {"vkGetRayTracingShaderGroupHandlesKHR", &wine_vkGetRayTracingShaderGroupHandlesKHR},
2195     {"vkGetRayTracingShaderGroupHandlesNV", &wine_vkGetRayTracingShaderGroupHandlesNV},
2196     {"vkGetRayTracingShaderGroupStackSizeKHR", &wine_vkGetRayTracingShaderGroupStackSizeKHR},
2197     {"vkGetRenderAreaGranularity", &wine_vkGetRenderAreaGranularity},
2198     {"vkGetSemaphoreCounterValue", &wine_vkGetSemaphoreCounterValue},
2199     {"vkGetSemaphoreCounterValueKHR", &wine_vkGetSemaphoreCounterValueKHR},
2200     {"vkGetShaderInfoAMD", &wine_vkGetShaderInfoAMD},
2201     {"vkGetSwapchainImagesKHR", &wine_vkGetSwapchainImagesKHR},
2202     {"vkGetValidationCacheDataEXT", &wine_vkGetValidationCacheDataEXT},
2203     {"vkInitializePerformanceApiINTEL", &wine_vkInitializePerformanceApiINTEL},
2204     {"vkInvalidateMappedMemoryRanges", &wine_vkInvalidateMappedMemoryRanges},
2205     {"vkMapMemory", &wine_vkMapMemory},
2206     {"vkMergePipelineCaches", &wine_vkMergePipelineCaches},
2207     {"vkMergeValidationCachesEXT", &wine_vkMergeValidationCachesEXT},
2208     {"vkQueueBeginDebugUtilsLabelEXT", &wine_vkQueueBeginDebugUtilsLabelEXT},
2209     {"vkQueueBindSparse", &wine_vkQueueBindSparse},
2210     {"vkQueueEndDebugUtilsLabelEXT", &wine_vkQueueEndDebugUtilsLabelEXT},
2211     {"vkQueueInsertDebugUtilsLabelEXT", &wine_vkQueueInsertDebugUtilsLabelEXT},
2212     {"vkQueuePresentKHR", &wine_vkQueuePresentKHR},
2213     {"vkQueueSetPerformanceConfigurationINTEL", &wine_vkQueueSetPerformanceConfigurationINTEL},
2214     {"vkQueueSubmit", &wine_vkQueueSubmit},
2215     {"vkQueueSubmit2KHR", &wine_vkQueueSubmit2KHR},
2216     {"vkQueueWaitIdle", &wine_vkQueueWaitIdle},
2217     {"vkReleasePerformanceConfigurationINTEL", &wine_vkReleasePerformanceConfigurationINTEL},
2218     {"vkReleaseProfilingLockKHR", &wine_vkReleaseProfilingLockKHR},
2219     {"vkResetCommandBuffer", &wine_vkResetCommandBuffer},
2220     {"vkResetCommandPool", &wine_vkResetCommandPool},
2221     {"vkResetDescriptorPool", &wine_vkResetDescriptorPool},
2222     {"vkResetEvent", &wine_vkResetEvent},
2223     {"vkResetFences", &wine_vkResetFences},
2224     {"vkResetQueryPool", &wine_vkResetQueryPool},
2225     {"vkResetQueryPoolEXT", &wine_vkResetQueryPoolEXT},
2226     {"vkSetDebugUtilsObjectNameEXT", &wine_vkSetDebugUtilsObjectNameEXT},
2227     {"vkSetDebugUtilsObjectTagEXT", &wine_vkSetDebugUtilsObjectTagEXT},
2228     {"vkSetEvent", &wine_vkSetEvent},
2229     {"vkSetPrivateDataEXT", &wine_vkSetPrivateDataEXT},
2230     {"vkSignalSemaphore", &wine_vkSignalSemaphore},
2231     {"vkSignalSemaphoreKHR", &wine_vkSignalSemaphoreKHR},
2232     {"vkTrimCommandPool", &wine_vkTrimCommandPool},
2233     {"vkTrimCommandPoolKHR", &wine_vkTrimCommandPoolKHR},
2234     {"vkUninitializePerformanceApiINTEL", &wine_vkUninitializePerformanceApiINTEL},
2235     {"vkUnmapMemory", &wine_vkUnmapMemory},
2236     {"vkUpdateDescriptorSetWithTemplate", &wine_vkUpdateDescriptorSetWithTemplate},
2237     {"vkUpdateDescriptorSetWithTemplateKHR", &wine_vkUpdateDescriptorSetWithTemplateKHR},
2238     {"vkUpdateDescriptorSets", &wine_vkUpdateDescriptorSets},
2239     {"vkWaitForFences", &wine_vkWaitForFences},
2240     {"vkWaitSemaphores", &wine_vkWaitSemaphores},
2241     {"vkWaitSemaphoresKHR", &wine_vkWaitSemaphoresKHR},
2242     {"vkWriteAccelerationStructuresPropertiesKHR", &wine_vkWriteAccelerationStructuresPropertiesKHR},
2243 };
2244
2245 static const struct vulkan_func vk_phys_dev_dispatch_table[] =
2246 {
2247     {"vkCreateDevice", &wine_vkCreateDevice},
2248     {"vkEnumerateDeviceExtensionProperties", &wine_vkEnumerateDeviceExtensionProperties},
2249     {"vkEnumerateDeviceLayerProperties", &wine_vkEnumerateDeviceLayerProperties},
2250     {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", &wine_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR},
2251     {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", &wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT},
2252     {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", &wine_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV},
2253     {"vkGetPhysicalDeviceExternalBufferProperties", &wine_vkGetPhysicalDeviceExternalBufferProperties},
2254     {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", &wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR},
2255     {"vkGetPhysicalDeviceExternalFenceProperties", &wine_vkGetPhysicalDeviceExternalFenceProperties},
2256     {"vkGetPhysicalDeviceExternalFencePropertiesKHR", &wine_vkGetPhysicalDeviceExternalFencePropertiesKHR},
2257     {"vkGetPhysicalDeviceExternalSemaphoreProperties", &wine_vkGetPhysicalDeviceExternalSemaphoreProperties},
2258     {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", &wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR},
2259     {"vkGetPhysicalDeviceFeatures", &wine_vkGetPhysicalDeviceFeatures},
2260     {"vkGetPhysicalDeviceFeatures2", &wine_vkGetPhysicalDeviceFeatures2},
2261     {"vkGetPhysicalDeviceFeatures2KHR", &wine_vkGetPhysicalDeviceFeatures2KHR},
2262     {"vkGetPhysicalDeviceFormatProperties", &wine_vkGetPhysicalDeviceFormatProperties},
2263     {"vkGetPhysicalDeviceFormatProperties2", &wine_vkGetPhysicalDeviceFormatProperties2},
2264     {"vkGetPhysicalDeviceFormatProperties2KHR", &wine_vkGetPhysicalDeviceFormatProperties2KHR},
2265     {"vkGetPhysicalDeviceFragmentShadingRatesKHR", &wine_vkGetPhysicalDeviceFragmentShadingRatesKHR},
2266     {"vkGetPhysicalDeviceImageFormatProperties", &wine_vkGetPhysicalDeviceImageFormatProperties},
2267     {"vkGetPhysicalDeviceImageFormatProperties2", &wine_vkGetPhysicalDeviceImageFormatProperties2},
2268     {"vkGetPhysicalDeviceImageFormatProperties2KHR", &wine_vkGetPhysicalDeviceImageFormatProperties2KHR},
2269     {"vkGetPhysicalDeviceMemoryProperties", &wine_vkGetPhysicalDeviceMemoryProperties},
2270     {"vkGetPhysicalDeviceMemoryProperties2", &wine_vkGetPhysicalDeviceMemoryProperties2},
2271     {"vkGetPhysicalDeviceMemoryProperties2KHR", &wine_vkGetPhysicalDeviceMemoryProperties2KHR},
2272     {"vkGetPhysicalDeviceMultisamplePropertiesEXT", &wine_vkGetPhysicalDeviceMultisamplePropertiesEXT},
2273     {"vkGetPhysicalDevicePresentRectanglesKHR", &wine_vkGetPhysicalDevicePresentRectanglesKHR},
2274     {"vkGetPhysicalDeviceProperties", &wine_vkGetPhysicalDeviceProperties},
2275     {"vkGetPhysicalDeviceProperties2", &wine_vkGetPhysicalDeviceProperties2},
2276     {"vkGetPhysicalDeviceProperties2KHR", &wine_vkGetPhysicalDeviceProperties2KHR},
2277     {"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", &wine_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR},
2278     {"vkGetPhysicalDeviceQueueFamilyProperties", &wine_vkGetPhysicalDeviceQueueFamilyProperties},
2279     {"vkGetPhysicalDeviceQueueFamilyProperties2", &wine_vkGetPhysicalDeviceQueueFamilyProperties2},
2280     {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", &wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR},
2281     {"vkGetPhysicalDeviceSparseImageFormatProperties", &wine_vkGetPhysicalDeviceSparseImageFormatProperties},
2282     {"vkGetPhysicalDeviceSparseImageFormatProperties2", &wine_vkGetPhysicalDeviceSparseImageFormatProperties2},
2283     {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", &wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR},
2284     {"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", &wine_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV},
2285     {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", &wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR},
2286     {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", &wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR},
2287     {"vkGetPhysicalDeviceSurfaceFormats2KHR", &wine_vkGetPhysicalDeviceSurfaceFormats2KHR},
2288     {"vkGetPhysicalDeviceSurfaceFormatsKHR", &wine_vkGetPhysicalDeviceSurfaceFormatsKHR},
2289     {"vkGetPhysicalDeviceSurfacePresentModesKHR", &wine_vkGetPhysicalDeviceSurfacePresentModesKHR},
2290     {"vkGetPhysicalDeviceSurfaceSupportKHR", &wine_vkGetPhysicalDeviceSurfaceSupportKHR},
2291     {"vkGetPhysicalDeviceToolPropertiesEXT", &wine_vkGetPhysicalDeviceToolPropertiesEXT},
2292     {"vkGetPhysicalDeviceWin32PresentationSupportKHR", &wine_vkGetPhysicalDeviceWin32PresentationSupportKHR},
2293 };
2294
2295 static const struct vulkan_func vk_instance_dispatch_table[] =
2296 {
2297     {"vkCreateDebugReportCallbackEXT", &wine_vkCreateDebugReportCallbackEXT},
2298     {"vkCreateDebugUtilsMessengerEXT", &wine_vkCreateDebugUtilsMessengerEXT},
2299     {"vkCreateWin32SurfaceKHR", &wine_vkCreateWin32SurfaceKHR},
2300     {"vkDebugReportMessageEXT", &wine_vkDebugReportMessageEXT},
2301     {"vkDestroyDebugReportCallbackEXT", &wine_vkDestroyDebugReportCallbackEXT},
2302     {"vkDestroyDebugUtilsMessengerEXT", &wine_vkDestroyDebugUtilsMessengerEXT},
2303     {"vkDestroyInstance", &wine_vkDestroyInstance},
2304     {"vkDestroySurfaceKHR", &wine_vkDestroySurfaceKHR},
2305     {"vkEnumeratePhysicalDeviceGroups", &wine_vkEnumeratePhysicalDeviceGroups},
2306     {"vkEnumeratePhysicalDeviceGroupsKHR", &wine_vkEnumeratePhysicalDeviceGroupsKHR},
2307     {"vkEnumeratePhysicalDevices", &wine_vkEnumeratePhysicalDevices},
2308     {"vkSubmitDebugUtilsMessageEXT", &wine_vkSubmitDebugUtilsMessageEXT},
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", debugstr_a(name));
2319             return vk_device_dispatch_table[i].func;
2320         }
2321     }
2322     return NULL;
2323 }
2324
2325 void *wine_vk_get_phys_dev_proc_addr(const char *name)
2326 {
2327     unsigned int i;
2328     for (i = 0; i < ARRAY_SIZE(vk_phys_dev_dispatch_table); i++)
2329     {
2330         if (strcmp(vk_phys_dev_dispatch_table[i].name, name) == 0)
2331         {
2332             TRACE("Found name=%s in physical device table\n", debugstr_a(name));
2333             return vk_phys_dev_dispatch_table[i].func;
2334         }
2335     }
2336     return NULL;
2337 }
2338
2339 void *wine_vk_get_instance_proc_addr(const char *name)
2340 {
2341     unsigned int i;
2342     for (i = 0; i < ARRAY_SIZE(vk_instance_dispatch_table); i++)
2343     {
2344         if (strcmp(vk_instance_dispatch_table[i].name, name) == 0)
2345         {
2346             TRACE("Found name=%s in instance table\n", debugstr_a(name));
2347             return vk_instance_dispatch_table[i].func;
2348         }
2349     }
2350     return NULL;
2351 }