AllegroGL: alleggl.c Source File

AllegroGL 0.4.4

- Main Page
- Related Pages
- Modules
- Files

- File List
- Globals

alleggl.c
Go to the documentation of this file.
1 /* This code is (C) AllegroGL contributors, and double licensed under
2 * the GPL and zlib licenses. See gpl.txt or zlib.txt for details.
3 */
11 #include <string.h>
12 #include <stdlib.h>
13
14 #include "alleggl.h"
15 #include "allglint.h"
16
17 #include <allegro/internal/aintern.h>
18 #ifdef ALLEGRO_MACOSX
19 #include <OpenGL/glu.h>
20 #else
21 #include <GL/glu.h>
22 #endif
23
24 #define PREFIX_I "agl INFO: "
25 #define PREFIX_E "agl ERROR: "
26 #define PREFIX_L "agl LOG: "
27
28
29 /* Structs containing the current driver state */
30 struct allegro_gl_driver *__allegro_gl_driver = NULL;
31 struct allegro_gl_display_info allegro_gl_display_info;
32
33 /* Settings required/suggested */
34 int __allegro_gl_required_settings, __allegro_gl_suggested_settings;
35
36 /* Valid context state */
37 int __allegro_gl_valid_context = 0;
38
39
40 /* Operation to enable while blitting. */
41 int __allegro_gl_blit_operation;
42
43
44 char allegro_gl_error[AGL_ERROR_SIZE] = EMPTY_STRING;
45
46 BLIT_BETWEEN_FORMATS_FUNC __blit_between_formats8;
47 BLIT_BETWEEN_FORMATS_FUNC __blit_between_formats15;
48 BLIT_BETWEEN_FORMATS_FUNC __blit_between_formats16;
49 BLIT_BETWEEN_FORMATS_FUNC __blit_between_formats24;
50 BLIT_BETWEEN_FORMATS_FUNC __blit_between_formats32;
51
52
53
62 BITMAP *allegro_gl_screen;
63
64
65
66 /* Allegro GFX_DRIVER list handling */
67 static _DRIVER_INFO our_driver_list[] = {
68 #ifdef GFX_OPENGL_WINDOWED
69 {GFX_OPENGL_WINDOWED, &gfx_allegro_gl_windowed, FALSE},
70 #endif
71 #ifdef GFX_OPENGL_FULLSCREEN
72 {GFX_OPENGL_FULLSCREEN, &gfx_allegro_gl_fullscreen, FALSE},
73 #endif
74 {GFX_OPENGL, &gfx_allegro_gl_default, FALSE},
75 {0, NULL, FALSE}
76 };
77
78
79
80 static _DRIVER_INFO *our_gfx_drivers(void)
81 {
82 return our_driver_list;
83 }
84
85
86
87 _DRIVER_INFO *(*saved_gfx_drivers) (void) = NULL;
88
89
90
91 static _DRIVER_INFO *list_saved_gfx_drivers(void)
92 {
93 return _gfx_driver_list;
94 }
95
96
97
98 static BITMAP *allegro_gl_default_gfx_init(int w, int h, int vw, int vh, int depth);
99
100
101
102 GFX_DRIVER gfx_allegro_gl_default =
103 {
104 GFX_OPENGL,
105 EMPTY_STRING,
106 EMPTY_STRING,
107 "AllegroGL Default Driver",
108 allegro_gl_default_gfx_init,
109 NULL,
110 NULL,
111 NULL, //_xwin_vsync,
112 NULL,
113 NULL, NULL, NULL,
114 NULL, /* create_video_bitmap */
115 NULL,
116 NULL, NULL, /* No show/request video bitmaps */
117 NULL, NULL,
118 NULL, NULL, NULL, NULL,
119 NULL,
120 NULL, NULL,
121 NULL, /* set_blender_mode */
122 NULL, /* No fetch_mode_list */
123 0, 0,
124 0,
125 0, 0,
126 0,
127 0,
128 FALSE /* Windowed mode */
129 };
130
131
132
176 /* void allegro_gl_clear_settings(void) */
193 void allegro_gl_clear_settings(void)
194 {
195 memset(&allegro_gl_display_info, 0, sizeof allegro_gl_display_info);
196
197 __allegro_gl_required_settings = __allegro_gl_suggested_settings = 0;
198
199 /* Pick sensible defaults */
200 allegro_gl_display_info.fullscreen = 1;
201 allegro_gl_display_info.rmethod = 1;
202 allegro_gl_display_info.doublebuffered = 1;
203 allegro_gl_display_info.vidmem_policy = AGL_KEEP;
204 __allegro_gl_suggested_settings =
205 AGL_FULLSCREEN | AGL_RENDERMETHOD | AGL_DOUBLEBUFFER;
206 }
207
208
209
210 /* void allegro_gl_set(int option, int value) */
274 void allegro_gl_set(int option, int value)
275 {
276 switch (option) {
277 /* Options stating importance of other options */
278 case AGL_REQUIRE:
279 __allegro_gl_required_settings |= value;
280 __allegro_gl_suggested_settings &= ~value;
281 break;
282 case AGL_SUGGEST:
283 __allegro_gl_suggested_settings |= value;
284 __allegro_gl_required_settings &= ~value;
285 break;
286 case AGL_DONTCARE:
287 __allegro_gl_required_settings &= ~value;
288 __allegro_gl_suggested_settings &= ~value;
289 break;
290
291 /* Options configuring the mode set */
292 case AGL_ALLEGRO_FORMAT:
293 allegro_gl_display_info.allegro_format = value;
294 break;
295 case AGL_RED_DEPTH:
296 allegro_gl_display_info.pixel_size.rgba.r = value;
297 break;
298 case AGL_GREEN_DEPTH:
299 allegro_gl_display_info.pixel_size.rgba.g = value;
300 break;
301 case AGL_BLUE_DEPTH:
302 allegro_gl_display_info.pixel_size.rgba.b = value;
303 break;
304 case AGL_ALPHA_DEPTH:
305 allegro_gl_display_info.pixel_size.rgba.a = value;
306 break;
307 case AGL_COLOR_DEPTH:
308 switch (value) {
309 case 8:
310 allegro_gl_set(AGL_RED_DEPTH, 3);
311 allegro_gl_set(AGL_GREEN_DEPTH, 3);
312 allegro_gl_set(AGL_BLUE_DEPTH, 2);
313 allegro_gl_set(AGL_ALPHA_DEPTH, 0);
314 break;
315 case 15:
316 allegro_gl_set(AGL_RED_DEPTH, 5);
317 allegro_gl_set(AGL_GREEN_DEPTH, 5);
318 allegro_gl_set(AGL_BLUE_DEPTH, 5);
319 allegro_gl_set(AGL_ALPHA_DEPTH, 1);
320 break;
321 case 16:
322 allegro_gl_set(AGL_RED_DEPTH, 5);
323 allegro_gl_set(AGL_GREEN_DEPTH, 6);
324 allegro_gl_set(AGL_BLUE_DEPTH, 5);
325 allegro_gl_set(AGL_ALPHA_DEPTH, 0);
326 break;
327 case 24:
328 case 32:
329 allegro_gl_set(AGL_RED_DEPTH, 8);
330 allegro_gl_set(AGL_GREEN_DEPTH, 8);
331 allegro_gl_set(AGL_BLUE_DEPTH, 8);
332 allegro_gl_set(AGL_ALPHA_DEPTH, value-24);
333 break;
334 }
335 allegro_gl_display_info.colour_depth = value;
336 break;
337 case AGL_ACC_RED_DEPTH:
338 allegro_gl_display_info.accum_size.rgba.r = value;
339 break;
340 case AGL_ACC_GREEN_DEPTH:
341 allegro_gl_display_info.accum_size.rgba.g = value;
342 break;
343 case AGL_ACC_BLUE_DEPTH:
344 allegro_gl_display_info.accum_size.rgba.b = value;
345 break;
346 case AGL_ACC_ALPHA_DEPTH:
347 allegro_gl_display_info.accum_size.rgba.a = value;
348 break;
349
350 case AGL_DOUBLEBUFFER:
351 allegro_gl_display_info.doublebuffered = value;
352 break;
353 case AGL_STEREO:
354 allegro_gl_display_info.stereo = value;
355 break;
356 case AGL_AUX_BUFFERS:
357 allegro_gl_display_info.aux_buffers = value;
358 break;
359 case AGL_Z_DEPTH:
360 allegro_gl_display_info.depth_size = value;
361 break;
362 case AGL_STENCIL_DEPTH:
363 allegro_gl_display_info.stencil_size = value;
364 break;
365
366 case AGL_WINDOW_X:
367 allegro_gl_display_info.x = value;
368 break;
369 case AGL_WINDOW_Y:
370 allegro_gl_display_info.y = value;
371 break;
372
373 case AGL_RENDERMETHOD:
374 allegro_gl_display_info.rmethod = value;
375 break;
376
377 case AGL_FULLSCREEN:
378 allegro_gl_display_info.fullscreen = value;
379 break;
380
381 case AGL_WINDOWED:
382 allegro_gl_display_info.fullscreen = !value;
383 break;
384 case AGL_VIDEO_MEMORY_POLICY:
385 if ((value == AGL_KEEP) || (value == AGL_RELEASE))
386 allegro_gl_display_info.vidmem_policy = value;
387 break;
388 case AGL_SAMPLE_BUFFERS:
389 allegro_gl_display_info.sample_buffers = value;
390 break;
391 case AGL_SAMPLES:
392 allegro_gl_display_info.samples = value;
393 break;
394 case AGL_FLOAT_COLOR:
395 allegro_gl_display_info.float_color = value;
396 break;
397 case AGL_FLOAT_Z:
398 allegro_gl_display_info.float_depth = value;
399 break;
400 }
401 }
402
403
404
421 int allegro_gl_get(int option)
422 {
423 switch (option) {
424 /* Options stating importance of other options */
425 case AGL_REQUIRE:
426 return __allegro_gl_required_settings;
427 case AGL_SUGGEST:
428 return __allegro_gl_suggested_settings;
429 case AGL_DONTCARE:
430 return ~0 & ~(__allegro_gl_required_settings |
431 __allegro_gl_suggested_settings);
432
433 /* Options configuring the mode set */
434 case AGL_ALLEGRO_FORMAT:
435 return allegro_gl_display_info.allegro_format;
436 case AGL_RED_DEPTH:
437 return allegro_gl_display_info.pixel_size.rgba.r;
438 case AGL_GREEN_DEPTH:
439 return allegro_gl_display_info.pixel_size.rgba.g;
440 case AGL_BLUE_DEPTH:
441 return allegro_gl_display_info.pixel_size.rgba.b;
442 case AGL_ALPHA_DEPTH:
443 return allegro_gl_display_info.pixel_size.rgba.a;
444 case AGL_COLOR_DEPTH:
445 return allegro_gl_display_info.pixel_size.rgba.r
446 + allegro_gl_display_info.pixel_size.rgba.g
447 + allegro_gl_display_info.pixel_size.rgba.b
448 + allegro_gl_display_info.pixel_size.rgba.a;
449 case AGL_ACC_RED_DEPTH:
450 return allegro_gl_display_info.accum_size.rgba.r;
451 case AGL_ACC_GREEN_DEPTH:
452 return allegro_gl_display_info.accum_size.rgba.g;
453 case AGL_ACC_BLUE_DEPTH:
454 return allegro_gl_display_info.accum_size.rgba.b;
455 case AGL_ACC_ALPHA_DEPTH:
456 return allegro_gl_display_info.accum_size.rgba.a;
457 case AGL_DOUBLEBUFFER:
458 return allegro_gl_display_info.doublebuffered;
459 case AGL_STEREO:
460 return allegro_gl_display_info.stereo;
461 case AGL_AUX_BUFFERS:
462 return allegro_gl_display_info.aux_buffers;
463 case AGL_Z_DEPTH:
464 return allegro_gl_display_info.depth_size;
465 case AGL_STENCIL_DEPTH:
466 return allegro_gl_display_info.stencil_size;
467 case AGL_WINDOW_X:
468 return allegro_gl_display_info.x;
469 case AGL_WINDOW_Y:
470 return allegro_gl_display_info.y;
471 case AGL_FULLSCREEN:
472 return allegro_gl_display_info.fullscreen;
473 case AGL_WINDOWED:
474 return !allegro_gl_display_info.fullscreen;
475 case AGL_VIDEO_MEMORY_POLICY:
476 return allegro_gl_display_info.vidmem_policy;
477 case AGL_SAMPLE_BUFFERS:
478 return allegro_gl_display_info.sample_buffers;
479 case AGL_SAMPLES:
480 return allegro_gl_display_info.samples;
481 case AGL_FLOAT_COLOR:
482 return allegro_gl_display_info.float_color;
483 case AGL_FLOAT_Z:
484 return allegro_gl_display_info.float_depth;
485 }
486 return -1;
487 }
488
489
490
491 /* Builds a string corresponding to the options set in 'opt'
492 * and writes in the config file
493 */
494 static void build_settings(int opt, char *section, char *name) {
495 char buf[2048];
496
497 usetc(buf, 0);
498
499 if (opt & AGL_ALLEGRO_FORMAT)
500 ustrcat(buf, "allegro_format ");
501 if (opt & AGL_RED_DEPTH)
502 ustrcat(buf, "red_depth ");
503 if (opt & AGL_GREEN_DEPTH)
504 ustrcat(buf, "green_depth ");
505 if (opt & AGL_BLUE_DEPTH)
506 ustrcat(buf, "blue_depth ");
507 if (opt & AGL_ALPHA_DEPTH)
508 ustrcat(buf, "alpha_depth ");
509 if (opt & AGL_COLOR_DEPTH)
510 ustrcat(buf, "color_depth ");
511 if (opt & AGL_ACC_RED_DEPTH)
512 ustrcat(buf, "accum_red_depth ");
513 if (opt & AGL_ACC_GREEN_DEPTH)
514 ustrcat(buf, "accum_green_depth ");
515 if (opt & AGL_ACC_BLUE_DEPTH)
516 ustrcat(buf, "accum_blue_depth ");
517 if (opt & AGL_ACC_ALPHA_DEPTH)
518 ustrcat(buf, "accum_alpha_depth ");
519 if (opt & AGL_DOUBLEBUFFER)
520 ustrcat(buf, "double_buffer ");
521 if (opt & AGL_STEREO)
522 ustrcat(buf, "stereo_display ");
523 if (opt & AGL_AUX_BUFFERS)
524 ustrcat(buf, "aux_buffers ");
525 if (opt & AGL_Z_DEPTH)
526 ustrcat(buf, "z_depth ");
527 if (opt & AGL_STENCIL_DEPTH)
528 ustrcat(buf, "stencil_depth ");
529 if (opt & AGL_WINDOW_X)
530 ustrcat(buf, "window_x ");
531 if (opt & AGL_WINDOW_Y)
532 ustrcat(buf, "window_y ");
533 if (opt & AGL_FULLSCREEN)
534 ustrcat(buf, "fullscreen ");
535 if (opt & AGL_WINDOWED)
536 ustrcat(buf, "windowed ");
537 if (opt & AGL_VIDEO_MEMORY_POLICY)
538 ustrcat(buf, "video_memory_policy ");
539 if (opt & AGL_SAMPLE_BUFFERS)
540 ustrcat(buf, "sample_buffers ");
541 if (opt & AGL_SAMPLES)
542 ustrcat(buf, "samples ");
543 if (opt & AGL_FLOAT_COLOR)
544 ustrcat(buf, "float_color ");
545 if (opt & AGL_FLOAT_Z)
546 ustrcat(buf, "float_depth ");
547
548 set_config_string(section, name, buf);
549 }
550
551
552
553 /* void allegro_gl_save_settings() */
560 void allegro_gl_save_settings() {
561
562 char *section = "OpenGL";
563 int save = allegro_gl_get(AGL_REQUIRE) | allegro_gl_get(AGL_SUGGEST);
564
565 if (save & AGL_ALLEGRO_FORMAT)
566 set_config_int(section, "allegro_format",
567 allegro_gl_get(AGL_ALLEGRO_FORMAT));
568 if (save & AGL_RED_DEPTH)
569 set_config_int(section, "red_depth",
570 allegro_gl_get(AGL_RED_DEPTH));
571 if (save & AGL_GREEN_DEPTH)
572 set_config_int(section, "green_depth",
573 allegro_gl_get(AGL_GREEN_DEPTH));
574 if (save & AGL_BLUE_DEPTH)
575 set_config_int(section, "blue_depth",
576 allegro_gl_get(AGL_BLUE_DEPTH));
577 if (save & AGL_ALPHA_DEPTH)
578 set_config_int(section, "alpha_depth",
579 allegro_gl_get(AGL_ALPHA_DEPTH));
580 if (save & AGL_COLOR_DEPTH)
581 set_config_int(section, "color_depth",
582 allegro_gl_get(AGL_COLOR_DEPTH));
583 if (save & AGL_ACC_RED_DEPTH)
584 set_config_int(section, "accum_red_depth",
585 allegro_gl_get(AGL_ACC_RED_DEPTH));
586 if (save & AGL_ACC_GREEN_DEPTH)
587 set_config_int(section, "accum_green_depth",
588 allegro_gl_get(AGL_ACC_GREEN_DEPTH));
589 if (save & AGL_ACC_BLUE_DEPTH)
590 set_config_int(section, "accum_blue_depth",
591 allegro_gl_get(AGL_ACC_BLUE_DEPTH));
592 if (save & AGL_ACC_ALPHA_DEPTH)
593 set_config_int(section, "accum_alpha_depth",
594 allegro_gl_get(AGL_ACC_ALPHA_DEPTH));
595 if (save & AGL_DOUBLEBUFFER)
596 set_config_int(section, "double_buffer",
597 allegro_gl_get(AGL_DOUBLEBUFFER));
598 if (save & AGL_STEREO)
599 set_config_int(section, "stereo_display",
600 allegro_gl_get(AGL_STEREO));
601 if (save & AGL_AUX_BUFFERS)
602 set_config_int(section, "aux_buffers",
603 allegro_gl_get(AGL_AUX_BUFFERS));
604 if (save & AGL_Z_DEPTH)
605 set_config_int(section, "z_depth",
606 allegro_gl_get(AGL_Z_DEPTH));
607 if (save & AGL_STENCIL_DEPTH)
608 set_config_int(section, "stencil_depth",
609 allegro_gl_get(AGL_STENCIL_DEPTH));
610 if (save & AGL_WINDOW_X)
611 set_config_int(section, "window_x",
612 allegro_gl_get(AGL_WINDOW_X));
613 if (save & AGL_WINDOW_Y)
614 set_config_int(section, "window_y",
615 allegro_gl_get(AGL_WINDOW_Y));
616 if (save & AGL_FULLSCREEN)
617 set_config_int(section, "fullscreen",
618 allegro_gl_get(AGL_FULLSCREEN));
619 if (save & AGL_WINDOWED)
620 set_config_int(section, "windowed",
621 allegro_gl_get(AGL_WINDOWED));
622 if (save & AGL_VIDEO_MEMORY_POLICY)
623 set_config_int(section, "video_memory_policy",
624 allegro_gl_get(AGL_VIDEO_MEMORY_POLICY));
625 if (save & AGL_SAMPLE_BUFFERS)
626 set_config_int(section, "sample_buffers",
627 allegro_gl_get(AGL_SAMPLE_BUFFERS));
628 if (save & AGL_SAMPLES)
629 set_config_int(section, "samples",
630 allegro_gl_get(AGL_SAMPLES));
631 if (save & AGL_FLOAT_COLOR)
632 set_config_int(section, "float_color",
633 allegro_gl_get(AGL_FLOAT_COLOR));
634 if (save & AGL_FLOAT_Z)
635 set_config_int(section, "float_depth",
636 allegro_gl_get(AGL_FLOAT_Z));
637
638 if (save & AGL_REQUIRE)
639 build_settings(allegro_gl_get(AGL_REQUIRE), section, "require");
640 if (save & AGL_SUGGEST)
641 build_settings(allegro_gl_get(AGL_SUGGEST), section, "suggest");
642 }
643
644
645
646 /* Parses an input string to read settings */
647 static void agl_parse_section(int sec, char *section, char *name) {
648 const char *end;
649 char *buf;
650 char *ptr;
651 int strsize;
652 int opt = 0;
653
654 end = get_config_string(section, name, "");
655 strsize = ustrsizez(end);
656
657 buf = (char*)malloc(sizeof(char) * strsize);
658
659 if (!buf) {
660 TRACE(PREFIX_E "parse_section: Ran out of memory "
661 "while trying to allocate %i bytes!",
662 (int)sizeof(char) * strsize);
663 return;
664 }
665
666 memcpy(buf, end, strsize);
667 end = buf + strsize;
668 ptr = buf;
669
670 while (ptr < end) {
671 char *s = ustrtok_r(ptr, " ;|+", &ptr);
672
673 if (!ustrcmp(s, "allegro_format"))
674 opt |= AGL_ALLEGRO_FORMAT;
675 if (!ustrcmp(s, "red_depth"))
676 opt |= AGL_RED_DEPTH;
677 if (!ustrcmp(s, "green_depth"))
678 opt |= AGL_GREEN_DEPTH;
679 if (!ustrcmp(s, "blue_depth"))
680 opt |= AGL_BLUE_DEPTH;
681 if (!ustrcmp(s, "alpha_depth"))
682 opt |= AGL_ALPHA_DEPTH;
683 if (!ustrcmp(s, "color_depth"))
684 opt |= AGL_COLOR_DEPTH;
685 if (!ustrcmp(s, "accum_red_depth"))
686 opt |= AGL_ACC_RED_DEPTH;
687 if (!ustrcmp(s, "accum_green_depth"))
688 opt |= AGL_ACC_GREEN_DEPTH;
689 if (!ustrcmp(s, "accum_blue_depth"))
690 opt |= AGL_ACC_BLUE_DEPTH;
691 if (!ustrcmp(s, "accum_alpha_depth"))
692 opt |= AGL_ACC_ALPHA_DEPTH;
693 if (!ustrcmp(s, "double_buffer"))
694 opt |= AGL_DOUBLEBUFFER;
695 if (!ustrcmp(s, "stereo_display"))
696 opt |= AGL_STEREO;
697 if (!ustrcmp(s, "aux_buffers"))
698 opt |= AGL_AUX_BUFFERS;
699 if (!ustrcmp(s, "z_depth"))
700 opt |= AGL_Z_DEPTH;
701 if (!ustrcmp(s, "stencil_depth"))
702 opt |= AGL_STENCIL_DEPTH;
703 if (!ustrcmp(s, "window_x"))
704 opt |= AGL_WINDOW_X;
705 if (!ustrcmp(s, "window_y"))
706 opt |= AGL_WINDOW_Y;
707 if (!ustrcmp(s, "fullscreen"))
708 opt |= AGL_FULLSCREEN;
709 if (!ustrcmp(s, "windowed"))
710 opt |= AGL_WINDOWED;
711 if (!ustrcmp(s, "video_memory_policy"))
712 opt |= AGL_VIDEO_MEMORY_POLICY;
713 if (!ustrcmp(s, "sample_buffers"))
714 opt |= AGL_SAMPLE_BUFFERS;
715 if (!ustrcmp(s, "samples"))
716 opt |= AGL_SAMPLES;
717 if (!ustrcmp(s, "float_color"))
718 opt |= AGL_FLOAT_COLOR;
719 if (!ustrcmp(s, "float_depth"))
720 opt |= AGL_FLOAT_Z;
721 }
722
723 free(buf);
724
725 allegro_gl_set(sec, opt);
726 }
727
728
729
730 /* void allegro_gl_load_settings() */
741 void allegro_gl_load_settings() {
742
743 int set;
744 char *section = "OpenGL";
745
746 set = get_config_int(section, "allegro_format", -1);
747 if (set != -1)
748 allegro_gl_set(AGL_ALLEGRO_FORMAT, set);
749 set = get_config_int(section, "red_depth", -1);
750 if (set != -1)
751 allegro_gl_set(AGL_RED_DEPTH, set);
752 set = get_config_int(section, "green_depth", -1);
753 if (set != -1)
754 allegro_gl_set(AGL_GREEN_DEPTH, set);
755 set = get_config_int(section, "blue_depth", -1);
756 if (set != -1)
757 allegro_gl_set(AGL_BLUE_DEPTH, set);
758 set = get_config_int(section, "alpha_depth", -1);
759 if (set != -1)
760 allegro_gl_set(AGL_ALPHA_DEPTH, set);
761 set = get_config_int(section, "color_depth", -1);
762 if (set != -1)
763 allegro_gl_set(AGL_COLOR_DEPTH, set);
764 set = get_config_int(section, "accum_red_depth", -1);
765 if (set != -1)
766 allegro_gl_set(AGL_ACC_RED_DEPTH, set);
767 set = get_config_int(section, "accum_green_depth", -1);
768 if (set != -1)
769 allegro_gl_set(AGL_ACC_GREEN_DEPTH, set);
770 set = get_config_int(section, "accum_blue_depth", -1);
771 if (set != -1)
772 allegro_gl_set(AGL_ACC_BLUE_DEPTH, set);
773 set = get_config_int(section, "accum_alpha_depth", -1);
774 if (set != -1)
775 allegro_gl_set(AGL_ACC_ALPHA_DEPTH, set);
776 set = get_config_int(section, "double_buffer", -1);
777 if (set != -1)
778 allegro_gl_set(AGL_DOUBLEBUFFER, set);
779 set = get_config_int(section, "stereo_display", -1);
780 if (set != -1)
781 allegro_gl_set(AGL_STEREO, set);
782 set = get_config_int(section, "aux_buffers", -1);
783 if (set != -1)
784 allegro_gl_set(AGL_AUX_BUFFERS, set);
785 set = get_config_int(section, "z_depth", -1);
786 if (set != -1)
787 allegro_gl_set(AGL_Z_DEPTH, set);
788 set = get_config_int(section, "stencil_depth", -1);
789 if (set != -1)
790 allegro_gl_set(AGL_STENCIL_DEPTH, set);
791 set = get_config_int(section, "window_x", -1);
792 if (set != -1)
793 allegro_gl_set(AGL_WINDOW_X, set);
794 set = get_config_int(section, "window_y", -1);
795 if (set != -1)
796 allegro_gl_set(AGL_WINDOW_Y, set);
797 set = get_config_int(section, "fullscreen", -1);
798 if (set != -1)
799 allegro_gl_set(AGL_FULLSCREEN, set);
800 set = get_config_int(section, "windowed", -1);
801 if (set != -1)
802 allegro_gl_set(AGL_WINDOWED, set);
803 set = get_config_int(section, "video_memory_policy", -1);
804 if (set != -1)
805 allegro_gl_set(AGL_VIDEO_MEMORY_POLICY, set);
806 set = get_config_int(section, "sample_buffers", -1);
807 if (set != -1)
808 allegro_gl_set(AGL_SAMPLE_BUFFERS, set);
809 set = get_config_int(section, "samples", -1);
810 if (set != -1)
811 allegro_gl_set(AGL_SAMPLES, set);
812 set = get_config_int(section, "float_color", -1);
813 if (set != -1)
814 allegro_gl_set(AGL_FLOAT_COLOR, set);
815 set = get_config_int(section, "float_depth", -1);
816 if (set != -1)
817 allegro_gl_set(AGL_FLOAT_Z, set);
818
819 agl_parse_section(AGL_REQUIRE, section, "require");
820 agl_parse_section(AGL_SUGGEST, section, "suggest");
821 }
822
823
824
825 /* int install_allegro_gl(void) */
836 int install_allegro_gl(void)
837 {
838 if (!system_driver)
839 return -1;
840
841 if (atexit(remove_allegro_gl))
842 return -1;
843
844 if (system_driver->gfx_drivers)
845 saved_gfx_drivers = system_driver->gfx_drivers;
846 else
847 saved_gfx_drivers = list_saved_gfx_drivers;
848
849 system_driver->gfx_drivers = our_gfx_drivers;
850
851 allegro_gl_clear_settings();
852
853 /* Save and replace old blit_between_formats methods */
854 #ifdef ALLEGRO_COLOR8
855 __blit_between_formats8 = __linear_vtable8.blit_between_formats;
856 __linear_vtable8.blit_between_formats =
857 allegro_gl_memory_blit_between_formats;
858 #endif
859 #ifdef ALLEGRO_COLOR16
860 __blit_between_formats15 = __linear_vtable15.blit_between_formats;
861 __linear_vtable15.blit_between_formats =
862 allegro_gl_memory_blit_between_formats;
863 __blit_between_formats16 = __linear_vtable16.blit_between_formats;
864 __linear_vtable16.blit_between_formats
865 = allegro_gl_memory_blit_between_formats;
866 #endif
867 #ifdef ALLEGRO_COLOR24
868 __blit_between_formats24 = __linear_vtable24.blit_between_formats;
869 __linear_vtable24.blit_between_formats
870 = allegro_gl_memory_blit_between_formats;
871 #endif
872 #ifdef ALLEGRO_COLOR32
873 __blit_between_formats32 = __linear_vtable32.blit_between_formats;
874 __linear_vtable32.blit_between_formats
875 = allegro_gl_memory_blit_between_formats;
876 #endif
877
878 usetc(allegro_gl_error, 0);
879
880 return 0;
881 }
882
883
884
885 /* void remove_allegro_gl(void) */
894 void remove_allegro_gl(void)
895 {
896 if ((!system_driver) || (!saved_gfx_drivers))
897 return;
898
899 if (saved_gfx_drivers == &list_saved_gfx_drivers)
900 system_driver->gfx_drivers = NULL;
901 else
902 system_driver->gfx_drivers = saved_gfx_drivers;
903
904 /* This function may be called twice (once by a user explicit call
905 * and once again at exit since the function is registered with at_exit)
906 * In order to prevent crashes, 'saved_gfx_drivers' is set to NULL
907 */
908 saved_gfx_drivers = NULL;
909
910 /* Restore the blit_between_formats methods */
911 #ifdef ALLEGRO_COLOR8
912 __linear_vtable8.blit_between_formats = __blit_between_formats8;
913 #endif
914 #ifdef ALLEGRO_COLOR16
915 __linear_vtable15.blit_between_formats = __blit_between_formats15;
916 __linear_vtable16.blit_between_formats = __blit_between_formats16;
917 #endif
918 #ifdef ALLEGRO_COLOR24
919 __linear_vtable24.blit_between_formats = __blit_between_formats24;
920 #endif
921 #ifdef ALLEGRO_COLOR32
922 __linear_vtable32.blit_between_formats = __blit_between_formats32;
923 #endif
924 }
925
926
927
928 /* void allegro_gl_flip(void) */
951 void allegro_gl_flip(void)
952 {
953 __allegro_gl_driver->flip();
954 }
955
956
957
958 /* float allegro_gl_opengl_version() */
971 float allegro_gl_opengl_version() {
972
973 const char *str;
974
975 if (!__allegro_gl_valid_context)
976 return 0.0f;
977
978 str = (const char*)glGetString(GL_VERSION);
979
980 if ((strncmp(str, "1.0 ", 4) == 0) || (strncmp(str, "1.0.0 ", 6) == 0))
981 return 1.0;
982 if ((strncmp(str, "1.1 ", 4) == 0) || (strncmp(str, "1.1.0 ", 6) == 0))
983 return 1.1;
984 if ((strncmp(str, "1.2 ", 4) == 0) || (strncmp(str, "1.2.0 ", 6) == 0))
985 return 1.2;
986 if ((strncmp(str, "1.2.1 ", 6) == 0))
987 return 1.21;
988 if ((strncmp(str, "1.2.2 ", 6) == 0))
989 return 1.22;
990 if ((strncmp(str, "1.3 ", 4) == 0) || (strncmp(str, "1.3.0 ", 6) == 0))
991 return 1.3;
992 if ((strncmp(str, "1.4 ", 4) == 0) || (strncmp(str, "1.4.0 ", 6) == 0))
993 return 1.4;
994 if ((strncmp(str, "1.5 ", 4) == 0) || (strncmp(str, "1.5.0 ", 6) == 0))
995 return 1.5;
996 if ((strncmp(str, "2.0 ", 4) == 0) || (strncmp(str, "2.0.0 ", 6) == 0))
997 return 2.0;
998 if ((strncmp(str, "2.1 ", 4) == 0) || (strncmp(str, "2.1.0 ", 6) == 0))
999 return 2.1;
1000 if ((strncmp(str, "3.0 ", 4) == 0) || (strncmp(str, "3.0.0 ", 6) == 0))
1001 return 3.0;
1002
1003 /* The OpenGL driver does not return a version
1004 * number. However it probably supports at least OpenGL 1.0
1005 */
1006 if (!str) {
1007 return 1.0;
1008 }
1009
1010 return atof(str);
1011 }
1012
1013
1014
1015 void __allegro_gl_set_allegro_image_format(int big_endian)
1016 {
1017 /* Sets up Allegro to use OpenGL formats */
1018 _rgb_r_shift_15 = 11;
1019 _rgb_g_shift_15 = 6;
1020 _rgb_b_shift_15 = 1;
1021
1022 _rgb_r_shift_16 = 11;
1023 _rgb_g_shift_16 = 5;
1024 _rgb_b_shift_16 = 0;
1025
1026 if (big_endian) {
1027 _rgb_r_shift_24 = 16;
1028 _rgb_g_shift_24 = 8;
1029 _rgb_b_shift_24 = 0;
1030
1031 _rgb_a_shift_32 = 0;
1032 _rgb_r_shift_32 = 24;
1033 _rgb_g_shift_32 = 16;
1034 _rgb_b_shift_32 = 8;
1035 }
1036 else {
1037 _rgb_r_shift_24 = 0;
1038 _rgb_g_shift_24 = 8;
1039 _rgb_b_shift_24 = 16;
1040
1041 _rgb_r_shift_32 = 0;
1042 _rgb_g_shift_32 = 8;
1043 _rgb_b_shift_32 = 16;
1044 _rgb_a_shift_32 = 24;
1045 }
1046
1047 return;
1048 }
1049
1050
1051
1052 /* allegro_gl_default_init:
1053 * Sets a graphics mode according to the mode (fullscreen or windowed)
1054 * requested by the user. If it fails to set up the mode then it tries
1055 * (if available) the other one unless the user has "AGL_REQUIRED" the mode.
1056 */
1057 static BITMAP *allegro_gl_default_gfx_init(int w, int h, int vw, int vh,
1058 int depth)
1059 {
1060 BITMAP* bmp = NULL;
1061
1062 if (allegro_gl_display_info.fullscreen) {
1063 TRACE(PREFIX_I "default_gfx_init: Trying to set up fullscreen mode.\n");
1064
1065 #ifdef GFX_OPENGL_FULLSCREEN
1066 /* Looks for fullscreen mode in our_driver_list */
1067 gfx_driver = &gfx_allegro_gl_fullscreen;
1068
1069 if (__allegro_gl_required_settings & AGL_FULLSCREEN)
1070 /* Fullscreen mode required and found */
1071 return gfx_allegro_gl_fullscreen.init(w, h, vw, vh, depth);
1072 else
1073 bmp = gfx_allegro_gl_fullscreen.init(w, h, vw, vh, depth);
1074
1075 if (bmp)
1076 /* Fullscreen mode found but not required (probably suggested) */
1077 return bmp;
1078
1079 #endif /*GFX_OPENGL_FULLSCREEN*/
1080
1081 /* Fullscreen mode not available but not required :
1082 * let's try windowed mode :
1083 */
1084 TRACE(PREFIX_I "default_gfx_init: Failed to set up fullscreen mode!\n");
1085 #ifdef GFX_OPENGL_WINDOWED
1086 TRACE(PREFIX_I "default_gfx_init: Trying windowed mode...\n");
1087 allegro_gl_display_info.fullscreen = FALSE;
1088 gfx_driver = &gfx_allegro_gl_windowed;
1089 return gfx_allegro_gl_windowed.init(w, h, vw, vh, depth);
1090 #else
1091 return NULL;
1092 #endif /* GFX_OPENGL_WINDOWED */
1093 }
1094 else {
1095 TRACE(PREFIX_I "default_gfx_init: Trying to set up windowed mode...\n");
1096
1097 #ifdef GFX_OPENGL_WINDOWED
1098 /* Looks for windowed mode in our_driver_list */
1099 gfx_driver = &gfx_allegro_gl_windowed;
1100
1101 if (__allegro_gl_required_settings & AGL_WINDOWED)
1102 /* Windowed mode required and found */
1103 return gfx_allegro_gl_windowed.init(w, h, vw, vh, depth);
1104 else
1105 bmp = gfx_allegro_gl_windowed.init(w, h, vw, vh, depth);
1106
1107 if (bmp)
1108 /* Windowed mode found but not required (probably suggested) */
1109 return bmp;
1110
1111 #endif /* GFX_OPENGL_WINDOWED */
1112
1113 /* Windowed mode not available but not required :
1114 * let's try fullscreen mode :
1115 */
1116 TRACE(PREFIX_I "default_gfx_init: Failed to set up windowed mode...\n");
1117 #ifdef GFX_OPENGL_FULLSCREEN
1118 TRACE(PREFIX_I "default_gfx_init: Trying fullscreen mode...\n");
1119 allegro_gl_display_info.fullscreen = TRUE;
1120 gfx_driver = &gfx_allegro_gl_fullscreen;
1121 return gfx_allegro_gl_fullscreen.init(w, h, vw, vh, depth);
1122 #else
1123 return NULL;
1124 #endif /*GFX_OPENGL_FULLSCREEN*/
1125 }
1126 }
1127
1128
1129
1130 /* allegro_gl_set_blender_mode (GFX_DRIVER vtable entry):
1131 * Sets the blending mode. Same implementation to all GFX vtables.
1132 */
1133 void allegro_gl_set_blender_mode(int mode, int r, int g, int b, int a) {
1134 __allegro_gl_blit_operation = AGL_OP_BLEND;
1135 /* These blenders do not need any special extensions.
1136 * We specify only pixel arithmetic here. Blend equation and blend
1137 * color (if available) are reset to defualt later.*/
1138 switch (mode) {
1139 case blender_mode_none:
1140 glBlendFunc(GL_ONE, GL_ZERO);
1141 break;
1142 case blender_mode_alpha:
1143 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1144 break;
1145 case blender_mode_invert:
1146 glLogicOp(GL_COPY_INVERTED);
1147 __allegro_gl_blit_operation = AGL_OP_LOGIC_OP;
1148 break;
1149 case blender_mode_multiply:
1150 glBlendFunc(GL_DST_COLOR, GL_ZERO);
1151 break;
1152 }
1153
1154 if (allegro_gl_opengl_version() >= 1.4 ||
1155 (allegro_gl_opengl_version() >= 1.2 &&
1156 allegro_gl_is_extension_supported("GL_ARB_imaging"))) {
1157 /* We're running a recent version of OpenGL and everything needed is here. */
1158
1159 glBlendColor(r / 255.f, g / 255.f, b / 255.f, a / 255.f);
1160
1161 switch (mode) {
1162 case blender_mode_none:
1163 glBlendEquation(GL_FUNC_ADD);
1164 break;
1165 case blender_mode_alpha:
1166 glBlendEquation(GL_FUNC_ADD);
1167 break;
1168 case blender_mode_trans:
1169 glBlendEquation(GL_FUNC_ADD);
1170 glBlendFunc(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA);
1171 break;
1172 case blender_mode_add:
1173 glBlendEquation(GL_FUNC_ADD);
1174 glBlendFunc(GL_CONSTANT_ALPHA, GL_ONE);
1175 break;
1176 case blender_mode_burn:
1177 glBlendEquation(GL_FUNC_SUBTRACT);
1178 glBlendFunc(GL_ONE, GL_CONSTANT_ALPHA);
1179 break;
1180 case blender_mode_dodge:
1181 glBlendEquation(GL_FUNC_ADD);
1182 glBlendFunc(GL_ONE, GL_CONSTANT_ALPHA);
1183 break;
1184 case blender_mode_multiply:
1185 glBlendEquation(GL_FUNC_ADD);
1186 break;
1187 }
1188
1189 return;
1190 }
1191
1192 /* Check for presence of glBlendColor() and special parameters to
1193 * glBlendFunc(). */
1194 if (allegro_gl_is_extension_supported("GL_EXT_blend_color")) {
1195 glBlendColorEXT(r / 255.f, g / 255.f, b / 255.f, a / 255.f);
1196
1197 switch (mode) {
1198 case blender_mode_trans:
1199 glBlendFunc(GL_CONSTANT_ALPHA_EXT, GL_ONE_MINUS_CONSTANT_ALPHA_EXT);
1200 break;
1201 case blender_mode_add:
1202 glBlendFunc(GL_CONSTANT_ALPHA_EXT, GL_ONE);
1203 break;
1204 case blender_mode_burn:
1205 glBlendFunc(GL_ONE, GL_CONSTANT_ALPHA_EXT);
1206 break;
1207 case blender_mode_dodge:
1208 glBlendFunc(GL_ONE, GL_CONSTANT_ALPHA_EXT);
1209 break;
1210 }
1211 }
1212 else if (mode == blender_mode_trans ||
1213 mode == blender_mode_add ||
1214 mode == blender_mode_burn ||
1215 mode == blender_mode_dodge) {
1216 /* glBlendColor() is not available and it is needed by the selected
1217 * bledner. Bail out.*/
1218 return;
1219 }
1220
1221 /* Check for presence of glBlendEquation(). */
1222 if (allegro_gl_is_extension_supported("GL_EXT_blend_minmax")) {
1223 switch (mode) {
1224 case blender_mode_none:
1225 glBlendEquationEXT(GL_FUNC_ADD_EXT);
1226 break;
1227 case blender_mode_alpha:
1228 glBlendEquationEXT(GL_FUNC_ADD_EXT);
1229 break;
1230 case blender_mode_trans:
1231 glBlendEquationEXT(GL_FUNC_ADD_EXT);
1232 break;
1233 case blender_mode_add:
1234 glBlendEquationEXT(GL_FUNC_ADD_EXT);
1235 break;
1236 case blender_mode_dodge:
1237 glBlendEquationEXT(GL_FUNC_ADD_EXT);
1238 break;
1239 case blender_mode_multiply:
1240 glBlendEquationEXT(GL_FUNC_ADD_EXT);
1241 break;
1242 case blender_mode_burn:
1243 if (allegro_gl_is_extension_supported("GL_EXT_blend_subtract")) {
1244 glBlendEquationEXT(GL_FUNC_SUBTRACT_EXT);
1245 }
1246 else {
1247 /* GL_FUNC_SUBTRACT is not supported and it is needed by the
1248 * selected blender. Bail out. */
1249 return;
1250 }
1251 break;
1252 }
1253 }
1254 }
1255
1256
1257 #ifdef DEBUGMODE
1258 #ifdef LOGLEVEL
1259
1260 void __allegro_gl_log(int level, const char *str)
1261 {
1262 if (level <= LOGLEVEL)
1263 TRACE(PREFIX_L "[%d] %s", level, str);
1264 }
1265
1266 #endif
1267 #endif
1268
AGL_KEEP
#define AGL_KEEP
Keep internal texture in video memory.
Definition: alleggl.h:399
AGL_SAMPLE_BUFFERS
#define AGL_SAMPLE_BUFFERS
Define multisample parameters Some OpenGL ICDs expose an extension called GL_ARB_multisample which pr...
Definition: alleggl.h:361
GFX_OPENGL_FULLSCREEN
#define GFX_OPENGL_FULLSCREEN
Fullscreen OpenGL graphics driver for Allegro.
Definition: alleggl.h:435
AGL_GREEN_DEPTH
#define AGL_GREEN_DEPTH
Select the green depth of the frame buffer.
Definition: alleggl.h:205
allegro_gl_opengl_version
float allegro_gl_opengl_version()
Returns the OpenGL version number of the client (the computer the program is running on)...
Definition: alleggl.c:971
AGL_STEREO
#define AGL_STEREO
Creates seperate left/right buffers for stereo display.
Definition: alleggl.h:269
AGL_REQUIRE
#define AGL_REQUIRE
Reject other values for these settings.
Definition: alleggl.h:393
AGL_DOUBLEBUFFER
#define AGL_DOUBLEBUFFER
Creates a backbuffer if set.
Definition: alleggl.h:260
install_allegro_gl
int install_allegro_gl(void)
Installs the AllegroGL addon to Allegro.
Definition: alleggl.c:836
allegro_gl_get
int allegro_gl_get(int option)
Reads the setting of a configuration option.
Definition: alleggl.c:421
AGL_ALPHA_DEPTH
#define AGL_ALPHA_DEPTH
Select the alpha depth of the frame buffer.
Definition: alleggl.h:218
AGL_SUGGEST
#define AGL_SUGGEST
Prefer the assigned values for these settings.
Definition: alleggl.h:392
AGL_SAMPLES
#define AGL_SAMPLES
Define multisample samples Set this value to the number of samples that can be accepted in the multis...
Definition: alleggl.h:369
AGL_VIDEO_MEMORY_POLICY
#define AGL_VIDEO_MEMORY_POLICY
Define AllegroGL&#39;s policy relative to video memory usage.
Definition: alleggl.h:337
allegro_gl_clear_settings
void allegro_gl_clear_settings(void)
Clear the option settings All settings are set to their default values, and marked as neither suggest...
Definition: alleggl.c:193
AGL_FULLSCREEN
#define AGL_FULLSCREEN
Set if you&#39;d like a full screen mode.
Definition: alleggl.h:315
remove_allegro_gl
void remove_allegro_gl(void)
Removes the AllegroGL addon.
Definition: alleggl.c:894
AGL_ACC_BLUE_DEPTH
#define AGL_ACC_BLUE_DEPTH
Select the blue depth of the accumulator buffer.
Definition: alleggl.h:246
allegro_gl_flip
void allegro_gl_flip(void)
Flips the front and back framebuffers.
Definition: alleggl.c:951
AGL_ACC_ALPHA_DEPTH
#define AGL_ACC_ALPHA_DEPTH
Select the alpha depth of the accumulator buffer.
Definition: alleggl.h:254
allegro_gl_save_settings
void allegro_gl_save_settings(void)
Saves the current settings (as specified by allegro_gl_set()) to the current config file...
Definition: alleggl.c:560
AGL_ACC_GREEN_DEPTH
#define AGL_ACC_GREEN_DEPTH
Select the green depth of the accumulator buffer.
Definition: alleggl.h:238
AGL_ALLEGRO_FORMAT
#define AGL_ALLEGRO_FORMAT
Use Allegro-compatible framebuffer.
Definition: alleggl.h:193
allegro_gl_set
void allegro_gl_set(int option, int value)
Sets a configuration option.
Definition: alleggl.c:274
AGL_Z_DEPTH
#define AGL_Z_DEPTH
Select the depth of the z-buffer.
Definition: alleggl.h:282
AGL_STENCIL_DEPTH
#define AGL_STENCIL_DEPTH
Select the depth of the stencil buffer.
Definition: alleggl.h:291
AGL_FLOAT_COLOR
#define AGL_FLOAT_COLOR
Floating-point Color buffer.
Definition: alleggl.h:375
AGL_WINDOW_X
#define AGL_WINDOW_X
Requests a placement of the window to a specified pixel location.
Definition: alleggl.h:296
GFX_OPENGL
#define GFX_OPENGL
Non-specific OpenGL graphics driver for Allegro.
Definition: alleggl.h:437
AGL_DONTCARE
#define AGL_DONTCARE
Ignore these settings.
Definition: alleggl.h:391
AGL_WINDOW_Y
#define AGL_WINDOW_Y
Same as AGL_WINDOW_X, but for the y-axis.
Definition: alleggl.h:300
AGL_COLOR_DEPTH
#define AGL_COLOR_DEPTH
Specify the total color depth of the frame buffer.
Definition: alleggl.h:223
AGL_FLOAT_Z
#define AGL_FLOAT_Z
Floating-point Depth buffer.
Definition: alleggl.h:379
AGL_AUX_BUFFERS
#define AGL_AUX_BUFFERS
Creates additional auxiliary buffers.
Definition: alleggl.h:275
GFX_OPENGL_WINDOWED
#define GFX_OPENGL_WINDOWED
Windowed OpenGL graphics driver for Allegro.
Definition: alleggl.h:433
allegro_gl_is_extension_supported
int allegro_gl_is_extension_supported(AL_CONST char *extension)
This function is an helper to determine whether an OpenGL extension is available or not...
Definition: glext.c:306
AGL_ACC_RED_DEPTH
#define AGL_ACC_RED_DEPTH
Select the red depth of the accumulator buffer.
Definition: alleggl.h:231
alleggl.h
Main header file for AllegroGL.
AGL_BLUE_DEPTH
#define AGL_BLUE_DEPTH
Select the blue depth of the frame buffer.
Definition: alleggl.h:211
allegro_gl_screen
BITMAP * allegro_gl_screen
Direct-mode GL `screen&#39; bitmap.
Definition: alleggl.c:62
AGL_WINDOWED
#define AGL_WINDOWED
Set if you&#39;d like a windowed mode.
Definition: alleggl.h:320
AGL_RED_DEPTH
#define AGL_RED_DEPTH
Select the red depth of the frame buffer.
Definition: alleggl.h:199
AGL_RELEASE
#define AGL_RELEASE
Release video memory occupied by internal texture.
Definition: alleggl.h:400
AGL_RENDERMETHOD
#define AGL_RENDERMETHOD
Set it if you&#39;d like AllegroGL to pay special attention on whether hardware acceleration is present o...
Definition: alleggl.h:310
allegro_gl_load_settings
void allegro_gl_load_settings(void)
Loads the settings from the current config file, in the section [OpenGL].
Definition: alleggl.c:741