1/* 2 SDL - Simple DirectMedia Layer 3 Copyright (C) 1997-2012 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 64static 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 102XVisualInfo *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.double_buffer ) { 147 attribs[i++] = GLX_DOUBLEBUFFER; 148 } 149 150 attribs[i++] = GLX_DEPTH_SIZE; 151 attribs[i++] = this->gl_config.depth_size; 152 153 if( this->gl_config.stencil_size ) { 154 attribs[i++] = GLX_STENCIL_SIZE; 155 attribs[i++] = this->gl_config.stencil_size; 156 } 157 158 if( this->gl_config.accum_red_size ) { 159 attribs[i++] = GLX_ACCUM_RED_SIZE; 160 attribs[i++] = this->gl_config.accum_red_size; 161 } 162 163 if( this->gl_config.accum_green_size ) { 164 attribs[i++] = GLX_ACCUM_GREEN_SIZE; 165 attribs[i++] = this->gl_config.accum_green_size; 166 } 167 168 if( this->gl_config.accum_blue_size ) { 169 attribs[i++] = GLX_ACCUM_BLUE_SIZE; 170 attribs[i++] = this->gl_config.accum_blue_size; 171 } 172 173 if( this->gl_config.accum_alpha_size ) { 174 attribs[i++] = GLX_ACCUM_ALPHA_SIZE; 175 attribs[i++] = this->gl_config.accum_alpha_size; 176 } 177 178 if( this->gl_config.stereo ) { 179 attribs[i++] = GLX_STEREO; 180 } 181 182 if( this->gl_config.multisamplebuffers ) { 183 attribs[i++] = GLX_SAMPLE_BUFFERS_ARB; 184 attribs[i++] = this->gl_config.multisamplebuffers; 185 } 186 187 if( this->gl_config.multisamplesamples ) { 188 attribs[i++] = GLX_SAMPLES_ARB; 189 attribs[i++] = this->gl_config.multisamplesamples; 190 } 191 192 if( this->gl_config.accelerated >= 0 && 193 glXExtensionSupported(this, "GLX_EXT_visual_rating") ) { 194 attribs[i++] = GLX_VISUAL_CAVEAT_EXT; 195 attribs[i++] = GLX_NONE_EXT; 196 } 197 198#ifdef GLX_DIRECT_COLOR /* Try for a DirectColor visual for gamma support */ 199 if ( !SDL_getenv("SDL_VIDEO_X11_NODIRECTCOLOR") ) { 200 attribs[i++] = GLX_X_VISUAL_TYPE; 201 attribs[i++] = GLX_DIRECT_COLOR; 202 } 203#endif 204 attribs[i++] = None; 205 206 glx_visualinfo = this->gl_data->glXChooseVisual(GFX_Display, 207 SDL_Screen, attribs); 208#ifdef GLX_DIRECT_COLOR 209 if( !glx_visualinfo && !SDL_getenv("SDL_VIDEO_X11_NODIRECTCOLOR") ) { /* No DirectColor visual? Try again.. */ 210 attribs[i-3] = None; 211 glx_visualinfo = this->gl_data->glXChooseVisual(GFX_Display, 212 SDL_Screen, attribs); 213 } 214#endif 215 if( !glx_visualinfo ) { 216 SDL_SetError( "Couldn't find matching GLX visual"); 217 return NULL; 218 } 219/* 220 printf("Found GLX visual 0x%x\n", glx_visualinfo->visualid); 221*/ 222 return glx_visualinfo; 223#else 224 SDL_SetError("X11 driver not configured with OpenGL"); 225 return NULL; 226#endif 227} 228 229int X11_GL_CreateWindow(_THIS, int w, int h) 230{ 231 int retval; 232#if SDL_VIDEO_OPENGL_GLX 233 XSetWindowAttributes attributes; 234 unsigned long mask; 235 unsigned long black; 236 237 black = (glx_visualinfo->visual == DefaultVisual(SDL_Display, 238 SDL_Screen)) 239 ? BlackPixel(SDL_Display, SDL_Screen) : 0; 240 attributes.background_pixel = black; 241 attributes.border_pixel = black; 242 attributes.colormap = SDL_XColorMap; 243 mask = CWBackPixel | CWBorderPixel | CWColormap; 244 245 SDL_Window = XCreateWindow(SDL_Display, WMwindow, 246 0, 0, w, h, 0, glx_visualinfo->depth, 247 InputOutput, glx_visualinfo->visual, 248 mask, &attributes); 249 if ( !SDL_Window ) { 250 SDL_SetError("Could not create window"); 251 return -1; 252 } 253 retval = 0; 254#else 255 SDL_SetError("X11 driver not configured with OpenGL"); 256 retval = -1; 257#endif 258 return(retval); 259} 260 261int X11_GL_CreateContext(_THIS) 262{ 263 int retval; 264#if SDL_VIDEO_OPENGL_GLX 265 266 /* We do this to create a clean separation between X and GLX errors. */ 267 XSync( SDL_Display, False ); 268 glx_context = this->gl_data->glXCreateContext(GFX_Display, 269 glx_visualinfo, NULL, True); 270 XSync( GFX_Display, False ); 271 272 if ( glx_context == NULL ) { 273 SDL_SetError("Could not create GL context"); 274 return(-1); 275 } 276 if ( X11_GL_MakeCurrent(this) < 0 ) { 277 return(-1); 278 } 279 gl_active = 1; 280 281 if ( !glXExtensionSupported(this, "GLX_SGI_swap_control") ) { 282 this->gl_data->glXSwapIntervalSGI = NULL; 283 } 284 if ( !glXExtensionSupported(this, "GLX_MESA_swap_control") ) { 285 this->gl_data->glXSwapIntervalMESA = NULL; 286 } 287 if ( !glXExtensionSupported(this, "GLX_EXT_swap_control") ) { 288 this->gl_data->glXSwapIntervalEXT = NULL; 289 } 290 291 if ( this->gl_config.swap_control >= 0 ) { 292 int rc = -1; 293 if ( this->gl_data->glXSwapIntervalEXT ) { 294 rc = this->gl_data->glXSwapIntervalEXT(GFX_Display, SDL_Window, 295 this->gl_config.swap_control); 296 } else if ( this->gl_data->glXSwapIntervalMESA ) { 297 rc = this->gl_data->glXSwapIntervalMESA(this->gl_config.swap_control); 298 } else if ( this->gl_data->glXSwapIntervalSGI ) { 299 rc = this->gl_data->glXSwapIntervalSGI(this->gl_config.swap_control); 300 } 301 if (rc == 0) { 302 this->gl_data->swap_interval = this->gl_config.swap_control; 303 } 304 } 305#else 306 SDL_SetError("X11 driver not configured with OpenGL"); 307#endif 308 if ( gl_active ) { 309 retval = 0; 310 } else { 311 retval = -1; 312 } 313 return(retval); 314} 315 316void X11_GL_Shutdown(_THIS) 317{ 318#if SDL_VIDEO_OPENGL_GLX 319 /* Clean up OpenGL */ 320 if( glx_context ) { 321 this->gl_data->glXMakeCurrent(GFX_Display, None, NULL); 322 323 if (glx_context != NULL) 324 this->gl_data->glXDestroyContext(GFX_Display, glx_context); 325 326 glx_context = NULL; 327 } 328 gl_active = 0; 329#endif /* SDL_VIDEO_OPENGL_GLX */ 330} 331 332#if SDL_VIDEO_OPENGL_GLX 333 334/* Make the current context active */ 335int X11_GL_MakeCurrent(_THIS) 336{ 337 int retval; 338 339 retval = 0; 340 if ( ! this->gl_data->glXMakeCurrent(GFX_Display, 341 SDL_Window, glx_context) ) { 342 SDL_SetError("Unable to make GL context current"); 343 retval = -1; 344 } 345 XSync( GFX_Display, False ); 346 347 /* More Voodoo X server workarounds... Grr... */ 348 SDL_Lock_EventThread(); 349 X11_CheckDGAMouse(this); 350 SDL_Unlock_EventThread(); 351 352 return(retval); 353} 354 355/* Get attribute data from glX. */ 356int X11_GL_GetAttribute(_THIS, SDL_GLattr attrib, int* value) 357{ 358 int retval = -1; 359 int unsupported = 0; 360 int glx_attrib = None; 361 362 switch( attrib ) { 363 case SDL_GL_RED_SIZE: 364 glx_attrib = GLX_RED_SIZE; 365 break; 366 case SDL_GL_GREEN_SIZE: 367 glx_attrib = GLX_GREEN_SIZE; 368 break; 369 case SDL_GL_BLUE_SIZE: 370 glx_attrib = GLX_BLUE_SIZE; 371 break; 372 case SDL_GL_ALPHA_SIZE: 373 glx_attrib = GLX_ALPHA_SIZE; 374 break; 375 case SDL_GL_DOUBLEBUFFER: 376 glx_attrib = GLX_DOUBLEBUFFER; 377 break; 378 case SDL_GL_BUFFER_SIZE: 379 glx_attrib = GLX_BUFFER_SIZE; 380 break; 381 case SDL_GL_DEPTH_SIZE: 382 glx_attrib = GLX_DEPTH_SIZE; 383 break; 384 case SDL_GL_STENCIL_SIZE: 385 glx_attrib = GLX_STENCIL_SIZE; 386 break; 387 case SDL_GL_ACCUM_RED_SIZE: 388 glx_attrib = GLX_ACCUM_RED_SIZE; 389 break; 390 case SDL_GL_ACCUM_GREEN_SIZE: 391 glx_attrib = GLX_ACCUM_GREEN_SIZE; 392 break; 393 case SDL_GL_ACCUM_BLUE_SIZE: 394 glx_attrib = GLX_ACCUM_BLUE_SIZE; 395 break; 396 case SDL_GL_ACCUM_ALPHA_SIZE: 397 glx_attrib = GLX_ACCUM_ALPHA_SIZE; 398 break; 399 case SDL_GL_STEREO: 400 glx_attrib = GLX_STEREO; 401 break; 402 case SDL_GL_MULTISAMPLEBUFFERS: 403 glx_attrib = GLX_SAMPLE_BUFFERS_ARB; 404 break; 405 case SDL_GL_MULTISAMPLESAMPLES: 406 glx_attrib = GLX_SAMPLES_ARB; 407 break; 408 case SDL_GL_ACCELERATED_VISUAL: 409 if ( glXExtensionSupported(this, "GLX_EXT_visual_rating") ) { 410 glx_attrib = GLX_VISUAL_CAVEAT_EXT; 411 retval = this->gl_data->glXGetConfig(GFX_Display, glx_visualinfo, glx_attrib, value); 412 if ( *value == GLX_SLOW_VISUAL_EXT ) { 413 *value = SDL_FALSE; 414 } else { 415 *value = SDL_TRUE; 416 } 417 return retval; 418 } else { 419 unsupported = 1; 420 } 421 break; 422 case SDL_GL_SWAP_CONTROL: 423 if ( ( this->gl_data->glXSwapIntervalEXT ) || 424 ( this->gl_data->glXSwapIntervalMESA ) || 425 ( this->gl_data->glXSwapIntervalSGI ) ) { 426 *value = this->gl_data->swap_interval; 427 return 0; 428 } else { 429 unsupported = 1; 430 } 431 break; 432 default: 433 unsupported = 1; 434 break; 435 } 436 437 if (unsupported) { 438 SDL_SetError("OpenGL attribute is unsupported on this system"); 439 } else { 440 retval = this->gl_data->glXGetConfig(GFX_Display, glx_visualinfo, glx_attrib, value); 441 } 442 return retval; 443} 444 445void X11_GL_SwapBuffers(_THIS) 446{ 447 this->gl_data->glXSwapBuffers(GFX_Display, SDL_Window); 448} 449 450#endif /* SDL_VIDEO_OPENGL_GLX */ 451 452#define OPENGL_REQUIRS_DLOPEN 453#if defined(OPENGL_REQUIRS_DLOPEN) && defined(SDL_LOADSO_DLOPEN) 454#include <dlfcn.h> 455#define GL_LoadObject(X) dlopen(X, (RTLD_NOW|RTLD_GLOBAL)) 456#define GL_LoadFunction dlsym 457#define GL_UnloadObject dlclose 458#else 459#define GL_LoadObject SDL_LoadObject 460#define GL_LoadFunction SDL_LoadFunction 461#define GL_UnloadObject SDL_UnloadObject 462#endif 463 464void X11_GL_UnloadLibrary(_THIS) 465{ 466#if SDL_VIDEO_OPENGL_GLX 467 if ( this->gl_config.driver_loaded ) { 468 469 GL_UnloadObject(this->gl_config.dll_handle); 470 471 this->gl_data->glXGetProcAddress = NULL; 472 this->gl_data->glXChooseVisual = NULL; 473 this->gl_data->glXCreateContext = NULL; 474 this->gl_data->glXDestroyContext = NULL; 475 this->gl_data->glXMakeCurrent = NULL; 476 this->gl_data->glXSwapBuffers = NULL; 477 this->gl_data->glXSwapIntervalSGI = NULL; 478 this->gl_data->glXSwapIntervalMESA = NULL; 479 this->gl_data->glXSwapIntervalEXT = NULL; 480 481 this->gl_config.dll_handle = NULL; 482 this->gl_config.driver_loaded = 0; 483 } 484#endif 485} 486 487#if SDL_VIDEO_OPENGL_GLX 488 489/* Passing a NULL path means load pointers from the application */ 490int X11_GL_LoadLibrary(_THIS, const char* path) 491{ 492 void* handle = NULL; 493 494 if ( gl_active ) { 495 SDL_SetError("OpenGL context already created"); 496 return -1; 497 } 498 499 if ( path == NULL ) { 500 path = SDL_getenv("SDL_VIDEO_GL_DRIVER"); 501 if ( path == NULL ) { 502 path = DEFAULT_OPENGL; 503 } 504 } 505 506 handle = GL_LoadObject(path); 507 if ( handle == NULL ) { 508#if defined(OPENGL_REQUIRS_DLOPEN) && defined(SDL_LOADSO_DLOPEN) 509 SDL_SetError("Failed loading %s", path); 510#else 511 /* SDL_LoadObject() will call SDL_SetError() for us. */ 512#endif 513 return -1; 514 } 515 516 /* Unload the old driver and reset the pointers */ 517 X11_GL_UnloadLibrary(this); 518 519 /* Save the handle for X11_GL_GetProcAddress() */ 520 this->gl_config.dll_handle = handle; 521 522 /* Load new function pointers */ 523 this->gl_data->glXGetProcAddress = 524 (void *(*)(const GLubyte *)) GL_LoadFunction(handle, "glXGetProcAddressARB"); 525 this->gl_data->glXChooseVisual = 526 (XVisualInfo *(*)(Display *, int, int *)) X11_GL_GetProcAddress(this, "glXChooseVisual"); 527 this->gl_data->glXCreateContext = 528 (GLXContext (*)(Display *, XVisualInfo *, GLXContext, int)) X11_GL_GetProcAddress(this, "glXCreateContext"); 529 this->gl_data->glXDestroyContext = 530 (void (*)(Display *, GLXContext)) X11_GL_GetProcAddress(this, "glXDestroyContext"); 531 this->gl_data->glXMakeCurrent = 532 (int (*)(Display *, GLXDrawable, GLXContext)) X11_GL_GetProcAddress(this, "glXMakeCurrent"); 533 this->gl_data->glXSwapBuffers = 534 (void (*)(Display *, GLXDrawable)) X11_GL_GetProcAddress(this, "glXSwapBuffers"); 535 this->gl_data->glXGetConfig = 536 (int (*)(Display *, XVisualInfo *, int, int *)) X11_GL_GetProcAddress(this, "glXGetConfig"); 537 this->gl_data->glXQueryExtensionsString = 538 (const char *(*)(Display *, int)) X11_GL_GetProcAddress(this, "glXQueryExtensionsString"); 539 this->gl_data->glXSwapIntervalSGI = 540 (int (*)(int)) X11_GL_GetProcAddress(this, "glXSwapIntervalSGI"); 541 this->gl_data->glXSwapIntervalMESA = 542 (GLint (*)(unsigned)) X11_GL_GetProcAddress(this, "glXSwapIntervalMESA"); 543 this->gl_data->glXSwapIntervalEXT = 544 (int (*)(Display*,GLXDrawable,int)) X11_GL_GetProcAddress(this, "glXSwapIntervalEXT"); 545 546 if ( (this->gl_data->glXChooseVisual == NULL) || 547 (this->gl_data->glXCreateContext == NULL) || 548 (this->gl_data->glXDestroyContext == NULL) || 549 (this->gl_data->glXMakeCurrent == NULL) || 550 (this->gl_data->glXSwapBuffers == NULL) || 551 (this->gl_data->glXGetConfig == NULL) || 552 (this->gl_data->glXQueryExtensionsString == NULL)) { 553 GL_UnloadObject(this->gl_config.dll_handle); 554 this->gl_config.dll_handle = NULL; 555 SDL_SetError("Could not retrieve OpenGL functions"); 556 return -1; 557 } 558 559 this->gl_config.driver_loaded = 1; 560 if ( path ) { 561 SDL_strlcpy(this->gl_config.driver_path, path, 562 SDL_arraysize(this->gl_config.driver_path)); 563 } else { 564 *this->gl_config.driver_path = '\0'; 565 } 566 return 0; 567} 568 569void *X11_GL_GetProcAddress(_THIS, const char* proc) 570{ 571 if ( this->gl_data->glXGetProcAddress ) { 572 return this->gl_data->glXGetProcAddress((const GLubyte *)proc); 573 } 574 return GL_LoadFunction(this->gl_config.dll_handle, proc); 575} 576 577#endif /* SDL_VIDEO_OPENGL_GLX */ 578