290 lines
12 KiB
C
290 lines
12 KiB
C
/*
|
|
Simple DirectMedia Layer
|
|
Copyright (C) 1997-2025 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"
|
|
#define DEFAULT_X11_XCB "libX11-xcb.so"
|
|
#else
|
|
#define DEFAULT_VULKAN "libvulkan.so.1"
|
|
#define DEFAULT_X11_XCB "libX11-xcb.so.1"
|
|
#endif
|
|
|
|
/*
|
|
typedef uint32_t xcb_window_t;
|
|
typedef uint32_t xcb_visualid_t;
|
|
*/
|
|
|
|
bool X11_Vulkan_LoadLibrary(SDL_VideoDevice *_this, const char *path)
|
|
{
|
|
SDL_VideoData *videoData = _this->internal;
|
|
VkExtensionProperties *extensions = NULL;
|
|
Uint32 extensionCount = 0;
|
|
bool hasSurfaceExtension = false;
|
|
bool hasXlibSurfaceExtension = false;
|
|
bool hasXCBSurfaceExtension = 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_GetHint(SDL_HINT_VULKAN_LIBRARY);
|
|
}
|
|
if (!path) {
|
|
path = DEFAULT_VULKAN;
|
|
}
|
|
_this->vulkan_config.loader_handle = SDL_LoadObject(path);
|
|
if (!_this->vulkan_config.loader_handle) {
|
|
return false;
|
|
}
|
|
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 = true;
|
|
} else if (SDL_strcmp(VK_KHR_XCB_SURFACE_EXTENSION_NAME, extensions[i].extensionName) == 0) {
|
|
hasXCBSurfaceExtension = true;
|
|
} else if (SDL_strcmp(VK_KHR_XLIB_SURFACE_EXTENSION_NAME, extensions[i].extensionName) == 0) {
|
|
hasXlibSurfaceExtension = 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_GetHint(SDL_HINT_X11_XCB_LIBRARY);
|
|
if (!libX11XCBLibraryName || !*libX11XCBLibraryName) {
|
|
libX11XCBLibraryName = DEFAULT_X11_XCB;
|
|
}
|
|
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 true;
|
|
|
|
fail:
|
|
SDL_UnloadObject(_this->vulkan_config.loader_handle);
|
|
_this->vulkan_config.loader_handle = NULL;
|
|
return false;
|
|
}
|
|
|
|
void X11_Vulkan_UnloadLibrary(SDL_VideoDevice *_this)
|
|
{
|
|
SDL_VideoData *videoData = _this->internal;
|
|
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->internal;
|
|
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;
|
|
}
|
|
}
|
|
|
|
bool X11_Vulkan_CreateSurface(SDL_VideoDevice *_this,
|
|
SDL_Window *window,
|
|
VkInstance instance,
|
|
const struct VkAllocationCallbacks *allocator,
|
|
VkSurfaceKHR *surface)
|
|
{
|
|
SDL_VideoData *videoData = _this->internal;
|
|
SDL_WindowData *windowData = window->internal;
|
|
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
|
|
if (!_this->vulkan_config.loader_handle) {
|
|
return SDL_SetError("Vulkan is not loaded");
|
|
}
|
|
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) {
|
|
return SDL_SetError(VK_KHR_XCB_SURFACE_EXTENSION_NAME " extension is not enabled in the Vulkan instance.");
|
|
}
|
|
SDL_zero(createInfo);
|
|
createInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
|
|
createInfo.connection = videoData->vulkan_XGetXCBConnection(videoData->display);
|
|
if (!createInfo.connection) {
|
|
return SDL_SetError("XGetXCBConnection failed");
|
|
}
|
|
createInfo.window = (xcb_window_t)windowData->xwindow;
|
|
result = vkCreateXcbSurfaceKHR(instance, &createInfo, allocator, surface);
|
|
if (result != VK_SUCCESS) {
|
|
return SDL_SetError("vkCreateXcbSurfaceKHR failed: %s", SDL_Vulkan_GetResultString(result));
|
|
}
|
|
} else {
|
|
PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR =
|
|
(PFN_vkCreateXlibSurfaceKHR)vkGetInstanceProcAddr(instance,
|
|
"vkCreateXlibSurfaceKHR");
|
|
VkXlibSurfaceCreateInfoKHR createInfo;
|
|
VkResult result;
|
|
if (!vkCreateXlibSurfaceKHR) {
|
|
return SDL_SetError(VK_KHR_XLIB_SURFACE_EXTENSION_NAME " extension is not enabled in the Vulkan instance.");
|
|
}
|
|
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) {
|
|
return SDL_SetError("vkCreateXlibSurfaceKHR failed: %s", SDL_Vulkan_GetResultString(result));
|
|
}
|
|
}
|
|
|
|
return true; // success!
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
bool X11_Vulkan_GetPresentationSupport(SDL_VideoDevice *_this,
|
|
VkInstance instance,
|
|
VkPhysicalDevice physicalDevice,
|
|
Uint32 queueFamilyIndex)
|
|
{
|
|
SDL_VideoData *videoData = _this->internal;
|
|
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
|
|
const char *forced_visual_id;
|
|
VisualID visualid;
|
|
|
|
if (!_this->vulkan_config.loader_handle) {
|
|
return SDL_SetError("Vulkan is not loaded");
|
|
}
|
|
vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)_this->vulkan_config.vkGetInstanceProcAddr;
|
|
|
|
forced_visual_id = SDL_GetHint(SDL_HINT_VIDEO_X11_WINDOW_VISUALID);
|
|
if (forced_visual_id) {
|
|
visualid = SDL_strtol(forced_visual_id, NULL, 0);
|
|
} else {
|
|
visualid = X11_XVisualIDFromVisual(DefaultVisual(videoData->display, DefaultScreen(videoData->display)));
|
|
}
|
|
|
|
if (videoData->vulkan_xlib_xcb_library) {
|
|
PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR =
|
|
(PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)vkGetInstanceProcAddr(
|
|
instance,
|
|
"vkGetPhysicalDeviceXcbPresentationSupportKHR");
|
|
|
|
if (!vkGetPhysicalDeviceXcbPresentationSupportKHR) {
|
|
return SDL_SetError(VK_KHR_XCB_SURFACE_EXTENSION_NAME " extension is not enabled in the Vulkan instance.");
|
|
}
|
|
|
|
return vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice,
|
|
queueFamilyIndex,
|
|
videoData->vulkan_XGetXCBConnection(videoData->display),
|
|
visualid);
|
|
} else {
|
|
PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR =
|
|
(PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)vkGetInstanceProcAddr(
|
|
instance,
|
|
"vkGetPhysicalDeviceXlibPresentationSupportKHR");
|
|
|
|
if (!vkGetPhysicalDeviceXlibPresentationSupportKHR) {
|
|
return SDL_SetError(VK_KHR_XLIB_SURFACE_EXTENSION_NAME " extension is not enabled in the Vulkan instance.");
|
|
}
|
|
|
|
return vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice,
|
|
queueFamilyIndex,
|
|
videoData->display,
|
|
visualid);
|
|
}
|
|
}
|
|
|
|
#endif
|