[sdl_omap.git] / src / video / x11 / SDL_x11gl.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

#include "SDL_x11video.h"
#include "../../events/SDL_events_c.h"
#include "SDL_x11dga_c.h"
#include "SDL_x11gl_c.h"

#if defined(__IRIX__)
/* IRIX doesn't have a GL library versioning system */
#define DEFAULT_OPENGL	"libGL.so"
#elif defined(__MACOSX__)
#define DEFAULT_OPENGL	"/usr/X11R6/lib/libGL.1.dylib"
#elif defined(__QNXNTO__)
#define DEFAULT_OPENGL	"libGL.so.3"
#elif defined(__OpenBSD__)
#define DEFAULT_OPENGL	"libGL.so.4.0"
#else
#define DEFAULT_OPENGL	"libGL.so.1"
#endif

#ifndef GLX_ARB_multisample
#define GLX_ARB_multisample
#define GLX_SAMPLE_BUFFERS_ARB             100000
#define GLX_SAMPLES_ARB                    100001
#endif

/* GLX_EXT_visual_rating stuff that might not be in the system headers... */
#ifndef GLX_VISUAL_CAVEAT_EXT
#define GLX_VISUAL_CAVEAT_EXT              0x20
#endif
#ifndef GLX_NONE_EXT
#define GLX_NONE_EXT                       0x8000
#endif
#ifndef GLX_SLOW_VISUAL_EXT
#define GLX_SLOW_VISUAL_EXT                0x8001
#endif
#ifndef GLX_NON_CONFORMANT_VISUAL_EXT
#define GLX_NON_CONFORMANT_VISUAL_EXT      0x800D
#endif


#if SDL_VIDEO_OPENGL_GLX
static int glXExtensionSupported(_THIS, const char *extension)
{
	const char *extensions;
	const char *start;
	const char *where, *terminator;

	/* Extension names should not have spaces. */
	where = SDL_strchr(extension, ' ');
	if ( where || *extension == '\0' ) {
	      return 0;
	}

	extensions = this->gl_data->glXQueryExtensionsString(GFX_Display,SDL_Screen);
	/* It takes a bit of care to be fool-proof about parsing the
	 * OpenGL extensions string. Don't be fooled by sub-strings, etc.
	 */

	/* http://bugs.debian.org/537487 */
	if (extensions == NULL) {
	      return 0;
	}
	
	start = extensions;
	
	for (;;) {
		where = SDL_strstr(start, extension);
		if (!where) break;
		
		terminator = where + strlen(extension);
		if (where == start || *(where - 1) == ' ')
	        if (*terminator == ' ' || *terminator == '\0') return 1;
						  
		start = terminator;
	}
	return 0;
}
#endif /* SDL_VIDEO_OPENGL_GLX */

XVisualInfo *X11_GL_GetVisual(_THIS)
{
#if SDL_VIDEO_OPENGL_GLX
	/* 64 seems nice. */
	int attribs[64];
	int i;

	/* load the gl driver from a default path */
	if ( ! this->gl_config.driver_loaded ) {
	        /* no driver has been loaded, use default (ourselves) */
	        if ( X11_GL_LoadLibrary(this, NULL) < 0 ) {
		        return NULL;
		}
	}

	/* See if we already have a window which we must use */
	if ( SDL_windowid ) {
		XWindowAttributes a;
		XVisualInfo vi_in;
		int out_count;

		XGetWindowAttributes(SDL_Display, SDL_Window, &a);
		vi_in.screen = SDL_Screen;
		vi_in.visualid = XVisualIDFromVisual(a.visual);
		glx_visualinfo = XGetVisualInfo(SDL_Display,
	                     VisualScreenMask|VisualIDMask, &vi_in, &out_count);
		return glx_visualinfo;
	}

        /* Setup our GLX attributes according to the gl_config. */
	i = 0;
	attribs[i++] = GLX_RGBA;
	attribs[i++] = GLX_RED_SIZE;
	attribs[i++] = this->gl_config.red_size;
	attribs[i++] = GLX_GREEN_SIZE;
	attribs[i++] = this->gl_config.green_size;
	attribs[i++] = GLX_BLUE_SIZE;
	attribs[i++] = this->gl_config.blue_size;

	if( this->gl_config.alpha_size ) {
		attribs[i++] = GLX_ALPHA_SIZE;
		attribs[i++] = this->gl_config.alpha_size;
	}

	if( this->gl_config.buffer_size ) {
		attribs[i++] = GLX_BUFFER_SIZE;
		attribs[i++] = this->gl_config.buffer_size;
	}

	if( this->gl_config.double_buffer ) {
		attribs[i++] = GLX_DOUBLEBUFFER;
	}

	attribs[i++] = GLX_DEPTH_SIZE;
	attribs[i++] = this->gl_config.depth_size;

	if( this->gl_config.stencil_size ) {
		attribs[i++] = GLX_STENCIL_SIZE;
		attribs[i++] = this->gl_config.stencil_size;
	}

	if( this->gl_config.accum_red_size ) {
		attribs[i++] = GLX_ACCUM_RED_SIZE;
		attribs[i++] = this->gl_config.accum_red_size;
	}

	if( this->gl_config.accum_green_size ) {
		attribs[i++] = GLX_ACCUM_GREEN_SIZE;
		attribs[i++] = this->gl_config.accum_green_size;
	}

	if( this->gl_config.accum_blue_size ) {
		attribs[i++] = GLX_ACCUM_BLUE_SIZE;
		attribs[i++] = this->gl_config.accum_blue_size;
	}

	if( this->gl_config.accum_alpha_size ) {
		attribs[i++] = GLX_ACCUM_ALPHA_SIZE;
		attribs[i++] = this->gl_config.accum_alpha_size;
	}

	if( this->gl_config.stereo ) {
		attribs[i++] = GLX_STEREO;
	}
	
	if( this->gl_config.multisamplebuffers ) {
		attribs[i++] = GLX_SAMPLE_BUFFERS_ARB;
		attribs[i++] = this->gl_config.multisamplebuffers;
	}
	
	if( this->gl_config.multisamplesamples ) {
		attribs[i++] = GLX_SAMPLES_ARB;
		attribs[i++] = this->gl_config.multisamplesamples;
	}

	if( this->gl_config.accelerated >= 0 &&
	    glXExtensionSupported(this, "GLX_EXT_visual_rating") ) {
		attribs[i++] = GLX_VISUAL_CAVEAT_EXT;
		attribs[i++] = GLX_NONE_EXT;
	}

#ifdef GLX_DIRECT_COLOR /* Try for a DirectColor visual for gamma support */
	if ( !SDL_getenv("SDL_VIDEO_X11_NODIRECTCOLOR") ) {
		attribs[i++] = GLX_X_VISUAL_TYPE;
		attribs[i++] = GLX_DIRECT_COLOR;
	}
#endif
	attribs[i++] = None;

 	glx_visualinfo = this->gl_data->glXChooseVisual(GFX_Display, 
						  SDL_Screen, attribs);
#ifdef GLX_DIRECT_COLOR
	if( !glx_visualinfo && !SDL_getenv("SDL_VIDEO_X11_NODIRECTCOLOR") ) { /* No DirectColor visual?  Try again.. */
		attribs[i-3] = None;
 		glx_visualinfo = this->gl_data->glXChooseVisual(GFX_Display, 
						  SDL_Screen, attribs);
	}
#endif
	if( !glx_visualinfo ) {
		SDL_SetError( "Couldn't find matching GLX visual");
		return NULL;
	}
/*
	printf("Found GLX visual 0x%x\n", glx_visualinfo->visualid);
*/
	return glx_visualinfo;
#else
	SDL_SetError("X11 driver not configured with OpenGL");
	return NULL;
#endif
}

