[PATCH v2 0/4] vulkan-1 implementation

[Roderick Colenbrander]

Hi all,

This is revised version of my previous vulkan-1 implementation.
It now relies on spec file forwards from vulkan-1 to winevulkan,
which keeps the implementation even simpler.

I was tempted to even leave out vkEnumerateInstanceExtensionProperties,
but ultimately kept it for the layer_name check. It is a check, which
winevulkan performs as well, but technically doesn't belong at the ICD
layer as the loader should sanitize such values, which native does now,
so maybe we could take it out of the ICD.

Thanks,
Roderick

Roderick Colenbrander (4):
  winevulkan: Export symbols for Core Vulkan functions.
  vulkan-1: Add initial implementation.
  vulkan-1: Implement vkEnumerateInstanceExtensionProperties.
  vulkan-1: Implement vkGetInstanceProcAddr.

configure.ac                    |   1 +
 dlls/vulkan-1/Makefile.in       |   7 ++
 dlls/vulkan-1/version.rc        |  27 ++++
 dlls/vulkan-1/vulkan-1.spec     | 159 ++++++++++++++++++++++++
 dlls/vulkan-1/vulkan.c          |  85 +++++++++++++
 dlls/winevulkan/Makefile.in     |   1 +
 dlls/winevulkan/make_vulkan     | 139 +++++++++++++++++++--
 dlls/winevulkan/vulkan.c        |   6 +-
 dlls/winevulkan/vulkan_thunks.c | 268 ++++++++++++++++++++--------------------
 dlls/winevulkan/vulkan_thunks.h |  22 ++--
 dlls/winevulkan/winevulkan.spec | 158 +++++++++++++++++++++++
 11 files changed, 715 insertions(+), 158 deletions(-)
 create mode 100644 dlls/vulkan-1/Makefile.in
 create mode 100644 dlls/vulkan-1/version.rc
 create mode 100644 dlls/vulkan-1/vulkan-1.spec
 create mode 100644 dlls/vulkan-1/vulkan.c

[PATCH 1/4] winevulkan: Export symbols for Core Vulkan functions.

[Roderick Colenbrander]

Signed-off-by: Roderick Colenbrander 
---
 dlls/winevulkan/Makefile.in     |   1 +
 dlls/winevulkan/make_vulkan     | 107 ++++++++++++++--
 dlls/winevulkan/vulkan.c        |   6 +-
 dlls/winevulkan/vulkan_thunks.c | 268 ++++++++++++++++++++--------------------
 dlls/winevulkan/vulkan_thunks.h |  22 ++--
 dlls/winevulkan/winevulkan.spec | 158 +++++++++++++++++++++++
 6 files changed, 404 insertions(+), 158 deletions(-)

diff --git a/dlls/winevulkan/Makefile.in b/dlls/winevulkan/Makefile.in
index a3c40bd398..e0bca6fad7 100644
--- a/dlls/winevulkan/Makefile.in
+++ b/dlls/winevulkan/Makefile.in
@@ -1,4 +1,5 @@
 MODULE    = winevulkan.dll
+IMPORTLIB = winevulkan
 IMPORTS   = user32 gdi32

C_SRCS = \
diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 2858309c06..7c4dc348be 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -65,6 +65,7 @@ LOGGER.addHandler(logging.StreamHandler())
 # Filenames to create.
 WINE_VULKAN_H = "../../include/wine/vulkan.h"
 WINE_VULKAN_DRIVER_H = "../../include/wine/vulkan_driver.h"
+WINE_VULKAN_SPEC = "winevulkan.spec"
 WINE_VULKAN_THUNKS_C = "vulkan_thunks.c"
 WINE_VULKAN_THUNKS_H = "vulkan_thunks.h"

@@ -106,6 +107,16 @@ BLACKLISTED_EXTENSIONS = [
     "VK_NV_external_memory_win32"
 ]

+# The Vulkan loader provides entry-points for core functionality and important
+# extensions. Based on vulkan-1.def this amounts to WSI extensions on 1.0.51.
+CORE_EXTENSIONS = [
+    "VK_KHR_display",
+    "VK_KHR_display_swapchain",
+    "VK_KHR_surface",
+    "VK_KHR_swapchain",
+    "VK_KHR_win32_surface"
+]
+
 # Functions part of our winevulkan graphics driver interface.
 # DRIVER_VERSION should be bumped on any change to driver interface
 # in FUNCTION_OVERRIDES
@@ -372,6 +383,20 @@ class VkFunction(object):

return conversions

+    def is_core_func(self):
+        """ Returns whether the function is a Vulkan core function.
+        Core functions are APIs defined by the Vulkan spec to be part of the
+        Core API as well as several KHR WSI extensions.
+        """
+
+        if self.extension is None:
+            return True
+
+        if self.extension in CORE_EXTENSIONS:
+            return True
+
+        return False
+
     def is_device_func(self):
         # If none of the other, it must be a device function
         return not self.is_global_func() and not self.is_instance_func()
@@ -545,6 +570,19 @@ class VkFunction(object):

return body

+    def spec(self, prefix=None):
+        """ Generate spec file entry for this function.
+
+        Args
+            prefix (str, optional): prefix to prepend to entry point name.
+        """
+
+        params = " ".join([p.spec() for p in self.params])
+        if prefix is not None:
+            return "@ stdcall {0}{1}({2})\n".format(prefix, self.name, params)
+        else:
+            return "@ stdcall {0}({1})\n".format(self.name, params)
+
     def stub(self, call_conv=None, prefix=None):
         stub = self.prototype(call_conv=call_conv, prefix=prefix)
         stub += "\n{\n"
@@ -1290,6 +1328,26 @@ class VkParam(object):
     def needs_output_conversion(self):
         return self.output_conv is not None

