| /* |
| Simple DirectMedia Layer |
| Copyright (C) 1997-2024 Sam Lantinga <slouken@libsdl.org> |
| |
| This software is provided 'as-is', without any express or implied |
| warranty. In no event will the authors be held liable for any damages |
| arising from the use of this software. |
| |
| Permission is granted to anyone to use this software for any purpose, |
| including commercial applications, and to alter it and redistribute it |
| freely, subject to the following restrictions: |
| |
| 1. The origin of this software must not be misrepresented; you must not |
| claim that you wrote the original software. If you use this software |
| in a product, an acknowledgment in the product documentation would be |
| appreciated but is not required. |
| 2. Altered source versions must be plainly marked as such, and must not be |
| misrepresented as being the original software. |
| 3. This notice may not be removed or altered from any source distribution. |
| */ |
| #include "SDL_internal.h" |
| |
| #if defined(SDL_VIDEO_VULKAN) && defined(SDL_VIDEO_DRIVER_X11) |
| |
| #include "../SDL_vulkan_internal.h" |
| |
| #include "SDL_x11video.h" |
| |
| #include "SDL_x11vulkan.h" |
| |
| #include <X11/Xlib.h> |
| /*#include <xcb/xcb.h>*/ |
| |
| #ifdef SDL_PLATFORM_OPENBSD |
| #define DEFAULT_VULKAN "libvulkan.so" |
| #else |
| #define DEFAULT_VULKAN "libvulkan.so.1" |
| #endif |
| |
| /* |
| typedef uint32_t xcb_window_t; |
| typedef uint32_t xcb_visualid_t; |
| */ |
| |
| int X11_Vulkan_LoadLibrary(SDL_VideoDevice *_this, const char *path) |
| { |
| SDL_VideoData *videoData = _this->driverdata; |
| VkExtensionProperties *extensions = NULL; |
| Uint32 extensionCount = 0; |
| SDL_bool hasSurfaceExtension = SDL_FALSE; |
| SDL_bool hasXlibSurfaceExtension = SDL_FALSE; |
| SDL_bool hasXCBSurfaceExtension = SDL_FALSE; |
| PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = NULL; |
| Uint32 i; |
| if (_this->vulkan_config.loader_handle) { |
| return SDL_SetError("Vulkan already loaded"); |
| } |
| |
| /* Load the Vulkan loader library */ |
| if (!path) { |
| path = SDL_getenv("SDL_VULKAN_LIBRARY"); |
| } |
| if (!path) { |
| path = DEFAULT_VULKAN; |
| } |
| _this->vulkan_config.loader_handle = SDL_LoadObject(path); |
| if (!_this->vulkan_config.loader_handle) { |
| return -1; |
| } |
| SDL_strlcpy(_this->vulkan_config.loader_path, path, SDL_arraysize(_this->vulkan_config.loader_path)); |
| vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)SDL_LoadFunction( |
| _this->vulkan_config.loader_handle, "vkGetInstanceProcAddr"); |
| if (!vkGetInstanceProcAddr) { |
| goto fail; |
| } |
| _this->vulkan_config.vkGetInstanceProcAddr = (void *)vkGetInstanceProcAddr; |
| _this->vulkan_config.vkEnumerateInstanceExtensionProperties = |
| (void *)((PFN_vkGetInstanceProcAddr)_this->vulkan_config.vkGetInstanceProcAddr)( |
| VK_NULL_HANDLE, "vkEnumerateInstanceExtensionProperties"); |
| if (!_this->vulkan_config.vkEnumerateInstanceExtensionProperties) { |
| goto fail; |
| } |
| extensions = SDL_Vulkan_CreateInstanceExtensionsList( |
| (PFN_vkEnumerateInstanceExtensionProperties) |
| _this->vulkan_config.vkEnumerateInstanceExtensionProperties, |
| &extensionCount); |
| if (!extensions) { |
| goto fail; |
| } |
| for (i = 0; i < extensionCount; i++) { |
| if (SDL_strcmp(VK_KHR_SURFACE_EXTENSION_NAME, extensions[i].extensionName) == 0) { |
| hasSurfaceExtension = SDL_TRUE; |
| } else if (SDL_strcmp(VK_KHR_XCB_SURFACE_EXTENSION_NAME, extensions[i].extensionName) == 0) { |
| hasXCBSurfaceExtension = SDL_TRUE; |
| } else if (SDL_strcmp(VK_KHR_XLIB_SURFACE_EXTENSION_NAME, extensions[i].extensionName) == 0) { |
| hasXlibSurfaceExtension = SDL_TRUE; |
| } |
| } |
| SDL_free(extensions); |
| if (!hasSurfaceExtension) { |
| SDL_SetError("Installed Vulkan doesn't implement the " VK_KHR_SURFACE_EXTENSION_NAME " extension"); |
| goto fail; |
| } |
| if (hasXlibSurfaceExtension) { |
| videoData->vulkan_xlib_xcb_library = NULL; |
| } else if (!hasXCBSurfaceExtension) { |
| SDL_SetError("Installed Vulkan doesn't implement either the " VK_KHR_XCB_SURFACE_EXTENSION_NAME "extension or the " VK_KHR_XLIB_SURFACE_EXTENSION_NAME " extension"); |
| goto fail; |
| } else { |
| const char *libX11XCBLibraryName = SDL_getenv("SDL_X11_XCB_LIBRARY"); |
| if (!libX11XCBLibraryName) { |
| libX11XCBLibraryName = "libX11-xcb.so"; |
| } |
| videoData->vulkan_xlib_xcb_library = SDL_LoadObject(libX11XCBLibraryName); |
| if (!videoData->vulkan_xlib_xcb_library) { |
| goto fail; |
| } |
| videoData->vulkan_XGetXCBConnection = |
| (PFN_XGetXCBConnection)SDL_LoadFunction(videoData->vulkan_xlib_xcb_library, "XGetXCBConnection"); |
| if (!videoData->vulkan_XGetXCBConnection) { |
| SDL_UnloadObject(videoData->vulkan_xlib_xcb_library); |
| goto fail; |
| } |
| } |
| return 0; |
| |
| fail: |
| SDL_UnloadObject(_this->vulkan_config.loader_handle); |
| _this->vulkan_config.loader_handle = NULL; |
| return -1; |
| } |
| |
| void X11_Vulkan_UnloadLibrary(SDL_VideoDevice *_this) |
| { |
| SDL_VideoData *videoData = _this->driverdata; |
| if (_this->vulkan_config.loader_handle) { |
| if (videoData->vulkan_xlib_xcb_library) { |
| SDL_UnloadObject(videoData->vulkan_xlib_xcb_library); |
| } |
| SDL_UnloadObject(_this->vulkan_config.loader_handle); |
| _this->vulkan_config.loader_handle = NULL; |
| } |
| } |
| |
| char const* const* X11_Vulkan_GetInstanceExtensions(SDL_VideoDevice *_this, |
| Uint32 *count) |
| { |
| SDL_VideoData *videoData = _this->driverdata; |
| if (videoData->vulkan_xlib_xcb_library) { |
| static const char *const extensionsForXCB[] = { |
| VK_KHR_SURFACE_EXTENSION_NAME, |
| VK_KHR_XCB_SURFACE_EXTENSION_NAME, |
| }; |
| if(count) { |
| *count = SDL_arraysize(extensionsForXCB); |
| } |
| return extensionsForXCB; |
| } else { |
| static const char *const extensionsForXlib[] = { |
| VK_KHR_SURFACE_EXTENSION_NAME, |
| VK_KHR_XLIB_SURFACE_EXTENSION_NAME, |
| }; |
| if(count) { |
| *count = SDL_arraysize(extensionsForXlib); |
| } |
| return extensionsForXlib; |
| } |
| } |
| |
| SDL_bool X11_Vulkan_CreateSurface(SDL_VideoDevice *_this, |
| SDL_Window *window, |
| VkInstance instance, |
| const struct VkAllocationCallbacks *allocator, |
| VkSurfaceKHR *surface) |
| { |
| SDL_VideoData *videoData = _this->driverdata; |
| SDL_WindowData *windowData = window->driverdata; |
| PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr; |
| if (!_this->vulkan_config.loader_handle) { |
| SDL_SetError("Vulkan is not loaded"); |
| return SDL_FALSE; |
| } |
| vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)_this->vulkan_config.vkGetInstanceProcAddr; |
| if (videoData->vulkan_xlib_xcb_library) { |
| PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = |
| (PFN_vkCreateXcbSurfaceKHR)vkGetInstanceProcAddr(instance, |
| "vkCreateXcbSurfaceKHR"); |
| VkXcbSurfaceCreateInfoKHR createInfo; |
| VkResult result; |
| if (!vkCreateXcbSurfaceKHR) { |
| SDL_SetError(VK_KHR_XCB_SURFACE_EXTENSION_NAME |
| " extension is not enabled in the Vulkan instance."); |
| return SDL_FALSE; |
| } |
| SDL_zero(createInfo); |
| createInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; |
| createInfo.connection = videoData->vulkan_XGetXCBConnection(videoData->display); |
| if (!createInfo.connection) { |
| SDL_SetError("XGetXCBConnection failed"); |
| return SDL_FALSE; |
| } |
| createInfo.window = (xcb_window_t)windowData->xwindow; |
| result = vkCreateXcbSurfaceKHR(instance, &createInfo, allocator, surface); |
| if (result != VK_SUCCESS) { |
| SDL_SetError("vkCreateXcbSurfaceKHR failed: %s", SDL_Vulkan_GetResultString(result)); |
| return SDL_FALSE; |
| } |
| return SDL_TRUE; |
| } else { |
| PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = |
| (PFN_vkCreateXlibSurfaceKHR)vkGetInstanceProcAddr(instance, |
| "vkCreateXlibSurfaceKHR"); |
| VkXlibSurfaceCreateInfoKHR createInfo; |
| VkResult result; |
| if (!vkCreateXlibSurfaceKHR) { |
| SDL_SetError(VK_KHR_XLIB_SURFACE_EXTENSION_NAME |
| " extension is not enabled in the Vulkan instance."); |
| return SDL_FALSE; |
| } |
| SDL_zero(createInfo); |
| createInfo.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; |
| createInfo.dpy = videoData->display; |
| createInfo.window = (xcb_window_t)windowData->xwindow; |
| result = vkCreateXlibSurfaceKHR(instance, &createInfo, allocator, surface); |
| if (result != VK_SUCCESS) { |
| SDL_SetError("vkCreateXlibSurfaceKHR failed: %s", SDL_Vulkan_GetResultString(result)); |
| return SDL_FALSE; |
| } |
| return SDL_TRUE; |
| } |
| } |
| |
| void X11_Vulkan_DestroySurface(SDL_VideoDevice *_this, |
| VkInstance instance, |
| VkSurfaceKHR surface, |
| const struct VkAllocationCallbacks *allocator) |
| { |
| if (_this->vulkan_config.loader_handle) { |
| SDL_Vulkan_DestroySurface_Internal(_this->vulkan_config.vkGetInstanceProcAddr, instance, surface, allocator); |
| } |
| } |
| |
| #endif |