path: root/src/sdl-freetype-opengles.c

/* sdl-freetype, a text rendering library for SDL.
 * Copyright (C) 2007 luojinghua <sunmoon1997@gmail.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it either under the terms of the GNU Lesser General Public
 * License version 2.1 as published by the Free Software Foundation
 * (the "LGPL") or, at your option, under the terms of the Mozilla
 * Public License Version 1.1 (the "MPL"). If you do not alter this
 * notice, a recipient may use your version of this file under either
 * the MPL or the LGPL.
 *
 * You should have received a copy of the LGPL along with this library
 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 * You should have received a copy of the MPL along with this library
 * in the file COPYING-MPL-1.1
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
 * the specific language governing rights and limitations.
 *
 * THANKS FOR ALL CAIRO AUTHORS, MOST OF IDEAS AND IMPLEMENT DTAILS ARE
 * STOLEN FROM CAIRO.
 *
 */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "sdl-freetype.h"
#include "sdl-freetype-area-manager.h"
#include "sdl-freetype-opengles.h"
#include "sdl-freetype-utils.h"

#include  <assert.h>
#include  <stdlib.h>
#include  <stdio.h>

#include  <GLES/gl.h>

#define FIXEDTOD(f) (sdl_freetype_fixed_to_double (f))

#define GLYPH_CACHE_SIZE  512
#define GLYPH_CACHE_LEVEL 64
#define VERTEX_BUFFER_SIZE 128

typedef struct sdl_freetype_opengles_render_s {
    sdl_freetype_glyph_render_t base;
    sdl_freetype_area_manager_t * manager;
    sdl_freetype_font_t * font;
    sdl_freetype_bool_t valid;
    sdl_freetype_bool_t subpixel;
    int bind;
    int width, height;
    float usx, usy;
    GLuint texture;
    GLfloat vertex_buffer[VERTEX_BUFFER_SIZE * 6 * 2];
    GLfloat texcoord_buffer[VERTEX_BUFFER_SIZE * 6 * 2];
} sdl_freetype_opengles_render_t;

typedef struct {
    float x, y;
} sdl_freetype_opengles_coord_t;

typedef struct {
    sdl_freetype_font_t * font;
    FT_UInt index;
    sdl_freetype_area_t * area;
    int locked;
    sdl_freetype_opengles_coord_t uv[2];
} sdl_freetype_opengles_user_data_t;

static sdl_freetype_opengles_user_data_t *
sdl_freetype_opengles_user_data_create (void)
{
    return calloc (sizeof (sdl_freetype_opengles_user_data_t), 1);
}

static void
sdl_freetype_opengles_user_data_destroy (sdl_freetype_opengles_user_data_t * data,
                                       sdl_freetype_area_manager_t * manager)
{
    if (data->area)
        sdl_freetype_area_manager_move_out (manager, data->area);

    free (data);
}