int X11_GL_CreateWindow(_THIS, int w, int h)
{
	int retval;
#if SDL_VIDEO_OPENGL_GLX
	XSetWindowAttributes attributes;
	unsigned long mask;
	unsigned long black;

	black = (glx_visualinfo->visual == DefaultVisual(SDL_Display,
						 	SDL_Screen))
	       	? BlackPixel(SDL_Display, SDL_Screen) : 0;
	attributes.background_pixel = black;
	attributes.border_pixel = black;
	attributes.colormap = SDL_XColorMap;
	mask = CWBackPixel | CWBorderPixel | CWColormap;

	SDL_Window = XCreateWindow(SDL_Display, WMwindow,
			0, 0, w, h, 0, glx_visualinfo->depth,
			InputOutput, glx_visualinfo->visual,
			mask, &attributes);
	if ( !SDL_Window ) {
		SDL_SetError("Could not create window");
		return -1;
	}
	retval = 0;
#else
	SDL_SetError("X11 driver not configured with OpenGL");
	retval = -1;
#endif
	return(retval);
}

int X11_GL_CreateContext(_THIS)
{
	int retval;
#if SDL_VIDEO_OPENGL_GLX

	/* We do this to create a clean separation between X and GLX errors. */
	XSync( SDL_Display, False );
	glx_context = this->gl_data->glXCreateContext(GFX_Display, 
				     glx_visualinfo, NULL, True);
	XSync( GFX_Display, False );

	if ( glx_context == NULL ) {
		SDL_SetError("Could not create GL context");
		return(-1);
	}
	if ( X11_GL_MakeCurrent(this) < 0 ) {
		return(-1);
	}
	gl_active = 1;

	if ( !glXExtensionSupported(this, "GLX_SGI_swap_control") ) {
		this->gl_data->glXSwapIntervalSGI = NULL;
	}
	if ( !glXExtensionSupported(this, "GLX_MESA_swap_control") ) {
		this->gl_data->glXSwapIntervalMESA = NULL;
	}
	if ( this->gl_config.swap_control >= 0 ) {
        int rc = -1;
		if ( this->gl_data->glXSwapIntervalMESA ) {
			rc = this->gl_data->glXSwapIntervalMESA(this->gl_config.swap_control);
		} else if ( this->gl_data->glXSwapIntervalSGI ) {
			rc = this->gl_data->glXSwapIntervalSGI(this->gl_config.swap_control);
		}
		if (rc == 0) {
			this->gl_data->swap_interval = this->gl_config.swap_control;
		}
	}
#else
	SDL_SetError("X11 driver not configured with OpenGL");
#endif
	if ( gl_active ) {
		retval = 0;
	} else {
		retval = -1;
	}
	return(retval);
}

