dlls/winex11.drv/vulkan.c

   1 /* X11DRV Vulkan implementation
   2  *
   3  * Copyright 2017 Roderick Colenbrander
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 /* NOTE: If making changes here, consider whether they should be reflected in
  21  * the other drivers. */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31
  32 #include "wine/debug.h"
  33 #include "wine/heap.h"
  34 #include "wine/library.h"
  35 #include "x11drv.h"
  36
  37 #define VK_NO_PROTOTYPES
  38 #define WINE_VK_HOST
  39
  40 #include "wine/vulkan.h"
  41 #include "wine/vulkan_driver.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
  44
  45 #ifdef SONAME_LIBVULKAN
  46 WINE_DECLARE_DEBUG_CHANNEL(fps);
  47
  48 static CRITICAL_SECTION context_section;
  49 static CRITICAL_SECTION_DEBUG critsect_debug =
  50 {
  51     0, 0, &context_section,
  52     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  53       0, 0, { (DWORD_PTR)(__FILE__ ": context_section") }
  54 };
  55 static CRITICAL_SECTION context_section = { &critsect_debug, -1, 0, 0, 0, 0 };
  56
  57 static XContext vulkan_hwnd_context;
  58
  59 #define VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR 1000004000
  60
  61 struct wine_vk_surface
  62 {
  63     LONG ref;
  64     Window window;
  65     VkSurfaceKHR surface; /* native surface */
  66 };
  67
  68 typedef struct VkXlibSurfaceCreateInfoKHR
  69 {
  70     VkStructureType sType;
  71     const void *pNext;
  72     VkXlibSurfaceCreateFlagsKHR flags;
  73     Display *dpy;
  74     Window window;
  75 } VkXlibSurfaceCreateInfoKHR;
  76
  77 static VkResult (*pvkCreateInstance)(const VkInstanceCreateInfo *, const VkAllocationCallbacks *, VkInstance *);
  78 static VkResult (*pvkCreateSwapchainKHR)(VkDevice, const VkSwapchainCreateInfoKHR *, const VkAllocationCallbacks *, VkSwapchainKHR *);
  79 static VkResult (*pvkCreateXlibSurfaceKHR)(VkInstance, const VkXlibSurfaceCreateInfoKHR *, const VkAllocationCallbacks *, VkSurfaceKHR *);
  80 static void (*pvkDestroyInstance)(VkInstance, const VkAllocationCallbacks *);
  81 static void (*pvkDestroySurfaceKHR)(VkInstance, VkSurfaceKHR, const VkAllocationCallbacks *);
  82 static void (*pvkDestroySwapchainKHR)(VkDevice, VkSwapchainKHR, const VkAllocationCallbacks *);
  83 static VkResult (*pvkEnumerateInstanceExtensionProperties)(const char *, uint32_t *, VkExtensionProperties *);
  84 static VkResult (*pvkGetDeviceGroupSurfacePresentModesKHR)(VkDevice, VkSurfaceKHR, VkDeviceGroupPresentModeFlagsKHR *);
  85 static void * (*pvkGetDeviceProcAddr)(VkDevice, const char *);
  86 static void * (*pvkGetInstanceProcAddr)(VkInstance, const char *);
  87 static VkResult (*pvkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice, VkSurfaceKHR, uint32_t *, VkRect2D *);
  88 static VkResult (*pvkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice, VkSurfaceKHR, VkSurfaceCapabilitiesKHR *);
  89 static VkResult (*pvkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice, VkSurfaceKHR, uint32_t *, VkSurfaceFormatKHR *);
  90 static VkResult (*pvkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice, VkSurfaceKHR, uint32_t *, VkPresentModeKHR *);
  91 static VkResult (*pvkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice, uint32_t, VkSurfaceKHR, VkBool32 *);
  92 static VkBool32 (*pvkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice, uint32_t, Display *, VisualID);
  93 static VkResult (*pvkGetSwapchainImagesKHR)(VkDevice, VkSwapchainKHR, uint32_t *, VkImage *);
  94 static VkResult (*pvkQueuePresentKHR)(VkQueue, const VkPresentInfoKHR *);
  95
  96 static void *X11DRV_get_vk_device_proc_addr(const char *name);
  97 static void *X11DRV_get_vk_instance_proc_addr(VkInstance instance, const char *name);
  98
  99 static inline struct wine_vk_surface *surface_from_handle(VkSurfaceKHR handle)
 100 {
 101     return (struct wine_vk_surface *)(uintptr_t)handle;
 102 }
 103
 104 static void *vulkan_handle;
 105
 106 static BOOL WINAPI wine_vk_init(INIT_ONCE *once, void *param, void **context)
 107 {
 108     if (!(vulkan_handle = wine_dlopen(SONAME_LIBVULKAN, RTLD_NOW, NULL, 0)))
 109     {
 110         ERR("Failed to load %s.\n", SONAME_LIBVULKAN);
 111         return TRUE;
 112     }
 113
 114 #define LOAD_FUNCPTR(f) if (!(p##f = wine_dlsym(vulkan_handle, #f, NULL, 0))) goto fail;
 115 #define LOAD_OPTIONAL_FUNCPTR(f) p##f = wine_dlsym(vulkan_handle, #f, NULL, 0);
 116     LOAD_FUNCPTR(vkCreateInstance)
 117     LOAD_FUNCPTR(vkCreateSwapchainKHR)
 118     LOAD_FUNCPTR(vkCreateXlibSurfaceKHR)
 119     LOAD_FUNCPTR(vkDestroyInstance)
 120     LOAD_FUNCPTR(vkDestroySurfaceKHR)
 121     LOAD_FUNCPTR(vkDestroySwapchainKHR)
 122     LOAD_FUNCPTR(vkEnumerateInstanceExtensionProperties)
 123     LOAD_FUNCPTR(vkGetDeviceProcAddr)
 124     LOAD_FUNCPTR(vkGetInstanceProcAddr)
 125     LOAD_FUNCPTR(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)
 126     LOAD_FUNCPTR(vkGetPhysicalDeviceSurfaceFormatsKHR)
 127     LOAD_FUNCPTR(vkGetPhysicalDeviceSurfacePresentModesKHR)
 128     LOAD_FUNCPTR(vkGetPhysicalDeviceSurfaceSupportKHR)
 129     LOAD_FUNCPTR(vkGetPhysicalDeviceXlibPresentationSupportKHR)
 130     LOAD_FUNCPTR(vkGetSwapchainImagesKHR)
 131     LOAD_FUNCPTR(vkQueuePresentKHR)
 132     LOAD_OPTIONAL_FUNCPTR(vkGetDeviceGroupSurfacePresentModesKHR)
 133     LOAD_OPTIONAL_FUNCPTR(vkGetPhysicalDevicePresentRectanglesKHR)
 134 #undef LOAD_FUNCPTR
 135 #undef LOAD_OPTIONAL_FUNCPTR
 136
 137     vulkan_hwnd_context = XUniqueContext();
 138
 139     return TRUE;
 140
 141 fail:
 142     wine_dlclose(vulkan_handle, NULL, 0);
 143     vulkan_handle = NULL;
 144     return TRUE;
 145 }
 146
 147 /* Helper function for converting between win32 and X11 compatible VkInstanceCreateInfo.
 148  * Caller is responsible for allocation and cleanup of 'dst'.
 149  */
 150 static VkResult wine_vk_instance_convert_create_info(const VkInstanceCreateInfo *src,
 151         VkInstanceCreateInfo *dst)
 152 {
 153     unsigned int i;
 154     const char **enabled_extensions = NULL;
 155
 156     dst->sType = src->sType;
 157     dst->flags = src->flags;
 158     dst->pApplicationInfo = src->pApplicationInfo;
 159     dst->pNext = src->pNext;
 160     dst->enabledLayerCount = 0;
 161     dst->ppEnabledLayerNames = NULL;
 162     dst->enabledExtensionCount = 0;
 163     dst->ppEnabledExtensionNames = NULL;
 164
 165     if (src->enabledExtensionCount > 0)
 166     {
 167         enabled_extensions = heap_calloc(src->enabledExtensionCount, sizeof(*src->ppEnabledExtensionNames));
 168         if (!enabled_extensions)
 169         {
 170             ERR("Failed to allocate memory for enabled extensions\n");
 171             return VK_ERROR_OUT_OF_HOST_MEMORY;
 172         }
 173
 174         for (i = 0; i < src->enabledExtensionCount; i++)
 175         {
 176             /* Substitute extension with X11 ones else copy. Long-term, when we
 177              * support more extensions, we should store these in a list.
 178              */
 179             if (!strcmp(src->ppEnabledExtensionNames[i], "VK_KHR_win32_surface"))
 180             {
 181                 enabled_extensions[i] = "VK_KHR_xlib_surface";
 182             }
 183             else
 184             {
 185                 enabled_extensions[i] = src->ppEnabledExtensionNames[i];
 186             }
 187         }
 188         dst->ppEnabledExtensionNames = enabled_extensions;
 189         dst->enabledExtensionCount = src->enabledExtensionCount;
 190     }
 191
 192     return VK_SUCCESS;
 193 }
 194
 195 static struct wine_vk_surface *wine_vk_surface_grab(struct wine_vk_surface *surface)
 196 {
 197     InterlockedIncrement(&surface->ref);
 198     return surface;
 199 }
 200
 201 static void wine_vk_surface_release(struct wine_vk_surface *surface)
 202 {
 203     if (InterlockedDecrement(&surface->ref))
 204         return;
 205
 206     if (surface->window)
 207         XDestroyWindow(gdi_display, surface->window);
 208
 209     heap_free(surface);
 210 }
 211
 212 void wine_vk_surface_destroy(HWND hwnd)
 213 {
 214     struct wine_vk_surface *surface;
 215     EnterCriticalSection(&context_section);
 216     if (!XFindContext(gdi_display, (XID)hwnd, vulkan_hwnd_context, (char **)&surface))
 217     {
 218         wine_vk_surface_release(surface);
 219     }
 220     XDeleteContext(gdi_display, (XID)hwnd, vulkan_hwnd_context);
 221     LeaveCriticalSection(&context_section);
 222 }
 223
 224 static VkResult X11DRV_vkCreateInstance(const VkInstanceCreateInfo *create_info,
 225         const VkAllocationCallbacks *allocator, VkInstance *instance)
 226 {
 227     VkInstanceCreateInfo create_info_host;
 228     VkResult res;
 229     TRACE("create_info %p, allocator %p, instance %p\n", create_info, allocator, instance);
 230
 231     if (allocator)
 232         FIXME("Support for allocation callbacks not implemented yet\n");
 233
 234     /* Perform a second pass on converting VkInstanceCreateInfo. Winevulkan
 235      * performed a first pass in which it handles everything except for WSI
 236      * functionality such as VK_KHR_win32_surface. Handle this now.
 237      */
 238     res = wine_vk_instance_convert_create_info(create_info, &create_info_host);
 239     if (res != VK_SUCCESS)
 240     {
 241         ERR("Failed to convert instance create info, res=%d\n", res);
 242         return res;
 243     }
 244
 245     res = pvkCreateInstance(&create_info_host, NULL /* allocator */, instance);
 246
 247     heap_free((void *)create_info_host.ppEnabledExtensionNames);
 248     return res;
 249 }
 250
 251 static VkResult X11DRV_vkCreateSwapchainKHR(VkDevice device,
 252         const VkSwapchainCreateInfoKHR *create_info,
 253         const VkAllocationCallbacks *allocator, VkSwapchainKHR *swapchain)
 254 {
 255     VkSwapchainCreateInfoKHR create_info_host;
 256     TRACE("%p %p %p %p\n", device, create_info, allocator, swapchain);
 257
 258     if (allocator)
 259         FIXME("Support for allocation callbacks not implemented yet\n");
 260
 261     create_info_host = *create_info;
 262     create_info_host.surface = surface_from_handle(create_info->surface)->surface;
 263
 264     return pvkCreateSwapchainKHR(device, &create_info_host, NULL /* allocator */, swapchain);
 265 }
 266
 267 static VkResult X11DRV_vkCreateWin32SurfaceKHR(VkInstance instance,
 268         const VkWin32SurfaceCreateInfoKHR *create_info,
 269         const VkAllocationCallbacks *allocator, VkSurfaceKHR *surface)
 270 {
 271     VkResult res;
 272     VkXlibSurfaceCreateInfoKHR create_info_host;
 273     struct wine_vk_surface *x11_surface, *prev;
 274
 275     TRACE("%p %p %p %p\n", instance, create_info, allocator, surface);
 276
 277     if (allocator)
 278         FIXME("Support for allocation callbacks not implemented yet\n");
 279
 280     /* TODO: support child window rendering. */
 281     if (GetAncestor(create_info->hwnd, GA_PARENT) != GetDesktopWindow())
 282     {
 283         FIXME("Application requires child window rendering, which is not implemented yet!\n");
 284         return VK_ERROR_INCOMPATIBLE_DRIVER;
 285     }
 286
 287     x11_surface = heap_alloc_zero(sizeof(*x11_surface));
 288     if (!x11_surface)
 289         return VK_ERROR_OUT_OF_HOST_MEMORY;
 290
 291     x11_surface->ref = 1;
 292
 293     x11_surface->window = create_client_window(create_info->hwnd, &default_visual);
 294     if (!x11_surface->window)
 295     {
 296         ERR("Failed to allocate client window for hwnd=%p\n", create_info->hwnd);
 297
 298         /* VK_KHR_win32_surface only allows out of host and device memory as errors. */
 299         res = VK_ERROR_OUT_OF_HOST_MEMORY;
 300         goto err;
 301     }
 302
 303     create_info_host.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
 304     create_info_host.pNext = NULL;
 305     create_info_host.flags = 0; /* reserved */
 306     create_info_host.dpy = gdi_display;
 307     create_info_host.window = x11_surface->window;
 308
 309     res = pvkCreateXlibSurfaceKHR(instance, &create_info_host, NULL /* allocator */, &x11_surface->surface);
 310     if (res != VK_SUCCESS)
 311     {
 312         ERR("Failed to create Xlib surface, res=%d\n", res);
 313         goto err;
 314     }
 315
 316     EnterCriticalSection(&context_section);
 317     if (!XFindContext(gdi_display, (XID)create_info->hwnd, vulkan_hwnd_context, (char **)&prev))
 318     {
 319         wine_vk_surface_release(prev);
 320     }
 321     XSaveContext(gdi_display, (XID)create_info->hwnd, vulkan_hwnd_context, (char *)wine_vk_surface_grab(x11_surface));
 322     LeaveCriticalSection(&context_section);
 323
 324     *surface = (uintptr_t)x11_surface;
 325
 326     TRACE("Created surface=0x%s\n", wine_dbgstr_longlong(*surface));
 327     return VK_SUCCESS;
 328
 329 err:
 330     wine_vk_surface_release(x11_surface);
 331     return res;
 332 }
 333
 334 static void X11DRV_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *allocator)
 335 {
 336     TRACE("%p %p\n", instance, allocator);
 337
 338     if (allocator)
 339         FIXME("Support for allocation callbacks not implemented yet\n");
 340
 341     pvkDestroyInstance(instance, NULL /* allocator */);
 342 }
 343
 344 static void X11DRV_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
 345         const VkAllocationCallbacks *allocator)
 346 {
 347     struct wine_vk_surface *x11_surface = surface_from_handle(surface);
 348
 349     TRACE("%p 0x%s %p\n", instance, wine_dbgstr_longlong(surface), allocator);
 350
 351     if (allocator)
 352         FIXME("Support for allocation callbacks not implemented yet\n");
 353
 354     /* vkDestroySurfaceKHR must handle VK_NULL_HANDLE (0) for surface. */
 355     if (x11_surface)
 356     {
 357         pvkDestroySurfaceKHR(instance, x11_surface->surface, NULL /* allocator */);
 358
 359         wine_vk_surface_release(x11_surface);
 360     }
 361 }
 362
 363 static void X11DRV_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
 364          const VkAllocationCallbacks *allocator)
 365 {
 366     TRACE("%p, 0x%s %p\n", device, wine_dbgstr_longlong(swapchain), allocator);
 367
 368     if (allocator)
 369         FIXME("Support for allocation callbacks not implemented yet\n");
 370
 371     pvkDestroySwapchainKHR(device, swapchain, NULL /* allocator */);
 372 }
 373
 374 static VkResult X11DRV_vkEnumerateInstanceExtensionProperties(const char *layer_name,
 375         uint32_t *count, VkExtensionProperties* properties)
 376 {
 377     unsigned int i;
 378     VkResult res;
 379
 380     TRACE("layer_name %s, count %p, properties %p\n", debugstr_a(layer_name), count, properties);
 381
 382     /* This shouldn't get called with layer_name set, the ICD loader prevents it. */
 383     if (layer_name)
 384     {
 385         ERR("Layer enumeration not supported from ICD.\n");
 386         return VK_ERROR_LAYER_NOT_PRESENT;
 387     }
 388
 389     /* We will return the same number of instance extensions reported by the host back to
 390      * winevulkan. Along the way we may replace xlib extensions with their win32 equivalents.
 391      * Winevulkan will perform more detailed filtering as it knows whether it has thunks
 392      * for a particular extension.
 393      */
 394     res = pvkEnumerateInstanceExtensionProperties(layer_name, count, properties);
 395     if (!properties || res < 0)
 396         return res;
 397
 398     for (i = 0; i < *count; i++)
 399     {
 400         /* For now the only x11 extension we need to fixup. Long-term we may need an array. */
 401         if (!strcmp(properties[i].extensionName, "VK_KHR_xlib_surface"))
 402         {
 403             TRACE("Substituting VK_KHR_xlib_surface for VK_KHR_win32_surface\n");
 404
 405             snprintf(properties[i].extensionName, sizeof(properties[i].extensionName),
 406                     VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
 407             properties[i].specVersion = VK_KHR_WIN32_SURFACE_SPEC_VERSION;
 408         }
 409     }
 410
 411     TRACE("Returning %u extensions.\n", *count);
 412     return res;
 413 }
 414
 415 static VkResult X11DRV_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device,
 416         VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *flags)
 417 {
 418     struct wine_vk_surface *x11_surface = surface_from_handle(surface);
 419
 420     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(surface), flags);
 421
 422     return pvkGetDeviceGroupSurfacePresentModesKHR(device, x11_surface->surface, flags);
 423 }
 424
 425 static void *X11DRV_vkGetDeviceProcAddr(VkDevice device, const char *name)
 426 {
 427     void *proc_addr;
 428
 429     TRACE("%p, %s\n", device, debugstr_a(name));
 430
 431     if ((proc_addr = X11DRV_get_vk_device_proc_addr(name)))
 432         return proc_addr;
 433
 434     return pvkGetDeviceProcAddr(device, name);
 435 }
 436
 437 static void *X11DRV_vkGetInstanceProcAddr(VkInstance instance, const char *name)
 438 {
 439     void *proc_addr;
 440
 441     TRACE("%p, %s\n", instance, debugstr_a(name));
 442
 443     if ((proc_addr = X11DRV_get_vk_instance_proc_addr(instance, name)))
 444         return proc_addr;
 445
 446     return pvkGetInstanceProcAddr(instance, name);
 447 }
 448
 449 static VkResult X11DRV_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice phys_dev,
 450         VkSurfaceKHR surface, uint32_t *count, VkRect2D *rects)
 451 {
 452     struct wine_vk_surface *x11_surface = surface_from_handle(surface);
 453
 454     TRACE("%p, 0x%s, %p, %p\n", phys_dev, wine_dbgstr_longlong(surface), count, rects);
 455
 456     return pvkGetPhysicalDevicePresentRectanglesKHR(phys_dev, x11_surface->surface, count, rects);
 457 }
 458
 459 static VkResult X11DRV_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice phys_dev,
 460         VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *capabilities)
 461 {
 462     struct wine_vk_surface *x11_surface = surface_from_handle(surface);
 463
 464     TRACE("%p, 0x%s, %p\n", phys_dev, wine_dbgstr_longlong(surface), capabilities);
 465
 466     return pvkGetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev, x11_surface->surface, capabilities);
 467 }
 468
 469 static VkResult X11DRV_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice phys_dev,
 470         VkSurfaceKHR surface, uint32_t *count, VkSurfaceFormatKHR *formats)
 471 {
 472     struct wine_vk_surface *x11_surface = surface_from_handle(surface);
 473
 474     TRACE("%p, 0x%s, %p, %p\n", phys_dev, wine_dbgstr_longlong(surface), count, formats);
 475
 476     return pvkGetPhysicalDeviceSurfaceFormatsKHR(phys_dev, x11_surface->surface, count, formats);
 477 }
 478
 479 static VkResult X11DRV_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice phys_dev,
 480         VkSurfaceKHR surface, uint32_t *count, VkPresentModeKHR *modes)
 481 {
 482     struct wine_vk_surface *x11_surface = surface_from_handle(surface);
 483
 484     TRACE("%p, 0x%s, %p, %p\n", phys_dev, wine_dbgstr_longlong(surface), count, modes);
 485
 486     return pvkGetPhysicalDeviceSurfacePresentModesKHR(phys_dev, x11_surface->surface, count, modes);
 487 }
 488
 489 static VkResult X11DRV_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice phys_dev,
 490         uint32_t index, VkSurfaceKHR surface, VkBool32 *supported)
 491 {
 492     struct wine_vk_surface *x11_surface = surface_from_handle(surface);
 493
 494     TRACE("%p, %u, 0x%s, %p\n", phys_dev, index, wine_dbgstr_longlong(surface), supported);
 495
 496     return pvkGetPhysicalDeviceSurfaceSupportKHR(phys_dev, index, x11_surface->surface, supported);
 497 }
 498
 499 static VkBool32 X11DRV_vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice phys_dev,
 500         uint32_t index)
 501 {
 502     TRACE("%p %u\n", phys_dev, index);
 503
 504     return pvkGetPhysicalDeviceXlibPresentationSupportKHR(phys_dev, index, gdi_display,
 505             default_visual.visual->visualid);
 506 }
 507
 508 static VkResult X11DRV_vkGetSwapchainImagesKHR(VkDevice device,
 509         VkSwapchainKHR swapchain, uint32_t *count, VkImage *images)
 510 {
 511     TRACE("%p, 0x%s %p %p\n", device, wine_dbgstr_longlong(swapchain), count, images);
 512     return pvkGetSwapchainImagesKHR(device, swapchain, count, images);
 513 }
 514
 515 static VkResult X11DRV_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *present_info)
 516 {
 517     VkResult res;
 518
 519     TRACE("%p, %p\n", queue, present_info);
 520
 521     res = pvkQueuePresentKHR(queue, present_info);
 522
 523     if (TRACE_ON(fps))
 524     {
 525         static unsigned long frames, frames_total;
 526         static long prev_time, start_time;
 527         DWORD time;
 528
 529         time = GetTickCount();
 530         frames++;
 531         frames_total++;
 532         if (time - prev_time > 1500)
 533         {
 534             TRACE_(fps)("%p @ approx %.2ffps, total %.2ffps\n",
 535                     queue, 1000.0 * frames / (time - prev_time),
 536                     1000.0 * frames_total / (time - start_time));
 537             prev_time = time;
 538             frames = 0;
 539             if (!start_time)
 540                 start_time = time;
 541         }
 542     }
 543
 544     return res;
 545 }
 546
 547 static const struct vulkan_funcs vulkan_funcs =
 548 {
 549     X11DRV_vkCreateInstance,
 550     X11DRV_vkCreateSwapchainKHR,
 551     X11DRV_vkCreateWin32SurfaceKHR,
 552     X11DRV_vkDestroyInstance,
 553     X11DRV_vkDestroySurfaceKHR,
 554     X11DRV_vkDestroySwapchainKHR,
 555     X11DRV_vkEnumerateInstanceExtensionProperties,
 556     X11DRV_vkGetDeviceGroupSurfacePresentModesKHR,
 557     X11DRV_vkGetDeviceProcAddr,
 558     X11DRV_vkGetInstanceProcAddr,
 559     X11DRV_vkGetPhysicalDevicePresentRectanglesKHR,
 560     X11DRV_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
 561     X11DRV_vkGetPhysicalDeviceSurfaceFormatsKHR,
 562     X11DRV_vkGetPhysicalDeviceSurfacePresentModesKHR,
 563     X11DRV_vkGetPhysicalDeviceSurfaceSupportKHR,
 564     X11DRV_vkGetPhysicalDeviceWin32PresentationSupportKHR,
 565     X11DRV_vkGetSwapchainImagesKHR,
 566     X11DRV_vkQueuePresentKHR,
 567 };
 568
 569 static void *X11DRV_get_vk_device_proc_addr(const char *name)
 570 {
 571     return get_vulkan_driver_device_proc_addr(&vulkan_funcs, name);
 572 }
 573
 574 static void *X11DRV_get_vk_instance_proc_addr(VkInstance instance, const char *name)
 575 {
 576     return get_vulkan_driver_instance_proc_addr(&vulkan_funcs, instance, name);
 577 }
 578
 579 const struct vulkan_funcs *get_vulkan_driver(UINT version)
 580 {
 581     static INIT_ONCE init_once = INIT_ONCE_STATIC_INIT;
 582
 583     if (version != WINE_VULKAN_DRIVER_VERSION)
 584     {
 585         ERR("version mismatch, vulkan wants %u but driver has %u\n", version, WINE_VULKAN_DRIVER_VERSION);
 586         return NULL;
 587     }
 588
 589     InitOnceExecuteOnce(&init_once, wine_vk_init, NULL, NULL);
 590     if (vulkan_handle)
 591         return &vulkan_funcs;
 592
 593     return NULL;
 594 }
 595
 596 #else /* No vulkan */
 597
 598 const struct vulkan_funcs *get_vulkan_driver(UINT version)
 599 {
 600     ERR("Wine was built without Vulkan support.\n");
 601     return NULL;
 602 }
 603
 604 void wine_vk_surface_destroy(HWND hwnd)
 605 {
 606 }
 607
 608 #endif /* SONAME_LIBVULKAN */