root/trunk/orca/gl/ttf_load.c

/*============================================================================
//
// Load FontResource using Freetype 2.
//
//==========================================================================*/


/*
  TODO:
   * Automatically compute best image size.
   * Pack glyphs more efficiently.
   * Speed up txf_kerning().
*/


#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include "os.h"
#include "gx.h"
#include "res_font.h"


#define KERN      1
//#define DUMP      1

#define FT_PIXELS(x)  (x >> 6)


//----------------------------------------------------------------------------


void txf_init( TexFont* txf, int w, int h )
{
    txf->tex_width  = w;
    txf->tex_height = h;
    txf->tgi        = 0;
    txf->table      = 0;
    txf->kerning    = 0;
}


void txf_free( TexFont* txf )
{
#define FREE(n) if(n) { memFree(n); n=0; }

    FREE( txf->tgi )
    FREE( txf->table )
    FREE( txf->kerning )
}


void txf_setGlyphCount( TexFont* txf, int n )
{
    if( txf->tgi )
        memFree( txf->tgi );
    txf->tgi   = (TexGlyphInfo*) memAlloc( sizeof(TexGlyphInfo) * n );
    txf->num_glyphs = n;
}


/**
  Build lookup table.
*/
void txf_buildTable( TexFont* txf )
{
    int min_glyph;
    int max_glyph;
    TexGlyphInfo* it;
    TexGlyphInfo* end;

    assert( txf->num_glyphs );

    // Find high & low glyph.
    min_glyph = txf->tgi[0].c;
    max_glyph = txf->tgi[0].c;

    it  = txf->tgi;
    end = it + txf->num_glyphs;

    while( it != end )
    {
        if( it->c < min_glyph )
            min_glyph = it->c;
        if( it->c > max_glyph )
            max_glyph = it->c;
        ++it;
    }

    txf->min_glyph  = min_glyph;
    txf->table_size = max_glyph - min_glyph + 1;

    // Allocate table.
    if( txf->table )
        memFree( txf->table );
    txf->table = (TexGlyphInfo**)
                 memAlloc( sizeof(TexGlyphInfo*) * txf->table_size );

    // Fill table.
    memSet( txf->table, 0, sizeof(TexGlyphInfo*) * txf->table_size );

    it = txf->tgi;
    while( it != end )
    {
        txf->table[ it->c - txf->min_glyph ] = it;
        ++it;
    }
}


/**
  Returns the TexGlyphInfo for a glyph or zero if it is not available.
  Automatically substitutes uppercase letters with lowercase if
  uppercase not available (and vice versa).
*/
TexGlyphInfo* txf_glyph( const TexFont* txf, int c )
{
    TexGlyphInfo* tgi;
    int max_glyph = txf->min_glyph + txf->table_size;

    if( (c >= txf->min_glyph) && (c < max_glyph) )
    {
        tgi = txf->table[c - txf->min_glyph];
        if( tgi )
            return tgi;

        if( (c >= 'a') && (c <= 'z') )
        {
            c -= 'a' - 'A';     // toupper

            if( (c >= txf->min_glyph) && (c < max_glyph) )
            {
                return txf->table[c - txf->min_glyph];
            }
        }
        else if( (c >= 'A') && (c <= 'Z') )
        {
            c += 'a' - 'A';     // tolower

            if( (c >= txf->min_glyph) && (c < max_glyph) )
            {
                return txf->table[c - txf->min_glyph];
            }
        }
    }

    return 0;
}


int txf_kerning( const TexFont* txf, const TexGlyphInfo* left,
                                     const TexGlyphInfo* right )
{
#ifdef KERN
    unsigned char* table; 
    if( left->kern_index > -1 )
    {
        table = txf->kerning + left->kern_index;
        while( *table )
        {
            /*
            // If table sorted...
            if( right->c < *table )
                break;
            */
            if( right->c == *table )
                return ((char*) table)[1];
            ++table;
        }
    }
#else
    (void) txf;
    (void) left;
    (void) right;
#endif
    return 0;
}


//----------------------------------------------------------------------------


#if DUMP
void dumpCharMaps( FT_Face face )
{
    FT_CharMap charmap;
    int n;

    printf( "  CharMaps %d [\n", face->num_charmaps );
    for( n = 0; n < face->num_charmaps; n++ )
    {
        long enc;
        charmap = face->charmaps[ n ];
        enc = charmap->encoding;
        printf( "    %lx (%c%c%c%c)\n", enc,
                 (char) ((enc >> 24) & 0xff),
                 (char) ((enc >> 16) & 0xff),
                 (char) ((enc >> 8) & 0xff),
                 (char) (enc & 0xff) );
    }
    printf( "  ]\n" );
}
#endif