void X11_GL_Shutdown(_THIS)
{
#if SDL_VIDEO_OPENGL_GLX
	/* Clean up OpenGL */
	if( glx_context ) {
		this->gl_data->glXMakeCurrent(GFX_Display, None, NULL);

		if (glx_context != NULL)
			this->gl_data->glXDestroyContext(GFX_Display, glx_context);

		glx_context = NULL;
	}
	gl_active = 0;
#endif /* SDL_VIDEO_OPENGL_GLX */
}

#if SDL_VIDEO_OPENGL_GLX

/* Make the current context active */
int X11_GL_MakeCurrent(_THIS)
{
	int retval;
	
	retval = 0;
	if ( ! this->gl_data->glXMakeCurrent(GFX_Display,
	                                     SDL_Window, glx_context) ) {
		SDL_SetError("Unable to make GL context current");
		retval = -1;
	}
	XSync( GFX_Display, False );

	/* More Voodoo X server workarounds... Grr... */
	SDL_Lock_EventThread();
	X11_CheckDGAMouse(this);
	SDL_Unlock_EventThread();

	return(retval);
}

/* Get attribute data from glX. */
int X11_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value)
{
	int retval = -1;
	int unsupported = 0;
	int glx_attrib = None;

	switch( attrib ) {
	    case SDL_GL_RED_SIZE:
		glx_attrib = GLX_RED_SIZE;
		break;
	    case SDL_GL_GREEN_SIZE:
		glx_attrib = GLX_GREEN_SIZE;
		break;
	    case SDL_GL_BLUE_SIZE:
		glx_attrib = GLX_BLUE_SIZE;
		break;
	    case SDL_GL_ALPHA_SIZE:
		glx_attrib = GLX_ALPHA_SIZE;
		break;
	    case SDL_GL_DOUBLEBUFFER:
		glx_attrib = GLX_DOUBLEBUFFER;
		break;
	    case SDL_GL_BUFFER_SIZE:
		glx_attrib = GLX_BUFFER_SIZE;
		break;
	    case SDL_GL_DEPTH_SIZE:
		glx_attrib = GLX_DEPTH_SIZE;
		break;
	    case SDL_GL_STENCIL_SIZE:
		glx_attrib = GLX_STENCIL_SIZE;
		break;
	    case SDL_GL_ACCUM_RED_SIZE:
		glx_attrib = GLX_ACCUM_RED_SIZE;
		break;
	    case SDL_GL_ACCUM_GREEN_SIZE:
		glx_attrib = GLX_ACCUM_GREEN_SIZE;
		break;
	    case SDL_GL_ACCUM_BLUE_SIZE:
		glx_attrib = GLX_ACCUM_BLUE_SIZE;
		break;
	    case SDL_GL_ACCUM_ALPHA_SIZE:
		glx_attrib = GLX_ACCUM_ALPHA_SIZE;
		break;
	    case SDL_GL_STEREO:
		glx_attrib = GLX_STEREO;
		break;
 	    case SDL_GL_MULTISAMPLEBUFFERS:
 		glx_attrib = GLX_SAMPLE_BUFFERS_ARB;
 		break;
 	    case SDL_GL_MULTISAMPLESAMPLES:
 		glx_attrib = GLX_SAMPLES_ARB;
 		break;
 	    case SDL_GL_ACCELERATED_VISUAL:
		if ( glXExtensionSupported(this, "GLX_EXT_visual_rating") ) {
			glx_attrib = GLX_VISUAL_CAVEAT_EXT;
			retval = this->gl_data->glXGetConfig(GFX_Display, glx_visualinfo, glx_attrib, value);
			if ( *value == GLX_SLOW_VISUAL_EXT ) {
				*value = SDL_FALSE;
			} else {
				*value = SDL_TRUE;
			}
			return retval;
		} else {
			unsupported = 1;
		}
		break;
	    case SDL_GL_SWAP_CONTROL:
		if ( ( this->gl_data->glXSwapIntervalMESA ) ||
		     ( this->gl_data->glXSwapIntervalSGI ) ) {
			*value = this->gl_data->swap_interval;
			return 0;
		} else {
			unsupported = 1;
		}
		break;
	    default:
			unsupported = 1;
			break;
	}

	if (unsupported) {
		SDL_SetError("OpenGL attribute is unsupported on this system");
	} else {
		retval = this->gl_data->glXGetConfig(GFX_Display, glx_visualinfo, glx_attrib, value);
	}
	return retval;
}

void X11_GL_SwapBuffers(_THIS)
{
	this->gl_data->glXSwapBuffers(GFX_Display, SDL_Window);
}

#endif /* SDL_VIDEO_OPENGL_GLX */

#define OPENGL_REQUIRS_DLOPEN
#if defined(OPENGL_REQUIRS_DLOPEN) && defined(SDL_LOADSO_DLOPEN)
#include <dlfcn.h>
#define GL_LoadObject(X)	dlopen(X, (RTLD_NOW|RTLD_GLOBAL))
#define GL_LoadFunction		dlsym
#define GL_UnloadObject		dlclose
#else
#define GL_LoadObject	SDL_LoadObject
#define GL_LoadFunction	SDL_LoadFunction
#define GL_UnloadObject	SDL_UnloadObject
#endif