+    def spec(self):
+        """ Generate spec file entry for this parameter. """
+
+        if self.type_info["category"] in ["bitmask", "enum"]:
+            return "long"
+        if self.is_pointer() and self.type == "char":
+            return "str"
+        if self.is_dispatchable() or self.is_pointer() or self.is_static_array():
+            return "ptr"
+        if self.is_handle() and not self.is_dispatchable():
+            return "int64"
+        if self.type == "float":
+            return "float"
+        if self.type in ["int", "int32_t", "size_t", "uint32_t", "VkBool32"]:
+            return "long"
+        if self.type in ["uint64_t", "VkDeviceSize"]:
+            return "int64"
+
+        LOGGER.error("Unhandled spec conversion for type: {0}".format(self.type))
+
     def variable(self, conv=False):
         """ Returns 'glue' code during generation of a function call on how to access the variable.
         This function handles various scenarios such as 'unwrapping' if dispatchable objects and
@@ -1753,7 +1811,10 @@ class VkGenerator(object):
             if not vk_func.needs_thunk():
                 continue

-            f.write("static " + vk_func.thunk(prefix=prefix, call_conv="WINAPI"))
+            # Exports symbols for Core functions.
+            if not vk_func.is_core_func():
+                f.write("static ")
+            f.write(vk_func.thunk(prefix=prefix, call_conv="WINAPI"))

f.write("static const struct vulkan_func vk_device_dispatch_table[] =\n{\n")
         for vk_func in self.registry.device_funcs:
@@ -1863,7 +1924,10 @@ class VkGenerator(object):
             if not vk_func.is_required() or vk_func.is_global_func() or vk_func.needs_thunk():
                 continue

-            f.write("{0};\n".format(vk_func.prototype("WINAPI", prefix="wine_", postfix="DECLSPEC_HIDDEN")))
+            if vk_func.is_core_func():
+                f.write("{0};\n".format(vk_func.prototype("WINAPI", prefix="wine_")))
+            else:
+                f.write("{0};\n".format(vk_func.prototype("WINAPI", prefix="wine_", postfix="DECLSPEC_HIDDEN")))
         f.write("\n")

for struct in self.host_structs:
@@ -2051,6 +2115,27 @@ class VkGenerator(object):
         f.write("extern const struct vulkan_funcs * CDECL __wine_get_vulkan_driver(HDC hdc, UINT version);\n\n")
         f.write("#endif /* __WINE_VULKAN_DRIVER_H */\n")

+    def generate_vulkan_spec(self, f):
+        f.write("# Automatically generated from Vulkan vk.xml; DO NOT EDIT!\n\n")
+        f.write("@ stdcall vk_icdGetInstanceProcAddr(ptr str) wine_vk_icdGetInstanceProcAddr\n")
+        f.write("@ stdcall vk_icdNegotiateLoaderICDInterfaceVersion(ptr) wine_vk_icdNegotiateLoaderICDInterfaceVersion\n")
+
+        # Export symbols for all Vulkan Core functions.
+        for func in self.registry.funcs.values():
+            if not func.is_core_func():
+                continue
+
+            # Not an ICD level function.
+            if func.name == "vkEnumerateInstanceLayerProperties":
+                continue
+
+            # We support all Core functions except for VK_KHR_display* APIs.
+            # Create stubs for unsupported Core functions.
+            if func.is_required():
+                f.write(func.spec(prefix="wine_"))
+            else:
+                f.write("@ stub {0}\n".format(func.name))
+

class VkRegistry(object):
     def __init__(self, reg_filename):
@@ -2191,6 +2276,13 @@ class VkRegistry(object):
         for ext in exts:
             ext_name = ext.attrib["name"]

+            # Set extension name on any functions calls part of this extension as we
+            # were not aware of the name during initial parsing.
+            commands = ext.findall("require/command")
+            for command in commands:
+                cmd_name = command.attrib["name"]
+                self.funcs[cmd_name].extension = ext_name
+
             # Some extensions are not ready or have numbers reserved as a place holder.
             if ext.attrib["supported"] == "disabled":
                 LOGGER.debug("Skipping disabled extension: {0}".format(ext_name))
@@ -2257,20 +2349,12 @@ class VkRegistry(object):
             ext_info = {"name" : ext_name, "type" : ext_type}
             extensions.append(ext_info)

-            commands = ext.findall("require/command")
-            if not commands:
-                continue
-
             # Pull in any commands we need. We infer types to pull in from the command
             # as well.
             for command in commands:
                 cmd_name = command.attrib["name"]
                 self._mark_command_required(cmd_name)

-                # Set extension name on the function call as we were not aware of the
-                # name during initial parsing.
-                self.funcs[cmd_name].extension = ext_name
-
         # Sort in alphabetical order.
         self.extensions = sorted(extensions, key=lambda ext: ext["name"])

@@ -2434,5 +2518,8 @@ def main():
     with open(WINE_VULKAN_THUNKS_C, "w") as f:
         generator.generate_thunks_c(f, "wine_")

+    with open(WINE_VULKAN_SPEC, "w") as f:
+        generator.generate_vulkan_spec(f)
+
 if __name__ == "__main__":
     main()
diff --git a/dlls/winevulkan/vulkan.c b/dlls/winevulkan/vulkan.c
index ad1a35c934..72943830e3 100644
--- a/dlls/winevulkan/vulkan.c
+++ b/dlls/winevulkan/vulkan.c
@@ -589,7 +589,7 @@ err:
     return res;
 }

-static VkResult WINAPI wine_vkCreateInstance(const VkInstanceCreateInfo *create_info,
+VkResult WINAPI wine_vkCreateInstance(const VkInstanceCreateInfo *create_info,
         const VkAllocationCallbacks *allocator, VkInstance *instance)
 {
     struct VkInstance_T *object = NULL;
@@ -714,7 +714,7 @@ VkResult WINAPI wine_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice phys_
     return res;
 }

-static VkResult WINAPI wine_vkEnumerateInstanceExtensionProperties(const char *layer_name,
+VkResult WINAPI wine_vkEnumerateInstanceExtensionProperties(const char *layer_name,
         uint32_t *count, VkExtensionProperties *properties)
 {
     VkResult res;
@@ -861,7 +861,7 @@ void WINAPI wine_vkGetDeviceQueue(VkDevice device, uint32_t family_index,
     *queue = &device->queues[family_index][queue_index];
 }

-static PFN_vkVoidFunction WINAPI wine_vkGetInstanceProcAddr(VkInstance instance, const char *name)
+PFN_vkVoidFunction WINAPI wine_vkGetInstanceProcAddr(VkInstance instance, const char *name)
 {
     void *func;

diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index 2f2b8c196f..15910aa7db 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -992,13 +992,13 @@ static inline void free_VkCopyDescriptorSet_array(VkCopyDescriptorSet_host *in,

#endif /* USE_STRUCT_CONVERSION */

-static VkResult WINAPI wine_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
+VkResult WINAPI wine_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(swapchain), wine_dbgstr_longlong(timeout), wine_dbgstr_longlong(semaphore), wine_dbgstr_longlong(fence), pImageIndex);
     return device->funcs.p_vkAcquireNextImageKHR(device->device, swapchain, timeout, semaphore, fence, pImageIndex);
 }

-static VkResult WINAPI wine_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
+VkResult WINAPI wine_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -1015,7 +1015,7 @@ static VkResult WINAPI wine_vkAllocateDescriptorSets(VkDevice device, const VkDe
 #endif
 }

-static VkResult WINAPI wine_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
+VkResult WINAPI wine_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -1032,7 +1032,7 @@ static VkResult WINAPI wine_vkAllocateMemory(VkDevice device, const VkMemoryAllo
 #endif
 }

-static VkResult WINAPI wine_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
+VkResult WINAPI wine_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -1050,25 +1050,25 @@ static VkResult WINAPI wine_vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
 #endif
 }

-static VkResult WINAPI wine_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+VkResult WINAPI wine_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset));
     return device->funcs.p_vkBindBufferMemory(device->device, buffer, memory, memoryOffset);
 }

-static VkResult WINAPI wine_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+VkResult WINAPI wine_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(image), wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset));
     return device->funcs.p_vkBindImageMemory(device->device, image, memory, memoryOffset);
 }

-static void WINAPI wine_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
+void WINAPI wine_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
 {
     TRACE("%p, 0x%s, %u, %#x\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, flags);
     commandBuffer->device->funcs.p_vkCmdBeginQuery(commandBuffer->command_buffer, queryPool, query, flags);
 }

-static void WINAPI wine_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
+void WINAPI wine_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkRenderPassBeginInfo_host pRenderPassBegin_host;
@@ -1083,55 +1083,55 @@ static void WINAPI wine_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, cons
 #endif
 }

-static void WINAPI wine_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
+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)
 {
     TRACE("%p, %d, 0x%s, %u, %u, %p, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
     commandBuffer->device->funcs.p_vkCmdBindDescriptorSets(commandBuffer->command_buffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 }

-static void WINAPI wine_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+void WINAPI wine_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 {
     TRACE("%p, 0x%s, 0x%s, %d\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), indexType);
     commandBuffer->device->funcs.p_vkCmdBindIndexBuffer(commandBuffer->command_buffer, buffer, offset, indexType);
 }

-static void WINAPI wine_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+void WINAPI wine_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 {
     TRACE("%p, %d, 0x%s\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(pipeline));
     commandBuffer->device->funcs.p_vkCmdBindPipeline(commandBuffer->command_buffer, pipelineBindPoint, pipeline);
 }

-static void WINAPI wine_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
+void WINAPI wine_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
 {
     TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
     commandBuffer->device->funcs.p_vkCmdBindVertexBuffers(commandBuffer->command_buffer, firstBinding, bindingCount, pBuffers, pOffsets);
 }

-static void WINAPI wine_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
+void WINAPI wine_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
 {
     TRACE("%p, 0x%s, %d, 0x%s, %d, %u, %p, %d\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions, filter);
     commandBuffer->device->funcs.p_vkCmdBlitImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
 }

-static void WINAPI wine_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
+void WINAPI wine_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
 {
     TRACE("%p, %u, %p, %u, %p\n", commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
     commandBuffer->device->funcs.p_vkCmdClearAttachments(commandBuffer->command_buffer, attachmentCount, pAttachments, rectCount, pRects);
 }

-static void WINAPI wine_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
+void WINAPI wine_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
 {
     TRACE("%p, 0x%s, %d, %p, %u, %p\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, pColor, rangeCount, pRanges);
     commandBuffer->device->funcs.p_vkCmdClearColorImage(commandBuffer->command_buffer, image, imageLayout, pColor, rangeCount, pRanges);
 }

-static void WINAPI wine_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
+void WINAPI wine_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
 {
     TRACE("%p, 0x%s, %d, %p, %u, %p\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, pDepthStencil, rangeCount, pRanges);
     commandBuffer->device->funcs.p_vkCmdClearDepthStencilImage(commandBuffer->command_buffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
 }

-static void WINAPI wine_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
+void WINAPI wine_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkBufferCopy_host *pRegions_host;
@@ -1147,7 +1147,7 @@ static void WINAPI wine_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer
 #endif
 }

-static void WINAPI wine_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
+void WINAPI wine_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkBufferImageCopy_host *pRegions_host;
@@ -1163,13 +1163,13 @@ static void WINAPI wine_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, Vk
 #endif
 }

-static void WINAPI wine_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
+void WINAPI wine_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
 {
     TRACE("%p, 0x%s, %d, 0x%s, %d, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
     commandBuffer->device->funcs.p_vkCmdCopyImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }

-static void WINAPI wine_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
+void WINAPI wine_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkBufferImageCopy_host *pRegions_host;
@@ -1185,37 +1185,37 @@ static void WINAPI wine_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, Vk
 #endif
 }

-static void WINAPI wine_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
+void WINAPI wine_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
 {
     TRACE("%p, 0x%s, %u, %u, 0x%s, 0x%s, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(queryPool), firstQuery, queryCount, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(stride), flags);
     commandBuffer->device->funcs.p_vkCmdCopyQueryPoolResults(commandBuffer->command_buffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
 }

-static void WINAPI wine_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+void WINAPI wine_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 {
     TRACE("%p, %u, %u, %u\n", commandBuffer, groupCountX, groupCountY, groupCountZ);
     commandBuffer->device->funcs.p_vkCmdDispatch(commandBuffer->command_buffer, groupCountX, groupCountY, groupCountZ);
 }

-static void WINAPI wine_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
+void WINAPI wine_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 {
     TRACE("%p, 0x%s, 0x%s\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset));
     commandBuffer->device->funcs.p_vkCmdDispatchIndirect(commandBuffer->command_buffer, buffer, offset);
 }

-static void WINAPI wine_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+void WINAPI wine_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
 {
     TRACE("%p, %u, %u, %u, %u\n", commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
     commandBuffer->device->funcs.p_vkCmdDraw(commandBuffer->command_buffer, vertexCount, instanceCount, firstVertex, firstInstance);
 }

-static void WINAPI wine_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
+void WINAPI wine_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
 {
     TRACE("%p, %u, %u, %u, %d, %u\n", commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
     commandBuffer->device->funcs.p_vkCmdDrawIndexed(commandBuffer->command_buffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
 }

-static void WINAPI wine_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+void WINAPI wine_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirect(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
@@ -1227,7 +1227,7 @@ static void WINAPI wine_vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer command
     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirectCountAMD(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }

-static void WINAPI wine_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+void WINAPI wine_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
     commandBuffer->device->funcs.p_vkCmdDrawIndirect(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
@@ -1239,31 +1239,31 @@ static void WINAPI wine_vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer,
     commandBuffer->device->funcs.p_vkCmdDrawIndirectCountAMD(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }

-static void WINAPI wine_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
+void WINAPI wine_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
 {
     TRACE("%p, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query);
     commandBuffer->device->funcs.p_vkCmdEndQuery(commandBuffer->command_buffer, queryPool, query);
 }

-static void WINAPI wine_vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
+void WINAPI wine_vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
 {
     TRACE("%p\n", commandBuffer);
     commandBuffer->device->funcs.p_vkCmdEndRenderPass(commandBuffer->command_buffer);
 }

-static void WINAPI wine_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
+void WINAPI wine_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(size), data);
     commandBuffer->device->funcs.p_vkCmdFillBuffer(commandBuffer->command_buffer, dstBuffer, dstOffset, size, data);
 }

-static void WINAPI wine_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
+void WINAPI wine_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
 {
     TRACE("%p, %d\n", commandBuffer, contents);
     commandBuffer->device->funcs.p_vkCmdNextSubpass(commandBuffer->command_buffer, contents);
 }

-static void WINAPI wine_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
+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)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkBufferMemoryBarrier_host *pBufferMemoryBarriers_host;
@@ -1282,7 +1282,7 @@ static void WINAPI wine_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPi
 #endif
 }

-static void WINAPI wine_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
+void WINAPI wine_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
 {
     TRACE("%p, 0x%s, %#x, %u, %u, %p\n", commandBuffer, wine_dbgstr_longlong(layout), stageFlags, offset, size, pValues);
     commandBuffer->device->funcs.p_vkCmdPushConstants(commandBuffer->command_buffer, layout, stageFlags, offset, size, pValues);
@@ -1310,37 +1310,37 @@ static void WINAPI wine_vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer co
     commandBuffer->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer->command_buffer, descriptorUpdateTemplate, layout, set, pData);
 }

-static void WINAPI wine_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+void WINAPI wine_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(event), stageMask);
     commandBuffer->device->funcs.p_vkCmdResetEvent(commandBuffer->command_buffer, event, stageMask);
 }

-static void WINAPI wine_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+void WINAPI wine_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
 {
     TRACE("%p, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), firstQuery, queryCount);
     commandBuffer->device->funcs.p_vkCmdResetQueryPool(commandBuffer->command_buffer, queryPool, firstQuery, queryCount);
 }

-static void WINAPI wine_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
+void WINAPI wine_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
 {
     TRACE("%p, 0x%s, %d, 0x%s, %d, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
     commandBuffer->device->funcs.p_vkCmdResolveImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }

-static void WINAPI wine_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
+void WINAPI wine_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
 {
     TRACE("%p, %p\n", commandBuffer, blendConstants);
     commandBuffer->device->funcs.p_vkCmdSetBlendConstants(commandBuffer->command_buffer, blendConstants);
 }

-static void WINAPI wine_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
+void WINAPI wine_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
 {
     TRACE("%p, %f, %f, %f\n", commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
     commandBuffer->device->funcs.p_vkCmdSetDepthBias(commandBuffer->command_buffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
 }

-static void WINAPI wine_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
+void WINAPI wine_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
 {
     TRACE("%p, %f, %f\n", commandBuffer, minDepthBounds, maxDepthBounds);
     commandBuffer->device->funcs.p_vkCmdSetDepthBounds(commandBuffer->command_buffer, minDepthBounds, maxDepthBounds);
@@ -1352,43 +1352,43 @@ static void WINAPI wine_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffe
     commandBuffer->device->funcs.p_vkCmdSetDiscardRectangleEXT(commandBuffer->command_buffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
 }

-static void WINAPI wine_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+void WINAPI wine_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(event), stageMask);
     commandBuffer->device->funcs.p_vkCmdSetEvent(commandBuffer->command_buffer, event, stageMask);
 }

-static void WINAPI wine_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
+void WINAPI wine_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
 {
     TRACE("%p, %f\n", commandBuffer, lineWidth);
     commandBuffer->device->funcs.p_vkCmdSetLineWidth(commandBuffer->command_buffer, lineWidth);
 }

-static void WINAPI wine_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
+void WINAPI wine_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
 {
     TRACE("%p, %u, %u, %p\n", commandBuffer, firstScissor, scissorCount, pScissors);
     commandBuffer->device->funcs.p_vkCmdSetScissor(commandBuffer->command_buffer, firstScissor, scissorCount, pScissors);
 }

-static void WINAPI wine_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
+void WINAPI wine_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
 {
     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, compareMask);
     commandBuffer->device->funcs.p_vkCmdSetStencilCompareMask(commandBuffer->command_buffer, faceMask, compareMask);
 }

-static void WINAPI wine_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
+void WINAPI wine_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
 {
     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, reference);
     commandBuffer->device->funcs.p_vkCmdSetStencilReference(commandBuffer->command_buffer, faceMask, reference);
 }

-static void WINAPI wine_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
+void WINAPI wine_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
 {
     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, writeMask);
     commandBuffer->device->funcs.p_vkCmdSetStencilWriteMask(commandBuffer->command_buffer, faceMask, writeMask);
 }

-static void WINAPI wine_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
+void WINAPI wine_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
 {
     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pViewports);
     commandBuffer->device->funcs.p_vkCmdSetViewport(commandBuffer->command_buffer, firstViewport, viewportCount, pViewports);
@@ -1400,13 +1400,13 @@ static void WINAPI wine_vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer
     commandBuffer->device->funcs.p_vkCmdSetViewportWScalingNV(commandBuffer->command_buffer, firstViewport, viewportCount, pViewportWScalings);
 }

-static void WINAPI wine_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
+void WINAPI wine_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, %p\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(dataSize), pData);
     commandBuffer->device->funcs.p_vkCmdUpdateBuffer(commandBuffer->command_buffer, dstBuffer, dstOffset, dataSize, pData);
 }

-static void WINAPI wine_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
+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)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkBufferMemoryBarrier_host *pBufferMemoryBarriers_host;
@@ -1425,13 +1425,13 @@ static void WINAPI wine_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t
 #endif
 }

-static void WINAPI wine_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
+void WINAPI wine_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
 {
     TRACE("%p, %d, 0x%s, %u\n", commandBuffer, pipelineStage, wine_dbgstr_longlong(queryPool), query);
     commandBuffer->device->funcs.p_vkCmdWriteTimestamp(commandBuffer->command_buffer, pipelineStage, queryPool, query);
 }

-static VkResult WINAPI wine_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
+VkResult WINAPI wine_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -1448,7 +1448,7 @@ static VkResult WINAPI wine_vkCreateBuffer(VkDevice device, const VkBufferCreate
 #endif
 }

-static VkResult WINAPI wine_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
+VkResult WINAPI wine_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -1465,13 +1465,13 @@ static VkResult WINAPI wine_vkCreateBufferView(VkDevice device, const VkBufferVi
 #endif
 }

-static VkResult WINAPI wine_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
+VkResult WINAPI wine_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pCommandPool);
     return device->funcs.p_vkCreateCommandPool(device->device, pCreateInfo, NULL, pCommandPool);
 }

-static VkResult WINAPI wine_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
+VkResult WINAPI wine_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -1489,13 +1489,13 @@ static VkResult WINAPI wine_vkCreateComputePipelines(VkDevice device, VkPipeline
 #endif
 }

-static VkResult WINAPI wine_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
+VkResult WINAPI wine_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorPool);
     return device->funcs.p_vkCreateDescriptorPool(device->device, pCreateInfo, NULL, pDescriptorPool);
 }

-static VkResult WINAPI wine_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
+VkResult WINAPI wine_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSetLayout);
     return device->funcs.p_vkCreateDescriptorSetLayout(device->device, pCreateInfo, NULL, pSetLayout);
@@ -1518,19 +1518,19 @@ static VkResult WINAPI wine_vkCreateDescriptorUpdateTemplateKHR(VkDevice device,
 #endif
 }

-static VkResult WINAPI wine_vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
+VkResult WINAPI wine_vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pEvent);
     return device->funcs.p_vkCreateEvent(device->device, pCreateInfo, NULL, pEvent);
 }

-static VkResult WINAPI wine_vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
+VkResult WINAPI wine_vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFence);
     return device->funcs.p_vkCreateFence(device->device, pCreateInfo, NULL, pFence);
 }

-static VkResult WINAPI wine_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
+VkResult WINAPI wine_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -1547,7 +1547,7 @@ static VkResult WINAPI wine_vkCreateFramebuffer(VkDevice device, const VkFramebu
 #endif
 }

-static VkResult WINAPI wine_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
+VkResult WINAPI wine_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -1565,13 +1565,13 @@ static VkResult WINAPI wine_vkCreateGraphicsPipelines(VkDevice device, VkPipelin
 #endif
 }

-static VkResult WINAPI wine_vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
+VkResult WINAPI wine_vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pImage);
     return device->funcs.p_vkCreateImage(device->device, pCreateInfo, NULL, pImage);
 }

-static VkResult WINAPI wine_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
+VkResult WINAPI wine_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -1588,49 +1588,49 @@ static VkResult WINAPI wine_vkCreateImageView(VkDevice device, const VkImageView
 #endif
 }

-static VkResult WINAPI wine_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
+VkResult WINAPI wine_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPipelineCache);
     return device->funcs.p_vkCreatePipelineCache(device->device, pCreateInfo, NULL, pPipelineCache);
 }

-static VkResult WINAPI wine_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
+VkResult WINAPI wine_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPipelineLayout);
     return device->funcs.p_vkCreatePipelineLayout(device->device, pCreateInfo, NULL, pPipelineLayout);
 }

-static VkResult WINAPI wine_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
+VkResult WINAPI wine_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pQueryPool);
     return device->funcs.p_vkCreateQueryPool(device->device, pCreateInfo, NULL, pQueryPool);
 }

-static VkResult WINAPI wine_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
+VkResult WINAPI wine_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass);
     return device->funcs.p_vkCreateRenderPass(device->device, pCreateInfo, NULL, pRenderPass);
 }

-static VkResult WINAPI wine_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
+VkResult WINAPI wine_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSampler);
     return device->funcs.p_vkCreateSampler(device->device, pCreateInfo, NULL, pSampler);
 }

-static VkResult WINAPI wine_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
+VkResult WINAPI wine_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSemaphore);
     return device->funcs.p_vkCreateSemaphore(device->device, pCreateInfo, NULL, pSemaphore);
 }

-static VkResult WINAPI wine_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
+VkResult WINAPI wine_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pShaderModule);
     return device->funcs.p_vkCreateShaderModule(device->device, pCreateInfo, NULL, pShaderModule);
 }

-static VkResult WINAPI wine_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
+VkResult WINAPI wine_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -1647,37 +1647,37 @@ static VkResult WINAPI wine_vkCreateSwapchainKHR(VkDevice device, const VkSwapch
 #endif
 }

-static VkResult WINAPI wine_vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
+VkResult WINAPI wine_vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
 {
     TRACE("%p, %p, %p, %p\n", instance, pCreateInfo, pAllocator, pSurface);
     return instance->funcs.p_vkCreateWin32SurfaceKHR(instance->instance, pCreateInfo, NULL, pSurface);
 }

-static void WINAPI wine_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pAllocator);
     device->funcs.p_vkDestroyBuffer(device->device, buffer, NULL);
 }

-static void WINAPI wine_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(bufferView), pAllocator);
     device->funcs.p_vkDestroyBufferView(device->device, bufferView, NULL);
 }

-static void WINAPI wine_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(commandPool), pAllocator);
     device->funcs.p_vkDestroyCommandPool(device->device, commandPool, NULL);
 }

-static void WINAPI wine_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorPool), pAllocator);
     device->funcs.p_vkDestroyDescriptorPool(device->device, descriptorPool, NULL);
 }

-static void WINAPI wine_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSetLayout), pAllocator);
     device->funcs.p_vkDestroyDescriptorSetLayout(device->device, descriptorSetLayout, NULL);
@@ -1689,115 +1689,115 @@ static void WINAPI wine_vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, Vk
     device->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(device->device, descriptorUpdateTemplate, NULL);
 }

-static void WINAPI wine_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(event), pAllocator);
     device->funcs.p_vkDestroyEvent(device->device, event, NULL);
 }

-static void WINAPI wine_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(fence), pAllocator);
     device->funcs.p_vkDestroyFence(device->device, fence, NULL);
 }

-static void WINAPI wine_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(framebuffer), pAllocator);
     device->funcs.p_vkDestroyFramebuffer(device->device, framebuffer, NULL);
 }

-static void WINAPI wine_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pAllocator);
     device->funcs.p_vkDestroyImage(device->device, image, NULL);
 }

-static void WINAPI wine_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(imageView), pAllocator);
     device->funcs.p_vkDestroyImageView(device->device, imageView, NULL);
 }

-static void WINAPI wine_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), pAllocator);
     device->funcs.p_vkDestroyPipeline(device->device, pipeline, NULL);
 }

-static void WINAPI wine_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipelineCache), pAllocator);
     device->funcs.p_vkDestroyPipelineCache(device->device, pipelineCache, NULL);
 }

-static void WINAPI wine_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipelineLayout), pAllocator);
     device->funcs.p_vkDestroyPipelineLayout(device->device, pipelineLayout, NULL);
 }

-static void WINAPI wine_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(queryPool), pAllocator);
     device->funcs.p_vkDestroyQueryPool(device->device, queryPool, NULL);
 }

-static void WINAPI wine_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pAllocator);
     device->funcs.p_vkDestroyRenderPass(device->device, renderPass, NULL);
 }

-static void WINAPI wine_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(sampler), pAllocator);
     device->funcs.p_vkDestroySampler(device->device, sampler, NULL);
 }

-static void WINAPI wine_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(semaphore), pAllocator);
     device->funcs.p_vkDestroySemaphore(device->device, semaphore, NULL);
 }

-static void WINAPI wine_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(shaderModule), pAllocator);
     device->funcs.p_vkDestroyShaderModule(device->device, shaderModule, NULL);
 }

-static void WINAPI wine_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", instance, wine_dbgstr_longlong(surface), pAllocator);
     instance->funcs.p_vkDestroySurfaceKHR(instance->instance, surface, NULL);
 }

-static void WINAPI wine_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(swapchain), pAllocator);
     device->funcs.p_vkDestroySwapchainKHR(device->device, swapchain, NULL);
 }

-static VkResult WINAPI wine_vkDeviceWaitIdle(VkDevice device)
+VkResult WINAPI wine_vkDeviceWaitIdle(VkDevice device)
 {
     TRACE("%p\n", device);
     return device->funcs.p_vkDeviceWaitIdle(device->device);
 }

-static VkResult WINAPI wine_vkEndCommandBuffer(VkCommandBuffer commandBuffer)
+VkResult WINAPI wine_vkEndCommandBuffer(VkCommandBuffer commandBuffer)
 {
     TRACE("%p\n", commandBuffer);
     return commandBuffer->device->funcs.p_vkEndCommandBuffer(commandBuffer->command_buffer);
 }

-static VkResult WINAPI wine_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
+VkResult WINAPI wine_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
 {
     TRACE("%p, %p, %p\n", physicalDevice, pPropertyCount, pProperties);
     return physicalDevice->instance->funcs.p_vkEnumerateDeviceLayerProperties(physicalDevice->phys_dev, pPropertyCount, pProperties);
 }

-static VkResult WINAPI wine_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
+VkResult WINAPI wine_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -1815,19 +1815,19 @@ static VkResult WINAPI wine_vkFlushMappedMemoryRanges(VkDevice device, uint32_t
 #endif
 }

-static VkResult WINAPI wine_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
+VkResult WINAPI wine_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
 {
     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(descriptorPool), descriptorSetCount, pDescriptorSets);
     return device->funcs.p_vkFreeDescriptorSets(device->device, descriptorPool, descriptorSetCount, pDescriptorSets);
 }

-static void WINAPI wine_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(memory), pAllocator);
     device->funcs.p_vkFreeMemory(device->device, memory, NULL);
 }

-static void WINAPI wine_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
+void WINAPI wine_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkMemoryRequirements_host pMemoryRequirements_host;
@@ -1842,25 +1842,25 @@ static void WINAPI wine_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer
 #endif
 }

-static void WINAPI wine_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
+void WINAPI wine_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(memory), pCommittedMemoryInBytes);
     device->funcs.p_vkGetDeviceMemoryCommitment(device->device, memory, pCommittedMemoryInBytes);
 }

-static VkResult WINAPI wine_vkGetEventStatus(VkDevice device, VkEvent event)
+VkResult WINAPI wine_vkGetEventStatus(VkDevice device, VkEvent event)
 {
     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
     return device->funcs.p_vkGetEventStatus(device->device, event);
 }

-static VkResult WINAPI wine_vkGetFenceStatus(VkDevice device, VkFence fence)
+VkResult WINAPI wine_vkGetFenceStatus(VkDevice device, VkFence fence)
 {
     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(fence));
     return device->funcs.p_vkGetFenceStatus(device->device, fence);
 }

-static void WINAPI wine_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
+void WINAPI wine_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkMemoryRequirements_host pMemoryRequirements_host;
@@ -1875,13 +1875,13 @@ static void WINAPI wine_vkGetImageMemoryRequirements(VkDevice device, VkImage im
 #endif
 }

-static void WINAPI wine_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
+void WINAPI wine_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
 {
     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSparseMemoryRequirementCount, pSparseMemoryRequirements);
     device->funcs.p_vkGetImageSparseMemoryRequirements(device->device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 }

-static void WINAPI wine_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
+void WINAPI wine_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkSubresourceLayout_host pLayout_host;
@@ -1896,7 +1896,7 @@ static void WINAPI wine_vkGetImageSubresourceLayout(VkDevice device, VkImage ima
 #endif
 }

-static void WINAPI wine_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
+void WINAPI wine_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
 {
     TRACE("%p, %p\n", physicalDevice, pFeatures);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures(physicalDevice->phys_dev, pFeatures);
@@ -1908,7 +1908,7 @@ static void WINAPI wine_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physica
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(physicalDevice->phys_dev, pFeatures);
 }

-static void WINAPI wine_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
+void WINAPI wine_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
 {
     TRACE("%p, %d, %p\n", physicalDevice, format, pFormatProperties);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(physicalDevice->phys_dev, format, pFormatProperties);
@@ -1920,7 +1920,7 @@ static void WINAPI wine_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice->phys_dev, format, pFormatProperties);
 }

-static VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
+VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -1955,7 +1955,7 @@ static VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysi
 #endif
 }

-static void WINAPI wine_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
+void WINAPI wine_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkPhysicalDeviceMemoryProperties_host pMemoryProperties_host;
@@ -1986,7 +1986,7 @@ static void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice
 #endif
 }

-static void WINAPI wine_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
+void WINAPI wine_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkPhysicalDeviceProperties_host pProperties_host;
@@ -2017,7 +2017,7 @@ static void WINAPI wine_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physi
 #endif
 }

-static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
+void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
 {
     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
@@ -2029,7 +2029,7 @@ static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalD
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
 }

-static void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
+void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
 {
     TRACE("%p, %d, %d, %d, %#x, %d, %p, %p\n", physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice->phys_dev, format, type, samples, usage, tiling, pPropertyCount, pProperties);
@@ -2041,61 +2041,61 @@ static void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhy
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice->phys_dev, pFormatInfo, pPropertyCount, pProperties);
 }

-static VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
+VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
 {
     TRACE("%p, 0x%s, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pSurfaceCapabilities);
     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice->phys_dev, surface, pSurfaceCapabilities);
 }

-static VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
+VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
 {
     TRACE("%p, 0x%s, %p, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pSurfaceFormatCount, pSurfaceFormats);
     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice->phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats);
 }

-static VkResult WINAPI wine_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
+VkResult WINAPI wine_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
 {
     TRACE("%p, 0x%s, %p, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pPresentModeCount, pPresentModes);
     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice->phys_dev, surface, pPresentModeCount, pPresentModes);
 }

-static VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
+VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
 {
     TRACE("%p, %u, 0x%s, %p\n", physicalDevice, queueFamilyIndex, wine_dbgstr_longlong(surface), pSupported);
     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice->phys_dev, queueFamilyIndex, surface, pSupported);
 }

-static VkBool32 WINAPI wine_vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
+VkBool32 WINAPI wine_vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
 {
     TRACE("%p, %u\n", physicalDevice, queueFamilyIndex);
     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice->phys_dev, queueFamilyIndex);
 }

-static VkResult WINAPI wine_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
+VkResult WINAPI wine_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
 {
     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), pDataSize, pData);
     return device->funcs.p_vkGetPipelineCacheData(device->device, pipelineCache, pDataSize, pData);
 }

-static VkResult WINAPI wine_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
+VkResult WINAPI wine_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
 {
     TRACE("%p, 0x%s, %u, %u, 0x%s, %p, 0x%s, %#x\n", device, wine_dbgstr_longlong(queryPool), firstQuery, queryCount, wine_dbgstr_longlong(dataSize), pData, wine_dbgstr_longlong(stride), flags);
     return device->funcs.p_vkGetQueryPoolResults(device->device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
 }

-static void WINAPI wine_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
+void WINAPI wine_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pGranularity);
     device->funcs.p_vkGetRenderAreaGranularity(device->device, renderPass, pGranularity);
 }

-static VkResult WINAPI wine_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
+VkResult WINAPI wine_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
 {
     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(swapchain), pSwapchainImageCount, pSwapchainImages);
     return device->funcs.p_vkGetSwapchainImagesKHR(device->device, swapchain, pSwapchainImageCount, pSwapchainImages);
 }

-static VkResult WINAPI wine_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
+VkResult WINAPI wine_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -2113,19 +2113,19 @@ static VkResult WINAPI wine_vkInvalidateMappedMemoryRanges(VkDevice device, uint
 #endif
 }

-static VkResult WINAPI wine_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
+VkResult WINAPI wine_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, %#x, %p\n", device, wine_dbgstr_longlong(memory), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(size), flags, ppData);
     return device->funcs.p_vkMapMemory(device->device, memory, offset, size, flags, ppData);
 }

-static VkResult WINAPI wine_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
+VkResult WINAPI wine_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
 {
     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(dstCache), srcCacheCount, pSrcCaches);
     return device->funcs.p_vkMergePipelineCaches(device->device, dstCache, srcCacheCount, pSrcCaches);
 }

-static VkResult WINAPI wine_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
+VkResult WINAPI wine_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -2143,49 +2143,49 @@ static VkResult WINAPI wine_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCo
 #endif
 }

-static VkResult WINAPI wine_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
+VkResult WINAPI wine_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
 {
     TRACE("%p, %p\n", queue, pPresentInfo);
     return queue->device->funcs.p_vkQueuePresentKHR(queue->queue, pPresentInfo);
 }

-static VkResult WINAPI wine_vkQueueWaitIdle(VkQueue queue)
+VkResult WINAPI wine_vkQueueWaitIdle(VkQueue queue)
 {
     TRACE("%p\n", queue);
     return queue->device->funcs.p_vkQueueWaitIdle(queue->queue);
 }

-static VkResult WINAPI wine_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
+VkResult WINAPI wine_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
 {
     TRACE("%p, %#x\n", commandBuffer, flags);
     return commandBuffer->device->funcs.p_vkResetCommandBuffer(commandBuffer->command_buffer, flags);
 }

-static VkResult WINAPI wine_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+VkResult WINAPI wine_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
 {
     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
     return device->funcs.p_vkResetCommandPool(device->device, commandPool, flags);
 }

-static VkResult WINAPI wine_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+VkResult WINAPI wine_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
 {
     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(descriptorPool), flags);
     return device->funcs.p_vkResetDescriptorPool(device->device, descriptorPool, flags);
 }

-static VkResult WINAPI wine_vkResetEvent(VkDevice device, VkEvent event)
+VkResult WINAPI wine_vkResetEvent(VkDevice device, VkEvent event)
 {
     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
     return device->funcs.p_vkResetEvent(device->device, event);
 }

-static VkResult WINAPI wine_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
+VkResult WINAPI wine_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
 {
     TRACE("%p, %u, %p\n", device, fenceCount, pFences);
     return device->funcs.p_vkResetFences(device->device, fenceCount, pFences);
 }

-static VkResult WINAPI wine_vkSetEvent(VkDevice device, VkEvent event)
+VkResult WINAPI wine_vkSetEvent(VkDevice device, VkEvent event)
 {
     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
     return device->funcs.p_vkSetEvent(device->device, event);
@@ -2197,7 +2197,7 @@ static void WINAPI wine_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool comm
     device->funcs.p_vkTrimCommandPoolKHR(device->device, commandPool, flags);
 }

-static void WINAPI wine_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
+void WINAPI wine_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
 {
     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(memory));
     device->funcs.p_vkUnmapMemory(device->device, memory);
@@ -2209,7 +2209,7 @@ static void WINAPI wine_vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, Vk
     device->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(device->device, descriptorSet, descriptorUpdateTemplate, pData);
 }

-static void WINAPI wine_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
+void WINAPI wine_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkWriteDescriptorSet_host *pDescriptorWrites_host;
@@ -2228,7 +2228,7 @@ static void WINAPI wine_vkUpdateDescriptorSets(VkDevice device, uint32_t descrip
 #endif
 }

-static VkResult WINAPI wine_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
+VkResult WINAPI wine_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
 {
     TRACE("%p, %u, %p, %u, 0x%s\n", device, fenceCount, pFences, waitAll, wine_dbgstr_longlong(timeout));
     return device->funcs.p_vkWaitForFences(device->device, fenceCount, pFences, waitAll, timeout);
diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h
index fb9afdf524..30a53aca77 100644
--- a/dlls/winevulkan/vulkan_thunks.h
+++ b/dlls/winevulkan/vulkan_thunks.h
@@ -16,17 +16,17 @@ BOOL wine_vk_device_extension_supported(const char *name) DECLSPEC_HIDDEN;
 BOOL wine_vk_instance_extension_supported(const char *name) DECLSPEC_HIDDEN;

/* Functions for which we have custom implementations outside of the thunks. */
-VkResult WINAPI wine_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers) DECLSPEC_HIDDEN;
-void WINAPI wine_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) DECLSPEC_HIDDEN;
-VkResult WINAPI wine_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) DECLSPEC_HIDDEN;
-void WINAPI wine_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) DECLSPEC_HIDDEN;
-void WINAPI wine_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) DECLSPEC_HIDDEN;
-VkResult WINAPI wine_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) DECLSPEC_HIDDEN;
-VkResult WINAPI wine_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices) DECLSPEC_HIDDEN;
-void WINAPI wine_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) DECLSPEC_HIDDEN;
-PFN_vkVoidFunction WINAPI wine_vkGetDeviceProcAddr(VkDevice device, const char *pName) DECLSPEC_HIDDEN;
-void WINAPI wine_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) DECLSPEC_HIDDEN;
-VkResult WINAPI wine_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) DECLSPEC_HIDDEN;
+VkResult WINAPI wine_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers);
+void WINAPI wine_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers);
+VkResult WINAPI wine_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice);
+void WINAPI wine_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator);
+void WINAPI wine_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator);
+VkResult WINAPI wine_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties);
+VkResult WINAPI wine_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices);
+void WINAPI wine_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers);
+PFN_vkVoidFunction WINAPI wine_vkGetDeviceProcAddr(VkDevice device, const char *pName);
+void WINAPI wine_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue);
+VkResult WINAPI wine_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence);

typedef struct VkCommandBufferAllocateInfo_host
 {
diff --git a/dlls/winevulkan/winevulkan.spec b/dlls/winevulkan/winevulkan.spec
index 8b87834041..3f96413f5c 100644
--- a/dlls/winevulkan/winevulkan.spec
+++ b/dlls/winevulkan/winevulkan.spec
@@ -1,2 +1,160 @@
+# Automatically generated from Vulkan vk.xml; DO NOT EDIT!
+
 @ stdcall vk_icdGetInstanceProcAddr(ptr str) wine_vk_icdGetInstanceProcAddr
 @ stdcall vk_icdNegotiateLoaderICDInterfaceVersion(ptr) wine_vk_icdNegotiateLoaderICDInterfaceVersion
+@ stdcall wine_vkAcquireNextImageKHR(ptr int64 int64 int64 int64 ptr)
+@ stdcall wine_vkAllocateCommandBuffers(ptr ptr ptr)
+@ stdcall wine_vkAllocateDescriptorSets(ptr ptr ptr)
+@ stdcall wine_vkAllocateMemory(ptr ptr ptr ptr)
+@ stdcall wine_vkBeginCommandBuffer(ptr ptr)
+@ stdcall wine_vkBindBufferMemory(ptr int64 int64 int64)
+@ stdcall wine_vkBindImageMemory(ptr int64 int64 int64)
+@ stdcall wine_vkCmdBeginQuery(ptr int64 long long)
+@ stdcall wine_vkCmdBeginRenderPass(ptr ptr long)
+@ stdcall wine_vkCmdBindDescriptorSets(ptr long int64 long long ptr long ptr)
+@ stdcall wine_vkCmdBindIndexBuffer(ptr int64 int64 long)
+@ stdcall wine_vkCmdBindPipeline(ptr long int64)
+@ stdcall wine_vkCmdBindVertexBuffers(ptr long long ptr ptr)
+@ stdcall wine_vkCmdBlitImage(ptr int64 long int64 long long ptr long)
+@ stdcall wine_vkCmdClearAttachments(ptr long ptr long ptr)
+@ stdcall wine_vkCmdClearColorImage(ptr int64 long ptr long ptr)
+@ stdcall wine_vkCmdClearDepthStencilImage(ptr int64 long ptr long ptr)
+@ stdcall wine_vkCmdCopyBuffer(ptr int64 int64 long ptr)
+@ stdcall wine_vkCmdCopyBufferToImage(ptr int64 int64 long long ptr)
+@ stdcall wine_vkCmdCopyImage(ptr int64 long int64 long long ptr)
+@ stdcall wine_vkCmdCopyImageToBuffer(ptr int64 long int64 long ptr)
+@ stdcall wine_vkCmdCopyQueryPoolResults(ptr int64 long long int64 int64 int64 long)
+@ stdcall wine_vkCmdDispatch(ptr long long long)
+@ stdcall wine_vkCmdDispatchIndirect(ptr int64 int64)
+@ stdcall wine_vkCmdDraw(ptr long long long long)
+@ stdcall wine_vkCmdDrawIndexed(ptr long long long long long)
+@ stdcall wine_vkCmdDrawIndexedIndirect(ptr int64 int64 long long)
+@ stdcall wine_vkCmdDrawIndirect(ptr int64 int64 long long)
+@ stdcall wine_vkCmdEndQuery(ptr int64 long)
+@ stdcall wine_vkCmdEndRenderPass(ptr)
+@ stdcall wine_vkCmdExecuteCommands(ptr long ptr)
+@ stdcall wine_vkCmdFillBuffer(ptr int64 int64 int64 long)
+@ stdcall wine_vkCmdNextSubpass(ptr long)
+@ stdcall wine_vkCmdPipelineBarrier(ptr long long long long ptr long ptr long ptr)
+@ stdcall wine_vkCmdPushConstants(ptr int64 long long long ptr)
+@ stdcall wine_vkCmdResetEvent(ptr int64 long)
+@ stdcall wine_vkCmdResetQueryPool(ptr int64 long long)
+@ stdcall wine_vkCmdResolveImage(ptr int64 long int64 long long ptr)
+@ stdcall wine_vkCmdSetBlendConstants(ptr ptr)
+@ stdcall wine_vkCmdSetDepthBias(ptr float float float)
+@ stdcall wine_vkCmdSetDepthBounds(ptr float float)
+@ stdcall wine_vkCmdSetEvent(ptr int64 long)
+@ stdcall wine_vkCmdSetLineWidth(ptr float)
+@ stdcall wine_vkCmdSetScissor(ptr long long ptr)
+@ stdcall wine_vkCmdSetStencilCompareMask(ptr long long)
+@ stdcall wine_vkCmdSetStencilReference(ptr long long)
+@ stdcall wine_vkCmdSetStencilWriteMask(ptr long long)
+@ stdcall wine_vkCmdSetViewport(ptr long long ptr)
+@ stdcall wine_vkCmdUpdateBuffer(ptr int64 int64 int64 ptr)
+@ stdcall wine_vkCmdWaitEvents(ptr long ptr long long long ptr long ptr long ptr)
+@ stdcall wine_vkCmdWriteTimestamp(ptr long int64 long)
+@ stdcall wine_vkCreateBuffer(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateBufferView(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateCommandPool(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateComputePipelines(ptr int64 long ptr ptr ptr)
+@ stdcall wine_vkCreateDescriptorPool(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateDescriptorSetLayout(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateDevice(ptr ptr ptr ptr)
+@ stub vkCreateDisplayModeKHR
+@ stub vkCreateDisplayPlaneSurfaceKHR
+@ stdcall wine_vkCreateEvent(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateFence(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateFramebuffer(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateGraphicsPipelines(ptr int64 long ptr ptr ptr)
+@ stdcall wine_vkCreateImage(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateImageView(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateInstance(ptr ptr ptr)
+@ stdcall wine_vkCreatePipelineCache(ptr ptr ptr ptr)
+@ stdcall wine_vkCreatePipelineLayout(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateQueryPool(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateRenderPass(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateSampler(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateSemaphore(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateShaderModule(ptr ptr ptr ptr)
+@ stub vkCreateSharedSwapchainsKHR
+@ stdcall wine_vkCreateSwapchainKHR(ptr ptr ptr ptr)
+@ stdcall wine_vkCreateWin32SurfaceKHR(ptr ptr ptr ptr)
+@ stdcall wine_vkDestroyBuffer(ptr int64 ptr)
+@ stdcall wine_vkDestroyBufferView(ptr int64 ptr)
+@ stdcall wine_vkDestroyCommandPool(ptr int64 ptr)
+@ stdcall wine_vkDestroyDescriptorPool(ptr int64 ptr)
+@ stdcall wine_vkDestroyDescriptorSetLayout(ptr int64 ptr)
+@ stdcall wine_vkDestroyDevice(ptr ptr)
+@ stdcall wine_vkDestroyEvent(ptr int64 ptr)
+@ stdcall wine_vkDestroyFence(ptr int64 ptr)
+@ stdcall wine_vkDestroyFramebuffer(ptr int64 ptr)
+@ stdcall wine_vkDestroyImage(ptr int64 ptr)
+@ stdcall wine_vkDestroyImageView(ptr int64 ptr)
+@ stdcall wine_vkDestroyInstance(ptr ptr)
+@ stdcall wine_vkDestroyPipeline(ptr int64 ptr)
+@ stdcall wine_vkDestroyPipelineCache(ptr int64 ptr)
+@ stdcall wine_vkDestroyPipelineLayout(ptr int64 ptr)
+@ stdcall wine_vkDestroyQueryPool(ptr int64 ptr)
+@ stdcall wine_vkDestroyRenderPass(ptr int64 ptr)
+@ stdcall wine_vkDestroySampler(ptr int64 ptr)
+@ stdcall wine_vkDestroySemaphore(ptr int64 ptr)
+@ stdcall wine_vkDestroyShaderModule(ptr int64 ptr)
+@ stdcall wine_vkDestroySurfaceKHR(ptr int64 ptr)
+@ stdcall wine_vkDestroySwapchainKHR(ptr int64 ptr)
+@ stdcall wine_vkDeviceWaitIdle(ptr)
+@ stdcall wine_vkEndCommandBuffer(ptr)
+@ stdcall wine_vkEnumerateDeviceExtensionProperties(ptr str ptr ptr)
+@ stdcall wine_vkEnumerateDeviceLayerProperties(ptr ptr ptr)
+@ stdcall wine_vkEnumerateInstanceExtensionProperties(str ptr ptr)
+@ stdcall wine_vkEnumeratePhysicalDevices(ptr ptr ptr)
+@ stdcall wine_vkFlushMappedMemoryRanges(ptr long ptr)
+@ stdcall wine_vkFreeCommandBuffers(ptr int64 long ptr)
+@ stdcall wine_vkFreeDescriptorSets(ptr int64 long ptr)
+@ stdcall wine_vkFreeMemory(ptr int64 ptr)
+@ stdcall wine_vkGetBufferMemoryRequirements(ptr int64 ptr)
+@ stdcall wine_vkGetDeviceMemoryCommitment(ptr int64 ptr)
+@ stdcall wine_vkGetDeviceProcAddr(ptr str)
+@ stdcall wine_vkGetDeviceQueue(ptr long long ptr)
+@ stub vkGetDisplayModePropertiesKHR
+@ stub vkGetDisplayPlaneCapabilitiesKHR
+@ stub vkGetDisplayPlaneSupportedDisplaysKHR
+@ stdcall wine_vkGetEventStatus(ptr int64)
+@ stdcall wine_vkGetFenceStatus(ptr int64)
+@ stdcall wine_vkGetImageMemoryRequirements(ptr int64 ptr)
+@ stdcall wine_vkGetImageSparseMemoryRequirements(ptr int64 ptr ptr)
+@ stdcall wine_vkGetImageSubresourceLayout(ptr int64 ptr ptr)
+@ stdcall wine_vkGetInstanceProcAddr(ptr str)
+@ stub vkGetPhysicalDeviceDisplayPlanePropertiesKHR
+@ stub vkGetPhysicalDeviceDisplayPropertiesKHR
+@ stdcall wine_vkGetPhysicalDeviceFeatures(ptr ptr)
+@ stdcall wine_vkGetPhysicalDeviceFormatProperties(ptr long ptr)
+@ stdcall wine_vkGetPhysicalDeviceImageFormatProperties(ptr long long long long long ptr)
+@ stdcall wine_vkGetPhysicalDeviceMemoryProperties(ptr ptr)
+@ stdcall wine_vkGetPhysicalDeviceProperties(ptr ptr)
+@ stdcall wine_vkGetPhysicalDeviceQueueFamilyProperties(ptr ptr ptr)
+@ stdcall wine_vkGetPhysicalDeviceSparseImageFormatProperties(ptr long long long long long ptr ptr)
+@ stdcall wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ptr int64 ptr)
+@ stdcall wine_vkGetPhysicalDeviceSurfaceFormatsKHR(ptr int64 ptr ptr)
+@ stdcall wine_vkGetPhysicalDeviceSurfacePresentModesKHR(ptr int64 ptr long)
+@ stdcall wine_vkGetPhysicalDeviceSurfaceSupportKHR(ptr long int64 ptr)
+@ stdcall wine_vkGetPhysicalDeviceWin32PresentationSupportKHR(ptr long)
+@ stdcall wine_vkGetPipelineCacheData(ptr int64 ptr ptr)
+@ stdcall wine_vkGetQueryPoolResults(ptr int64 long long long ptr int64 long)
+@ stdcall wine_vkGetRenderAreaGranularity(ptr int64 ptr)
+@ stdcall wine_vkGetSwapchainImagesKHR(ptr int64 ptr ptr)
+@ stdcall wine_vkInvalidateMappedMemoryRanges(ptr long ptr)
+@ stdcall wine_vkMapMemory(ptr int64 int64 int64 long ptr)
+@ stdcall wine_vkMergePipelineCaches(ptr int64 long ptr)
+@ stdcall wine_vkQueueBindSparse(ptr long ptr int64)
+@ stdcall wine_vkQueuePresentKHR(ptr ptr)
+@ stdcall wine_vkQueueSubmit(ptr long ptr int64)
+@ stdcall wine_vkQueueWaitIdle(ptr)
+@ stdcall wine_vkResetCommandBuffer(ptr long)
+@ stdcall wine_vkResetCommandPool(ptr int64 long)
+@ stdcall wine_vkResetDescriptorPool(ptr int64 long)
+@ stdcall wine_vkResetEvent(ptr int64)
+@ stdcall wine_vkResetFences(ptr long ptr)
+@ stdcall wine_vkSetEvent(ptr int64)
+@ stdcall wine_vkUnmapMemory(ptr int64)
+@ stdcall wine_vkUpdateDescriptorSets(ptr long ptr long ptr)
+@ stdcall wine_vkWaitForFences(ptr long ptr long int64)

[PATCH 1/4] winevulkan: Export symbols for Core Vulkan functions.

[Józef Kucia]

Signed-off-by: Józef Kucia

[PATCH 2/4] vulkan-1: Add initial implementation.

[Roderick Colenbrander]

Signed-off-by: Roderick Colenbrander 
---
 configure.ac                |   1 +
 dlls/vulkan-1/Makefile.in   |   7 ++
 dlls/vulkan-1/version.rc    |  27 ++++++++
 dlls/vulkan-1/vulkan-1.spec | 159 ++++++++++++++++++++++++++++++++++++++++++++
 dlls/vulkan-1/vulkan.c      |  68 +++++++++++++++++++
 dlls/winevulkan/make_vulkan |  38 ++++++++++-
 6 files changed, 297 insertions(+), 3 deletions(-)
 create mode 100644 dlls/vulkan-1/Makefile.in
 create mode 100644 dlls/vulkan-1/version.rc
 create mode 100644 dlls/vulkan-1/vulkan-1.spec
 create mode 100644 dlls/vulkan-1/vulkan.c

diff --git a/configure.ac b/configure.ac
index 6a30601ca0..60c410c1f1 100644
--- a/configure.ac
+++ b/configure.ac
@@ -3692,6 +3692,7 @@ WINE_CONFIG_MAKEFILE(dlls/vnbt.vxd,enable_win16)
 WINE_CONFIG_MAKEFILE(dlls/vnetbios.vxd,enable_win16)
 WINE_CONFIG_MAKEFILE(dlls/vssapi)
 WINE_CONFIG_MAKEFILE(dlls/vtdapi.vxd,enable_win16)
+WINE_CONFIG_MAKEFILE(dlls/vulkan-1)
 WINE_CONFIG_MAKEFILE(dlls/vwin32.vxd,enable_win16)
 WINE_CONFIG_MAKEFILE(dlls/w32skrnl,enable_win16)
 WINE_CONFIG_MAKEFILE(dlls/w32sys.dll16,enable_win16)
diff --git a/dlls/vulkan-1/Makefile.in b/dlls/vulkan-1/Makefile.in
new file mode 100644
index 0000000000..4bb8cec412
--- /dev/null
+++ b/dlls/vulkan-1/Makefile.in
@@ -0,0 +1,7 @@
+MODULE    = vulkan-1.dll
+IMPORTS   = winevulkan
+
+C_SRCS = \
+	vulkan.c
+
+RC_SRCS = version.rc
diff --git a/dlls/vulkan-1/version.rc b/dlls/vulkan-1/version.rc
new file mode 100644
index 0000000000..ec75462ddf
--- /dev/null
+++ b/dlls/vulkan-1/version.rc
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2018 Roderick Colenbrander
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "config.h" /* Needed to get PACKAGE_VERSION */
+
+#define WINE_FILEDESCRIPTION_STR "Wine Vulkan Loader"
+#define WINE_FILENAME_STR "vulkan-1.dll"
+#define WINE_FILEVERSION_STR PACKAGE_VERSION
+#define WINE_PRODUCTVERSION_STR PACKAGE_VERSION
+#define WINE_PRODUCTNAME_STR "Wine Vulkan"
+
+#include "wine/wine_common_ver.rc"
diff --git a/dlls/vulkan-1/vulkan-1.spec b/dlls/vulkan-1/vulkan-1.spec
new file mode 100644
index 0000000000..49af817d57
--- /dev/null
+++ b/dlls/vulkan-1/vulkan-1.spec
@@ -0,0 +1,159 @@
+# Automatically generated from Vulkan vk.xml; DO NOT EDIT!
+
+@ stdcall vkAcquireNextImageKHR(ptr int64 int64 int64 int64 ptr) winevulkan.wine_vkAcquireNextImageKHR
+@ stdcall vkAllocateCommandBuffers(ptr ptr ptr) winevulkan.wine_vkAllocateCommandBuffers
+@ stdcall vkAllocateDescriptorSets(ptr ptr ptr) winevulkan.wine_vkAllocateDescriptorSets
+@ stdcall vkAllocateMemory(ptr ptr ptr ptr) winevulkan.wine_vkAllocateMemory
+@ stdcall vkBeginCommandBuffer(ptr ptr) winevulkan.wine_vkBeginCommandBuffer
+@ stdcall vkBindBufferMemory(ptr int64 int64 int64) winevulkan.wine_vkBindBufferMemory
+@ stdcall vkBindImageMemory(ptr int64 int64 int64) winevulkan.wine_vkBindImageMemory
+@ stdcall vkCmdBeginQuery(ptr int64 long long) winevulkan.wine_vkCmdBeginQuery
+@ stdcall vkCmdBeginRenderPass(ptr ptr long) winevulkan.wine_vkCmdBeginRenderPass
+@ stdcall vkCmdBindDescriptorSets(ptr long int64 long long ptr long ptr) winevulkan.wine_vkCmdBindDescriptorSets
+@ stdcall vkCmdBindIndexBuffer(ptr int64 int64 long) winevulkan.wine_vkCmdBindIndexBuffer
+@ stdcall vkCmdBindPipeline(ptr long int64) winevulkan.wine_vkCmdBindPipeline
+@ stdcall vkCmdBindVertexBuffers(ptr long long ptr ptr) winevulkan.wine_vkCmdBindVertexBuffers
+@ stdcall vkCmdBlitImage(ptr int64 long int64 long long ptr long) winevulkan.wine_vkCmdBlitImage
+@ stdcall vkCmdClearAttachments(ptr long ptr long ptr) winevulkan.wine_vkCmdClearAttachments
+@ stdcall vkCmdClearColorImage(ptr int64 long ptr long ptr) winevulkan.wine_vkCmdClearColorImage
+@ stdcall vkCmdClearDepthStencilImage(ptr int64 long ptr long ptr) winevulkan.wine_vkCmdClearDepthStencilImage
+@ stdcall vkCmdCopyBuffer(ptr int64 int64 long ptr) winevulkan.wine_vkCmdCopyBuffer
+@ stdcall vkCmdCopyBufferToImage(ptr int64 int64 long long ptr) winevulkan.wine_vkCmdCopyBufferToImage
+@ stdcall vkCmdCopyImage(ptr int64 long int64 long long ptr) winevulkan.wine_vkCmdCopyImage
+@ stdcall vkCmdCopyImageToBuffer(ptr int64 long int64 long ptr) winevulkan.wine_vkCmdCopyImageToBuffer
+@ stdcall vkCmdCopyQueryPoolResults(ptr int64 long long int64 int64 int64 long) winevulkan.wine_vkCmdCopyQueryPoolResults
+@ stdcall vkCmdDispatch(ptr long long long) winevulkan.wine_vkCmdDispatch
+@ stdcall vkCmdDispatchIndirect(ptr int64 int64) winevulkan.wine_vkCmdDispatchIndirect
+@ stdcall vkCmdDraw(ptr long long long long) winevulkan.wine_vkCmdDraw
+@ stdcall vkCmdDrawIndexed(ptr long long long long long) winevulkan.wine_vkCmdDrawIndexed
+@ stdcall vkCmdDrawIndexedIndirect(ptr int64 int64 long long) winevulkan.wine_vkCmdDrawIndexedIndirect
+@ stdcall vkCmdDrawIndirect(ptr int64 int64 long long) winevulkan.wine_vkCmdDrawIndirect
+@ stdcall vkCmdEndQuery(ptr int64 long) winevulkan.wine_vkCmdEndQuery
+@ stdcall vkCmdEndRenderPass(ptr) winevulkan.wine_vkCmdEndRenderPass
+@ stdcall vkCmdExecuteCommands(ptr long ptr) winevulkan.wine_vkCmdExecuteCommands
+@ stdcall vkCmdFillBuffer(ptr int64 int64 int64 long) winevulkan.wine_vkCmdFillBuffer
+@ stdcall vkCmdNextSubpass(ptr long) winevulkan.wine_vkCmdNextSubpass
+@ stdcall vkCmdPipelineBarrier(ptr long long long long ptr long ptr long ptr) winevulkan.wine_vkCmdPipelineBarrier
+@ stdcall vkCmdPushConstants(ptr int64 long long long ptr) winevulkan.wine_vkCmdPushConstants
+@ stdcall vkCmdResetEvent(ptr int64 long) winevulkan.wine_vkCmdResetEvent
+@ stdcall vkCmdResetQueryPool(ptr int64 long long) winevulkan.wine_vkCmdResetQueryPool
+@ stdcall vkCmdResolveImage(ptr int64 long int64 long long ptr) winevulkan.wine_vkCmdResolveImage
+@ stdcall vkCmdSetBlendConstants(ptr ptr) winevulkan.wine_vkCmdSetBlendConstants
+@ stdcall vkCmdSetDepthBias(ptr float float float) winevulkan.wine_vkCmdSetDepthBias
+@ stdcall vkCmdSetDepthBounds(ptr float float) winevulkan.wine_vkCmdSetDepthBounds
+@ stdcall vkCmdSetEvent(ptr int64 long) winevulkan.wine_vkCmdSetEvent
+@ stdcall vkCmdSetLineWidth(ptr float) winevulkan.wine_vkCmdSetLineWidth
+@ stdcall vkCmdSetScissor(ptr long long ptr) winevulkan.wine_vkCmdSetScissor
+@ stdcall vkCmdSetStencilCompareMask(ptr long long) winevulkan.wine_vkCmdSetStencilCompareMask
+@ stdcall vkCmdSetStencilReference(ptr long long) winevulkan.wine_vkCmdSetStencilReference
+@ stdcall vkCmdSetStencilWriteMask(ptr long long) winevulkan.wine_vkCmdSetStencilWriteMask
+@ stdcall vkCmdSetViewport(ptr long long ptr) winevulkan.wine_vkCmdSetViewport
+@ stdcall vkCmdUpdateBuffer(ptr int64 int64 int64 ptr) winevulkan.wine_vkCmdUpdateBuffer
+@ stdcall vkCmdWaitEvents(ptr long ptr long long long ptr long ptr long ptr) winevulkan.wine_vkCmdWaitEvents
+@ stdcall vkCmdWriteTimestamp(ptr long int64 long) winevulkan.wine_vkCmdWriteTimestamp
+@ stdcall vkCreateBuffer(ptr ptr ptr ptr) winevulkan.wine_vkCreateBuffer
+@ stdcall vkCreateBufferView(ptr ptr ptr ptr) winevulkan.wine_vkCreateBufferView
+@ stdcall vkCreateCommandPool(ptr ptr ptr ptr) winevulkan.wine_vkCreateCommandPool
+@ stdcall vkCreateComputePipelines(ptr int64 long ptr ptr ptr) winevulkan.wine_vkCreateComputePipelines
+@ stdcall vkCreateDescriptorPool(ptr ptr ptr ptr) winevulkan.wine_vkCreateDescriptorPool
+@ stdcall vkCreateDescriptorSetLayout(ptr ptr ptr ptr) winevulkan.wine_vkCreateDescriptorSetLayout
+@ stdcall vkCreateDevice(ptr ptr ptr ptr) winevulkan.wine_vkCreateDevice
+@ stub vkCreateDisplayModeKHR
+@ stub vkCreateDisplayPlaneSurfaceKHR
+@ stdcall vkCreateEvent(ptr ptr ptr ptr) winevulkan.wine_vkCreateEvent
+@ stdcall vkCreateFence(ptr ptr ptr ptr) winevulkan.wine_vkCreateFence
+@ stdcall vkCreateFramebuffer(ptr ptr ptr ptr) winevulkan.wine_vkCreateFramebuffer
+@ stdcall vkCreateGraphicsPipelines(ptr int64 long ptr ptr ptr) winevulkan.wine_vkCreateGraphicsPipelines
+@ stdcall vkCreateImage(ptr ptr ptr ptr) winevulkan.wine_vkCreateImage
+@ stdcall vkCreateImageView(ptr ptr ptr ptr) winevulkan.wine_vkCreateImageView
+@ stdcall vkCreateInstance(ptr ptr ptr) winevulkan.wine_vkCreateInstance
+@ stdcall vkCreatePipelineCache(ptr ptr ptr ptr) winevulkan.wine_vkCreatePipelineCache
+@ stdcall vkCreatePipelineLayout(ptr ptr ptr ptr) winevulkan.wine_vkCreatePipelineLayout
+@ stdcall vkCreateQueryPool(ptr ptr ptr ptr) winevulkan.wine_vkCreateQueryPool
+@ stdcall vkCreateRenderPass(ptr ptr ptr ptr) winevulkan.wine_vkCreateRenderPass
+@ stdcall vkCreateSampler(ptr ptr ptr ptr) winevulkan.wine_vkCreateSampler
+@ stdcall vkCreateSemaphore(ptr ptr ptr ptr) winevulkan.wine_vkCreateSemaphore
+@ stdcall vkCreateShaderModule(ptr ptr ptr ptr) winevulkan.wine_vkCreateShaderModule
+@ stub vkCreateSharedSwapchainsKHR
+@ stdcall vkCreateSwapchainKHR(ptr ptr ptr ptr) winevulkan.wine_vkCreateSwapchainKHR
+@ stdcall vkCreateWin32SurfaceKHR(ptr ptr ptr ptr) winevulkan.wine_vkCreateWin32SurfaceKHR
+@ stdcall vkDestroyBuffer(ptr int64 ptr) winevulkan.wine_vkDestroyBuffer
+@ stdcall vkDestroyBufferView(ptr int64 ptr) winevulkan.wine_vkDestroyBufferView
+@ stdcall vkDestroyCommandPool(ptr int64 ptr) winevulkan.wine_vkDestroyCommandPool
+@ stdcall vkDestroyDescriptorPool(ptr int64 ptr) winevulkan.wine_vkDestroyDescriptorPool
+@ stdcall vkDestroyDescriptorSetLayout(ptr int64 ptr) winevulkan.wine_vkDestroyDescriptorSetLayout
+@ stdcall vkDestroyDevice(ptr ptr) winevulkan.wine_vkDestroyDevice
+@ stdcall vkDestroyEvent(ptr int64 ptr) winevulkan.wine_vkDestroyEvent
+@ stdcall vkDestroyFence(ptr int64 ptr) winevulkan.wine_vkDestroyFence
+@ stdcall vkDestroyFramebuffer(ptr int64 ptr) winevulkan.wine_vkDestroyFramebuffer
+@ stdcall vkDestroyImage(ptr int64 ptr) winevulkan.wine_vkDestroyImage
+@ stdcall vkDestroyImageView(ptr int64 ptr) winevulkan.wine_vkDestroyImageView
+@ stdcall vkDestroyInstance(ptr ptr) winevulkan.wine_vkDestroyInstance
+@ stdcall vkDestroyPipeline(ptr int64 ptr) winevulkan.wine_vkDestroyPipeline
+@ stdcall vkDestroyPipelineCache(ptr int64 ptr) winevulkan.wine_vkDestroyPipelineCache
+@ stdcall vkDestroyPipelineLayout(ptr int64 ptr) winevulkan.wine_vkDestroyPipelineLayout
+@ stdcall vkDestroyQueryPool(ptr int64 ptr) winevulkan.wine_vkDestroyQueryPool
+@ stdcall vkDestroyRenderPass(ptr int64 ptr) winevulkan.wine_vkDestroyRenderPass
+@ stdcall vkDestroySampler(ptr int64 ptr) winevulkan.wine_vkDestroySampler
+@ stdcall vkDestroySemaphore(ptr int64 ptr) winevulkan.wine_vkDestroySemaphore
+@ stdcall vkDestroyShaderModule(ptr int64 ptr) winevulkan.wine_vkDestroyShaderModule
+@ stdcall vkDestroySurfaceKHR(ptr int64 ptr) winevulkan.wine_vkDestroySurfaceKHR
+@ stdcall vkDestroySwapchainKHR(ptr int64 ptr) winevulkan.wine_vkDestroySwapchainKHR
+@ stdcall vkDeviceWaitIdle(ptr) winevulkan.wine_vkDeviceWaitIdle
+@ stdcall vkEndCommandBuffer(ptr) winevulkan.wine_vkEndCommandBuffer
+@ stdcall vkEnumerateDeviceExtensionProperties(ptr str ptr ptr) winevulkan.wine_vkEnumerateDeviceExtensionProperties
+@ stdcall vkEnumerateDeviceLayerProperties(ptr ptr ptr) winevulkan.wine_vkEnumerateDeviceLayerProperties
+@ stdcall vkEnumerateInstanceExtensionProperties(str ptr ptr)
+@ stdcall vkEnumerateInstanceLayerProperties(ptr ptr)
+@ stdcall vkEnumeratePhysicalDevices(ptr ptr ptr) winevulkan.wine_vkEnumeratePhysicalDevices
+@ stdcall vkFlushMappedMemoryRanges(ptr long ptr) winevulkan.wine_vkFlushMappedMemoryRanges
+@ stdcall vkFreeCommandBuffers(ptr int64 long ptr) winevulkan.wine_vkFreeCommandBuffers
+@ stdcall vkFreeDescriptorSets(ptr int64 long ptr) winevulkan.wine_vkFreeDescriptorSets
+@ stdcall vkFreeMemory(ptr int64 ptr) winevulkan.wine_vkFreeMemory
+@ stdcall vkGetBufferMemoryRequirements(ptr int64 ptr) winevulkan.wine_vkGetBufferMemoryRequirements
+@ stdcall vkGetDeviceMemoryCommitment(ptr int64 ptr) winevulkan.wine_vkGetDeviceMemoryCommitment
+@ stdcall vkGetDeviceProcAddr(ptr str) winevulkan.wine_vkGetDeviceProcAddr
+@ stdcall vkGetDeviceQueue(ptr long long ptr) winevulkan.wine_vkGetDeviceQueue
+@ stub vkGetDisplayModePropertiesKHR
+@ stub vkGetDisplayPlaneCapabilitiesKHR
+@ stub vkGetDisplayPlaneSupportedDisplaysKHR
+@ stdcall vkGetEventStatus(ptr int64) winevulkan.wine_vkGetEventStatus
+@ stdcall vkGetFenceStatus(ptr int64) winevulkan.wine_vkGetFenceStatus
+@ stdcall vkGetImageMemoryRequirements(ptr int64 ptr) winevulkan.wine_vkGetImageMemoryRequirements
+@ stdcall vkGetImageSparseMemoryRequirements(ptr int64 ptr ptr) winevulkan.wine_vkGetImageSparseMemoryRequirements
+@ stdcall vkGetImageSubresourceLayout(ptr int64 ptr ptr) winevulkan.wine_vkGetImageSubresourceLayout
+@ stdcall vkGetInstanceProcAddr(ptr str)
+@ stub vkGetPhysicalDeviceDisplayPlanePropertiesKHR
+@ stub vkGetPhysicalDeviceDisplayPropertiesKHR
+@ stdcall vkGetPhysicalDeviceFeatures(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceFeatures
+@ stdcall vkGetPhysicalDeviceFormatProperties(ptr long ptr) winevulkan.wine_vkGetPhysicalDeviceFormatProperties
+@ stdcall vkGetPhysicalDeviceImageFormatProperties(ptr long long long long long ptr) winevulkan.wine_vkGetPhysicalDeviceImageFormatProperties
+@ stdcall vkGetPhysicalDeviceMemoryProperties(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceMemoryProperties
+@ stdcall vkGetPhysicalDeviceProperties(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceProperties
+@ stdcall vkGetPhysicalDeviceQueueFamilyProperties(ptr ptr ptr) winevulkan.wine_vkGetPhysicalDeviceQueueFamilyProperties
+@ stdcall vkGetPhysicalDeviceSparseImageFormatProperties(ptr long long long long long ptr ptr) winevulkan.wine_vkGetPhysicalDeviceSparseImageFormatProperties
+@ stdcall vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ptr int64 ptr) winevulkan.wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR
+@ stdcall vkGetPhysicalDeviceSurfaceFormatsKHR(ptr int64 ptr ptr) winevulkan.wine_vkGetPhysicalDeviceSurfaceFormatsKHR
+@ stdcall vkGetPhysicalDeviceSurfacePresentModesKHR(ptr int64 ptr long) winevulkan.wine_vkGetPhysicalDeviceSurfacePresentModesKHR
+@ stdcall vkGetPhysicalDeviceSurfaceSupportKHR(ptr long int64 ptr) winevulkan.wine_vkGetPhysicalDeviceSurfaceSupportKHR
+@ stdcall vkGetPhysicalDeviceWin32PresentationSupportKHR(ptr long) winevulkan.wine_vkGetPhysicalDeviceWin32PresentationSupportKHR
+@ stdcall vkGetPipelineCacheData(ptr int64 ptr ptr) winevulkan.wine_vkGetPipelineCacheData
+@ stdcall vkGetQueryPoolResults(ptr int64 long long long ptr int64 long) winevulkan.wine_vkGetQueryPoolResults
+@ stdcall vkGetRenderAreaGranularity(ptr int64 ptr) winevulkan.wine_vkGetRenderAreaGranularity
+@ stdcall vkGetSwapchainImagesKHR(ptr int64 ptr ptr) winevulkan.wine_vkGetSwapchainImagesKHR
+@ stdcall vkInvalidateMappedMemoryRanges(ptr long ptr) winevulkan.wine_vkInvalidateMappedMemoryRanges
+@ stdcall vkMapMemory(ptr int64 int64 int64 long ptr) winevulkan.wine_vkMapMemory
+@ stdcall vkMergePipelineCaches(ptr int64 long ptr) winevulkan.wine_vkMergePipelineCaches
+@ stdcall vkQueueBindSparse(ptr long ptr int64) winevulkan.wine_vkQueueBindSparse
+@ stdcall vkQueuePresentKHR(ptr ptr) winevulkan.wine_vkQueuePresentKHR
+@ stdcall vkQueueSubmit(ptr long ptr int64) winevulkan.wine_vkQueueSubmit
+@ stdcall vkQueueWaitIdle(ptr) winevulkan.wine_vkQueueWaitIdle
+@ stdcall vkResetCommandBuffer(ptr long) winevulkan.wine_vkResetCommandBuffer
+@ stdcall vkResetCommandPool(ptr int64 long) winevulkan.wine_vkResetCommandPool
+@ stdcall vkResetDescriptorPool(ptr int64 long) winevulkan.wine_vkResetDescriptorPool
+@ stdcall vkResetEvent(ptr int64) winevulkan.wine_vkResetEvent
+@ stdcall vkResetFences(ptr long ptr) winevulkan.wine_vkResetFences
+@ stdcall vkSetEvent(ptr int64) winevulkan.wine_vkSetEvent
+@ stdcall vkUnmapMemory(ptr int64) winevulkan.wine_vkUnmapMemory
+@ stdcall vkUpdateDescriptorSets(ptr long ptr long ptr) winevulkan.wine_vkUpdateDescriptorSets
+@ stdcall vkWaitForFences(ptr long ptr long int64) winevulkan.wine_vkWaitForFences
diff --git a/dlls/vulkan-1/vulkan.c b/dlls/vulkan-1/vulkan.c
new file mode 100644
index 0000000000..5f974eed52
--- /dev/null
+++ b/dlls/vulkan-1/vulkan.c
@@ -0,0 +1,68 @@
+/* Wine Vulkan loader implementation
+ *
+ * Copyright 2018 Roderick Colenbrander
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+
+#include "wine/debug.h"
+#include "wine/vulkan.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
+
+VkResult WINAPI vkEnumerateInstanceExtensionProperties(const char *layer_name,
+        uint32_t *count, VkExtensionProperties *properties)
+{
+    FIXME("stub: %p %p %p\n", layer_name, count, properties);
+    return VK_ERROR_OUT_OF_HOST_MEMORY;
+}
+
+VkResult WINAPI vkEnumerateInstanceLayerProperties(uint32_t *count,
+        VkLayerProperties *properties)
+{
+    TRACE("%p, %p\n", count, properties);
+
+    /* We don't support any layers. */
+    *count = 0;
+    return VK_SUCCESS;
+}
+
+PFN_vkVoidFunction WINAPI vkGetInstanceProcAddr(VkInstance instance, const char *name)
+{
+    FIXME("stub: %p %s\n", instance, debugstr_a(name));
+    return NULL;
+}
+
+BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, void *reserved)
+{
+    TRACE("(%p, %u, %p)\n", hinst, reason, reserved);
+
+    switch (reason)
+    {
+        case DLL_WINE_PREATTACH:
+            /* Prefer native as it provides more functionality. */
+            return FALSE;
+
+        case DLL_PROCESS_ATTACH:
+            DisableThreadLibraryCalls(hinst);
+            return TRUE;
+    }
+    return TRUE;
+}
diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 7c4dc348be..e781313440 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -65,6 +65,7 @@ LOGGER.addHandler(logging.StreamHandler())
 # Filenames to create.
 WINE_VULKAN_H = "../../include/wine/vulkan.h"
 WINE_VULKAN_DRIVER_H = "../../include/wine/vulkan_driver.h"
+WINE_VULKAN_LOADER_SPEC = "../vulkan-1/vulkan-1.spec"
 WINE_VULKAN_SPEC = "winevulkan.spec"
 WINE_VULKAN_THUNKS_C = "vulkan_thunks.c"
 WINE_VULKAN_THUNKS_H = "vulkan_thunks.h"
@@ -570,18 +571,26 @@ class VkFunction(object):

return body

-    def spec(self, prefix=None):
+    def spec(self, prefix=None, symbol=None):
         """ Generate spec file entry for this function.

