dlls/winemac.drv/vulkan.c

   1 /* Mac Driver Vulkan implementation
   2  *
   3  * Copyright 2017 Roderick Colenbrander
   4  * Copyright 2018 Andrew Eikum for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 /* NOTE: If making changes here, consider whether they should be reflected in
  22  * the other drivers. */
  23
  24 #if 0
  25 #pragma makedep unix
  26 #endif
  27
  28 #include "config.h"
  29
  30 #include <stdarg.h>
  31 #include <stdio.h>
  32 #include <dlfcn.h>
  33
  34 #include "macdrv.h"
  35 #include "wine/debug.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_LIBMOLTENVK
  46
  47 WINE_DECLARE_DEBUG_CHANNEL(fps);
  48
  49 typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
  50 #define VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK 1000123000
  51
  52 typedef VkFlags VkMetalSurfaceCreateFlagsEXT;
  53 #define VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT 1000217000
  54
  55 struct wine_vk_surface
  56 {
  57     macdrv_metal_device device;
  58     macdrv_metal_view view;
  59     VkSurfaceKHR surface; /* native surface */
  60 };
  61
  62 typedef struct VkMacOSSurfaceCreateInfoMVK
  63 {
  64     VkStructureType sType;
  65     const void *pNext;
  66     VkMacOSSurfaceCreateFlagsMVK flags;
  67     const void *pView; /* NSView */
  68 } VkMacOSSurfaceCreateInfoMVK;
  69
  70 typedef struct VkMetalSurfaceCreateInfoEXT
  71 {
  72     VkStructureType sType;
  73     const void *pNext;
  74     VkMetalSurfaceCreateFlagsEXT flags;
  75     const void *pLayer; /* CAMetalLayer */
  76 } VkMetalSurfaceCreateInfoEXT;
  77
  78 static VkResult (*pvkCreateInstance)(const VkInstanceCreateInfo *, const VkAllocationCallbacks *, VkInstance *);
  79 static VkResult (*pvkCreateSwapchainKHR)(VkDevice, const VkSwapchainCreateInfoKHR *, const VkAllocationCallbacks *, VkSwapchainKHR *);
  80 static VkResult (*pvkCreateMacOSSurfaceMVK)(VkInstance, const VkMacOSSurfaceCreateInfoMVK*, const VkAllocationCallbacks *, VkSurfaceKHR *);
  81 static VkResult (*pvkCreateMetalSurfaceEXT)(VkInstance, const VkMetalSurfaceCreateInfoEXT*, const VkAllocationCallbacks *, VkSurfaceKHR *);
  82 static void (*pvkDestroyInstance)(VkInstance, const VkAllocationCallbacks *);
  83 static void (*pvkDestroySurfaceKHR)(VkInstance, VkSurfaceKHR, const VkAllocationCallbacks *);
  84 static void (*pvkDestroySwapchainKHR)(VkDevice, VkSwapchainKHR, const VkAllocationCallbacks *);
  85 static VkResult (*pvkEnumerateInstanceExtensionProperties)(const char *, uint32_t *, VkExtensionProperties *);
  86 static void * (*pvkGetDeviceProcAddr)(VkDevice, const char *);
  87 static void * (*pvkGetInstanceProcAddr)(VkInstance, const char *);
  88 static VkResult (*pvkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *, VkSurfaceCapabilities2KHR *);
  89 static VkResult (*pvkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice, VkSurfaceKHR, VkSurfaceCapabilitiesKHR *);
  90 static VkResult (*pvkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *, uint32_t *, VkSurfaceFormat2KHR *);
  91 static VkResult (*pvkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice, VkSurfaceKHR, uint32_t *, VkSurfaceFormatKHR *);
  92 static VkResult (*pvkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice, VkSurfaceKHR, uint32_t *, VkPresentModeKHR *);
  93 static VkResult (*pvkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice, uint32_t, VkSurfaceKHR, VkBool32 *);
  94 static VkResult (*pvkGetSwapchainImagesKHR)(VkDevice, VkSwapchainKHR, uint32_t *, VkImage *);
  95 static VkResult (*pvkQueuePresentKHR)(VkQueue, const VkPresentInfoKHR *);
  96
  97 static void *macdrv_get_vk_device_proc_addr(const char *name);
  98 static void *macdrv_get_vk_instance_proc_addr(VkInstance instance, const char *name);
  99
 100 static inline struct wine_vk_surface *surface_from_handle(VkSurfaceKHR handle)
 101 {
 102     return (struct wine_vk_surface *)(uintptr_t)handle;
 103 }
 104
 105 static void *vulkan_handle;
 106
 107 static void wine_vk_init(void)
 108 {
 109     if (!(vulkan_handle = dlopen(SONAME_LIBMOLTENVK, RTLD_NOW)))
 110     {
 111         ERR("Failed to load %s\n", SONAME_LIBMOLTENVK);
 112         return;
 113     }
 114
 115 #define LOAD_FUNCPTR(f) if ((p##f = dlsym(vulkan_handle, #f)) == NULL) goto fail;
 116     LOAD_FUNCPTR(vkCreateInstance)
 117     LOAD_FUNCPTR(vkCreateSwapchainKHR)
 118     LOAD_FUNCPTR(vkCreateMacOSSurfaceMVK)
 119     LOAD_FUNCPTR(vkCreateMetalSurfaceEXT)
 120     LOAD_FUNCPTR(vkDestroyInstance)
 121     LOAD_FUNCPTR(vkDestroySurfaceKHR)
 122     LOAD_FUNCPTR(vkDestroySwapchainKHR)
 123     LOAD_FUNCPTR(vkEnumerateInstanceExtensionProperties)
 124     LOAD_FUNCPTR(vkGetDeviceProcAddr)
 125     LOAD_FUNCPTR(vkGetInstanceProcAddr)
 126     LOAD_FUNCPTR(vkGetPhysicalDeviceSurfaceCapabilities2KHR)
 127     LOAD_FUNCPTR(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)
 128     LOAD_FUNCPTR(vkGetPhysicalDeviceSurfaceFormats2KHR)
 129     LOAD_FUNCPTR(vkGetPhysicalDeviceSurfaceFormatsKHR)
 130     LOAD_FUNCPTR(vkGetPhysicalDeviceSurfacePresentModesKHR)
 131     LOAD_FUNCPTR(vkGetPhysicalDeviceSurfaceSupportKHR)
 132     LOAD_FUNCPTR(vkGetSwapchainImagesKHR)
 133     LOAD_FUNCPTR(vkQueuePresentKHR)
 134 #undef LOAD_FUNCPTR
 135
 136     return;
 137
 138 fail:
 139     dlclose(vulkan_handle);
 140     vulkan_handle = NULL;
 141 }
 142
 143 /* Helper function for converting between win32 and MoltenVK compatible VkInstanceCreateInfo.
 144  * Caller is responsible for allocation and cleanup of 'dst'.
 145  */
 146 static VkResult wine_vk_instance_convert_create_info(const VkInstanceCreateInfo *src,
 147         VkInstanceCreateInfo *dst)
 148 {
 149     unsigned int i;
 150     const char **enabled_extensions = NULL;
 151
 152     dst->sType = src->sType;
 153     dst->flags = src->flags;
 154     dst->pApplicationInfo = src->pApplicationInfo;
 155     dst->pNext = src->pNext;
 156     dst->enabledLayerCount = 0;
 157     dst->ppEnabledLayerNames = NULL;
 158     dst->enabledExtensionCount = 0;
 159     dst->ppEnabledExtensionNames = NULL;
 160
 161     if (src->enabledExtensionCount > 0)
 162     {
 163         enabled_extensions = calloc(src->enabledExtensionCount, sizeof(*src->ppEnabledExtensionNames));
 164         if (!enabled_extensions)
 165         {
 166             ERR("Failed to allocate memory for enabled extensions\n");
 167             return VK_ERROR_OUT_OF_HOST_MEMORY;
 168         }
 169
 170         for (i = 0; i < src->enabledExtensionCount; i++)
 171         {
 172             /* Substitute extension with MoltenVK ones else copy. Long-term, when we
 173              * support more extensions, we should store these in a list.
 174              */
 175             if (!strcmp(src->ppEnabledExtensionNames[i], "VK_KHR_win32_surface"))
 176             {
 177                 enabled_extensions[i] = pvkCreateMetalSurfaceEXT ? "VK_EXT_metal_surface" : "VK_MVK_macos_surface";
 178             }
 179             else
 180             {
 181                 enabled_extensions[i] = src->ppEnabledExtensionNames[i];
 182             }
 183         }
 184         dst->ppEnabledExtensionNames = enabled_extensions;
 185         dst->enabledExtensionCount = src->enabledExtensionCount;
 186     }
 187
 188     return VK_SUCCESS;
 189 }
 190
 191 static void wine_vk_surface_destroy(VkInstance instance, struct wine_vk_surface *surface)
 192 {
 193     /* vkDestroySurfaceKHR must handle VK_NULL_HANDLE (0) for surface. */
 194     if (!surface)
 195         return;
 196
 197     pvkDestroySurfaceKHR(instance, surface->surface, NULL /* allocator */);
 198
 199     if (surface->view)
 200         macdrv_view_release_metal_view(surface->view);
 201
 202     if (surface->device)
 203         macdrv_release_metal_device(surface->device);
 204
 205     free(surface);
 206 }
 207
 208 static VkResult macdrv_vkCreateInstance(const VkInstanceCreateInfo *create_info,
 209         const VkAllocationCallbacks *allocator, VkInstance *instance)
 210 {
 211     VkInstanceCreateInfo create_info_host;
 212     VkResult res;
 213     TRACE("create_info %p, allocator %p, instance %p\n", create_info, allocator, instance);
 214
 215     if (allocator)
 216         FIXME("Support for allocation callbacks not implemented yet\n");
 217
 218     /* Perform a second pass on converting VkInstanceCreateInfo. Winevulkan
 219      * performed a first pass in which it handles everything except for WSI
 220      * functionality such as VK_KHR_win32_surface. Handle this now.
 221      */
 222     res = wine_vk_instance_convert_create_info(create_info, &create_info_host);
 223     if (res != VK_SUCCESS)
 224     {
 225         ERR("Failed to convert instance create info, res=%d\n", res);
 226         return res;
 227     }
 228
 229     res = pvkCreateInstance(&create_info_host, NULL /* allocator */, instance);
 230
 231     free((void *)create_info_host.ppEnabledExtensionNames);
 232     return res;
 233 }
 234
 235 static VkResult macdrv_vkCreateSwapchainKHR(VkDevice device,
 236         const VkSwapchainCreateInfoKHR *create_info,
 237         const VkAllocationCallbacks *allocator, VkSwapchainKHR *swapchain)
 238 {
 239     VkSwapchainCreateInfoKHR create_info_host;
 240     TRACE("%p %p %p %p\n", device, create_info, allocator, swapchain);
 241
 242     if (allocator)
 243         FIXME("Support for allocation callbacks not implemented yet\n");
 244
 245     create_info_host = *create_info;
 246     create_info_host.surface = surface_from_handle(create_info->surface)->surface;
 247
 248     return pvkCreateSwapchainKHR(device, &create_info_host, NULL /* allocator */,
 249             swapchain);
 250 }
 251
 252 static VkResult macdrv_vkCreateWin32SurfaceKHR(VkInstance instance,
 253         const VkWin32SurfaceCreateInfoKHR *create_info,
 254         const VkAllocationCallbacks *allocator, VkSurfaceKHR *surface)
 255 {
 256     VkResult res;
 257     struct wine_vk_surface *mac_surface;
 258     struct macdrv_win_data *data;
 259
 260     TRACE("%p %p %p %p\n", instance, create_info, allocator, surface);
 261
 262     if (allocator)
 263         FIXME("Support for allocation callbacks not implemented yet\n");
 264
 265     if (!(data = get_win_data(create_info->hwnd)))
 266     {
 267         FIXME("DC for window %p of other process: not implemented\n", create_info->hwnd);
 268         return VK_ERROR_INCOMPATIBLE_DRIVER;
 269     }
 270
 271     mac_surface = calloc(1, sizeof(*mac_surface));
 272     if (!mac_surface)
 273     {
 274         release_win_data(data);
 275         return VK_ERROR_OUT_OF_HOST_MEMORY;
 276     }
 277
 278     mac_surface->device = macdrv_create_metal_device();
 279     if (!mac_surface->device)
 280     {
 281         ERR("Failed to allocate Metal device for hwnd=%p\n", create_info->hwnd);
 282         res = VK_ERROR_OUT_OF_HOST_MEMORY;
 283         goto err;
 284     }
 285
 286     mac_surface->view = macdrv_view_create_metal_view(data->client_cocoa_view, mac_surface->device);
 287     if (!mac_surface->view)
 288     {
 289         ERR("Failed to allocate Metal view for hwnd=%p\n", create_info->hwnd);
 290
 291         /* VK_KHR_win32_surface only allows out of host and device memory as errors. */
 292         res = VK_ERROR_OUT_OF_HOST_MEMORY;
 293         goto err;
 294     }
 295
 296     if (pvkCreateMetalSurfaceEXT)
 297     {
 298         VkMetalSurfaceCreateInfoEXT create_info_host;
 299         create_info_host.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
 300         create_info_host.pNext = NULL;
 301         create_info_host.flags = 0; /* reserved */
 302         create_info_host.pLayer = macdrv_view_get_metal_layer(mac_surface->view);
 303
 304         res = pvkCreateMetalSurfaceEXT(instance, &create_info_host, NULL /* allocator */, &mac_surface->surface);
 305     }
 306     else
 307     {
 308         VkMacOSSurfaceCreateInfoMVK create_info_host;
 309         create_info_host.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
 310         create_info_host.pNext = NULL;
 311         create_info_host.flags = 0; /* reserved */
 312         create_info_host.pView = macdrv_view_get_metal_layer(mac_surface->view);
 313
 314         res = pvkCreateMacOSSurfaceMVK(instance, &create_info_host, NULL /* allocator */, &mac_surface->surface);
 315     }
 316     if (res != VK_SUCCESS)
 317     {
 318         ERR("Failed to create MoltenVK surface, res=%d\n", res);
 319         goto err;
 320     }
 321
 322     *surface = (uintptr_t)mac_surface;
 323
 324     release_win_data(data);
 325
 326     TRACE("Created surface=0x%s\n", wine_dbgstr_longlong(*surface));
 327     return VK_SUCCESS;
 328
 329 err:
 330     wine_vk_surface_destroy(instance, mac_surface);
 331     release_win_data(data);
 332     return res;
 333 }
 334
 335 static void macdrv_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *allocator)
 336 {
 337     TRACE("%p %p\n", instance, allocator);
 338
 339     if (allocator)
 340         FIXME("Support for allocation callbacks not implemented yet\n");
 341
 342     pvkDestroyInstance(instance, NULL /* allocator */);
 343 }
 344
 345 static void macdrv_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
 346         const VkAllocationCallbacks *allocator)
 347 {
 348     struct wine_vk_surface *mac_surface = surface_from_handle(surface);
 349
 350     TRACE("%p 0x%s %p\n", instance, wine_dbgstr_longlong(surface), allocator);
 351
 352     if (allocator)
 353         FIXME("Support for allocation callbacks not implemented yet\n");
 354
 355     wine_vk_surface_destroy(instance, mac_surface);
 356 }
 357
 358 static void macdrv_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
 359          const VkAllocationCallbacks *allocator)
 360 {
 361     TRACE("%p, 0x%s %p\n", device, wine_dbgstr_longlong(swapchain), allocator);
 362
 363     if (allocator)
 364         FIXME("Support for allocation callbacks not implemented yet\n");
 365
 366     pvkDestroySwapchainKHR(device, swapchain, NULL /* allocator */);
 367 }
 368
 369 static VkResult macdrv_vkEnumerateInstanceExtensionProperties(const char *layer_name,
 370         uint32_t *count, VkExtensionProperties* properties)
 371 {
 372     unsigned int i;
 373     BOOL seen_surface = FALSE;
 374     VkResult res;
 375
 376     TRACE("layer_name %s, count %p, properties %p\n", debugstr_a(layer_name), count, properties);
 377
 378     /* This shouldn't get called with layer_name set, the ICD loader prevents it. */
 379     if (layer_name)
 380     {
 381         ERR("Layer enumeration not supported from ICD.\n");
 382         return VK_ERROR_LAYER_NOT_PRESENT;
 383     }
 384
 385     /* We will return at most the same number of instance extensions reported by the host back to
 386      * winevulkan. Along the way we may replace MoltenVK extensions with their win32 equivalents,
 387      * or remove redundant extensions outright.
 388      * Winevulkan will perform more detailed filtering as it knows whether it has thunks
 389      * for a particular extension.
 390      */
 391     res = pvkEnumerateInstanceExtensionProperties(layer_name, count, properties);
 392     if (!properties || res < 0)
 393         return res;
 394
 395     for (i = 0; i < *count; i++)
 396     {
 397         /* For now the only MoltenVK extensions we need to fixup. Long-term we may need an array. */
 398         if (!strcmp(properties[i].extensionName, "VK_MVK_macos_surface") ||
 399             !strcmp(properties[i].extensionName, "VK_EXT_metal_surface"))
 400         {
 401             if (seen_surface)
 402             {
 403                 /* If we've already seen a surface extension, just hide this one. */
 404                 memmove(properties + i, properties + i + 1, (*count - i - 1) * sizeof(*properties));
 405                 --*count;
 406                 --i;
 407                 continue;
 408             }
 409             TRACE("Substituting %s for VK_KHR_win32_surface\n", properties[i].extensionName);
 410
 411             snprintf(properties[i].extensionName, sizeof(properties[i].extensionName),
 412                     VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
 413             properties[i].specVersion = VK_KHR_WIN32_SURFACE_SPEC_VERSION;
 414             seen_surface = TRUE;
 415         }
 416     }
 417
 418     TRACE("Returning %u extensions.\n", *count);
 419     return res;
 420 }
 421
 422 static const char *wine_vk_native_fn_name(const char *name)
 423 {
 424     const char *create_surface_name =
 425         pvkCreateMetalSurfaceEXT ? "vkCreateMetalSurfaceEXT" : "vkCreateMacOSSurfaceMVK";
 426
 427     if (!strcmp(name, "vkCreateWin32SurfaceKHR"))
 428         return create_surface_name;
 429     /* We just need something where non-NULL is returned if the correct extension is enabled.
 430      * So since there is no native equivalent of this function check for the create
 431      * surface function.
 432      */
 433     if (!strcmp(name, "vkGetPhysicalDeviceWin32PresentationSupportKHR"))
 434         return create_surface_name;
 435
 436     return name;
 437 }
 438
 439 static void *macdrv_vkGetDeviceProcAddr(VkDevice device, const char *name)
 440 {
 441     void *proc_addr;
 442
 443     TRACE("%p, %s\n", device, debugstr_a(name));
 444
 445     if (!pvkGetDeviceProcAddr(device, wine_vk_native_fn_name(name)))
 446         return NULL;
 447
 448     if ((proc_addr = macdrv_get_vk_device_proc_addr(name)))
 449         return proc_addr;
 450
 451     return pvkGetDeviceProcAddr(device, name);
 452 }
 453
 454 static void *macdrv_vkGetInstanceProcAddr(VkInstance instance, const char *name)
 455 {
 456     void *proc_addr;
 457
 458     TRACE("%p, %s\n", instance, debugstr_a(name));
 459
 460     if (!pvkGetInstanceProcAddr(instance, wine_vk_native_fn_name(name)))
 461         return NULL;
 462
 463     if ((proc_addr = macdrv_get_vk_instance_proc_addr(instance, name)))
 464         return proc_addr;
 465
 466     return pvkGetInstanceProcAddr(instance, name);
 467 }
 468
 469 static VkResult macdrv_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice phys_dev,
 470         const VkPhysicalDeviceSurfaceInfo2KHR *surface_info, VkSurfaceCapabilities2KHR *capabilities)
 471 {
 472     VkPhysicalDeviceSurfaceInfo2KHR surface_info_host;
 473
 474     TRACE("%p, %p, %p\n", phys_dev, surface_info, capabilities);
 475
 476     surface_info_host = *surface_info;
 477     surface_info_host.surface = surface_from_handle(surface_info->surface)->surface;
 478
 479     return pvkGetPhysicalDeviceSurfaceCapabilities2KHR(phys_dev, &surface_info_host, capabilities);
 480 }
 481
 482 static VkResult macdrv_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice phys_dev,
 483         VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *capabilities)
 484 {
 485     struct wine_vk_surface *mac_surface = surface_from_handle(surface);
 486
 487     TRACE("%p, 0x%s, %p\n", phys_dev, wine_dbgstr_longlong(surface), capabilities);
 488
 489     return pvkGetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev, mac_surface->surface,
 490             capabilities);
 491 }
 492
 493 static VkResult macdrv_vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice phys_dev,
 494         const VkPhysicalDeviceSurfaceInfo2KHR *surface_info, uint32_t *count, VkSurfaceFormat2KHR *formats)
 495 {
 496     VkPhysicalDeviceSurfaceInfo2KHR surface_info_host;
 497
 498     TRACE("%p, %p, %p, %p\n", phys_dev, surface_info, count, formats);
 499
 500     surface_info_host = *surface_info;
 501     surface_info_host.surface = surface_from_handle(surface_info->surface)->surface;
 502
 503     return pvkGetPhysicalDeviceSurfaceFormats2KHR(phys_dev, &surface_info_host, count, formats);
 504 }
 505
 506 static VkResult macdrv_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice phys_dev,
 507         VkSurfaceKHR surface, uint32_t *count, VkSurfaceFormatKHR *formats)
 508 {
 509     struct wine_vk_surface *mac_surface = surface_from_handle(surface);
 510
 511     TRACE("%p, 0x%s, %p, %p\n", phys_dev, wine_dbgstr_longlong(surface), count, formats);
 512
 513     return pvkGetPhysicalDeviceSurfaceFormatsKHR(phys_dev, mac_surface->surface,
 514             count, formats);
 515 }
 516
 517 static VkResult macdrv_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice phys_dev,
 518         VkSurfaceKHR surface, uint32_t *count, VkPresentModeKHR *modes)
 519 {
 520     struct wine_vk_surface *mac_surface = surface_from_handle(surface);
 521
 522     TRACE("%p, 0x%s, %p, %p\n", phys_dev, wine_dbgstr_longlong(surface), count, modes);
 523
 524     return pvkGetPhysicalDeviceSurfacePresentModesKHR(phys_dev, mac_surface->surface, count,
 525             modes);
 526 }
 527
 528 static VkResult macdrv_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice phys_dev,
 529         uint32_t index, VkSurfaceKHR surface, VkBool32 *supported)
 530 {
 531     struct wine_vk_surface *mac_surface = surface_from_handle(surface);
 532
 533     TRACE("%p, %u, 0x%s, %p\n", phys_dev, index, wine_dbgstr_longlong(surface), supported);
 534
 535     return pvkGetPhysicalDeviceSurfaceSupportKHR(phys_dev, index, mac_surface->surface,
 536             supported);
 537 }
 538
 539 static VkBool32 macdrv_vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice phys_dev,
 540         uint32_t index)
 541 {
 542     TRACE("%p %u\n", phys_dev, index);
 543
 544     return VK_TRUE;
 545 }
 546
 547 static VkResult macdrv_vkGetSwapchainImagesKHR(VkDevice device,
 548         VkSwapchainKHR swapchain, uint32_t *count, VkImage *images)
 549 {
 550     TRACE("%p, 0x%s %p %p\n", device, wine_dbgstr_longlong(swapchain), count, images);
 551     return pvkGetSwapchainImagesKHR(device, swapchain, count, images);
 552 }
 553
 554 static VkResult macdrv_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *present_info)
 555 {
 556     TRACE("%p, %p\n", queue, present_info);
 557     VkResult res = pvkQueuePresentKHR(queue, present_info);
 558
 559     if (TRACE_ON(fps))
 560     {
 561         static unsigned long frames, frames_total;
 562         static long prev_time, start_time;
 563         DWORD time;
 564
 565         time = NtGetTickCount();
 566         frames++;
 567         frames_total++;
 568         if (time - prev_time > 1500)
 569         {
 570             TRACE_(fps)("%p @ approx %.2ffps, total %.2ffps\n",
 571                     queue, 1000.0 * frames / (time - prev_time),
 572                     1000.0 * frames_total / (time - start_time));
 573             prev_time = time;
 574             frames = 0;
 575             if (!start_time)
 576                 start_time = time;
 577         }
 578     }
 579
 580     return res;
 581 }
 582
 583 static VkSurfaceKHR macdrv_wine_get_native_surface(VkSurfaceKHR surface)
 584 {
 585     struct wine_vk_surface *mac_surface = surface_from_handle(surface);
 586
 587     TRACE("0x%s\n", wine_dbgstr_longlong(surface));
 588
 589     return mac_surface->surface;
 590 }
 591
 592 static const struct vulkan_funcs vulkan_funcs =
 593 {
 594     macdrv_vkCreateInstance,
 595     macdrv_vkCreateSwapchainKHR,
 596     macdrv_vkCreateWin32SurfaceKHR,
 597     macdrv_vkDestroyInstance,
 598     macdrv_vkDestroySurfaceKHR,
 599     macdrv_vkDestroySwapchainKHR,
 600     macdrv_vkEnumerateInstanceExtensionProperties,
 601     NULL,
 602     macdrv_vkGetDeviceProcAddr,
 603     macdrv_vkGetInstanceProcAddr,
 604     NULL,
 605     macdrv_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
 606     macdrv_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
 607     macdrv_vkGetPhysicalDeviceSurfaceFormats2KHR,
 608     macdrv_vkGetPhysicalDeviceSurfaceFormatsKHR,
 609     macdrv_vkGetPhysicalDeviceSurfacePresentModesKHR,
 610     macdrv_vkGetPhysicalDeviceSurfaceSupportKHR,
 611     macdrv_vkGetPhysicalDeviceWin32PresentationSupportKHR,
 612     macdrv_vkGetSwapchainImagesKHR,
 613     macdrv_vkQueuePresentKHR,
 614
 615     macdrv_wine_get_native_surface,
 616 };
 617
 618 static void *macdrv_get_vk_device_proc_addr(const char *name)
 619 {
 620     return get_vulkan_driver_device_proc_addr(&vulkan_funcs, name);
 621 }
 622
 623 static void *macdrv_get_vk_instance_proc_addr(VkInstance instance, const char *name)
 624 {
 625     return get_vulkan_driver_instance_proc_addr(&vulkan_funcs, instance, name);
 626 }
 627
 628 static const struct vulkan_funcs *get_vulkan_driver(UINT version)
 629 {
 630     static pthread_once_t init_once = PTHREAD_ONCE_INIT;
 631
 632     if (version != WINE_VULKAN_DRIVER_VERSION)
 633     {
 634         ERR("version mismatch, vulkan wants %u but driver has %u\n", version, WINE_VULKAN_DRIVER_VERSION);
 635         return NULL;
 636     }
 637
 638     pthread_once(&init_once, wine_vk_init);
 639     if (vulkan_handle)
 640         return &vulkan_funcs;
 641
 642     return NULL;
 643 }
 644
 645 #else /* No vulkan */
 646
 647 static const struct vulkan_funcs *get_vulkan_driver(UINT version)
 648 {
 649     ERR("Wine was built without Vulkan support.\n");
 650     return NULL;
 651 }
 652
 653 #endif /* SONAME_LIBMOLTENVK */
 654
 655 const struct vulkan_funcs *macdrv_wine_get_vulkan_driver(UINT version)
 656 {
 657     return get_vulkan_driver( version );
 658 }