alleggl.c

Go to the documentation of this file.

/* This code is (C) AllegroGL contributors, and double licensed under
 * the GPL and zlib licenses. See gpl.txt or zlib.txt for details.
 */
#include <string.h>
#include <stdlib.h>

#include "alleggl.h"
#include "allglint.h"

#include <allegro/internal/aintern.h>
#ifdef ALLEGRO_MACOSX
#include <OpenGL/glu.h>
#else
#include <GL/glu.h>
#endif

#define PREFIX_I                "agl INFO: "
#define PREFIX_E                "agl ERROR: "
#define PREFIX_L                "agl LOG: "


/* Structs containing the current driver state */
struct allegro_gl_driver *__allegro_gl_driver = NULL;
struct allegro_gl_display_info allegro_gl_display_info;

/* Settings required/suggested */
int __allegro_gl_required_settings, __allegro_gl_suggested_settings;

/* Valid context state */
int __allegro_gl_valid_context = 0;


/* Operation to enable while blitting. */
int __allegro_gl_blit_operation;


char allegro_gl_error[AGL_ERROR_SIZE] = EMPTY_STRING;

BLIT_BETWEEN_FORMATS_FUNC __blit_between_formats8;
BLIT_BETWEEN_FORMATS_FUNC __blit_between_formats15;
BLIT_BETWEEN_FORMATS_FUNC __blit_between_formats16;
BLIT_BETWEEN_FORMATS_FUNC __blit_between_formats24;
BLIT_BETWEEN_FORMATS_FUNC __blit_between_formats32;



BITMAP *allegro_gl_screen;



/* Allegro GFX_DRIVER list handling */
static _DRIVER_INFO our_driver_list[] = {
#ifdef GFX_OPENGL_WINDOWED
    {GFX_OPENGL_WINDOWED, &gfx_allegro_gl_windowed, FALSE},
#endif
#ifdef GFX_OPENGL_FULLSCREEN
    {GFX_OPENGL_FULLSCREEN, &gfx_allegro_gl_fullscreen, FALSE},
#endif
    {GFX_OPENGL, &gfx_allegro_gl_default, FALSE},
    {0, NULL, FALSE}
};



static _DRIVER_INFO *our_gfx_drivers(void)
{
    return our_driver_list;
}



_DRIVER_INFO *(*saved_gfx_drivers) (void) = NULL;



static _DRIVER_INFO *list_saved_gfx_drivers(void)
{
    return _gfx_driver_list;
}



static BITMAP *allegro_gl_default_gfx_init(int w, int h, int vw, int vh, int depth);



GFX_DRIVER gfx_allegro_gl_default =
{
   GFX_OPENGL,
   EMPTY_STRING,
   EMPTY_STRING,
   "AllegroGL Default Driver",
   allegro_gl_default_gfx_init,
   NULL,
   NULL,
   NULL,               //_xwin_vsync,
   NULL,
   NULL, NULL, NULL,
   NULL,        /* create_video_bitmap */
   NULL,
   NULL, NULL,  /* No show/request video bitmaps */
   NULL, NULL,
   NULL, NULL, NULL, NULL,
   NULL,
   NULL, NULL,
   NULL,        /* set_blender_mode */
   NULL,        /* No fetch_mode_list */
   0, 0,
   0,
   0, 0,
   0,
   0,
   FALSE        /* Windowed mode */
};



/* void allegro_gl_clear_settings(void) */
void allegro_gl_clear_settings(void)
{
    memset(&allegro_gl_display_info, 0, sizeof allegro_gl_display_info);

    __allegro_gl_required_settings = __allegro_gl_suggested_settings = 0;
    
    /* Pick sensible defaults */
    allegro_gl_display_info.fullscreen = 1;
    allegro_gl_display_info.rmethod = 1;
    allegro_gl_display_info.doublebuffered = 1;
    allegro_gl_display_info.vidmem_policy = AGL_KEEP;
    __allegro_gl_suggested_settings =
                           AGL_FULLSCREEN | AGL_RENDERMETHOD | AGL_DOUBLEBUFFER;
}



