aglf.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 <math.h>
#include <string.h>
#include <stdio.h>

#include <allegro.h>

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

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

#if defined ALLEGRO_WITH_XWINDOWS && !defined ALLEGROGL_GENERIC_DRIVER
#include <xalleg.h>
#include <GL/glx.h>
#endif

#define PREFIX_E "agl-font ERROR: "



static int aglf_font_generation_mode = AGL_FONT_POLYGONS;


/* find_range:
 *  Searches a font for a specific character.
 */
static AL_CONST FONT_AGL_DATA *find_range(AL_CONST FONT_AGL_DATA *f, int c) {

    while (f) {
        if ((c >= f->start) && (c < f->end))
            return f;

        f = f->next;
    }

    return NULL;
}



/* allegro_gl_printf(FONT *f, float x, float y, float z, int color,
            char *format, ...) */
int allegro_gl_printf(AL_CONST FONT *f, float x, float y, float z, int color,
                      AL_CONST char *format, ...) {

#define BUF_SIZE 1024
    char buf[BUF_SIZE];
    va_list ap;
    
    if (!__allegro_gl_valid_context)
        return 0;
    
    /* Get the string */
    va_start(ap, format);
        uvszprintf(buf, BUF_SIZE, format, ap);
    va_end(ap);

#undef BUF_SIZE

    /* Set color */
    {
        GLubyte c[4];
        c[0] = (GLubyte)getr(color);
        c[1] = (GLubyte)getg(color);
        c[2] = (GLubyte)getb(color);
        c[3] = (__allegro_gl_use_alpha && bitmap_color_depth(screen) == 32)
             ? (GLubyte)geta(color) : 255;

        glColor4ubv(c);
    }

    return allegro_gl_printf_ex(f, x, y, z, buf);
}



/* allegro_gl_printf_ex(FONT *f, float x, float y, float z,
 *                      char *format, ...)
 */
int allegro_gl_printf_ex(AL_CONST FONT *f, float x, float y, float z,
                         AL_CONST char *format, ...) {
    #define BUF_SIZE 1024
    char buf[BUF_SIZE];
    va_list ap;
    
    AL_CONST FONT_AGL_DATA *range = NULL;
    int c, pos = 0;
    int count = 0;
    AL_CONST FONT_AGL_DATA *d;
    GLint vert_order, cull_mode;
    GLint matrix_mode;

    int restore_rasterpos = 0;
    GLuint old_texture_bind = 0;
    GLfloat old_raster_pos[4];
    

    if (!__allegro_gl_valid_context)
        return 0;

    /* Check arguments */
    if (!format || !f) {
        TRACE(PREFIX_E "agl_printf: Null parameter\n");
        return 0;
    }
        
    if (f->vtable != font_vtable_agl) {
        TRACE(PREFIX_E "agl_printf: Font parameter isn't of the AGL "
              "type.\n");
        return 0;
    }
        
    d = (AL_CONST FONT_AGL_DATA*)f->data;

    /* Get the string */
    va_start(ap, format);
        uvszprintf(buf, BUF_SIZE, format, ap);
    va_end(ap);

#undef BUF_SIZE

    glGetIntegerv(GL_MATRIX_MODE, &matrix_mode);
    glGetIntegerv(GL_FRONT_FACE, &vert_order);
    glGetIntegerv(GL_CULL_FACE_MODE, &cull_mode);   
    
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    
    glFrontFace(GL_CW);
    glCullFace(GL_BACK);

    {   GLint temp;
        glGetIntegerv(GL_TEXTURE_BINDING_2D, &temp);
        old_texture_bind = (GLuint)temp;
    }

    if (d->type == AGL_FONT_TYPE_BITMAP) {
        glTranslatef(0, 0, -1);
        glBindTexture(GL_TEXTURE_2D, 0);
        
        glGetFloatv(GL_CURRENT_RASTER_POSITION, old_raster_pos);
        glRasterPos2f(x, y);
        restore_rasterpos = 1;
    }
    else if (d->type == AGL_FONT_TYPE_OUTLINE) {
        glTranslatef(x, y, z);
        glBindTexture(GL_TEXTURE_2D, 0);
    }
    else if (d->type == AGL_FONT_TYPE_TEXTURED) {
        glTranslatef(x, y, z);
    }


    while ((c = ugetc(buf + pos)) != 0) {

        pos += ucwidth(c);

        if ((!range) || (c < range->start) || (c >= range->end)) {
            /* search for a suitable character range */
            range = find_range(d, c);

            if (!range) {
                range = find_range(d, (c = '^'));

                if (!range)
                    continue;
            }
        }
        
        /* Set up texture */
        if (d->type == AGL_FONT_TYPE_TEXTURED) {
            glBindTexture(GL_TEXTURE_2D, range->texture);
        }
        
        /* draw the character */
        c -= range->start;
        c += range->list_base;
        
        glCallList(c);

        count++;
    }
    
    glPopMatrix();

    glMatrixMode(matrix_mode);
    glFrontFace(vert_order);
    glCullFace(cull_mode);  

    glBindTexture(GL_TEXTURE_2D, old_texture_bind);

    if (restore_rasterpos) {
        glRasterPos4fv(old_raster_pos);
    }

    return count;
}