void blitGlyphToBitmap( FT_Bitmap* src, FT_Bitmap* dst, int x, int y )
{
    unsigned char* s;
    unsigned char* d;
    unsigned char* dend;
    int r;

    s = src->buffer;
    d = dst->buffer + (y * dst->pitch) + x;
    dend = dst->buffer + (dst->rows * dst->pitch);

    r = src->rows;
    while( r && (d < dend) )
    {
        memcpy( d, s, src->width );
        s += src->pitch;
        d += dst->pitch;
        r--;
    }
}


static FT_Error renderGlyph( FT_Bitmap* img, FT_GlyphSlot glyph,
                             int x_offset, int y_offset, int antialias )
{
    /* first, render the glyph into an intermediate buffer */
    if( glyph->format != ft_glyph_format_bitmap )
    {
        FT_Error error = FT_Render_Glyph( glyph,
                antialias ? ft_render_mode_normal : ft_render_mode_mono );
        if( error )
            return error;
    }
 
#if 0
    printf( "\nKR target offset %dx%d\n", x_offset, y_offset );
    printf( "KR bitmap left/top %d %d\n", glyph->bitmap_left, glyph->bitmap_top );
    printf( "KR metrics %ldx%ld %ldx%ld %ld\n", 
            FT_PIXELS(glyph->metrics.width),
            FT_PIXELS(glyph->metrics.height),
            FT_PIXELS(glyph->metrics.horiBearingX),
            FT_PIXELS(glyph->metrics.horiBearingY),
            FT_PIXELS(glyph->metrics.horiAdvance) );
#endif
 
    // Then, blit the image to the target surface
    // Ajusting by bitmap_top to pretty up the vertical alignment.
    blitGlyphToBitmap( &glyph->bitmap, img,
                       x_offset /*+ glyph->bitmap_left*/,
                       y_offset - glyph->bitmap_top );

    return 0;
}


#ifdef KERN
/*
   Returns index into table or -1 if there is no kerning for left_glyph.
*/
static int loadKerning( OArray* table, FT_Face face, FT_UInt left_glyph,
                        const char* codes )
{
    FT_Vector kern;
    FT_UInt right_glyph;
    const char* ci;
    char* entry;
    int start = table->used;

    ci = codes;
    for( ci = codes; *ci != '\0'; ++ci )
    {
        right_glyph = FT_Get_Char_Index( face, *ci );
        if( right_glyph == 0 )
            continue;

        FT_Get_Kerning( face, left_glyph, right_glyph,
                        FT_KERNING_DEFAULT,
                        //FT_KERNING_UNFITTED, FT_KERNING_UNSCALED
                        &kern );
        if( kern.x || kern.y )
        {
          //printf(" %c %ld %ld\n", *ci, FT_PIXELS(kern.x), FT_PIXELS(kern.y));

            orArrayReserve( table, 1, table->used + 3 );
            entry = table->charArray + table->used;
            table->used += 2;

            // NOTE: kern.y is ignored since is it almost always zero.
            entry[0] = *ci;
            entry[1] = FT_PIXELS(kern.x);
        }
    }

    if( table->used > start )
    {
        // Terminate entries.
        table->charArray[ table->used ] = 0;
        ++table->used;

        return start;
    }

    return -1;
}
#endif