void X11_GL_UnloadLibrary(_THIS)
{
#if SDL_VIDEO_OPENGL_GLX
	if ( this->gl_config.driver_loaded ) {

		GL_UnloadObject(this->gl_config.dll_handle);

		this->gl_data->glXGetProcAddress = NULL;
		this->gl_data->glXChooseVisual = NULL;
		this->gl_data->glXCreateContext = NULL;
		this->gl_data->glXDestroyContext = NULL;
		this->gl_data->glXMakeCurrent = NULL;
		this->gl_data->glXSwapBuffers = NULL;
		this->gl_data->glXSwapIntervalSGI = NULL;
		this->gl_data->glXSwapIntervalMESA = NULL;

		this->gl_config.dll_handle = NULL;
		this->gl_config.driver_loaded = 0;
	}
#endif
}

#if SDL_VIDEO_OPENGL_GLX

/* Passing a NULL path means load pointers from the application */
int X11_GL_LoadLibrary(_THIS, const char* path) 
{
	void* handle = NULL;

	if ( gl_active ) {
		SDL_SetError("OpenGL context already created");
		return -1;
	}

	if ( path == NULL ) {
		path = SDL_getenv("SDL_VIDEO_GL_DRIVER");
		if ( path == NULL ) {
			path = DEFAULT_OPENGL;
		}
	}

	handle = GL_LoadObject(path);
	if ( handle == NULL ) {
#if defined(OPENGL_REQUIRS_DLOPEN) && defined(SDL_LOADSO_DLOPEN)
		SDL_SetError("Failed loading %s", path);
#else
		/* SDL_LoadObject() will call SDL_SetError() for us. */
#endif
		return -1;
	}

	/* Unload the old driver and reset the pointers */
	X11_GL_UnloadLibrary(this);

	/* Load new function pointers */
	this->gl_data->glXGetProcAddress =
		(void *(*)(const GLubyte *)) GL_LoadFunction(handle, "glXGetProcAddressARB");
	this->gl_data->glXChooseVisual =
		(XVisualInfo *(*)(Display *, int, int *)) GL_LoadFunction(handle, "glXChooseVisual");
	this->gl_data->glXCreateContext =
		(GLXContext (*)(Display *, XVisualInfo *, GLXContext, int)) GL_LoadFunction(handle, "glXCreateContext");
	this->gl_data->glXDestroyContext =
		(void (*)(Display *, GLXContext)) GL_LoadFunction(handle, "glXDestroyContext");
	this->gl_data->glXMakeCurrent =
		(int (*)(Display *, GLXDrawable, GLXContext)) GL_LoadFunction(handle, "glXMakeCurrent");
	this->gl_data->glXSwapBuffers =
		(void (*)(Display *, GLXDrawable)) GL_LoadFunction(handle, "glXSwapBuffers");
	this->gl_data->glXGetConfig =
		(int (*)(Display *, XVisualInfo *, int, int *)) GL_LoadFunction(handle, "glXGetConfig");
	this->gl_data->glXQueryExtensionsString =
		(const char *(*)(Display *, int)) GL_LoadFunction(handle, "glXQueryExtensionsString");
	this->gl_data->glXSwapIntervalSGI =
		(int (*)(int)) GL_LoadFunction(handle, "glXSwapIntervalSGI");
	this->gl_data->glXSwapIntervalMESA =
		(GLint (*)(unsigned)) GL_LoadFunction(handle, "glXSwapIntervalMESA");

	if ( (this->gl_data->glXChooseVisual == NULL) || 
	     (this->gl_data->glXCreateContext == NULL) ||
	     (this->gl_data->glXDestroyContext == NULL) ||
	     (this->gl_data->glXMakeCurrent == NULL) ||
	     (this->gl_data->glXSwapBuffers == NULL) ||
	     (this->gl_data->glXGetConfig == NULL) ||
	     (this->gl_data->glXQueryExtensionsString == NULL)) {
		SDL_SetError("Could not retrieve OpenGL functions");
		return -1;
	}

	this->gl_config.dll_handle = handle;
	this->gl_config.driver_loaded = 1;
	if ( path ) {
		SDL_strlcpy(this->gl_config.driver_path, path,
			SDL_arraysize(this->gl_config.driver_path));
	} else {
		*this->gl_config.driver_path = '\0';
	}
	return 0;
}

void *X11_GL_GetProcAddress(_THIS, const char* proc)
{
	void* handle;
	
	handle = this->gl_config.dll_handle;
	if ( this->gl_data->glXGetProcAddress ) {
		return this->gl_data->glXGetProcAddress((const GLubyte *)proc);
	}
	return GL_LoadFunction(handle, proc);
}

