mirror of
https://github.com/Relintai/sdl2_frt.git
synced 2024-12-29 20:27:12 +01:00
244 lines
9.1 KiB
C
244 lines
9.1 KiB
C
/*
|
|
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: */
|