Attachment #515818 for bug #644732

View | Details | Raw Unified | Return to bug 644732
Collapse All | Expand All

Lines 2546-2551 Link Here

(-)a/configure.in (+6 lines)
2546	if test x$enable_video_vulkan = xyes; then	2546	if test x$enable_video_vulkan = xyes; then
2547	AC_DEFINE(SDL_VIDEO_VULKAN, 1, [ ])	2547	AC_DEFINE(SDL_VIDEO_VULKAN, 1, [ ])
2548	SUMMARY_video="${SUMMARY_video} vulkan"	2548	SUMMARY_video="${SUMMARY_video} vulkan"
		2549
		2550	VULKAN_CFLAGS=`$PKG_CONFIG --cflags vulkan`
		2551	VULKAN_LIBS=`$PKG_CONFIG --libs vulkan`
		2552
		2553	EXTRA_CFLAGS="$EXTRA_CFLAGS $VULKAN_CFLAGS"
		2554	EXTRA_LDFLAGS="$EXTRA_LDFLAGS $VULKAN_LIBS"
2549	fi	2555	fi
2550	}	2556	}
2551		2557





#include "SDL_stdinc.h"

#if defined(SDL_LOADSO_DISABLED)
#undef SDL_VIDEO_VULKAN
#define SDL_VIDEO_VULKAN 0
#endif

#if SDL_VIDEO_VULKAN

#if SDL_VIDEO_DRIVER_ANDROID

#define VK_USE_PLATFORM_XCB_KHR
#endif

#include <vulkan/vulkan.h>
#include "./khronos/vulkan/vulkan.h"

#include "SDL_vulkan.h"





#include "SDL_x11video.h"
#include "SDL_assert.h"

#include "SDL_loadso.h"
#include "SDL_x11vulkan.h"