/* void allegro_gl_set(int option, int value) */
void allegro_gl_set(int option, int value)
{
    switch (option) {
            /* Options stating importance of other options */
        case AGL_REQUIRE:
            __allegro_gl_required_settings |= value;
            __allegro_gl_suggested_settings &= ~value;
            break;
        case AGL_SUGGEST:
            __allegro_gl_suggested_settings |= value;
            __allegro_gl_required_settings &= ~value;
            break;
        case AGL_DONTCARE:
            __allegro_gl_required_settings &= ~value;
            __allegro_gl_suggested_settings &= ~value;
            break;

            /* Options configuring the mode set */
        case AGL_ALLEGRO_FORMAT:
            allegro_gl_display_info.allegro_format = value;
            break;
        case AGL_RED_DEPTH:
            allegro_gl_display_info.pixel_size.rgba.r = value;
            break;
        case AGL_GREEN_DEPTH:
            allegro_gl_display_info.pixel_size.rgba.g = value;
            break;
        case AGL_BLUE_DEPTH:
            allegro_gl_display_info.pixel_size.rgba.b = value;
            break;
        case AGL_ALPHA_DEPTH:
            allegro_gl_display_info.pixel_size.rgba.a = value;
            break;
        case AGL_COLOR_DEPTH:
            switch (value) {
                case 8:
                    allegro_gl_set(AGL_RED_DEPTH, 3);
                    allegro_gl_set(AGL_GREEN_DEPTH, 3);
                    allegro_gl_set(AGL_BLUE_DEPTH, 2);
                    allegro_gl_set(AGL_ALPHA_DEPTH, 0);
                    break;
                case 15:
                    allegro_gl_set(AGL_RED_DEPTH, 5);
                    allegro_gl_set(AGL_GREEN_DEPTH, 5);
                    allegro_gl_set(AGL_BLUE_DEPTH, 5);
                    allegro_gl_set(AGL_ALPHA_DEPTH, 1);
                    break;
                case 16:
                    allegro_gl_set(AGL_RED_DEPTH, 5);
                    allegro_gl_set(AGL_GREEN_DEPTH, 6);
                    allegro_gl_set(AGL_BLUE_DEPTH, 5);
                    allegro_gl_set(AGL_ALPHA_DEPTH, 0);
                    break;
                case 24:
                case 32:
                    allegro_gl_set(AGL_RED_DEPTH, 8);
                    allegro_gl_set(AGL_GREEN_DEPTH, 8);
                    allegro_gl_set(AGL_BLUE_DEPTH, 8);
                    allegro_gl_set(AGL_ALPHA_DEPTH, value-24);
                    break;
            }
            allegro_gl_display_info.colour_depth = value;
            break;
        case AGL_ACC_RED_DEPTH:
            allegro_gl_display_info.accum_size.rgba.r = value;
            break;
        case AGL_ACC_GREEN_DEPTH:
            allegro_gl_display_info.accum_size.rgba.g = value;
            break;
        case AGL_ACC_BLUE_DEPTH:
            allegro_gl_display_info.accum_size.rgba.b = value;
            break;
        case AGL_ACC_ALPHA_DEPTH:
            allegro_gl_display_info.accum_size.rgba.a = value;
            break;

        case AGL_DOUBLEBUFFER:
            allegro_gl_display_info.doublebuffered = value;
            break;
        case AGL_STEREO:
            allegro_gl_display_info.stereo = value;
            break;
        case AGL_AUX_BUFFERS:
            allegro_gl_display_info.aux_buffers = value;
            break;
        case AGL_Z_DEPTH:
            allegro_gl_display_info.depth_size = value;
            break;
        case AGL_STENCIL_DEPTH:
            allegro_gl_display_info.stencil_size = value;
            break;

        case AGL_WINDOW_X:
            allegro_gl_display_info.x = value;
            break;
        case AGL_WINDOW_Y:
            allegro_gl_display_info.y = value;
            break;

        case AGL_RENDERMETHOD:
            allegro_gl_display_info.rmethod = value;
            break;

        case AGL_FULLSCREEN:
            allegro_gl_display_info.fullscreen = value;
            break;

        case AGL_WINDOWED:
            allegro_gl_display_info.fullscreen = !value;
            break;
        case AGL_VIDEO_MEMORY_POLICY:
            if ((value == AGL_KEEP) || (value == AGL_RELEASE))
                allegro_gl_display_info.vidmem_policy = value;
            break;
        case AGL_SAMPLE_BUFFERS:
            allegro_gl_display_info.sample_buffers = value;
            break;
        case AGL_SAMPLES:
            allegro_gl_display_info.samples = value;
            break;
        case AGL_FLOAT_COLOR:
            allegro_gl_display_info.float_color = value;
            break;
        case AGL_FLOAT_Z:
            allegro_gl_display_info.float_depth = value;
            break;
    }
}