#endif /* SDL_VIDEO_OPENGL_GLX */
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 Sam Lantinga
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18
	19	Sam Lantinga
	20	slouken@libsdl.org
	21	*/
	22	#include "SDL_config.h"
	23
	24	#include "SDL_x11video.h"
	25	#include "../../events/SDL_events_c.h"
	26	#include "SDL_x11dga_c.h"
	27	#include "SDL_x11gl_c.h"
	28
	29	#if defined(__IRIX__)
	30	/* IRIX doesn't have a GL library versioning system */
	31	#define DEFAULT_OPENGL "libGL.so"
	32	#elif defined(__MACOSX__)
	33	#define DEFAULT_OPENGL "/usr/X11R6/lib/libGL.1.dylib"
	34	#elif defined(__QNXNTO__)
	35	#define DEFAULT_OPENGL "libGL.so.3"
	36	#elif defined(__OpenBSD__)
	37	#define DEFAULT_OPENGL "libGL.so.4.0"
	38	#else
	39	#define DEFAULT_OPENGL "libGL.so.1"
	40	#endif
	41
	42	#ifndef GLX_ARB_multisample
	43	#define GLX_ARB_multisample
	44	#define GLX_SAMPLE_BUFFERS_ARB 100000
	45	#define GLX_SAMPLES_ARB 100001
	46	#endif
	47
	48	/* GLX_EXT_visual_rating stuff that might not be in the system headers... */
	49	#ifndef GLX_VISUAL_CAVEAT_EXT
	50	#define GLX_VISUAL_CAVEAT_EXT 0x20
	51	#endif
	52	#ifndef GLX_NONE_EXT
	53	#define GLX_NONE_EXT 0x8000
	54	#endif
	55	#ifndef GLX_SLOW_VISUAL_EXT
	56	#define GLX_SLOW_VISUAL_EXT 0x8001
	57	#endif
	58	#ifndef GLX_NON_CONFORMANT_VISUAL_EXT
	59	#define GLX_NON_CONFORMANT_VISUAL_EXT 0x800D
	60	#endif
	61
	62
	63	#if SDL_VIDEO_OPENGL_GLX
	64	static int glXExtensionSupported(_THIS, const char *extension)