/**
  Returns number of glyphs added or zero if fails.
*/
int txf_build( TexFont* txf, const char* file,
               const char* codes, FT_Bitmap* img, int psize, int gap,
               int asBitmap )
{
    FT_Library library;
    FT_Face face;
    FT_Error error;
    FT_GlyphSlot glyph;
    FT_Size size;
    FT_F26Dot6 start_x;
    FT_F26Dot6 step_y;
    FT_F26Dot6 x, y;
#ifdef KERN
    OArray kern;
#endif
    const char* ci;
    int count = 0;
    int fail = 0;


    error = FT_Init_FreeType( &library );
    if( error )
    {
        return 0;
    }

    error = FT_New_Face( library, file, 0, &face );
    if( error )
    {
        return 0;
    }


#if DUMP
#define EM_PIX(n)   n,FT_PIXELS(n)
        printf( "FT_Face [\n" );
        printf( "  family_name:  \"%s\"\n", face->family_name );
        printf( "  style_name:   \"%s\"\n", face->style_name );
        printf( "  num_glyphs:   %ld\n",    face->num_glyphs );
        printf( "  units_per_EM: %d (%d)\n", EM_PIX(face->units_per_EM) );
        printf( "  ascender:     %d (%d)\n", EM_PIX(face->ascender) );
        printf( "  descender:    %d (%d)\n", EM_PIX(face->descender) );
        printf( "  height:       %d (%d)\n", EM_PIX(face->height) );
        dumpCharMaps( face );
        printf( "]\n" );
#endif


    error = FT_Set_Pixel_Sizes( face, psize, psize );
    if( error )
    {
        return 0;
    }

#ifdef KERN
    orArrayInit( &kern, 1, 0 );
#endif

    glyph = face->glyph;
    size  = face->size;


    txf_setGlyphCount( txf, face->num_glyphs );
    //txf.max_ascent  = size->metrics.y_ppem;
    txf->max_ascent  =  face->ascender  * psize / face->units_per_EM;
    txf->max_descent = -face->descender * psize / face->units_per_EM;


    /* Clear bitmap */
    memSet( img->buffer, 0, img->rows * img->pitch );


    step_y = size->metrics.y_ppem + gap;

    start_x = gap;
    x = start_x;
    y = step_y;

    ci = codes;
    for( ci = codes; *ci != '\0'; ++ci )
    {
        int glyph_index = FT_Get_Char_Index( face, *ci );
        if( glyph_index == 0 )
        {
            printf( "Code 0x%x (%c) is undefined\n", (int) *ci, (char) *ci );
            continue;
        }

        error = FT_Load_Glyph( face, glyph_index, FT_LOAD_DEFAULT );
        if( ! error )
        {
            TexGlyphInfo* tgi;
            int nextX = x + FT_PIXELS(glyph->metrics.width) + gap;

            if( nextX > img->width )
            {
                x  = start_x;
                y += step_y;

                //if( (y + step_y) >= img->rows )
                if( y >= img->rows )
                {
                    fprintf(stderr, "** Texture too small\n");
                    break;
                }

                nextX = x + FT_PIXELS(glyph->metrics.width) + gap;
            }

            renderGlyph( img, glyph, x, y, ! asBitmap );

            tgi = txf->tgi + count;
            count++;

            tgi->c       = *ci;
            tgi->width   = FT_PIXELS(glyph->metrics.width);
            tgi->height  = FT_PIXELS(glyph->metrics.height);
            tgi->xoffset = FT_PIXELS(glyph->metrics.horiBearingX);
            tgi->yoffset = FT_PIXELS(glyph->metrics.horiBearingY) - tgi->height;
            tgi->advance = FT_PIXELS(glyph->metrics.horiAdvance);
            tgi->x       = x /*+ tgi->xoffset*/;
            tgi->y       = img->rows - y + tgi->yoffset;
            tgi->kern_index = -1;

#ifdef KERN
            if( FT_HAS_KERNING( face ) )
            {
                //printf( "KR Kern %c\n", *ci );
                tgi->kern_index = loadKerning(&kern, face, glyph_index, codes);
            }
#endif

            x = nextX;
        }
        else
        {
            fail++;
        }
    }

    if( fail )
        printf( "Failed to load %d glyphs.\n", fail );

#ifdef KERN
    if( kern.used )
    {
        if( txf->kerning )
            memFree( txf->kerning );
        txf->kerning = memAlloc( kern.used );
        memCpy( txf->kerning, kern.charArray, kern.used );
    }
    orArrayFree( &kern );
#endif

    FT_Done_Face( face );
    FT_Done_FreeType( library );

    return count;
}


//----------------------------------------------------------------------------


static GLuint buildFontTexture( OImage* img )
{
    GLuint id;
    GLenum format;
    GLint  comp;

    switch( img->format )
    {
        case OR_IMG_GRAY:
            //format = GL_LUMINANCE;
            //comp   = 1;
            format = GL_LUMINANCE_ALPHA;
            comp   = GL_LUMINANCE_ALPHA;
            break;

        case OR_IMG_RGB:
            format = GL_RGB;
            comp   = 3;
            break;

        case OR_IMG_RGBA:
            format = GL_RGBA;
            comp   = 4;
            break;

        default:
            return 0;
    }

    glGenTextures( 1, &id );
    glBindTexture( GL_TEXTURE_2D, id );

    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
    glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );

    if( format == GL_LUMINANCE_ALPHA )
    {
        int i;
        int tsize = img->width * img->height;
        GLubyte* buf = (GLubyte*) memAlloc( 2 * tsize );
        GLubyte* src = (GLubyte*) (img + 1);
        GLubyte* dst = buf;

        for( i = 0; i < tsize; i++ )
        {
            *dst++ = *src;
            *dst++ = *src++;
        }

        glTexImage2D( GL_TEXTURE_2D, 0, comp, img->width, img->height, 0,
                      format, GL_UNSIGNED_BYTE, buf );

        memFree( buf );
    }
    else
    {
        glTexImage2D( GL_TEXTURE_2D, 0, comp, img->width, img->height, 0,
                      format, GL_UNSIGNED_BYTE, img + 1 );
    }


    glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );

    return id;
}