#include <X11/Xlib.h>

    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.vkGetInstanceProcAddr)
        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;

    {
        videoData->vulkan_xlib_xcb_library = NULL;
    }
    else
    {
        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:
    _this->vulkan_config.vkGetInstanceProcAddr = NULL;
    _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,

                                          const char **names)
{
    SDL_VideoData *videoData = (SDL_VideoData *)_this->driverdata;
    if(!_this->vulkan_config.vkGetInstanceProcAddr)
    {
        SDL_SetError("Vulkan is not loaded");
        return SDL_FALSE;

    SDL_VideoData *videoData = (SDL_VideoData *)_this->driverdata;
    SDL_WindowData *windowData = (SDL_WindowData *)window->driverdata;
    PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
    if(!_this->vulkan_config.vkGetInstanceProcAddr)
    {
        SDL_SetError("Vulkan is not loaded");
        return SDL_FALSE;

Return to bug 644732

Lines 25-35 Link Here

(-)a/src/video/SDL_vulkan_internal.h (-7 / +1 lines)
25		25
26	#include "SDL_stdinc.h"	26	#include "SDL_stdinc.h"
27		27
28	#if defined(SDL_LOADSO_DISABLED)
29	#undef SDL_VIDEO_VULKAN
30	#define SDL_VIDEO_VULKAN 0
31	#endif
32
33	#if SDL_VIDEO_VULKAN	28	#if SDL_VIDEO_VULKAN
34		29
35	#if SDL_VIDEO_DRIVER_ANDROID	30	#if SDL_VIDEO_DRIVER_ANDROID
Lines 57-64 Link Here
57	#define VK_USE_PLATFORM_XCB_KHR	52	#define VK_USE_PLATFORM_XCB_KHR
58	#endif	53	#endif
59		54
60	#define VK_NO_PROTOTYPES	55	#include <vulkan/vulkan.h>
61	#include "./khronos/vulkan/vulkan.h"
62		56
63	#include "SDL_vulkan.h"	57	#include "SDL_vulkan.h"
64		58

Lines 25-31 Link Here

(-)a/src/video/x11/SDL_x11vulkan.c (-41 / +5 lines)
25	#include "SDL_x11video.h"	25	#include "SDL_x11video.h"
26	#include "SDL_assert.h"	26	#include "SDL_assert.h"
27		27
28	#include "SDL_loadso.h"
29	#include "SDL_x11vulkan.h"	28	#include "SDL_x11vulkan.h"
30		29
31	#include <X11/Xlib.h>	30	#include <X11/Xlib.h>
Lines 43-64 Link Here
43	SDL_bool hasSurfaceExtension = SDL_FALSE;	42	SDL_bool hasSurfaceExtension = SDL_FALSE;
44	SDL_bool hasXlibSurfaceExtension = SDL_FALSE;	43	SDL_bool hasXlibSurfaceExtension = SDL_FALSE;
45	SDL_bool hasXCBSurfaceExtension = SDL_FALSE;	44	SDL_bool hasXCBSurfaceExtension = SDL_FALSE;
46	PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = NULL;
47	Uint32 i;	45	Uint32 i;
48	if(_this->vulkan_config.loader_handle)	46	if(_this->vulkan_config.vkGetInstanceProcAddr)
49	return SDL_SetError("Vulkan already loaded");	47	return SDL_SetError("Vulkan already loaded");
50		48
51	/* Load the Vulkan loader library */	49	/* Load the Vulkan loader library */
52	if(!path)
53	path = SDL_getenv("SDL_VULKAN_LIBRARY");
54	if(!path)
55	path = "libvulkan.so.1";
56	_this->vulkan_config.loader_handle = SDL_LoadObject(path);
57	if(!_this->vulkan_config.loader_handle)
58	return -1;
59	SDL_strlcpy(_this->vulkan_config.loader_path, path, SDL_arraysize(_this->vulkan_config.loader_path));
60	vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)SDL_LoadFunction(
61	_this->vulkan_config.loader_handle, "vkGetInstanceProcAddr");
62	if(!vkGetInstanceProcAddr)	50	if(!vkGetInstanceProcAddr)
63	goto fail;	51	goto fail;
64	_this->vulkan_config.vkGetInstanceProcAddr = (void *)vkGetInstanceProcAddr;	52	_this->vulkan_config.vkGetInstanceProcAddr = (void *)vkGetInstanceProcAddr;
Lines 93-139 Link Here
93	{	81	{
94	videoData->vulkan_xlib_xcb_library = NULL;	82	videoData->vulkan_xlib_xcb_library = NULL;
95	}	83	}
96	else if(!hasXCBSurfaceExtension)	84	else
97	{	85	{
98	SDL_SetError("Installed Vulkan doesn't implement either the "	86	SDL_SetError("Installed Vulkan doesn't implement either the "
99	VK_KHR_XCB_SURFACE_EXTENSION_NAME "extension or the "	87	VK_KHR_XCB_SURFACE_EXTENSION_NAME "extension or the "
100	VK_KHR_XLIB_SURFACE_EXTENSION_NAME " extension");	88	VK_KHR_XLIB_SURFACE_EXTENSION_NAME " extension");
101	goto fail;	89	goto fail;
102	}	90	}
103	else
104	{
105	const char *libX11XCBLibraryName = SDL_getenv("SDL_X11_XCB_LIBRARY");
106	if(!libX11XCBLibraryName)
107	libX11XCBLibraryName = "libX11-xcb.so";
108	videoData->vulkan_xlib_xcb_library = SDL_LoadObject(libX11XCBLibraryName);
109	if(!videoData->vulkan_xlib_xcb_library)
110	goto fail;
111	videoData->vulkan_XGetXCBConnection =
112	SDL_LoadFunction(videoData->vulkan_xlib_xcb_library, "XGetXCBConnection");
113	if(!videoData->vulkan_XGetXCBConnection)
114	{
115	SDL_UnloadObject(videoData->vulkan_xlib_xcb_library);
116	goto fail;
117	}
118	}
119	return 0;	91	return 0;
120		92
121	fail:	93	fail:
122	SDL_UnloadObject(_this->vulkan_config.loader_handle);	94	_this->vulkan_config.vkGetInstanceProcAddr = NULL;
123	_this->vulkan_config.loader_handle = NULL;
124	return -1;	95	return -1;
125	}	96	}
126		97
127	void X11_Vulkan_UnloadLibrary(_THIS)	98	void X11_Vulkan_UnloadLibrary(_THIS)
128	{	99	{
129	SDL_VideoData videoData = (SDL_VideoData )_this->driverdata;	100	SDL_VideoData videoData = (SDL_VideoData )_this->driverdata;
130	if(_this->vulkan_config.loader_handle)
131	{
132	if(videoData->vulkan_xlib_xcb_library)
133	SDL_UnloadObject(videoData->vulkan_xlib_xcb_library);
134	SDL_UnloadObject(_this->vulkan_config.loader_handle);
135	_this->vulkan_config.loader_handle = NULL;
136	}
137	}	101	}
138		102
139	SDL_bool X11_Vulkan_GetInstanceExtensions(_THIS,	103	SDL_bool X11_Vulkan_GetInstanceExtensions(_THIS,
Lines 142-148 Link Here
142	const char **names)	106	const char **names)
143	{	107	{
144	SDL_VideoData videoData = (SDL_VideoData )_this->driverdata;	108	SDL_VideoData videoData = (SDL_VideoData )_this->driverdata;
145	if(!_this->vulkan_config.loader_handle)	109	if(!_this->vulkan_config.vkGetInstanceProcAddr)
146	{	110	{
147	SDL_SetError("Vulkan is not loaded");	111	SDL_SetError("Vulkan is not loaded");
148	return SDL_FALSE;	112	return SDL_FALSE;
Lines 173-179 Link Here
173	SDL_VideoData videoData = (SDL_VideoData )_this->driverdata;	137	SDL_VideoData videoData = (SDL_VideoData )_this->driverdata;
174	SDL_WindowData windowData = (SDL_WindowData )window->driverdata;	138	SDL_WindowData windowData = (SDL_WindowData )window->driverdata;
175	PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;	139	PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
176	if(!_this->vulkan_config.loader_handle)	140	if(!_this->vulkan_config.vkGetInstanceProcAddr)
177	{	141	{
178	SDL_SetError("Vulkan is not loaded");	142	SDL_SetError("Vulkan is not loaded");
179	return SDL_FALSE;	143	return SDL_FALSE;