65	{
66	const char *extensions;
67	const char *start;
68	const char where, terminator;
69
70	/* Extension names should not have spaces. */
71	where = SDL_strchr(extension, ' ');
72	if ( where \|\| *extension == '\0' ) {
73	return 0;
74	}
75
76	extensions = this->gl_data->glXQueryExtensionsString(GFX_Display,SDL_Screen);
77	/* It takes a bit of care to be fool-proof about parsing the
78	* OpenGL extensions string. Don't be fooled by sub-strings, etc.
79	*/
80
81	/* http://bugs.debian.org/537487 */
82	if (extensions == NULL) {
83	return 0;
84	}
85
86	start = extensions;
87
88	for (;;) {
89	where = SDL_strstr(start, extension);
90	if (!where) break;
91
92	terminator = where + strlen(extension);
93	if (where == start \|\| *(where - 1) == ' ')
94	if (terminator == ' ' \|\| terminator == '\0') return 1;
95
96	start = terminator;
97	}
98	return 0;
99	}
100	#endif /* SDL_VIDEO_OPENGL_GLX */
101
102	XVisualInfo *X11_GL_GetVisual(_THIS)
103	{
104	#if SDL_VIDEO_OPENGL_GLX
105	/* 64 seems nice. */
106	int attribs[64];
107	int i;
108
109	/* load the gl driver from a default path */
110	if ( ! this->gl_config.driver_loaded ) {
111	/* no driver has been loaded, use default (ourselves) */
112	if ( X11_GL_LoadLibrary(this, NULL) < 0 ) {
113	return NULL;
114	}
115	}
116
117	/* See if we already have a window which we must use */
118	if ( SDL_windowid ) {
119	XWindowAttributes a;
120	XVisualInfo vi_in;
121	int out_count;
122
123	XGetWindowAttributes(SDL_Display, SDL_Window, &a);
124	vi_in.screen = SDL_Screen;
125	vi_in.visualid = XVisualIDFromVisual(a.visual);
126	glx_visualinfo = XGetVisualInfo(SDL_Display,
127	VisualScreenMask\|VisualIDMask, &vi_in, &out_count);
128	return glx_visualinfo;
129	}
130
131	/* Setup our GLX attributes according to the gl_config. */
132	i = 0;
133	attribs[i++] = GLX_RGBA;
134	attribs[i++] = GLX_RED_SIZE;
135	attribs[i++] = this->gl_config.red_size;
136	attribs[i++] = GLX_GREEN_SIZE;
137	attribs[i++] = this->gl_config.green_size;
138	attribs[i++] = GLX_BLUE_SIZE;
139	attribs[i++] = this->gl_config.blue_size;
140
141	if( this->gl_config.alpha_size ) {
142	attribs[i++] = GLX_ALPHA_SIZE;
143	attribs[i++] = this->gl_config.alpha_size;
144	}
145
146	if( this->gl_config.buffer_size ) {
147	attribs[i++] = GLX_BUFFER_SIZE;
148	attribs[i++] = this->gl_config.buffer_size;
149	}
150
151	if( this->gl_config.double_buffer ) {
152	attribs[i++] = GLX_DOUBLEBUFFER;
153	}
154
155	attribs[i++] = GLX_DEPTH_SIZE;
156	attribs[i++] = this->gl_config.depth_size;
157
158	if( this->gl_config.stencil_size ) {
159	attribs[i++] = GLX_STENCIL_SIZE;
160	attribs[i++] = this->gl_config.stencil_size;
161	}
162
163	if( this->gl_config.accum_red_size ) {
164	attribs[i++] = GLX_ACCUM_RED_SIZE;
165	attribs[i++] = this->gl_config.accum_red_size;
166	}
167
168	if( this->gl_config.accum_green_size ) {
169	attribs[i++] = GLX_ACCUM_GREEN_SIZE;
170	attribs[i++] = this->gl_config.accum_green_size;
171	}
172
173	if( this->gl_config.accum_blue_size ) {
174	attribs[i++] = GLX_ACCUM_BLUE_SIZE;
175	attribs[i++] = this->gl_config.accum_blue_size;
176	}
177
178	if( this->gl_config.accum_alpha_size ) {
179	attribs[i++] = GLX_ACCUM_ALPHA_SIZE;
180	attribs[i++] = this->gl_config.accum_alpha_size;
181	}
182
183	if( this->gl_config.stereo ) {
184	attribs[i++] = GLX_STEREO;
185	}
186
187	if( this->gl_config.multisamplebuffers ) {
188	attribs[i++] = GLX_SAMPLE_BUFFERS_ARB;
189	attribs[i++] = this->gl_config.multisamplebuffers;
190	}
191
192	if( this->gl_config.multisamplesamples ) {
193	attribs[i++] = GLX_SAMPLES_ARB;
194	attribs[i++] = this->gl_config.multisamplesamples;
195	}
196
197	if( this->gl_config.accelerated >= 0 &&
198	glXExtensionSupported(this, "GLX_EXT_visual_rating") ) {
199	attribs[i++] = GLX_VISUAL_CAVEAT_EXT;
200	attribs[i++] = GLX_NONE_EXT;
201	}
202
203	#ifdef GLX_DIRECT_COLOR /* Try for a DirectColor visual for gamma support */
204	if ( !SDL_getenv("SDL_VIDEO_X11_NODIRECTCOLOR") ) {
205	attribs[i++] = GLX_X_VISUAL_TYPE;
206	attribs[i++] = GLX_DIRECT_COLOR;
207	}
208	#endif
209	attribs[i++] = None;
210
211	glx_visualinfo = this->gl_data->glXChooseVisual(GFX_Display,
212	SDL_Screen, attribs);
213	#ifdef GLX_DIRECT_COLOR
214	if( !glx_visualinfo && !SDL_getenv("SDL_VIDEO_X11_NODIRECTCOLOR") ) { /* No DirectColor visual? Try again.. */
215	attribs[i-3] = None;
216	glx_visualinfo = this->gl_data->glXChooseVisual(GFX_Display,
217	SDL_Screen, attribs);
218	}
219	#endif
220	if( !glx_visualinfo ) {
221	SDL_SetError( "Couldn't find matching GLX visual");
222	return NULL;
223	}
224	/*
225	printf("Found GLX visual 0x%x\n", glx_visualinfo->visualid);
226	*/
227	return glx_visualinfo;
228	#else
229	SDL_SetError("X11 driver not configured with OpenGL");
230	return NULL;
231	#endif
232	}
233
234	int X11_GL_CreateWindow(_THIS, int w, int h)
235	{
236	int retval;
237	#if SDL_VIDEO_OPENGL_GLX
238	XSetWindowAttributes attributes;
239	unsigned long mask;
240	unsigned long black;
241
242	black = (glx_visualinfo->visual == DefaultVisual(SDL_Display,
243	SDL_Screen))
244	? BlackPixel(SDL_Display, SDL_Screen) : 0;
245	attributes.background_pixel = black;
246	attributes.border_pixel = black;
247	attributes.colormap = SDL_XColorMap;
248	mask = CWBackPixel \| CWBorderPixel \| CWColormap;
249
250	SDL_Window = XCreateWindow(SDL_Display, WMwindow,
251	0, 0, w, h, 0, glx_visualinfo->depth,
252	InputOutput, glx_visualinfo->visual,
253	mask, &attributes);
254	if ( !SDL_Window ) {
255	SDL_SetError("Could not create window");
256	return -1;
257	}
258	retval = 0;
259	#else
260	SDL_SetError("X11 driver not configured with OpenGL");
261	retval = -1;
262	#endif
263	return(retval);
264	}
265
266	int X11_GL_CreateContext(_THIS)
267	{
268	int retval;
269	#if SDL_VIDEO_OPENGL_GLX
270
271	/* We do this to create a clean separation between X and GLX errors. */
272	XSync( SDL_Display, False );
273	glx_context = this->gl_data->glXCreateContext(GFX_Display,
274	glx_visualinfo, NULL, True);
275	XSync( GFX_Display, False );
276
277	if ( glx_context == NULL ) {
278	SDL_SetError("Could not create GL context");
279	return(-1);
280	}
281	if ( X11_GL_MakeCurrent(this) < 0 ) {
282	return(-1);
283	}
284	gl_active = 1;
285
286	if ( !glXExtensionSupported(this, "GLX_SGI_swap_control") ) {
287	this->gl_data->glXSwapIntervalSGI = NULL;
288	}
289	if ( !glXExtensionSupported(this, "GLX_MESA_swap_control") ) {
290	this->gl_data->glXSwapIntervalMESA = NULL;
291	}
292	if ( this->gl_config.swap_control >= 0 ) {
293	int rc = -1;
294	if ( this->gl_data->glXSwapIntervalMESA ) {
295	rc = this->gl_data->glXSwapIntervalMESA(this->gl_config.swap_control);
296	} else if ( this->gl_data->glXSwapIntervalSGI ) {
297	rc = this->gl_data->glXSwapIntervalSGI(this->gl_config.swap_control);
298	}
299	if (rc == 0) {
300	this->gl_data->swap_interval = this->gl_config.swap_control;
301	}
302	}
303	#else
304	SDL_SetError("X11 driver not configured with OpenGL");
305	#endif
306	if ( gl_active ) {
307	retval = 0;
308	} else {
309	retval = -1;
310	}
311	return(retval);
312	}
313
314	void X11_GL_Shutdown(_THIS)
315	{
316	#if SDL_VIDEO_OPENGL_GLX
317	/* Clean up OpenGL */
318	if( glx_context ) {
319	this->gl_data->glXMakeCurrent(GFX_Display, None, NULL);
320
321	if (glx_context != NULL)
322	this->gl_data->glXDestroyContext(GFX_Display, glx_context);
323
324	glx_context = NULL;
325	}
326	gl_active = 0;
327	#endif /* SDL_VIDEO_OPENGL_GLX */
328	}
329
330	#if SDL_VIDEO_OPENGL_GLX
331
332	/* Make the current context active */
333	int X11_GL_MakeCurrent(_THIS)
334	{
335	int retval;
336
337	retval = 0;
338	if ( ! this->gl_data->glXMakeCurrent(GFX_Display,
339	SDL_Window, glx_context) ) {
340	SDL_SetError("Unable to make GL context current");
341	retval = -1;
342	}
343	XSync( GFX_Display, False );
344
345	/* More Voodoo X server workarounds... Grr... */
346	SDL_Lock_EventThread();
347	X11_CheckDGAMouse(this);
348	SDL_Unlock_EventThread();
349
350	return(retval);
351	}
352
353	/* Get attribute data from glX. */
354	int X11_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value)
355	{
356	int retval = -1;
357	int unsupported = 0;
358	int glx_attrib = None;
359
360	switch( attrib ) {
361	case SDL_GL_RED_SIZE:
362	glx_attrib = GLX_RED_SIZE;
363	break;
364	case SDL_GL_GREEN_SIZE:
365	glx_attrib = GLX_GREEN_SIZE;
366	break;
367	case SDL_GL_BLUE_SIZE:
368	glx_attrib = GLX_BLUE_SIZE;
369	break;
370	case SDL_GL_ALPHA_SIZE:
371	glx_attrib = GLX_ALPHA_SIZE;
372	break;
373	case SDL_GL_DOUBLEBUFFER:
374	glx_attrib = GLX_DOUBLEBUFFER;
375	break;
376	case SDL_GL_BUFFER_SIZE:
377	glx_attrib = GLX_BUFFER_SIZE;
378	break;
379	case SDL_GL_DEPTH_SIZE:
380	glx_attrib = GLX_DEPTH_SIZE;
381	break;
382	case SDL_GL_STENCIL_SIZE:
383	glx_attrib = GLX_STENCIL_SIZE;
384	break;
385	case SDL_GL_ACCUM_RED_SIZE:
386	glx_attrib = GLX_ACCUM_RED_SIZE;
387	break;
388	case SDL_GL_ACCUM_GREEN_SIZE:
389	glx_attrib = GLX_ACCUM_GREEN_SIZE;
390	break;
391	case SDL_GL_ACCUM_BLUE_SIZE:
392	glx_attrib = GLX_ACCUM_BLUE_SIZE;
393	break;
394	case SDL_GL_ACCUM_ALPHA_SIZE:
395	glx_attrib = GLX_ACCUM_ALPHA_SIZE;
396	break;
397	case SDL_GL_STEREO:
398	glx_attrib = GLX_STEREO;
399	break;
400	case SDL_GL_MULTISAMPLEBUFFERS:
401	glx_attrib = GLX_SAMPLE_BUFFERS_ARB;
402	break;
403	case SDL_GL_MULTISAMPLESAMPLES:
404	glx_attrib = GLX_SAMPLES_ARB;
405	break;
406	case SDL_GL_ACCELERATED_VISUAL:
407	if ( glXExtensionSupported(this, "GLX_EXT_visual_rating") ) {
408	glx_attrib = GLX_VISUAL_CAVEAT_EXT;
409	retval = this->gl_data->glXGetConfig(GFX_Display, glx_visualinfo, glx_attrib, value);
410	if ( *value == GLX_SLOW_VISUAL_EXT ) {
411	*value = SDL_FALSE;
412	} else {
413	*value = SDL_TRUE;
414	}
415	return retval;
416	} else {
417	unsupported = 1;
418	}
419	break;
420	case SDL_GL_SWAP_CONTROL:
421	if ( ( this->gl_data->glXSwapIntervalMESA ) \|\|
422	( this->gl_data->glXSwapIntervalSGI ) ) {
423	*value = this->gl_data->swap_interval;
424	return 0;
425	} else {
426	unsupported = 1;
427	}
428	break;
429	default:
430	unsupported = 1;
431	break;
432	}
433
434	if (unsupported) {
435	SDL_SetError("OpenGL attribute is unsupported on this system");
436	} else {
437	retval = this->gl_data->glXGetConfig(GFX_Display, glx_visualinfo, glx_attrib, value);
438	}
439	return retval;
440	}
441
442	void X11_GL_SwapBuffers(_THIS)
443	{
444	this->gl_data->glXSwapBuffers(GFX_Display, SDL_Window);
445	}
446
447	#endif /* SDL_VIDEO_OPENGL_GLX */
448
449	#define OPENGL_REQUIRS_DLOPEN
450	#if defined(OPENGL_REQUIRS_DLOPEN) && defined(SDL_LOADSO_DLOPEN)
451	#include <dlfcn.h>
452	#define GL_LoadObject(X) dlopen(X, (RTLD_NOW\|RTLD_GLOBAL))
453	#define GL_LoadFunction dlsym
454	#define GL_UnloadObject dlclose
455	#else
456	#define GL_LoadObject SDL_LoadObject
457	#define GL_LoadFunction SDL_LoadFunction
458	#define GL_UnloadObject SDL_UnloadObject
459	#endif
460
461	void X11_GL_UnloadLibrary(_THIS)
462	{
463	#if SDL_VIDEO_OPENGL_GLX
464	if ( this->gl_config.driver_loaded ) {
465
466	GL_UnloadObject(this->gl_config.dll_handle);
467
468	this->gl_data->glXGetProcAddress = NULL;
469	this->gl_data->glXChooseVisual = NULL;
470	this->gl_data->glXCreateContext = NULL;
471	this->gl_data->glXDestroyContext = NULL;
472	this->gl_data->glXMakeCurrent = NULL;
473	this->gl_data->glXSwapBuffers = NULL;
474	this->gl_data->glXSwapIntervalSGI = NULL;
475	this->gl_data->glXSwapIntervalMESA = NULL;
476
477	this->gl_config.dll_handle = NULL;
478	this->gl_config.driver_loaded = 0;
479	}
480	#endif
481	}
482
483	#if SDL_VIDEO_OPENGL_GLX
484
485	/* Passing a NULL path means load pointers from the application */
486	int X11_GL_LoadLibrary(_THIS, const char* path)
487	{
488	void* handle = NULL;
489
490	if ( gl_active ) {
491	SDL_SetError("OpenGL context already created");
492	return -1;
493	}
494
495	if ( path == NULL ) {
496	path = SDL_getenv("SDL_VIDEO_GL_DRIVER");
497	if ( path == NULL ) {
498	path = DEFAULT_OPENGL;
499	}
500	}
501
502	handle = GL_LoadObject(path);
503	if ( handle == NULL ) {
504	#if defined(OPENGL_REQUIRS_DLOPEN) && defined(SDL_LOADSO_DLOPEN)
505	SDL_SetError("Failed loading %s", path);
506	#else
507	/* SDL_LoadObject() will call SDL_SetError() for us. */
508	#endif
509	return -1;
510	}
511
512	/* Unload the old driver and reset the pointers */
513	X11_GL_UnloadLibrary(this);
514
515	/* Load new function pointers */
516	this->gl_data->glXGetProcAddress =
517	(void ()(const GLubyte *)) GL_LoadFunction(handle, "glXGetProcAddressARB");
518	this->gl_data->glXChooseVisual =
519	(XVisualInfo ()(Display , int, int )) GL_LoadFunction(handle, "glXChooseVisual");
520	this->gl_data->glXCreateContext =
521	(GLXContext ()(Display , XVisualInfo *, GLXContext, int)) GL_LoadFunction(handle, "glXCreateContext");
522	this->gl_data->glXDestroyContext =
523	(void ()(Display , GLXContext)) GL_LoadFunction(handle, "glXDestroyContext");
524	this->gl_data->glXMakeCurrent =
525	(int ()(Display , GLXDrawable, GLXContext)) GL_LoadFunction(handle, "glXMakeCurrent");
526	this->gl_data->glXSwapBuffers =
527	(void ()(Display , GLXDrawable)) GL_LoadFunction(handle, "glXSwapBuffers");
528	this->gl_data->glXGetConfig =
529	(int ()(Display , XVisualInfo , int, int )) GL_LoadFunction(handle, "glXGetConfig");
530	this->gl_data->glXQueryExtensionsString =
531	(const char ()(Display *, int)) GL_LoadFunction(handle, "glXQueryExtensionsString");
532	this->gl_data->glXSwapIntervalSGI =
533	(int (*)(int)) GL_LoadFunction(handle, "glXSwapIntervalSGI");
534	this->gl_data->glXSwapIntervalMESA =
535	(GLint (*)(unsigned)) GL_LoadFunction(handle, "glXSwapIntervalMESA");
536
537	if ( (this->gl_data->glXChooseVisual == NULL) \|\|
538	(this->gl_data->glXCreateContext == NULL) \|\|
539	(this->gl_data->glXDestroyContext == NULL) \|\|
540	(this->gl_data->glXMakeCurrent == NULL) \|\|
541	(this->gl_data->glXSwapBuffers == NULL) \|\|
542	(this->gl_data->glXGetConfig == NULL) \|\|
543	(this->gl_data->glXQueryExtensionsString == NULL)) {
544	SDL_SetError("Could not retrieve OpenGL functions");
545	return -1;
546	}
547
548	this->gl_config.dll_handle = handle;
549	this->gl_config.driver_loaded = 1;
550	if ( path ) {
551	SDL_strlcpy(this->gl_config.driver_path, path,
552	SDL_arraysize(this->gl_config.driver_path));
553	} else {
554	*this->gl_config.driver_path = '\0';
555	}
556	return 0;
557	}
558
559	void X11_GL_GetProcAddress(_THIS, const char proc)
560	{
561	void* handle;
562
563	handle = this->gl_config.dll_handle;
564	if ( this->gl_data->glXGetProcAddress ) {
565	return this->gl_data->glXGetProcAddress((const GLubyte *)proc);
566	}
567	return GL_LoadFunction(handle, proc);
568	}
569
570	#endif /* SDL_VIDEO_OPENGL_GLX */