int allegro_gl_get(int option)
{
    switch (option) {
            /* Options stating importance of other options */
        case AGL_REQUIRE:
            return __allegro_gl_required_settings;
        case AGL_SUGGEST:
            return __allegro_gl_suggested_settings;
        case AGL_DONTCARE:
            return ~0 & ~(__allegro_gl_required_settings |
                          __allegro_gl_suggested_settings);

            /* Options configuring the mode set */
        case AGL_ALLEGRO_FORMAT:
            return allegro_gl_display_info.allegro_format;
        case AGL_RED_DEPTH:
            return allegro_gl_display_info.pixel_size.rgba.r;
        case AGL_GREEN_DEPTH:
            return allegro_gl_display_info.pixel_size.rgba.g;
        case AGL_BLUE_DEPTH:
            return allegro_gl_display_info.pixel_size.rgba.b;
        case AGL_ALPHA_DEPTH:
            return allegro_gl_display_info.pixel_size.rgba.a;
        case AGL_COLOR_DEPTH:
            return allegro_gl_display_info.pixel_size.rgba.r
                + allegro_gl_display_info.pixel_size.rgba.g
                + allegro_gl_display_info.pixel_size.rgba.b
                + allegro_gl_display_info.pixel_size.rgba.a;
        case AGL_ACC_RED_DEPTH:
            return allegro_gl_display_info.accum_size.rgba.r;
        case AGL_ACC_GREEN_DEPTH:
            return allegro_gl_display_info.accum_size.rgba.g;
        case AGL_ACC_BLUE_DEPTH:
            return allegro_gl_display_info.accum_size.rgba.b;
        case AGL_ACC_ALPHA_DEPTH:
            return allegro_gl_display_info.accum_size.rgba.a;
        case AGL_DOUBLEBUFFER:
            return allegro_gl_display_info.doublebuffered;
        case AGL_STEREO:
            return allegro_gl_display_info.stereo;
        case AGL_AUX_BUFFERS:
            return allegro_gl_display_info.aux_buffers;
        case AGL_Z_DEPTH:
            return allegro_gl_display_info.depth_size;
        case AGL_STENCIL_DEPTH:
            return allegro_gl_display_info.stencil_size;
        case AGL_WINDOW_X:
            return allegro_gl_display_info.x;
        case AGL_WINDOW_Y:
            return allegro_gl_display_info.y;
        case AGL_FULLSCREEN:
            return allegro_gl_display_info.fullscreen;
        case AGL_WINDOWED:
            return !allegro_gl_display_info.fullscreen;
        case AGL_VIDEO_MEMORY_POLICY:
            return allegro_gl_display_info.vidmem_policy;
        case AGL_SAMPLE_BUFFERS:
            return allegro_gl_display_info.sample_buffers;
        case AGL_SAMPLES:
            return allegro_gl_display_info.samples;
        case AGL_FLOAT_COLOR:
            return allegro_gl_display_info.float_color;
        case AGL_FLOAT_Z:
            return allegro_gl_display_info.float_depth;
    }
    return -1;
}



/* Builds a string corresponding to the options set in 'opt'
 * and writes in the config file
 */
static void build_settings(int opt, char *section, char *name) {
    char buf[2048];

    usetc(buf, 0);

    if (opt & AGL_ALLEGRO_FORMAT)
        ustrcat(buf, "allegro_format ");
    if (opt & AGL_RED_DEPTH)
        ustrcat(buf, "red_depth ");
    if (opt & AGL_GREEN_DEPTH)
        ustrcat(buf, "green_depth ");
    if (opt & AGL_BLUE_DEPTH)
        ustrcat(buf, "blue_depth ");
    if (opt & AGL_ALPHA_DEPTH)
        ustrcat(buf, "alpha_depth ");
    if (opt & AGL_COLOR_DEPTH)
        ustrcat(buf, "color_depth ");
    if (opt & AGL_ACC_RED_DEPTH)
        ustrcat(buf, "accum_red_depth ");
    if (opt & AGL_ACC_GREEN_DEPTH)
        ustrcat(buf, "accum_green_depth ");
    if (opt & AGL_ACC_BLUE_DEPTH)
        ustrcat(buf, "accum_blue_depth ");
    if (opt & AGL_ACC_ALPHA_DEPTH)
        ustrcat(buf, "accum_alpha_depth ");
    if (opt & AGL_DOUBLEBUFFER)
        ustrcat(buf, "double_buffer ");
    if (opt & AGL_STEREO)
        ustrcat(buf, "stereo_display ");
    if (opt & AGL_AUX_BUFFERS)
        ustrcat(buf, "aux_buffers ");
    if (opt & AGL_Z_DEPTH)
        ustrcat(buf, "z_depth ");
    if (opt & AGL_STENCIL_DEPTH)
        ustrcat(buf, "stencil_depth ");
    if (opt & AGL_WINDOW_X)
        ustrcat(buf, "window_x ");
    if (opt & AGL_WINDOW_Y)
        ustrcat(buf, "window_y ");
    if (opt & AGL_FULLSCREEN)
        ustrcat(buf, "fullscreen ");
    if (opt & AGL_WINDOWED)
        ustrcat(buf, "windowed ");
    if (opt & AGL_VIDEO_MEMORY_POLICY)
        ustrcat(buf, "video_memory_policy ");
    if (opt & AGL_SAMPLE_BUFFERS)
        ustrcat(buf, "sample_buffers ");
    if (opt & AGL_SAMPLES)
        ustrcat(buf, "samples ");
    if (opt & AGL_FLOAT_COLOR)
        ustrcat(buf, "float_color ");
    if (opt & AGL_FLOAT_Z)
        ustrcat(buf, "float_depth ");
        
    set_config_string(section, name, buf);
}