#ifndef ALLEGROGL_GENERIC_DRIVER
#ifdef ALLEGRO_WINDOWS

static FONT *win_load_system_font(char *name, int type, int style, int w, int h, float depth, int start, int end) {

    HFONT hFont;

    FONT_AGL_DATA *data;
    FONT *ret;
    
    ret = malloc(sizeof(FONT));
    if (!ret) {
        TRACE(PREFIX_E "win_load_system_font: Ran out of memory "
              "while allocating %i bytes\n", sizeof(FONT));
        return NULL;
    }
    data = malloc(sizeof(FONT_AGL_DATA));
    if (!data) {
        free(ret);
        TRACE(PREFIX_E "win_load_system_font: Ran out of memory "
              "while allocating %i bytes\n", sizeof(FONT_AGL_DATA));
        return NULL;
    }
    ret->vtable = font_vtable_agl;
    ret->data = data;
        
    data->list_base = glGenLists(end - start);
    data->start = start;
    data->end = end;
    data->next = NULL;
    data->is_free_chunk = 0;

    if (type == AGL_FONT_TYPE_BITMAP || type == AGL_FONT_TYPE_DONT_CARE) {

        HDC dc;

        hFont = CreateFont( -h, w,
            0, 0,
            (style & AGL_FONT_STYLE_BOLD) ? FW_BOLD
                     : ((style & AGL_FONT_STYLE_BLACK) ? FW_BLACK : FW_NORMAL),
            ((style & AGL_FONT_STYLE_ITALIC) ? TRUE : FALSE),
            ((style & AGL_FONT_STYLE_UNDERLINE) ? TRUE : FALSE),
            ((style & AGL_FONT_STYLE_STRIKEOUT) ? TRUE : FALSE),
            ANSI_CHARSET,
            OUT_TT_PRECIS,
            CLIP_DEFAULT_PRECIS,
            (style & AGL_FONT_STYLE_ANTI_ALIASED) ? ANTIALIASED_QUALITY
                     : DEFAULT_QUALITY,
            FF_DONTCARE | DEFAULT_PITCH,
            name);

        dc = GetDC(win_get_window());

        SelectObject(dc, hFont);

        wglUseFontBitmaps(dc, start, end - start, data->list_base);
        data->type = AGL_FONT_TYPE_BITMAP;
        data->data = NULL;
    }
    else if (type == AGL_FONT_TYPE_OUTLINE) {
        HDC dc;

        GLYPHMETRICSFLOAT *gmf;
        gmf = malloc(sizeof(GLYPHMETRICSFLOAT) * (end - start));
        memset(gmf, 0, sizeof(GLYPHMETRICSFLOAT) * (end - start));

        hFont = CreateFont( -h, w,
            0, 0,
            (style & AGL_FONT_STYLE_BOLD) ? FW_BOLD
                      : ((style & AGL_FONT_STYLE_BLACK) ? FW_BLACK : FW_NORMAL),
            ((style & AGL_FONT_STYLE_ITALIC) ? TRUE : FALSE),
            ((style & AGL_FONT_STYLE_UNDERLINE) ? TRUE : FALSE),
            ((style & AGL_FONT_STYLE_STRIKEOUT) ? TRUE : FALSE),
            ANSI_CHARSET,
            OUT_TT_PRECIS,
            CLIP_DEFAULT_PRECIS,
            (style & AGL_FONT_STYLE_ANTI_ALIASED) ? ANTIALIASED_QUALITY
                      : DEFAULT_QUALITY,
            FF_DONTCARE | DEFAULT_PITCH,
            name);

        dc = GetDC(win_get_window());

        SelectObject(dc, hFont);
        wglUseFontOutlines(dc, start, end - start, data->list_base,
            0.0, depth, (aglf_font_generation_mode == AGL_FONT_POLYGONS)
            ? WGL_FONT_POLYGONS : WGL_FONT_LINES, gmf);

        data->type = AGL_FONT_TYPE_OUTLINE;
        data->data = gmf;
    }

    return ret;
}
#endif



