| /* |
| Simple DirectMedia Layer |
| Copyright (C) 1997-2020 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 SDL_VIDEO_VULKAN && SDL_VIDEO_DRIVER_X11 |
| |
| #include "SDL_x11video.h" |
| #include "SDL_assert.h" |
| |
| #include "SDL_loadso.h" |
| #include "SDL_x11vulkan.h" |
| |
| #include <X11/Xlib.h> |
| /*#include <xcb/xcb.h>*/ |
| /* |
| typedef uint32_t xcb_window_t; |
| typedef uint32_t xcb_visualid_t; |
| */ |
| |
| int X11_Vulkan_LoadLibrary(_THIS, const char *path) |
| { |
| SDL_VideoData *videoData = (SDL_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 = "libvulkan.so.1"; |
| _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 = |
| 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(_THIS) |
| { |
| SDL_VideoData *videoData = (SDL_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; |
| } |
| } |
| |
| SDL_bool X11_Vulkan_GetInstanceExtensions(_THIS, |
| SDL_Window *window, |
| unsigned *count, |
| const char **names) |
| { |
| SDL_VideoData *videoData = (SDL_VideoData *)_this->driverdata; |
| if(!_this->vulkan_config.loader_handle) |
| { |
| SDL_SetError("Vulkan is not loaded"); |
| return SDL_FALSE; |
| } |
| if(videoData->vulkan_xlib_xcb_library) |
| { |
| static const char *const extensionsForXCB[] = { |
| VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XCB_SURFACE_EXTENSION_NAME, |
| }; |
| return SDL_Vulkan_GetInstanceExtensions_Helper( |
| count, names, SDL_arraysize(extensionsForXCB), extensionsForXCB); |
| } |
| else |
| { |
| static const char *const extensionsForXlib[] = { |
| VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XLIB_SURFACE_EXTENSION_NAME, |
| }; |
| return SDL_Vulkan_GetInstanceExtensions_Helper( |
| count, names, SDL_arraysize(extensionsForXlib), extensionsForXlib); |
| } |
| } |
| |
| SDL_bool X11_Vulkan_CreateSurface(_THIS, |
| SDL_Window *window, |
| VkInstance instance, |
| VkSurfaceKHR *surface) |
| { |
| SDL_VideoData *videoData = (SDL_VideoData *)_this->driverdata; |
| SDL_WindowData *windowData = (SDL_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, |
| NULL, 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, |
| NULL, surface); |
| if(result != VK_SUCCESS) |
| { |
| SDL_SetError("vkCreateXlibSurfaceKHR failed: %s", SDL_Vulkan_GetResultString(result)); |
| return SDL_FALSE; |
| } |
| return SDL_TRUE; |
| } |
| } |
| |
| #endif |
| |
| /* vim: set ts=4 sw=4 expandtab: */ |