/* void allegro_gl_save_settings() */
void allegro_gl_save_settings() {

    char *section = "OpenGL";
    int save = allegro_gl_get(AGL_REQUIRE) | allegro_gl_get(AGL_SUGGEST);
    
    if (save & AGL_ALLEGRO_FORMAT)
        set_config_int(section, "allegro_format",
            allegro_gl_get(AGL_ALLEGRO_FORMAT));
    if (save & AGL_RED_DEPTH)
        set_config_int(section, "red_depth",
            allegro_gl_get(AGL_RED_DEPTH));
    if (save & AGL_GREEN_DEPTH)
        set_config_int(section, "green_depth",
            allegro_gl_get(AGL_GREEN_DEPTH));
    if (save & AGL_BLUE_DEPTH)
        set_config_int(section, "blue_depth",
            allegro_gl_get(AGL_BLUE_DEPTH));
    if (save & AGL_ALPHA_DEPTH)
        set_config_int(section, "alpha_depth",
            allegro_gl_get(AGL_ALPHA_DEPTH));
    if (save & AGL_COLOR_DEPTH)
        set_config_int(section, "color_depth",
            allegro_gl_get(AGL_COLOR_DEPTH));
    if (save & AGL_ACC_RED_DEPTH)
        set_config_int(section, "accum_red_depth",
            allegro_gl_get(AGL_ACC_RED_DEPTH));
    if (save & AGL_ACC_GREEN_DEPTH)
        set_config_int(section, "accum_green_depth",
            allegro_gl_get(AGL_ACC_GREEN_DEPTH));
    if (save & AGL_ACC_BLUE_DEPTH)
        set_config_int(section, "accum_blue_depth",
            allegro_gl_get(AGL_ACC_BLUE_DEPTH));
    if (save & AGL_ACC_ALPHA_DEPTH)
        set_config_int(section, "accum_alpha_depth",
            allegro_gl_get(AGL_ACC_ALPHA_DEPTH));
    if (save & AGL_DOUBLEBUFFER)
        set_config_int(section, "double_buffer",
            allegro_gl_get(AGL_DOUBLEBUFFER));
    if (save & AGL_STEREO)
        set_config_int(section, "stereo_display",
            allegro_gl_get(AGL_STEREO));
    if (save & AGL_AUX_BUFFERS)
        set_config_int(section, "aux_buffers",
            allegro_gl_get(AGL_AUX_BUFFERS));
    if (save & AGL_Z_DEPTH)
        set_config_int(section, "z_depth",
            allegro_gl_get(AGL_Z_DEPTH));
    if (save & AGL_STENCIL_DEPTH)
        set_config_int(section, "stencil_depth",
            allegro_gl_get(AGL_STENCIL_DEPTH));
    if (save & AGL_WINDOW_X)
        set_config_int(section, "window_x",
            allegro_gl_get(AGL_WINDOW_X));
    if (save & AGL_WINDOW_Y)
        set_config_int(section, "window_y",
            allegro_gl_get(AGL_WINDOW_Y));
    if (save & AGL_FULLSCREEN)
        set_config_int(section, "fullscreen",
            allegro_gl_get(AGL_FULLSCREEN));
    if (save & AGL_WINDOWED)
        set_config_int(section, "windowed",
            allegro_gl_get(AGL_WINDOWED));
    if (save & AGL_VIDEO_MEMORY_POLICY)
        set_config_int(section, "video_memory_policy",
            allegro_gl_get(AGL_VIDEO_MEMORY_POLICY));
    if (save & AGL_SAMPLE_BUFFERS)
        set_config_int(section, "sample_buffers",
                       allegro_gl_get(AGL_SAMPLE_BUFFERS));
    if (save & AGL_SAMPLES)
        set_config_int(section, "samples",
                       allegro_gl_get(AGL_SAMPLES));
    if (save & AGL_FLOAT_COLOR)
        set_config_int(section, "float_color",
                       allegro_gl_get(AGL_FLOAT_COLOR));
    if (save & AGL_FLOAT_Z)
        set_config_int(section, "float_depth",
                       allegro_gl_get(AGL_FLOAT_Z));

    if (save & AGL_REQUIRE)
        build_settings(allegro_gl_get(AGL_REQUIRE), section, "require");
    if (save & AGL_SUGGEST)
        build_settings(allegro_gl_get(AGL_SUGGEST), section, "suggest");
}