static sdl_freetype_error_t
sdl_freetype_opengles_glyph_user_data_init (sdl_freetype_font_t * font,
                                            sdl_freetype_glyph_render_t * render,
                                            sdl_freetype_glyph_info_t * info,
                                            FT_UInt index)
{
    sdl_freetype_opengles_render_t * opengles_render =
        (sdl_freetype_opengles_render_t *) render;
    sdl_freetype_opengles_user_data_t * user_data;
    sdl_freetype_area_t * area;
    sdl_freetype_error_t err;
    FT_Bitmap * bitmap;
    unsigned int pitch, width, height;
    unsigned char * data;

    if (info->flags & SDL_FREETYPE_GLYPH_EMPTY)
        return SDL_FREETYPE_ERR_OK;

    if (!(info->flags & SDL_FREETYPE_GLYPH_SURFACE_DATA) &&
        !sdl_freetype_font_glyph_info_lookup (font, index,
                                              SDL_FREETYPE_GLYPH_SURFACE_DATA))
        return SDL_FREETYPE_ERR_OUT_OF_RESOURCES;
    if (!(info->flags & SDL_FREETYPE_GLYPH_SURFACE_DATA))
        return SDL_FREETYPE_ERR_OUT_OF_RESOURCES;

    bitmap = &info->bitmap;
    if (!opengles_render->valid) {
        unsigned char * data;

        glGenTextures (1, &opengles_render->texture);
        glBindTexture (GL_TEXTURE_2D, opengles_render->texture);
        glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

        switch (bitmap->pixel_mode) {
        case FT_PIXEL_MODE_MONO:
        case FT_PIXEL_MODE_GRAY:
            data = calloc (opengles_render->width * opengles_render->height, 1);
            if (!data)
                return SDL_FREETYPE_ERR_OUT_OF_MEMORY;
            glTexImage2D (GL_TEXTURE_2D, 0, GL_ALPHA,
                          opengles_render->width, opengles_render->height, 0,
                          GL_ALPHA, GL_UNSIGNED_BYTE, data);
            free (data);
            break;
        case FT_PIXEL_MODE_LCD:
        case FT_PIXEL_MODE_LCD_V:
            data = calloc (opengles_render->width * opengles_render->height, 1);
            if (!data)
                return SDL_FREETYPE_ERR_OUT_OF_MEMORY;
            glTexImage2D (GL_TEXTURE_2D, 0, GL_ALPHA,
                          opengles_render->width, opengles_render->height, 0,
                          GL_ALPHA, GL_UNSIGNED_BYTE, data);
            free (data);
            break;
        default:
            glDeleteTextures (1, &opengles_render->texture);
            return SDL_FREETYPE_ERR_NOT_IMPLEMENTED;
            break;
        }
        opengles_render->font = font;
        opengles_render->valid = SDL_FREETYPE_TRUE;
    }

    /* convert bitmap to 8bit alpha pixmap */
    if (bitmap->pixel_mode == FT_PIXEL_MODE_MONO) {
        unsigned char * src, * dst;
        int h;

        width = pitch = (bitmap->width + 1 + 3) & ~3;
        data = calloc (pitch * info->bitmap.rows, 1);
        if (!data)
            return SDL_FREETYPE_ERR_OUT_OF_MEMORY;

        src = bitmap->buffer;
        dst = data;
        for (h = bitmap->rows; h > 0; h--, src += bitmap->pitch, dst += pitch) {
            int  x;

            for (x = 0; x < bitmap->width; x++) {
                if (src[(x >> 3)] & (0x80 >> (x & 7)))
                    dst[x] = 0xff;
            }
        }
    } else if (bitmap->pixel_mode == FT_PIXEL_MODE_LCD ||
               bitmap->pixel_mode == FT_PIXEL_MODE_LCD_V) {
        unsigned char * src, * dst;
        int h;

        width = pitch = (bitmap->width + 1 + 3) & ~3;
        data = calloc (pitch * info->bitmap.rows, 1);
        if (!data)
            return SDL_FREETYPE_ERR_OUT_OF_MEMORY;

        src = bitmap->buffer;
        dst = data;
        for (h = bitmap->rows; h > 0; h--, src += bitmap->pitch, dst += pitch) {
            int  x;
            unsigned int *s = (unsigned int*)src;

            for (x = 0; x < bitmap->width; x++)
                dst[x] = s[x] >> 24;
        }
    } else {
        data = NULL;
        pitch = bitmap->pitch;
        width = (bitmap->width + 1 + 3) & ~3;
    }
    height = (bitmap->rows + 1 + 3) & ~3;

    user_data = sdl_freetype_opengles_user_data_create ();
    if (!user_data)
        return SDL_FREETYPE_ERR_OUT_OF_MEMORY;

    err = sdl_freetype_area_manager_find (opengles_render->manager,
                                          width, height,
                                          SDL_FREETYPE_FALSE,
                                          user_data);
    if (err != SDL_FREETYPE_ERR_OK) {
        err = sdl_freetype_area_manager_find (opengles_render->manager,
                                               width, height,
                                               SDL_FREETYPE_TRUE,
                                               user_data);
        if (err != SDL_FREETYPE_ERR_OK) {
            sdl_freetype_opengles_user_data_destroy (user_data,
                                                   opengles_render->manager);
            return SDL_FREETYPE_ERR_OUT_OF_RESOURCES;
        }
    }

    area = user_data->area;

    glBindTexture (GL_TEXTURE_2D, opengles_render->texture);
    switch (info->bitmap.pixel_mode) {
    case FT_PIXEL_MODE_MONO:
        glTexSubImage2D (GL_TEXTURE_2D, 0,
                         area->x, area->y, pitch, bitmap->rows,
                         GL_ALPHA, GL_UNSIGNED_BYTE, data);
        break;
    case FT_PIXEL_MODE_GRAY:
        glTexSubImage2D (GL_TEXTURE_2D, 0,
                         area->x, area->y, pitch, bitmap->rows,
                         GL_ALPHA, GL_UNSIGNED_BYTE, bitmap->buffer);
        break;
    case FT_PIXEL_MODE_LCD:
    case FT_PIXEL_MODE_LCD_V:
        glTexSubImage2D (GL_TEXTURE_2D, 0,
                         area->x, area->y, pitch, bitmap->rows,
                         GL_ALPHA, GL_UNSIGNED_BYTE, data);
        break;
    }


    if (data)
        free (data);

    user_data->font = font;
    user_data->index = index;
    user_data->uv[0].x = (float)area->x / opengles_render->width;
    user_data->uv[0].y = (float)area->y / opengles_render->height;
    user_data->uv[1].x = (float)(area->x + bitmap->width) / opengles_render->width;
    user_data->uv[1].y = (float)(area->y + bitmap->rows) / opengles_render->height;
    info->data = user_data;
    return SDL_FREETYPE_ERR_OK;
}

