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