/* Parses an input string to read settings */
static void agl_parse_section(int sec, char *section, char *name) {
    const char *end;
    char *buf;
    char *ptr;
    int strsize;
    int opt = 0;

    end = get_config_string(section, name, "");
    strsize = ustrsizez(end);
    
    buf = (char*)malloc(sizeof(char) * strsize);
    
    if (!buf) {
        TRACE(PREFIX_E "parse_section: Ran out of memory "
              "while trying to allocate %i bytes!",
              (int)sizeof(char) * strsize);
        return;
    }

    memcpy(buf, end, strsize);
    end = buf + strsize;
    ptr = buf;

    while (ptr < end) {
        char *s = ustrtok_r(ptr, " ;|+", &ptr);
        
        if (!ustrcmp(s, "allegro_format"))
            opt |= AGL_ALLEGRO_FORMAT;
        if (!ustrcmp(s, "red_depth"))
            opt |= AGL_RED_DEPTH;
        if (!ustrcmp(s, "green_depth"))
            opt |= AGL_GREEN_DEPTH;
        if (!ustrcmp(s, "blue_depth"))
            opt |= AGL_BLUE_DEPTH;
        if (!ustrcmp(s, "alpha_depth"))
            opt |= AGL_ALPHA_DEPTH;
        if (!ustrcmp(s, "color_depth"))
            opt |= AGL_COLOR_DEPTH;
        if (!ustrcmp(s, "accum_red_depth"))
            opt |= AGL_ACC_RED_DEPTH;
        if (!ustrcmp(s, "accum_green_depth"))
            opt |= AGL_ACC_GREEN_DEPTH;
        if (!ustrcmp(s, "accum_blue_depth"))
            opt |= AGL_ACC_BLUE_DEPTH;
        if (!ustrcmp(s, "accum_alpha_depth"))
            opt |= AGL_ACC_ALPHA_DEPTH;
        if (!ustrcmp(s, "double_buffer"))
            opt |= AGL_DOUBLEBUFFER;
        if (!ustrcmp(s, "stereo_display"))
            opt |= AGL_STEREO;
        if (!ustrcmp(s, "aux_buffers"))
            opt |= AGL_AUX_BUFFERS;
        if (!ustrcmp(s, "z_depth"))
            opt |= AGL_Z_DEPTH;
        if (!ustrcmp(s, "stencil_depth"))
            opt |= AGL_STENCIL_DEPTH;
        if (!ustrcmp(s, "window_x"))
            opt |= AGL_WINDOW_X;
        if (!ustrcmp(s, "window_y"))
            opt |= AGL_WINDOW_Y;
        if (!ustrcmp(s, "fullscreen"))
            opt |= AGL_FULLSCREEN;
        if (!ustrcmp(s, "windowed"))
            opt |= AGL_WINDOWED;
        if (!ustrcmp(s, "video_memory_policy"))
            opt |= AGL_VIDEO_MEMORY_POLICY;
        if (!ustrcmp(s, "sample_buffers"))
            opt |= AGL_SAMPLE_BUFFERS;
        if (!ustrcmp(s, "samples"))
            opt |= AGL_SAMPLES;
        if (!ustrcmp(s, "float_color"))
            opt |= AGL_FLOAT_COLOR;
        if (!ustrcmp(s, "float_depth"))
            opt |= AGL_FLOAT_Z;
    }
    
    free(buf);
    
    allegro_gl_set(sec, opt);
}



/* void allegro_gl_load_settings() */
void allegro_gl_load_settings() {

    int set;
    char *section = "OpenGL";
    
    set = get_config_int(section, "allegro_format", -1);
    if (set != -1)
        allegro_gl_set(AGL_ALLEGRO_FORMAT, set);
    set = get_config_int(section, "red_depth", -1);
    if (set != -1)
        allegro_gl_set(AGL_RED_DEPTH, set);
    set = get_config_int(section, "green_depth", -1);
    if (set != -1)
        allegro_gl_set(AGL_GREEN_DEPTH, set);
    set = get_config_int(section, "blue_depth", -1);
    if (set != -1)
        allegro_gl_set(AGL_BLUE_DEPTH, set);
    set = get_config_int(section, "alpha_depth", -1);
    if (set != -1)
        allegro_gl_set(AGL_ALPHA_DEPTH, set);
    set = get_config_int(section, "color_depth", -1);
    if (set != -1)
        allegro_gl_set(AGL_COLOR_DEPTH, set);
    set = get_config_int(section, "accum_red_depth", -1);
    if (set != -1)
        allegro_gl_set(AGL_ACC_RED_DEPTH, set);
    set = get_config_int(section, "accum_green_depth", -1);
    if (set != -1)
        allegro_gl_set(AGL_ACC_GREEN_DEPTH, set);
    set = get_config_int(section, "accum_blue_depth", -1);
    if (set != -1)
        allegro_gl_set(AGL_ACC_BLUE_DEPTH, set);
    set = get_config_int(section, "accum_alpha_depth", -1);
    if (set != -1)
        allegro_gl_set(AGL_ACC_ALPHA_DEPTH, set);
    set = get_config_int(section, "double_buffer", -1);
    if (set != -1)
        allegro_gl_set(AGL_DOUBLEBUFFER, set);
    set = get_config_int(section, "stereo_display", -1);
    if (set != -1)
        allegro_gl_set(AGL_STEREO, set);
    set = get_config_int(section, "aux_buffers", -1);
    if (set != -1)
        allegro_gl_set(AGL_AUX_BUFFERS, set);
    set = get_config_int(section, "z_depth", -1);
    if (set != -1)
        allegro_gl_set(AGL_Z_DEPTH, set);
    set = get_config_int(section, "stencil_depth", -1);
    if (set != -1)
        allegro_gl_set(AGL_STENCIL_DEPTH, set);
    set = get_config_int(section, "window_x", -1);
    if (set != -1)
        allegro_gl_set(AGL_WINDOW_X, set);
    set = get_config_int(section, "window_y", -1);
    if (set != -1)
        allegro_gl_set(AGL_WINDOW_Y, set);
    set = get_config_int(section, "fullscreen", -1);
    if (set != -1)
        allegro_gl_set(AGL_FULLSCREEN, set);
    set = get_config_int(section, "windowed", -1);
    if (set != -1)
        allegro_gl_set(AGL_WINDOWED, set);
    set = get_config_int(section, "video_memory_policy", -1);
    if (set != -1)
        allegro_gl_set(AGL_VIDEO_MEMORY_POLICY, set);
    set = get_config_int(section, "sample_buffers", -1);
    if (set != -1)
        allegro_gl_set(AGL_SAMPLE_BUFFERS, set);
    set = get_config_int(section, "samples", -1);
    if (set != -1)
        allegro_gl_set(AGL_SAMPLES, set);
    set = get_config_int(section, "float_color", -1);
    if (set != -1)
        allegro_gl_set(AGL_FLOAT_COLOR, set);
    set = get_config_int(section, "float_depth", -1);
    if (set != -1)
        allegro_gl_set(AGL_FLOAT_Z, set);
    
    agl_parse_section(AGL_REQUIRE, section, "require");
    agl_parse_section(AGL_SUGGEST, section, "suggest");
}