#ifdef ALLEGRO_WITH_XWINDOWS
static FONT *x_load_system_font(char *name, int type, int style, int w, int h,
                                              float depth, int start, int end) {
    FONT_AGL_DATA *data;
    FONT *ret;
    XFontStruct *xfont;

    ret = malloc(sizeof(FONT));
    if (!ret) {
        TRACE(PREFIX_E "x_load_system_font: Ran out of memory "
              "while allocating %zi bytes\n", sizeof(FONT));
        return NULL;
    }
    data = malloc(sizeof(FONT_AGL_DATA));
    if (!data) {
        free(ret);
        TRACE(PREFIX_E "x_load_system_font: Ran out of memory "
              "while allocating %zi bytes\n", sizeof(FONT_AGL_DATA));
        return NULL;
    }
    ret->vtable = font_vtable_agl;
    ret->data = data;
        
    data->list_base = glGenLists(end - start);
    data->start = start;
    data->end = end;
    data->next = NULL;
    data->is_free_chunk = 0;

    if (type == AGL_FONT_TYPE_BITMAP || type == AGL_FONT_TYPE_DONT_CARE) {
        char buf[256], major_type[256], minor_type[2];
        
        usprintf(major_type, "medium");
        if (style & AGL_FONT_STYLE_BOLD)
            usprintf(major_type, "bold");
        minor_type[0] = (style & AGL_FONT_STYLE_ITALIC) ? 'i' : 'r';
        minor_type[1] = '\0';
        
        usprintf(buf, "-*-%s-%s-%s-normal-*-%i-*-*-*-*-*-*-*", name,
                                                    major_type, minor_type, h);
        /* Load the font */
        xfont = XLoadQueryFont(_xwin.display, buf);
        if (!xfont) {
            free(ret);
            free(data);
            TRACE(PREFIX_E "x_load_system_font: Failed to load "
                  "%s\n", buf);
            return NULL;
        }
        glXUseXFont(xfont->fid, start, end - start, data->list_base);
        data->type = AGL_FONT_TYPE_BITMAP;
        data->data = NULL;
        XFreeFont(_xwin.display, xfont);
    }
    else {
        /* Not Yet Implemented */
        return NULL;
    }
    
    return ret;
}
#endif
#endif /* ALLEGROGL_GENERIC_DRIVER */



/* void allegro_gl_set_font_generation_mode(int mode) */
void allegro_gl_set_font_generation_mode(int mode) {
    aglf_font_generation_mode = mode;
    return;
}



/* FONT *allegro_gl_load_system_font(char *name, int style, int w, int h) */
FONT *allegro_gl_load_system_font(char *name, int style, int w, int h) {

    return allegro_gl_load_system_font_ex(name, AGL_FONT_TYPE_OUTLINE,
                                          style, w, h, 0.0f, 32, 256);
}