FontResource* createFont()
{
    FontResource* fr = memAlloc( sizeof(FontResource) );
    if( fr )
    {
        fr->res.resType = RES_TYPE_FONT;
        //fr->name    = 0;
        fr->imgHold = OR_INVALID_HOLD;
        fr->glTexId = 0;
        txf_init( &fr->tfont, 256, 256 );
    }
    return fr;
}


void destroyFont( Resource* res )
{
    FontResource* fr = (FontResource*) res;
    if( res )
    {
        //if( fr->name )
        //    memFree( fr->name );

        if( orHoldIsValid(fr->imgHold) )
            orRelease( fr->imgHold );

        if( fr->glTexId )
            glDeleteTextures( 1, &fr->glTexId );

        txf_free( &fr->tfont );

        memFree( res );
    }
}


#if 0
static char* intToStr00( char* cp, int n )
{
    int d;
    if( n > 99 )
    {
        d = n / 100;
        *cp++ = d + '0';
        n -= d * 100;
    }
    if( n > 9 )
    {
        d = n / 10;
        *cp++ = d + '0';
        n -= d * 10;
    }
    *cp++ = n + '0';
    return cp;
}
#endif


static char _default_codes[] = " ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyz?.;,!*:\"/+-|'@#$%^&<>()[]{}_";


#define REF_GLYPHS  a1 + 3
#define REF_CODES   a1 + 4
#define REF_DIM     a1 + 5
#define REF_SIZE    a1 + 6

/*
  make-texfont: native [
      name    [string! issue!]
      file    [file!]
      pntsize [integer!]
      /glyphs codes [string!]
      /dim    size  [integer! pair!]
  ]
*/
OR_NATIVE_PUB( makeTexfontNative )
{
    OValue* arg;
    OString* str;
    OBinary* bin;
    FT_Bitmap fbm;
    TexFont* tf;
    FontResource* res;
    int psize;
    const char* codes = _default_codes;


    res = createFont();
    tf  = &res->tfont;

    psize = orInt(a1 + 2);
    if( psize < 1 )
        psize = 20;
    else if( psize > 100 )
        psize = 100;

    arg = REF_GLYPHS;
    if( orRefineSet(arg) )
    {
        ++arg;
        str = orSTRING(arg);
        orTermCStr( str );
        codes = orStrChars( str, arg );
    }

    arg = REF_DIM;
    if( orRefineSet(arg) )
    {
        ++arg;
        if( arg->type == OT_INTEGER )
        {
            tf->tex_width  = orInt(arg);
            tf->tex_height = orInt(arg);
        }
        else
        {
            tf->tex_width  = arg->pair[0];
            tf->tex_height = arg->pair[1];
        }
    }

    bin = orMakeImage( OR_IMG_GRAY, tf->tex_width, tf->tex_height );
    if( bin->buf )
    {
        OValue* a2 = a1 + 1;
        char* ffile;

        res->imgHold = orHold( OT_BINARY, orBinaryN(bin) );

        str = orSTRING(a2);
        orTermCStr( str );
        ffile = orStrChars( str, a2 );

        fbm.width  = tf->tex_width;
        fbm.rows   = tf->tex_height;
        fbm.pitch  = fbm.width;
        fbm.buffer = (unsigned char*) orImagePixels(bin);

        tf->num_glyphs = txf_build( tf, ffile, codes, &fbm, psize, 1, 0 );
        if( tf->num_glyphs )
        {
            txf_buildTable( &res->tfont );

            res->glTexId = buildFontTexture( (OImage*) bin->buf );
#if 0
            {
            char* cp;
            int len;
            uint32_t key;
            len = (str->charArray + str->used) - ffile;
            res->name = cp = memAlloc( len + 6 );
            memCpy( res->name, ffile, len );
            cp += len;
            *cp++ = '.';
            cp = intToStr00( cp, psize );
            *cp = '\0';

            key = resd_hash( res->name, cp - res->name );
            resd_add( &gEnv.resd, &res->res, key );
            }
#else
            resd_add( &gEnv.resd, &res->res, gxHashString( a1 ) );
#endif

            gxResultRES( res )
            return;
        }
        else
        {
            orError( "No glyphs found in font" );
        }
    }

    destroyFont( &res->res );
}


/*EOF*/