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