/* int install_allegro_gl(void) */
int install_allegro_gl(void)
{
    if (!system_driver)
        return -1;

    if (atexit(remove_allegro_gl))
        return -1;
    
    if (system_driver->gfx_drivers)
        saved_gfx_drivers = system_driver->gfx_drivers;
    else
        saved_gfx_drivers = list_saved_gfx_drivers;
    
    system_driver->gfx_drivers = our_gfx_drivers;

    allegro_gl_clear_settings();

    /* Save and replace old blit_between_formats methods */
#ifdef ALLEGRO_COLOR8
    __blit_between_formats8 = __linear_vtable8.blit_between_formats;
    __linear_vtable8.blit_between_formats =
                                         allegro_gl_memory_blit_between_formats;
#endif
#ifdef ALLEGRO_COLOR16
    __blit_between_formats15 = __linear_vtable15.blit_between_formats;
    __linear_vtable15.blit_between_formats =
                                         allegro_gl_memory_blit_between_formats;
    __blit_between_formats16 = __linear_vtable16.blit_between_formats;
    __linear_vtable16.blit_between_formats
                                       = allegro_gl_memory_blit_between_formats;
#endif
#ifdef ALLEGRO_COLOR24
    __blit_between_formats24 = __linear_vtable24.blit_between_formats;
    __linear_vtable24.blit_between_formats
                                       = allegro_gl_memory_blit_between_formats;
#endif
#ifdef ALLEGRO_COLOR32
    __blit_between_formats32 = __linear_vtable32.blit_between_formats;
    __linear_vtable32.blit_between_formats
                                       = allegro_gl_memory_blit_between_formats;
#endif

    usetc(allegro_gl_error, 0);
    
    return 0;
}



/* void remove_allegro_gl(void) */
void remove_allegro_gl(void)
{
    if ((!system_driver) || (!saved_gfx_drivers))
        return;

    if (saved_gfx_drivers == &list_saved_gfx_drivers)
        system_driver->gfx_drivers = NULL;
    else
        system_driver->gfx_drivers = saved_gfx_drivers;

    /* This function may be called twice (once by a user explicit call
     * and once again at exit since the function is registered with at_exit)
     * In order to prevent crashes, 'saved_gfx_drivers' is set to NULL
     */
    saved_gfx_drivers = NULL;

    /* Restore the blit_between_formats methods */
    #ifdef ALLEGRO_COLOR8
    __linear_vtable8.blit_between_formats = __blit_between_formats8;
    #endif
    #ifdef ALLEGRO_COLOR16
    __linear_vtable15.blit_between_formats = __blit_between_formats15;
    __linear_vtable16.blit_between_formats = __blit_between_formats16;
    #endif
    #ifdef ALLEGRO_COLOR24
    __linear_vtable24.blit_between_formats = __blit_between_formats24;
    #endif
    #ifdef ALLEGRO_COLOR32
    __linear_vtable32.blit_between_formats = __blit_between_formats32;
    #endif
}



/* void allegro_gl_flip(void) */
void allegro_gl_flip(void)
{
    __allegro_gl_driver->flip();
}



/* float allegro_gl_opengl_version() */
float allegro_gl_opengl_version() {
    
    const char *str;
    
    if (!__allegro_gl_valid_context)
        return 0.0f;
    
    str = (const char*)glGetString(GL_VERSION);

    if ((strncmp(str, "1.0 ", 4) == 0) || (strncmp(str, "1.0.0 ", 6) == 0))
        return 1.0;
    if ((strncmp(str, "1.1 ", 4) == 0) || (strncmp(str, "1.1.0 ", 6) == 0))
        return 1.1;
    if ((strncmp(str, "1.2 ", 4) == 0) || (strncmp(str, "1.2.0 ", 6) == 0))
        return 1.2;
    if ((strncmp(str, "1.2.1 ", 6) == 0))
        return 1.21;
    if ((strncmp(str, "1.2.2 ", 6) == 0))
        return 1.22;
    if ((strncmp(str, "1.3 ", 4) == 0) || (strncmp(str, "1.3.0 ", 6) == 0))
        return 1.3;
    if ((strncmp(str, "1.4 ", 4) == 0) || (strncmp(str, "1.4.0 ", 6) == 0))
        return 1.4;
    if ((strncmp(str, "1.5 ", 4) == 0) || (strncmp(str, "1.5.0 ", 6) == 0))
        return 1.5;
    if ((strncmp(str, "2.0 ", 4) == 0) || (strncmp(str, "2.0.0 ", 6) == 0))
        return 2.0;
    if ((strncmp(str, "2.1 ", 4) == 0) || (strncmp(str, "2.1.0 ", 6) == 0))
        return 2.1;

    /* The OpenGL driver does not return a version
     * number. However it probably supports at least OpenGL 1.0
     */ 
    if (!str) {
        return 1.0;
    }
    
    return atof(str);
}