static void
sdl_freetype_opengles_glyph_user_data_fini (sdl_freetype_font_t * font,
                                          sdl_freetype_glyph_render_t * render,
                                          void * data)
{
    sdl_freetype_opengles_render_t * opengles_render =
        (sdl_freetype_opengles_render_t *) render;

    if (!data)
        return;

    sdl_freetype_opengles_user_data_destroy (data, opengles_render->manager);
}

#define LOCAL_BUF 64
typedef struct {
    sdl_freetype_glyph_info_t * info;
    int index;
} sdl_freetype_opengles_glyph_info_t;

static sdl_freetype_error_t
sdl_freetype_opengles_glyphs_render (sdl_freetype_font_t * font,
                                   void * dst,
                                   unsigned int r,
                                   unsigned int g,
                                   unsigned int b,
                                   unsigned int a,
                                   int x, int y,
                                   const sdl_freetype_glyph_t * glyphs,
                                   int num_glyphs)
{
    sdl_freetype_opengles_render_t * render =
        (sdl_freetype_opengles_render_t *) sdl_freetype_font_get_render (font);
    sdl_freetype_opengles_user_data_t * user_data;
    sdl_freetype_opengles_glyph_info_t * cached, stack_cached[LOCAL_BUF];
    sdl_freetype_glyph_info_t * info;
    double x1, y1, x2, y2;
    int i, start, num_cached;
    sdl_freetype_bool_t dirty = SDL_FREETYPE_FALSE;
    GLboolean blend_enabled;

    if (!render->valid) {
        for (i = 0; i < num_glyphs && !render->valid; i++)
            sdl_freetype_font_glyph_info_lookup (font, glyphs[i].index,
                                                 SDL_FREETYPE_GLYPH_SURFACE |
                                                 SDL_FREETYPE_GLYPH_SURFACE_DATA |
                                                 SDL_FREETYPE_GLYPH_USER_DATA);
        if (!render->valid)
            return SDL_FREETYPE_ERR_UNKNOWN;
    }

    if (!render->width || !render->height)
        return SDL_FREETYPE_ERR_OK;

    if (num_glyphs > LOCAL_BUF)
        cached = malloc (sizeof (sdl_freetype_opengles_glyph_info_t) * num_glyphs);
    else
        cached = stack_cached;
    if (!cached)
        return SDL_FREETYPE_ERR_OUT_OF_MEMORY;

    blend_enabled = glIsEnabled(GL_BLEND);

    start = 0;
    while (start < num_glyphs) {
	int end;

	num_cached = 0;
	for (i = start; i < num_glyphs; i++) {
	    info = sdl_freetype_font_glyph_info_lookup (font, glyphs[i].index,
							SDL_FREETYPE_GLYPH_SURFACE |
							SDL_FREETYPE_GLYPH_USER_DATA);
	    if (!info || info->flags & SDL_FREETYPE_GLYPH_EMPTY)
		continue;

	    user_data = info->data;
	    if (!user_data) {
		if (num_cached)
		    i--;
		break;
	    }
	    if (!user_data->area)
		continue;
	    user_data->locked++;
	    cached[num_cached].index  = i;
	    cached[num_cached++].info = info;
	}
	end = i + 1;

	if (num_cached) {
	    GLfloat *vertex_buffer = render->vertex_buffer;
	    GLfloat *texcoord_buffer = render->texcoord_buffer;
	    int left = num_cached;

	    if (!dirty) {
		dirty = SDL_FREETYPE_TRUE;

		glMatrixMode (GL_TEXTURE);
		glPushMatrix ();
		glLoadIdentity ();

		glMatrixMode (GL_MODELVIEW);
		glPushMatrix ();

		glEnable (GL_BLEND);
		glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

		glEnable (GL_TEXTURE_2D);
		glBindTexture (GL_TEXTURE_2D, render->texture);

		glTranslatef (x * render->usx, y * render->usy, 0.0f);

		glColor4ub (r, g, b, a);

		glEnableClientState (GL_VERTEX_ARRAY);
		glEnableClientState (GL_TEXTURE_COORD_ARRAY);

		glVertexPointer (2, GL_FLOAT, 0, vertex_buffer);
		glTexCoordPointer (2, GL_FLOAT, 0, texcoord_buffer);
	    }

	    i = 0;
	    while (left) {
		int num_quads = VERTEX_BUFFER_SIZE;
		int max_index;
		int j;

		if (left < num_quads)
		    num_quads = left;

		max_index = i + num_quads;

		for (j = 0; i < max_index; i++, j += 12) {
		    user_data = cached[i].info->data;

		    assert (user_data->locked != 0);

		    x1 = FIXEDTOD (glyphs[cached[i].index].x) + cached[i].info->x_offset;
		    y1 = FIXEDTOD (glyphs[cached[i].index].y) + cached[i].info->y_offset;
		    x2 = x1 + cached[i].info->bitmap.width;
		    y2 = y1 + cached[i].info->bitmap.rows;

		    x1 *= render->usx;
		    y1 *= render->usy;
		    x2 *= render->usx;
		    y2 *= render->usy;

		    texcoord_buffer[j + 0] = user_data->uv[0].x;
		    texcoord_buffer[j + 1] = user_data->uv[0].y;
		    vertex_buffer[j + 0] = x1;
		    vertex_buffer[j + 1] = y1;

		    texcoord_buffer[j + 2] = user_data->uv[0].x;
		    texcoord_buffer[j + 3] = user_data->uv[1].y;
		    vertex_buffer[j + 2] = x1;
		    vertex_buffer[j + 3] = y2;

		    texcoord_buffer[j + 4] = user_data->uv[1].x;
		    texcoord_buffer[j + 5] = user_data->uv[1].y;
		    vertex_buffer[j + 4] = x2;
		    vertex_buffer[j + 5] = y2;

		    texcoord_buffer[j + 6] = user_data->uv[1].x;
		    texcoord_buffer[j + 7] = user_data->uv[1].y;
		    vertex_buffer[j + 6] = x2;
		    vertex_buffer[j + 7] = y2;

		    texcoord_buffer[j + 8] = user_data->uv[1].x;
		    texcoord_buffer[j + 9] = user_data->uv[0].y;
		    vertex_buffer[j + 8] = x2;
		    vertex_buffer[j + 9] = y1;

		    texcoord_buffer[j + 10] = user_data->uv[0].x;
		    texcoord_buffer[j + 11] = user_data->uv[0].y;
		    vertex_buffer[j + 10] = x1;
		    vertex_buffer[j + 11] = y1;

		    user_data->locked--;
		}

		glDrawArrays (GL_TRIANGLES, 0, num_quads * 6);

		left -= num_quads;
	    }
	}
	start = end;
    }

    if (dirty) {
	glDisableClientState (GL_VERTEX_ARRAY);
	glDisableClientState (GL_TEXTURE_COORD_ARRAY);

	glPopMatrix ();

	glMatrixMode (GL_TEXTURE);
	glPopMatrix ();

	if (!blend_enabled)
	    glDisable (GL_BLEND);

	glBindTexture (GL_TEXTURE_2D, 0);

	glMatrixMode (GL_MODELVIEW);
    }

    if (cached != stack_cached)
        free (cached);

    return SDL_FREETYPE_ERR_OK;
}

