| 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 |
} |