void __allegro_gl_set_allegro_image_format(int big_endian)
{
    /* Sets up Allegro to use OpenGL formats */
    _rgb_r_shift_15 = 11;
    _rgb_g_shift_15 = 6;
    _rgb_b_shift_15 = 1;

    _rgb_r_shift_16 = 11;
    _rgb_g_shift_16 = 5;
    _rgb_b_shift_16 = 0;

    if (big_endian) {
        _rgb_r_shift_24 = 16;
        _rgb_g_shift_24 = 8;
        _rgb_b_shift_24 = 0;

        _rgb_a_shift_32 = 0;
        _rgb_r_shift_32 = 24;
        _rgb_g_shift_32 = 16;
        _rgb_b_shift_32 = 8;
    }
    else {
        _rgb_r_shift_24 = 0;
        _rgb_g_shift_24 = 8;
        _rgb_b_shift_24 = 16;

        _rgb_r_shift_32 = 0;
        _rgb_g_shift_32 = 8;
        _rgb_b_shift_32 = 16;
        _rgb_a_shift_32 = 24;
    }

    return;
}



/* allegro_gl_default_init:
 *  Sets a graphics mode according to the mode (fullscreen or windowed)
 *  requested by the user. If it fails to set up the mode then it tries
 *  (if available) the other one unless the user has "AGL_REQUIRED" the mode.
 */
static BITMAP *allegro_gl_default_gfx_init(int w, int h, int vw, int vh,
                                                                     int depth)
{
    BITMAP* bmp = NULL;
    
    if (allegro_gl_display_info.fullscreen) {
        TRACE(PREFIX_I "default_gfx_init: Trying to set up fullscreen mode.\n");
        
#ifdef GFX_OPENGL_FULLSCREEN
        /* Looks for fullscreen mode in our_driver_list */
        gfx_driver = &gfx_allegro_gl_fullscreen;

        if (__allegro_gl_required_settings & AGL_FULLSCREEN)
            /* Fullscreen mode required and found */
            return gfx_allegro_gl_fullscreen.init(w, h, vw, vh, depth);
        else
            bmp = gfx_allegro_gl_fullscreen.init(w, h, vw, vh, depth);
        
        if (bmp)
            /* Fullscreen mode found but not required (probably suggested) */
            return bmp;

#endif /*GFX_OPENGL_FULLSCREEN*/

        /* Fullscreen mode not available but not required :
         * let's try windowed mode :
         */
        TRACE(PREFIX_I "default_gfx_init: Failed to set up fullscreen mode!\n");
#ifdef GFX_OPENGL_WINDOWED
        TRACE(PREFIX_I "default_gfx_init: Trying windowed mode...\n");
        allegro_gl_display_info.fullscreen = FALSE;
        gfx_driver = &gfx_allegro_gl_windowed;
        return gfx_allegro_gl_windowed.init(w, h, vw, vh, depth);
#else
        return NULL;
#endif /* GFX_OPENGL_WINDOWED */
    }
    else {
        TRACE(PREFIX_I "default_gfx_init: Trying to set up windowed mode...\n");
        
#ifdef GFX_OPENGL_WINDOWED
        /* Looks for windowed mode in our_driver_list */
        gfx_driver = &gfx_allegro_gl_windowed;

        if (__allegro_gl_required_settings & AGL_WINDOWED)
            /* Windowed mode required and found */
            return gfx_allegro_gl_windowed.init(w, h, vw, vh, depth);
        else
            bmp = gfx_allegro_gl_windowed.init(w, h, vw, vh, depth);
        
        if (bmp)
            /* Windowed mode found but not required (probably suggested) */
            return bmp;

#endif /* GFX_OPENGL_WINDOWED */

        /* Windowed mode not available but not required :
         * let's try fullscreen mode :
         */
        TRACE(PREFIX_I "default_gfx_init: Failed to set up windowed mode...\n");
#ifdef GFX_OPENGL_FULLSCREEN
        TRACE(PREFIX_I "default_gfx_init: Trying fullscreen mode...\n");
        allegro_gl_display_info.fullscreen = TRUE;
        gfx_driver = &gfx_allegro_gl_fullscreen;
        return gfx_allegro_gl_fullscreen.init(w, h, vw, vh, depth);
#else
        return NULL;
#endif /*GFX_OPENGL_FULLSCREEN*/
    }
}