static void
sdl_freetype_opengles_render_destroy (sdl_freetype_font_t * font,
                                    sdl_freetype_glyph_render_t * render)
{
    sdl_freetype_opengles_render_t * opengles_render =
        (sdl_freetype_opengles_render_t *) render;

    if (!opengles_render)
        return;

    if (opengles_render->manager)
        sdl_freetype_area_manager_destroy (opengles_render->manager);

    if (opengles_render->valid)
        glDeleteTextures (1, &opengles_render->texture);

    free (opengles_render);
}

static sdl_freetype_error_t
sdl_freetype_opengles_glyph_move_in (sdl_freetype_area_manager_t * manager,
                                   sdl_freetype_area_t * area, void * closure)
{
    sdl_freetype_opengles_user_data_t * user_data = closure;

    user_data->area = area;
    return SDL_FREETYPE_ERR_OK;
}

static void
sdl_freetype_opengles_glyph_move_out (sdl_freetype_area_manager_t * manager,
                                      sdl_freetype_area_t * area, void * closure)
{
    sdl_freetype_opengles_user_data_t * user_data = closure;

    user_data->area = NULL;
    sdl_freetype_font_glyph_clear_user_data(user_data->font, user_data->index);
}

static int
sdl_freetype_opengles_glyph_compare_score (sdl_freetype_area_manager_t * manager,
                                           sdl_freetype_area_t * area,
                                           void * closure1, void * closure2)
{
    sdl_freetype_opengles_user_data_t * user_data = closure1;

    if (user_data->locked)
        return 1;
    return -1;
}

