Debian Codegraph @

src/x/xglx_config.c

raw
1 #include "allegro5/allegro.h"
2 #include "allegro5/allegro_opengl.h"
3 #include "allegro5/opengl/gl_ext.h"
4 #include "allegro5/internal/aintern.h"
5 #include "allegro5/internal/aintern_display.h"
6 #include "allegro5/internal/aintern_opengl.h"
7 #include "allegro5/internal/aintern_pixels.h"
8 #include "allegro5/internal/aintern_x.h"
9 #include "allegro5/internal/aintern_xdisplay.h"
10 #include "allegro5/internal/aintern_xglx_config.h"
11 #include "allegro5/internal/aintern_xsystem.h"
12
13 ALLEGRO_DEBUG_CHANNEL("xglx_config")
14
15 #ifdef DEBUGMODE
16 static void display_pixel_format(ALLEGRO_EXTRA_DISPLAY_SETTINGS *eds)
17 {
18 ALLEGRO_DEBUG("Single-buffer: %s\n", eds->settings[ALLEGRO_SINGLE_BUFFER] ? "yes" : "no");
19 if (eds->settings[ALLEGRO_SWAP_METHOD] > 0)
20 ALLEGRO_DEBUG("Swap method: %s\n", eds->settings[ALLEGRO_SWAP_METHOD] == 2 ? "flip" : "copy");
21 else
22 ALLEGRO_DEBUG("Swap method: undefined\n");
23 ALLEGRO_DEBUG("Color format: r%i g%i b%i a%i, %i bit\n",
24 eds->settings[ALLEGRO_RED_SIZE],
25 eds->settings[ALLEGRO_GREEN_SIZE],
26 eds->settings[ALLEGRO_BLUE_SIZE],
27 eds->settings[ALLEGRO_ALPHA_SIZE],
28 eds->settings[ALLEGRO_COLOR_SIZE]);
29 ALLEGRO_DEBUG("Depth buffer: %i bits\n", eds->settings[ALLEGRO_DEPTH_SIZE]);
30 ALLEGRO_DEBUG("Sample buffers: %s\n", eds->settings[ALLEGRO_SAMPLE_BUFFERS] ? "yes" : "no");
31 ALLEGRO_DEBUG("Samples: %i\n", eds->settings[ALLEGRO_SAMPLES]);
32 }
33 #endif
34
35 static int get_shift(int mask)
36 {
37 int i = 0, j = 1;
38 if (!mask)
39 return -1;
40 while (!(j & mask)) {
41 i++;
42 j <<= 1;
43 }
44 return i;
45 }
46
47 static void figure_out_colors(ALLEGRO_EXTRA_DISPLAY_SETTINGS *eds, XVisualInfo *v)
48 {
49 eds->settings[ALLEGRO_RED_SHIFT] = get_shift(v->red_mask);
50 eds->settings[ALLEGRO_GREEN_SHIFT] = get_shift(v->green_mask);
51 eds->settings[ALLEGRO_BLUE_SHIFT] = get_shift(v->blue_mask);
52 eds->settings[ALLEGRO_ALPHA_SHIFT] = 0;
53
54 eds->settings[ALLEGRO_COLOR_SIZE] = 0;
55
56 if (eds->settings[ALLEGRO_RED_SIZE] == 3
57 && eds->settings[ALLEGRO_GREEN_SIZE] == 3
58 && eds->settings[ALLEGRO_BLUE_SIZE] == 2) {
59 eds->settings[ALLEGRO_COLOR_SIZE] = 8;
60 }
61
62 if (eds->settings[ALLEGRO_RED_SIZE] == 5
63 && eds->settings[ALLEGRO_BLUE_SIZE] == 5) {
64 if (eds->settings[ALLEGRO_GREEN_SIZE] == 5) {
65 eds->settings[ALLEGRO_COLOR_SIZE] = 15;
66 }
67 if (eds->settings[ALLEGRO_GREEN_SIZE] == 6) {
68 eds->settings[ALLEGRO_COLOR_SIZE] = 16;
69 }
70 }
71
72 if (eds->settings[ALLEGRO_RED_SIZE] == 8
73 && eds->settings[ALLEGRO_GREEN_SIZE] == 8
74 && eds->settings[ALLEGRO_BLUE_SIZE] == 8) {
75 if (eds->settings[ALLEGRO_ALPHA_SIZE] == 0) {
76 eds->settings[ALLEGRO_COLOR_SIZE] = 24;
77 }
78 if (eds->settings[ALLEGRO_ALPHA_SIZE] == 8) {
79 eds->settings[ALLEGRO_COLOR_SIZE] = 32;
80 /* small hack that tries to guess alpha shifting */
81 eds->settings[ALLEGRO_ALPHA_SHIFT] = 48 - eds->settings[ALLEGRO_RED_SHIFT]
82 - eds->settings[ALLEGRO_GREEN_SHIFT]
83 - eds->settings[ALLEGRO_BLUE_SHIFT];
84 }
85 }
86 }
87
88 static ALLEGRO_EXTRA_DISPLAY_SETTINGS* read_fbconfig(Display *dpy,
89 GLXFBConfig fbc)
90 {
91 int render_type, visual_type, buffer_size, sbuffers, samples;
92 int drawable_type, renderable, swap_method, double_buffer;
93 ALLEGRO_EXTRA_DISPLAY_SETTINGS *eds;
94 XVisualInfo *v;
95
96 eds = al_calloc(1, sizeof(ALLEGRO_EXTRA_DISPLAY_SETTINGS));
97 eds->settings[ALLEGRO_RENDER_METHOD] = 2;
98
99 if (glXGetFBConfigAttrib (dpy, fbc, GLX_RENDER_TYPE,
100 &render_type)
101 || glXGetFBConfigAttrib (dpy, fbc, GLX_X_RENDERABLE,
102 &renderable)
103 || glXGetFBConfigAttrib (dpy, fbc, GLX_DRAWABLE_TYPE,
104 &drawable_type)
105 || glXGetFBConfigAttrib (dpy, fbc, GLX_X_VISUAL_TYPE,
106 &visual_type)
107 || glXGetFBConfigAttrib (dpy, fbc, GLX_BUFFER_SIZE,
108 &buffer_size)
109 || glXGetFBConfigAttrib (dpy, fbc, GLX_DEPTH_SIZE,
110 &eds->settings[ALLEGRO_DEPTH_SIZE])
111 || glXGetFBConfigAttrib (dpy, fbc, GLX_STEREO,
112 &eds->settings[ALLEGRO_STEREO])
113 || glXGetFBConfigAttrib (dpy, fbc, GLX_RED_SIZE,
114 &eds->settings[ALLEGRO_RED_SIZE])
115 || glXGetFBConfigAttrib (dpy, fbc, GLX_GREEN_SIZE,
116 &eds->settings[ALLEGRO_GREEN_SIZE])
117 || glXGetFBConfigAttrib (dpy, fbc, GLX_BLUE_SIZE,
118 &eds->settings[ALLEGRO_BLUE_SIZE])
119 || glXGetFBConfigAttrib (dpy, fbc, GLX_ALPHA_SIZE,
120 &eds->settings[ALLEGRO_ALPHA_SIZE])
121 || glXGetFBConfigAttrib (dpy, fbc, GLX_DOUBLEBUFFER,
122 &double_buffer)
123 || glXGetFBConfigAttrib (dpy, fbc, GLX_AUX_BUFFERS,
124 &eds->settings[ALLEGRO_AUX_BUFFERS])
125 || glXGetFBConfigAttrib (dpy, fbc, GLX_STENCIL_SIZE,
126 &eds->settings[ALLEGRO_STENCIL_SIZE])
127 || glXGetFBConfigAttrib (dpy, fbc, GLX_ACCUM_RED_SIZE,
128 &eds->settings[ALLEGRO_ACC_RED_SIZE])
129 || glXGetFBConfigAttrib (dpy, fbc, GLX_ACCUM_GREEN_SIZE,
130 &eds->settings[ALLEGRO_ACC_GREEN_SIZE])
131 || glXGetFBConfigAttrib (dpy, fbc, GLX_ACCUM_BLUE_SIZE,
132 &eds->settings[ALLEGRO_ACC_BLUE_SIZE])
133 || glXGetFBConfigAttrib (dpy, fbc, GLX_ACCUM_ALPHA_SIZE,
134 &eds->settings[ALLEGRO_ACC_ALPHA_SIZE])) {
135 ALLEGRO_DEBUG("Incomplete glX mode ...\n");
136 al_free(eds);
137 return NULL;
138 }
139 eds->settings[ALLEGRO_SINGLE_BUFFER] = !double_buffer;
140
141 if (!(render_type & GLX_RGBA_BIT) && !(render_type & GLX_RGBA_FLOAT_BIT_ARB)) {
142 ALLEGRO_DEBUG("Not RGBA mode\n");
143 al_free(eds);
144 return NULL;
145 }
146
147 if (!(drawable_type & GLX_WINDOW_BIT)) {
148 ALLEGRO_DEBUG("Cannot render to a window.\n");
149 al_free(eds);
150 return NULL;
151 }
152
153 if (renderable == False) {
154 ALLEGRO_DEBUG("GLX windows not supported.\n");
155 al_free(eds);
156 return NULL;
157 }
158
159 if (visual_type != GLX_TRUE_COLOR && visual_type != GLX_DIRECT_COLOR) {
160 ALLEGRO_DEBUG("visual type other than TrueColor and "
161 "DirectColor.\n");
162 al_free(eds);
163 return NULL;
164 }
165
166 /* Floating-point depth is not supported as glx extension (yet). */
167 eds->settings[ALLEGRO_FLOAT_DEPTH] = 0;
168
169 eds->settings[ALLEGRO_FLOAT_COLOR] = (render_type & GLX_RGBA_FLOAT_BIT_ARB);
170
171 v = glXGetVisualFromFBConfig(dpy, fbc);
172 if (!v) {
173 ALLEGRO_DEBUG("Cannot get associated visual for the FBConfig.\n");
174 al_free(eds);
175 return NULL;
176 }
177 figure_out_colors(eds, v);
178
179 if (glXGetConfig(dpy, v, GLX_SAMPLE_BUFFERS, &sbuffers)) {
180 /* Multisample extension is not supported */
181 eds->settings[ALLEGRO_SAMPLE_BUFFERS] = 0;
182 }
183 else {
184 eds->settings[ALLEGRO_SAMPLE_BUFFERS] = sbuffers;
185 }
186 if (glXGetConfig(dpy, v, GLX_SAMPLES, &samples)) {
187 /* Multisample extension is not supported */
188 eds->settings[ALLEGRO_SAMPLES] = 0;
189 }
190 else {
191 eds->settings[ALLEGRO_SAMPLES] = samples;
192 }
193 if (glXGetFBConfigAttrib(dpy, fbc, GLX_SWAP_METHOD_OML,
194 &swap_method) == GLX_BAD_ATTRIBUTE) {
195 /* GLX_OML_swap_method extension is not supported */
196 eds->settings[ALLEGRO_SWAP_METHOD] = 0;
197 }
198 else {
199 eds->settings[ALLEGRO_SWAP_METHOD] = swap_method;
200 }
201
202 /* We can only guarantee vsync is off. */
203 eds->settings[ALLEGRO_VSYNC] = 2;
204
205 eds->settings[ALLEGRO_COMPATIBLE_DISPLAY] = (_al_deduce_color_format(eds)
206 != ALLEGRO_PIXEL_FORMAT_ANY);
207
208 XFree(v);
209
210 return eds;
211 }
212
213
214 static ALLEGRO_EXTRA_DISPLAY_SETTINGS** get_visuals_new(ALLEGRO_DISPLAY_XGLX *glx, int *eds_count)
215 {
216 int num_fbconfigs, i, j;
217 GLXFBConfig *fbconfig;
218 ALLEGRO_EXTRA_DISPLAY_SETTINGS *ref;
219 ALLEGRO_EXTRA_DISPLAY_SETTINGS **eds = NULL;
220 ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver();
221
222 ref = _al_get_new_display_settings();
223
224 fbconfig = glXGetFBConfigs(system->gfxdisplay, glx->xscreen, &num_fbconfigs);
225 if (!fbconfig || !num_fbconfigs) {
226 if (fbconfig) {
227 XFree(fbconfig);
228 }
229 ALLEGRO_DEBUG("glXGetFBConfigs(xscreen=%d) returned NULL.\n", glx->xscreen);
230 return NULL;
231 }
232
233 eds = al_malloc(num_fbconfigs * sizeof(*eds));
234
235 ALLEGRO_INFO("%i formats.\n", num_fbconfigs);
236
237 for (i = j = 0; i < num_fbconfigs; i++) {
238 ALLEGRO_DEBUG("-- \n");
239 ALLEGRO_DEBUG("Decoding visual no. %i...\n", i);
240 eds[j] = read_fbconfig(system->gfxdisplay, fbconfig[i]);
241 if (!eds[j])
242 continue;
243 #ifdef DEBUGMODE
244 display_pixel_format(eds[j]);
245 #endif
246 eds[j]->score = _al_score_display_settings(eds[j], ref);
247 if (eds[j]->score == -1) {
248 al_free(eds[j]);
249 continue;
250 }
251 eds[j]->index = i;
252 eds[j]->info = al_malloc(sizeof(GLXFBConfig));
253 memcpy(eds[j]->info, &fbconfig[i], sizeof(GLXFBConfig));
254 j++;
255 }
256
257 *eds_count = j;
258 ALLEGRO_INFO("%i visuals are good enough.\n", j);
259 if (j == 0) {
260 al_free(eds);
261 eds = NULL;
262 }
263
264 XFree(fbconfig);
265
266 return eds;
267 }
268
269
270 static ALLEGRO_EXTRA_DISPLAY_SETTINGS* read_xvisual(Display *dpy,
271 XVisualInfo *v)
272 {
273 int rgba, buffer_size, use_gl, sbuffers, samples, double_buffer;
274 ALLEGRO_EXTRA_DISPLAY_SETTINGS *eds;
275
276 /* We can only support TrueColor and DirectColor visuals --
277 * we only support RGBA mode */
278 if (v->class != TrueColor && v->class != DirectColor)
279 return NULL;
280
281 eds = al_calloc(1, sizeof(ALLEGRO_EXTRA_DISPLAY_SETTINGS));
282 eds->settings[ALLEGRO_RENDER_METHOD] = 2;
283
284 if (glXGetConfig (dpy, v, GLX_RGBA, &rgba)
285 || glXGetConfig (dpy, v, GLX_USE_GL, &use_gl)
286 || glXGetConfig (dpy, v, GLX_BUFFER_SIZE, &buffer_size)
287 || glXGetConfig (dpy, v, GLX_RED_SIZE, &eds->settings[ALLEGRO_RED_SIZE])
288 || glXGetConfig (dpy, v, GLX_GREEN_SIZE, &eds->settings[ALLEGRO_GREEN_SIZE])
289 || glXGetConfig (dpy, v, GLX_BLUE_SIZE, &eds->settings[ALLEGRO_BLUE_SIZE])
290 || glXGetConfig (dpy, v, GLX_ALPHA_SIZE, &eds->settings[ALLEGRO_ALPHA_SIZE])
291 || glXGetConfig (dpy, v, GLX_DOUBLEBUFFER, &double_buffer)
292 || glXGetConfig (dpy, v, GLX_STEREO, &eds->settings[ALLEGRO_STEREO])
293 || glXGetConfig (dpy, v, GLX_AUX_BUFFERS, &eds->settings[ALLEGRO_AUX_BUFFERS])
294 || glXGetConfig (dpy, v, GLX_DEPTH_SIZE, &eds->settings[ALLEGRO_DEPTH_SIZE])
295 || glXGetConfig (dpy, v, GLX_STENCIL_SIZE, &eds->settings[ALLEGRO_STENCIL_SIZE])
296 || glXGetConfig (dpy, v, GLX_ACCUM_RED_SIZE,
297 &eds->settings[ALLEGRO_ACC_RED_SIZE])
298 || glXGetConfig (dpy, v, GLX_ACCUM_GREEN_SIZE,
299 &eds->settings[ALLEGRO_ACC_GREEN_SIZE])
300 || glXGetConfig (dpy, v, GLX_ACCUM_BLUE_SIZE,
301 &eds->settings[ALLEGRO_ACC_BLUE_SIZE])
302 || glXGetConfig (dpy, v, GLX_ACCUM_ALPHA_SIZE,
303 &eds->settings[ALLEGRO_ACC_ALPHA_SIZE])) {
304 ALLEGRO_DEBUG("Incomplete glX mode ...\n");
305 al_free(eds);
306 return NULL;
307 }
308 eds->settings[ALLEGRO_SINGLE_BUFFER] = !double_buffer;
309
310 if (!rgba) {
311 ALLEGRO_DEBUG("Not RGBA mode\n");
312 al_free(eds);
313 return NULL;
314 }
315
316 if (!use_gl) {
317 ALLEGRO_DEBUG("OpenGL Unsupported\n");
318 al_free(eds);
319 return NULL;
320 }
321
322 eds->settings[ALLEGRO_COLOR_SIZE] = 0;
323 figure_out_colors(eds, v);
324
325 eds->settings[ALLEGRO_FLOAT_COLOR] = 0;
326 eds->settings[ALLEGRO_FLOAT_DEPTH] = 0;
327
328 if (glXGetConfig(dpy, v, GLX_SAMPLE_BUFFERS, &sbuffers) == GLX_BAD_ATTRIBUTE) {
329 /* Multisample extension is not supported */
330 eds->settings[ALLEGRO_SAMPLE_BUFFERS] = 0;
331 }
332 else {
333 eds->settings[ALLEGRO_SAMPLE_BUFFERS] = sbuffers;
334 }
335 if (glXGetConfig(dpy, v, GLX_SAMPLES, &samples) == GLX_BAD_ATTRIBUTE) {
336 /* Multisample extension is not supported */
337 eds->settings[ALLEGRO_SAMPLES] = 0;
338 }
339 else {
340 eds->settings[ALLEGRO_SAMPLES] = samples;
341 }
342
343 eds->settings[ALLEGRO_SWAP_METHOD] = 0;
344 eds->settings[ALLEGRO_COMPATIBLE_DISPLAY] = (_al_deduce_color_format(eds)
345 != ALLEGRO_PIXEL_FORMAT_ANY);
346
347 return eds;
348 }
349
350 static ALLEGRO_EXTRA_DISPLAY_SETTINGS** get_visuals_old(int *eds_count)
351 {
352 int i, j, num_visuals;
353 XVisualInfo *xv;
354 ALLEGRO_EXTRA_DISPLAY_SETTINGS *ref;
355 ALLEGRO_EXTRA_DISPLAY_SETTINGS **eds;
356 ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver();
357
358 ref = _al_get_new_display_settings();
359
360 xv = XGetVisualInfo(system->gfxdisplay, 0, NULL, &num_visuals);
361 if (!xv || !num_visuals)
362 return NULL;
363
364 eds = al_malloc(num_visuals * sizeof(*eds));
365
366 ALLEGRO_INFO("%i formats.\n", num_visuals);
367
368 for (i = j = 0; i < num_visuals; i++) {
369 ALLEGRO_DEBUG("-- \n");
370 ALLEGRO_DEBUG("Decoding visual no. %i...\n", i);
371 eds[j] = read_xvisual(system->gfxdisplay, xv + i);
372 if (!eds[j])
373 continue;
374 #ifdef DEBUGMODE
375 display_pixel_format(eds[j]);
376 #endif
377 eds[j]->score = _al_score_display_settings(eds[j], ref);
378 if (eds[j]->score == -1) {
379 al_free(eds[j]);
380 continue;
381 }
382 eds[j]->index = i;
383 /* Seems that XVinfo is static. */
384 eds[j]->info = al_malloc(sizeof(XVisualInfo));
385 memcpy(eds[j]->info, xv + i, sizeof(XVisualInfo));
386 j++;
387 }
388
389 *eds_count = j;
390 ALLEGRO_INFO("%i visuals are good enough.\n", j);
391 if (j == 0) {
392 al_free(eds);
393 eds = NULL;
394 }
395
396 XFree(xv);
397
398 return eds;
399 }
400
401
402 static void select_best_visual(ALLEGRO_DISPLAY_XGLX *glx,
403 ALLEGRO_EXTRA_DISPLAY_SETTINGS* *eds, int eds_count,
404 bool using_fbc)
405 {
406 ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver();
407
408 qsort(eds, eds_count, sizeof(*eds), _al_display_settings_sorter);
409
410 ASSERT(eds_count > 0);
411 ASSERT(eds[0] != NULL);
412
413 if (!eds[0]->info) {
414 ALLEGRO_ERROR("No matching displays found.\n");
415 glx->xvinfo = NULL;
416 return;
417 }
418
419 ALLEGRO_INFO("Chose visual no. %i\n", eds[0]->index);
420 #ifdef DEBUGMODE
421 display_pixel_format(eds[0]);
422 #endif
423 if (using_fbc) {
424 glx->fbc = al_malloc(sizeof(GLXFBConfig));
425 memcpy(glx->fbc, eds[0]->info, sizeof(GLXFBConfig));
426
427 glx->xvinfo = glXGetVisualFromFBConfig(system->gfxdisplay, *glx->fbc);
428 }
429 else {
430 glx->xvinfo = al_malloc(sizeof(XVisualInfo));
431 memcpy(glx->xvinfo, eds[0]->info, sizeof(XVisualInfo));
432 }
433
434 ALLEGRO_INFO("Corresponding X11 visual id: %lu\n", glx->xvinfo->visualid);
435 memcpy(&glx->display.extra_settings, eds[0], sizeof(ALLEGRO_EXTRA_DISPLAY_SETTINGS));
436 }
437
438
439
440 void _al_xglx_config_select_visual(ALLEGRO_DISPLAY_XGLX *glx)
441 {
442 ALLEGRO_EXTRA_DISPLAY_SETTINGS **eds;
443 int eds_count, i;
444 bool force_old = false;
445 bool using_fbc;
446
447 const char *selection_mode;
448 selection_mode = al_get_config_value(al_get_system_config(), "graphics",
449 "config_selection");
450 if (selection_mode && selection_mode[0] != '\0') {
451 if (!_al_stricmp(selection_mode, "old")) {
452 ALLEGRO_WARN("Forcing OLD visual selection method.\n");
453 force_old = true;
454 }
455 else if (!_al_stricmp(selection_mode, "new"))
456 force_old = false;
457 }
458
459 if (glx->glx_version >= 130 && !force_old)
460 eds = get_visuals_new(glx, &eds_count);
461 else
462 eds = NULL;
463
464 if (!eds) {
465 eds = get_visuals_old(&eds_count);
466 using_fbc = false;
467 }
468 else
469 using_fbc = true;
470
471 if (!eds) {
472 ALLEGRO_ERROR("Failed to get any visual info.\n");
473 return;
474 }
475
476 select_best_visual(glx, eds, eds_count, using_fbc);
477
478 for (i = 0; i < eds_count; i++) {
479 if (eds[i]) {
480 al_free(eds[i]->info);
481 al_free(eds[i]);
482 }
483 }
484 al_free(eds);
485 }
486
487 static GLXContext create_context_new(int ver, Display *dpy, GLXFBConfig fb,
488 GLXContext ctx, bool forward_compat, bool want_es, bool core_profile, int major, int minor)
489 {
490 typedef GLXContext (*GCCA_PROC) (Display*, GLXFBConfig, GLXContext, Bool, const int*);
491 GCCA_PROC _xglx_glXCreateContextAttribsARB = NULL;
492
493 if (ver >= 140) {
494 /* GLX 1.4 should have this, if it's defined, use it directly. */
495 /* OTOH it *could* be there but only available through dynamic loading. */
496 /* In that case, fallback to calling glxXGetProcAddress. */
497 #ifdef glXCreateContextAttribsARB
498 _xglx_glXCreateContextAttribsARB = glXCreateContextAttribsARB;
499 #endif // glXCreateContextAttribsARB
500 }
501 if (!_xglx_glXCreateContextAttribsARB) {
502 /* Load the extension manually. */
503 _xglx_glXCreateContextAttribsARB =
504 (GCCA_PROC)glXGetProcAddress((const GLubyte*)"glXCreateContextAttribsARB");
505 }
506 if (!_xglx_glXCreateContextAttribsARB) {
507 ALLEGRO_ERROR("GLX_ARB_create_context not supported and needed for OpenGL 3\n");
508 return NULL;
509 }
510
511 int attrib[] = {GLX_CONTEXT_MAJOR_VERSION_ARB, major,
512 GLX_CONTEXT_MINOR_VERSION_ARB, minor,
513 GLX_CONTEXT_FLAGS_ARB, 0,
514 0, 0,
515 0};
516 if (forward_compat)
517 attrib[5] = GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
518 if (want_es) {
519 attrib[6] = GLX_CONTEXT_PROFILE_MASK_ARB;
520 attrib[7] = GLX_CONTEXT_ES_PROFILE_BIT_EXT;
521 }
522 else if (core_profile) {
523 attrib[6] = GLX_CONTEXT_PROFILE_MASK_ARB;
524 attrib[7] = GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
525 }
526 return _xglx_glXCreateContextAttribsARB(dpy, fb, ctx, True, attrib);
527 }
528
529 bool _al_xglx_config_create_context(ALLEGRO_DISPLAY_XGLX *glx)
530 {
531 ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver();
532 ALLEGRO_DISPLAY *disp = (void*)glx;
533 GLXContext existing_ctx = NULL;
534
535 /* Find an existing context with which to share display lists. */
536 if (_al_vector_size(&system->system.displays) > 1) {
537 ALLEGRO_DISPLAY_XGLX **existing_dpy;
538 existing_dpy = _al_vector_ref_front(&system->system.displays);
539 if (*existing_dpy != glx)
540 existing_ctx = (*existing_dpy)->context;
541 }
542
543 int major = al_get_new_display_option(ALLEGRO_OPENGL_MAJOR_VERSION, 0);
544 int minor = al_get_new_display_option(ALLEGRO_OPENGL_MINOR_VERSION, 0);
545
546 if (glx->fbc) {
547 bool forward_compat = (disp->flags & ALLEGRO_OPENGL_FORWARD_COMPATIBLE) != 0;
548 bool core_profile = (disp->flags & ALLEGRO_OPENGL_CORE_PROFILE) != 0;
549 /* Create a GLX context from FBC. */
550 if (disp->flags & ALLEGRO_OPENGL_ES_PROFILE) {
551 if (major == 0)
552 major = 2;
553 glx->context = create_context_new(glx->glx_version,
554 system->gfxdisplay, *glx->fbc, existing_ctx, forward_compat,
555 true, core_profile, major, minor);
556 }
557 else if ((disp->flags & ALLEGRO_OPENGL_3_0) || major != 0 || core_profile) {
558 if (major == 0)
559 major = 3;
560 if (core_profile && major == 3 && minor < 2) // core profile requires at least 3.2
561 minor = 2;
562 glx->context = create_context_new(glx->glx_version,
563 system->gfxdisplay, *glx->fbc, existing_ctx, forward_compat,
564 false, core_profile, major, minor);
565 /* TODO: Right now Allegro's own OpenGL driver only works with a 3.0+
566 * context when using the programmable pipeline, for some reason. All
567 * that's missing is probably a default shader though.
568 */
569 disp->extra_settings.settings[ALLEGRO_COMPATIBLE_DISPLAY] = 1;
570 if (forward_compat && !(disp->flags & ALLEGRO_PROGRAMMABLE_PIPELINE))
571 disp->extra_settings.settings[ALLEGRO_COMPATIBLE_DISPLAY] = 0;
572 }
573 else {
574 glx->context = glXCreateNewContext(system->gfxdisplay, *glx->fbc,
575 GLX_RGBA_TYPE, existing_ctx, True);
576 }
577
578 /* Create a GLX subwindow inside our window. */
579 glx->glxwindow = glXCreateWindow(system->gfxdisplay, *glx->fbc,
580 glx->window, 0);
581 }
582 else {
583 /* Create a GLX context from visual info. */
584 glx->context = glXCreateContext(system->gfxdisplay, glx->xvinfo,
585 existing_ctx, True);
586 glx->glxwindow = glx->window;
587 }
588
589 if (!glx->context || !glx->glxwindow) {
590 ALLEGRO_ERROR("Failed to create GLX context.\n");
591 return false;
592 }
593
594 disp->ogl_extras->is_shared = true;
595
596 ALLEGRO_DEBUG("Got GLX context.\n");
597 return true;
598 }