/* FONT *allegro_gl_load_system_font_ex(char *name, int type, int style,
            int w, int h, float depth, int start, int end) */
FONT *allegro_gl_load_system_font_ex(char *name, int type, int style,
                                int w, int h, float depth, int start, int end) {

    FONT *ret = NULL;

    if (!__allegro_gl_valid_context)
        return NULL;

    if (!name) {
        TRACE(PREFIX_E "load_system_font: Nameless font\n");
        return NULL;
    }

    /* Load a system font */

#ifndef ALLEGROGL_GENERIC_DRIVER
#ifdef ALLEGRO_WINDOWS
    ret = win_load_system_font(name, type, style, w, h, depth, start, end);
#elif defined ALLEGRO_UNIX
    XLOCK();
    ret = x_load_system_font(name, type, style, w, h, depth, start, end);
    XUNLOCK();
#else
    /* Other platform */
#endif
#endif

    return ret;
}



void allegro_gl_destroy_font(FONT *f) {

    FONT_AGL_DATA *data;

    if (!f) {
        return;
    }
    if (f->vtable != font_vtable_agl) {
        TRACE(PREFIX_E "destroy_font: Font is not of AGL type\n");  
        return;
    }
    
    data = f->data;
    
    if (!data) {
        TRACE(PREFIX_E "destroy_font: Font is inconsistent\n"); 
        return;
    }

    /* Iterate through every segment of the font */
    while (data) {  
        FONT_AGL_DATA *datanext;
        
        /* Release all resources taken up by this font */
        if (data->type == AGL_FONT_TYPE_BITMAP
         || data->type == AGL_FONT_TYPE_OUTLINE
         || data->type == AGL_FONT_TYPE_TEXTURED) {

            if (__allegro_gl_valid_context) {
                if (data->list_base)
                    glDeleteLists(data->list_base, data->end - data->start);
                if (data->texture)
                    glDeleteTextures(1, &data->texture);
            }
        }
        if (data->type == AGL_FONT_TYPE_OUTLINE) {
            if (data->data) 
                free(data->data);
        }
        else if (data->type == AGL_FONT_TYPE_TEXTURED) {
            if (data->data)
                destroy_bitmap(data->data);
            if (data->glyph_coords)
                free(data->glyph_coords);
        }
        else if (data->type == AGL_FONT_TYPE_BITMAP) {
            if (data->data) {
                int i;
                FONT_GLYPH **gl = data->data;
                for (i = 0; i < data->end - data->start; i++) {
                    if (gl[i])
                        free(gl[i]);
                }
                free(gl);
            }
        }
        datanext = data->next;

        if (data->is_free_chunk)
            free(data);
            
        data = datanext;
    }
    free(f->data);

    if (f != font)
        free(f);
    
    return;
}



/* size_t allegro_gl_list_font_textures(FONT *f, GLuint *ids, size_t max_num_id) */
size_t allegro_gl_list_font_textures(FONT *f, GLuint *ids, size_t max_num_id) {

    size_t num_ids = 0;
    FONT_AGL_DATA *data;

    if (!f) {
        return 0;
    }
    if (f->vtable != font_vtable_agl) {
        TRACE(PREFIX_E "list_font_textures: Font is not of AGL type\n");    
        return 0;
    }
    
    data = f->data;
    
    if (!data) {
        TRACE(PREFIX_E "list_font_textures: Font is inconsistent\n");   
        return 0;
    }

    if (!__allegro_gl_valid_context) {
        return 0;
    }

    /* Iterate through all font segments */
    while (data) {
        if (data->texture) {
            /* Add the texture ID in the array, if it's not NULL and if there
             * is room.
             */
            if (ids && num_ids < max_num_id) {
                ids[num_ids] = data->texture;
            }
            num_ids++;
        }

        data = data->next;
    }
    
    return num_ids;
}

---