static const sdl_freetype_area_manager_ops_t
sdl_freetype_opengles_glyph_ops = {
    sdl_freetype_opengles_glyph_move_in,
    sdl_freetype_opengles_glyph_move_out,
    sdl_freetype_opengles_glyph_compare_score
};

sdl_freetype_glyph_render_t *
sdl_freetype_opengles_render_create (void)
{
    sdl_freetype_opengles_render_t * render;

    render = malloc (sizeof (sdl_freetype_opengles_render_t));
    if (!render)
        goto errquit0;

    render->valid = SDL_FREETYPE_FALSE;
    render->subpixel = SDL_FREETYPE_FALSE;
    render->usx = render->usy = 1.0;
    render->width = render->height = GLYPH_CACHE_SIZE;
    render->manager =
        sdl_freetype_area_manager_create (render->width,
                                          render->height,
                                          GLYPH_CACHE_LEVEL,
                                          &sdl_freetype_opengles_glyph_ops);
    if (!render->manager)
        goto errquit1;

    render->base.caps = SDL_FT_RENDER_CAPS_CLEARTYPE;
    render->base.glyph_user_data_init = sdl_freetype_opengles_glyph_user_data_init;
    render->base.glyph_user_data_fini = sdl_freetype_opengles_glyph_user_data_fini;
    render->base.glyph_render = NULL;
    render->base.glyphs_render = sdl_freetype_opengles_glyphs_render;
    render->base.destroy = sdl_freetype_opengles_render_destroy;

    return &render->base;
 errquit1:
    free (render);
 errquit0:
    return NULL;
}

sdl_freetype_error_t
sdl_freetype_opengles_render_set_unit_scale (sdl_freetype_glyph_render_t * render,
                                             float sx, float sy)
{
    sdl_freetype_opengles_render_t * opengles_render =
        (sdl_freetype_opengles_render_t *) render;

    if (sx == 0.0 || sy == 0.0)
        return SDL_FREETYPE_ERR_INVALID_VALUE;

    if (opengles_render->usx == sx && opengles_render->usx == sx)
        return SDL_FREETYPE_ERR_OK;

    opengles_render->usx = sx;
    opengles_render->usy = sy;

    return SDL_FREETYPE_ERR_OK;
}