/* allegro_gl_set_blender_mode (GFX_DRIVER vtable entry):
 * Sets the blending mode. Same implementation to all GFX vtables.
 */
void allegro_gl_set_blender_mode(int mode, int r, int g, int b, int a) {
    __allegro_gl_blit_operation = AGL_OP_BLEND;
    /* These blenders do not need any special extensions. 
     * We specify only pixel arithmetic here. Blend equation and blend
     * color (if available) are reset to defualt later.*/
    switch (mode) {
        case blender_mode_none:
            glBlendFunc(GL_ONE, GL_ZERO);
        break;
        case blender_mode_alpha:
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        break;
        case blender_mode_invert:
            glLogicOp(GL_COPY_INVERTED);
            __allegro_gl_blit_operation = AGL_OP_LOGIC_OP;
        break;
        case blender_mode_multiply:
            glBlendFunc(GL_DST_COLOR, GL_ZERO);
        break;
    }
    
    if (allegro_gl_opengl_version() >= 1.4 ||
       (allegro_gl_opengl_version() >= 1.2 &&
        allegro_gl_is_extension_supported("ARB_imaging"))) {
        /* We're running a recent version of OpenGL and everything needed is here. */
        
        glBlendColor(r / 255.f, g / 255.f, b / 255.f, a / 255.f);

        switch (mode) {
            case blender_mode_none:
                glBlendEquation(GL_FUNC_ADD);
            break;
            case blender_mode_alpha:
                glBlendEquation(GL_FUNC_ADD);
            break;
            case blender_mode_trans:
                glBlendEquation(GL_FUNC_ADD);
                glBlendFunc(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA);
            break;
            case blender_mode_add:
                glBlendEquation(GL_FUNC_ADD);
                glBlendFunc(GL_CONSTANT_ALPHA, GL_ONE);
            break;
            case blender_mode_burn:
                glBlendEquation(GL_FUNC_SUBTRACT);
                glBlendFunc(GL_ONE, GL_CONSTANT_ALPHA);
            break;
            case blender_mode_dodge:
                glBlendEquation(GL_FUNC_ADD);
                glBlendFunc(GL_ONE, GL_CONSTANT_ALPHA);
            break;
            case blender_mode_multiply:
                glBlendEquation(GL_FUNC_ADD);
            break;
        }

        return;
    }
    
    /* Check for presence of glBlendColor() and special parameters to
     * glBlendFunc(). */
    if (allegro_gl_is_extension_supported("GL_EXT_blend_color")) {
        glBlendColorEXT(r / 255.f, g / 255.f, b / 255.f, a / 255.f);

        switch (mode) {
            case blender_mode_trans:
                glBlendFunc(GL_CONSTANT_ALPHA_EXT, GL_ONE_MINUS_CONSTANT_ALPHA_EXT);
            break;
            case blender_mode_add:
                glBlendFunc(GL_CONSTANT_ALPHA_EXT, GL_ONE);
            break;
            case blender_mode_burn:
                glBlendFunc(GL_ONE, GL_CONSTANT_ALPHA_EXT);
            break;
            case blender_mode_dodge:
                glBlendFunc(GL_ONE, GL_CONSTANT_ALPHA_EXT);
            break;
        }
    }
    else if (mode == blender_mode_trans ||
             mode == blender_mode_add ||
             mode == blender_mode_burn ||
             mode == blender_mode_dodge) {
        /* glBlendColor() is not available and it is needed by the selected
         * bledner. Bail out.*/
        return;
    }

    /* Check for presence of glBlendEquation(). */
    if (allegro_gl_is_extension_supported("GL_EXT_blend_minmax")) {
        switch (mode) {
            case blender_mode_none:
                glBlendEquationEXT(GL_FUNC_ADD_EXT);
            break;
            case blender_mode_alpha:
                glBlendEquationEXT(GL_FUNC_ADD_EXT);
            break;
            case blender_mode_trans:
                glBlendEquationEXT(GL_FUNC_ADD_EXT);
            break;
            case blender_mode_add:
                glBlendEquationEXT(GL_FUNC_ADD_EXT);
            break;
            case blender_mode_dodge:
                glBlendEquationEXT(GL_FUNC_ADD_EXT);
            break;
            case blender_mode_multiply:
                glBlendEquationEXT(GL_FUNC_ADD_EXT);
            break;
            case blender_mode_burn:
                if (allegro_gl_is_extension_supported("GL_EXT_blend_subtract")) {
                    glBlendEquationEXT(GL_FUNC_SUBTRACT_EXT);
                }
                else {
                    /* GL_FUNC_SUBTRACT is not supported and it is needed by the
                     * selected blender. Bail out. */
                    return;
                }
            break;
        }
    }
}


#ifdef DEBUGMODE
#ifdef LOGLEVEL

void __allegro_gl_log(int level, const char *str)
{
    if (level <= LOGLEVEL)
        TRACE(PREFIX_L "[%d] %s", level, str);
}

#endif
#endif

---