Args
             prefix (str, optional): prefix to prepend to entry point name.
+            symbol (str, optional): allows to override function name implementing entry point.
         """

+        spec = ""
         params = " ".join([p.spec() for p in self.params])
         if prefix is not None:
-            return "@ stdcall {0}{1}({2})\n".format(prefix, self.name, params)
+            spec += "@ stdcall {0}{1}({2})".format(prefix, self.name, params)
         else:
-            return "@ stdcall {0}({1})\n".format(self.name, params)
+            spec += "@ stdcall {0}({1})".format(self.name, params)
+
+        if symbol is not None:
+            spec += " " + symbol
+
+        spec += "\n"
+        return spec

def stub(self, call_conv=None, prefix=None):
         stub = self.prototype(call_conv=call_conv, prefix=prefix)
@@ -2136,6 +2145,26 @@ class VkGenerator(object):
             else:
                 f.write("@ stub {0}\n".format(func.name))

+    def generate_vulkan_loader_spec(self, f):
+        f.write("# Automatically generated from Vulkan vk.xml; DO NOT EDIT!\n\n")
+
+        # Export symbols for all Vulkan Core functions.
+        for func in self.registry.funcs.values():
+            if not func.is_core_func():
+                continue
+
+            # We support all Core functions except for VK_KHR_display* APIs.
+            # Create stubs for unsupported Core functions.
+            if func.is_required():
+                # Global functions need a custom implementation, except for
+                # vkCreateInstance, which we can just forward.
+                if func.is_global_func() and func.name != "vkCreateInstance":
+                    f.write(func.spec())
+                else:
+                    f.write(func.spec(symbol="winevulkan.wine_" + func.name))
+            else:
+                f.write("@ stub {0}\n".format(func.name))
+

class VkRegistry(object):
     def __init__(self, reg_filename):
@@ -2521,5 +2550,8 @@ def main():
     with open(WINE_VULKAN_SPEC, "w") as f:
         generator.generate_vulkan_spec(f)

+    with open(WINE_VULKAN_LOADER_SPEC, "w") as f:
+        generator.generate_vulkan_loader_spec(f)
+
 if __name__ == "__main__":
     main()

[PATCH 2/4] vulkan-1: Add initial implementation.

[Józef Kucia]

Signed-off-by: Józef Kucia

[PATCH 3/4] vulkan-1: Implement vkEnumerateInstanceExtensionProperties.

[Roderick Colenbrander]

Signed-off-by: Roderick Colenbrander 
---
 dlls/vulkan-1/vulkan.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/dlls/vulkan-1/vulkan.c b/dlls/vulkan-1/vulkan.c
index 5f974eed52..fbc3d1c45f 100644
--- a/dlls/vulkan-1/vulkan.c
+++ b/dlls/vulkan-1/vulkan.c
@@ -27,11 +27,17 @@

WINE_DEFAULT_DEBUG_CHANNEL(vulkan);

+VkResult WINAPI wine_vkEnumerateInstanceExtensionProperties(const char *, uint32_t *, VkExtensionProperties *);
+
 VkResult WINAPI vkEnumerateInstanceExtensionProperties(const char *layer_name,
         uint32_t *count, VkExtensionProperties *properties)
 {
-    FIXME("stub: %p %p %p\n", layer_name, count, properties);
-    return VK_ERROR_OUT_OF_HOST_MEMORY;
+    TRACE("%p %p %p\n", layer_name, count, properties);
+
+    if (layer_name)
+        return VK_ERROR_LAYER_NOT_PRESENT;
+
+    return wine_vkEnumerateInstanceExtensionProperties(NULL, count, properties);
 }

VkResult WINAPI vkEnumerateInstanceLayerProperties(uint32_t *count,

[PATCH 3/4] vulkan-1: Implement vkEnumerateInstanceExtensionProperties.

[Józef Kucia]

Signed-off-by: Józef Kucia

[PATCH 4/4] vulkan-1: Implement vkGetInstanceProcAddr.

[Roderick Colenbrander]

Signed-off-by: Roderick Colenbrander 
---
 dlls/vulkan-1/vulkan.c | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/dlls/vulkan-1/vulkan.c b/dlls/vulkan-1/vulkan.c
index fbc3d1c45f..6f7ab43c4f 100644
--- a/dlls/vulkan-1/vulkan.c
+++ b/dlls/vulkan-1/vulkan.c
@@ -28,6 +28,7 @@
 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);

VkResult WINAPI wine_vkEnumerateInstanceExtensionProperties(const char *, uint32_t *, VkExtensionProperties *);
+PFN_vkVoidFunction WINAPI wine_vkGetInstanceProcAddr(VkInstance, const char *);

VkResult WINAPI vkEnumerateInstanceExtensionProperties(const char *layer_name,
         uint32_t *count, VkExtensionProperties *properties)
@@ -52,8 +53,18 @@ VkResult WINAPI vkEnumerateInstanceLayerProperties(uint32_t *count,

PFN_vkVoidFunction WINAPI vkGetInstanceProcAddr(VkInstance instance, const char *name)
 {
-    FIXME("stub: %p %s\n", instance, debugstr_a(name));
-    return NULL;
+    TRACE("%p %s\n", instance, debugstr_a(name));
+
+    if (!strcmp(name, "vkEnumerateInstanceExtensionProperties"))
+        return (PFN_vkVoidFunction)vkEnumerateInstanceExtensionProperties;
+
+    if (!strcmp(name, "vkEnumerateInstanceLayerProperties"))
+        return (PFN_vkVoidFunction)vkEnumerateInstanceLayerProperties;
+
+    if (!strcmp(name, "vkGetInstanceProcAddr"))
+        return (PFN_vkVoidFunction)vkGetInstanceProcAddr;
+
+    return wine_vkGetInstanceProcAddr(instance, name);
 }

BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, void *reserved)

[PATCH 4/4] vulkan-1: Implement vkGetInstanceProcAddr.

[Józef Kucia]

Signed-off-by: Józef Kucia