Changeset 512 for trunk/thune/gl/TexFont.c

Timestamp:

02/16/08 17:53:55 (9 months ago)

Author:

krobillard

Message:

font! can now be made from a raster! & binary!.
Re-wrote TexFont? to simplify storage.
'to now works for custom datatypes.
Added .t
if/ now requires selector.
Can make vector! (int) from binary!
Can load PNG from binary!
Added FindThuneGL.cmake

Files:

• trunk/thune/gl/TexFont.c (modified) (14 diffs)

trunk/thune/gl/TexFont.c

@@ -21 +21 @@
 
 
-#define KERN      1
 //#define DUMP      1
 
-#define FT_PIXELS(x)  (x >> 6)
-
-
-#ifdef KERN
-typedef struct
-{
-    uint32_t avail;
-    uint32_t used;
-    char* ptr;
-}
-Array;
-
-
-static void arrayReserve( Array* arr, size_t nsize )
-{
-    if( nsize > arr->avail )
-    {
-        size_t count;
-
-        count = arr->avail * 2;
-        if( count < nsize )
-            count = (nsize < 8) ? 8 : nsize;
-
-        arr->ptr = (char*) realloc( arr->ptr, count );
-        assert( arr->ptr );
-    }
-}
-#endif
+#define FT_PIXELS(x)    (x >> 6)
+
+#define GLYPHS(tf)      ((TexGlyphInfo*) (tf + 1))
+#define TABLE(tf)       (((uint16_t*) tf) + tf->table_offset)
+#define KERN(tf)        (((int16_t*) tf) + tf->kern_offset)
 
 
 //----------------------------------------------------------------------------
-
-
-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) { free(n); n=0; }
-
-    FREE( txf->tgi )
-    FREE( txf->table )
-    FREE( txf->kerning )
-}
-
-
-void txf_setGlyphCount( TexFont* txf, int n )
-{
-    if( txf->tgi )
-        free( txf->tgi );
-    txf->tgi = (TexGlyphInfo*) malloc( sizeof(TexGlyphInfo) * n );
-    txf->num_glyphs = n;
-}
-
-
-/**
-  Build glyph lookup table.
-*/
-static void _buildGlyphTable( 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 )
-        free( txf->table );
-    txf->table = (TexGlyphInfo**)
-                 malloc( 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;
-    }
-}
 
 
@@ -140 +38 @@
   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;
+TexGlyphInfo* txf_glyph( const TexFont* tf, int c )
+{
+    uint16_t n;
+    uint16_t* table = TABLE(tf);
+    int min_glyph = tf->min_glyph;
+    int max_glyph = min_glyph + tf->table_size;
+
+    if( (c >= min_glyph) && (c < max_glyph) )
+    {
+        n = table[ c - min_glyph ];
+        if( n < 0xffff )
+            return GLYPHS(tf) + n;
 
         if( (c >= 'a') && (c <= 'z') )
         {
             c -= 'a' - 'A';     // toupper
-
-            if( (c >= txf->min_glyph) && (c < max_glyph) )
-            {
-                return txf->table[c - txf->min_glyph];
-            }
+            if( (c >= min_glyph) && (c < max_glyph) )
+                return GLYPHS(tf) + table[ c - 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];
-            }
-        }
-    }
-
+            if( (c >= min_glyph) && (c < max_glyph) )
+                return GLYPHS(tf) + table[ c - min_glyph ];
+        }
+    }
     return 0;
 }
 
 
-int txf_kerning( const TexFont* txf, const TexGlyphInfo* left,
-                                     const TexGlyphInfo* right )
-{
-#ifdef KERN
-    unsigned char* table; 
+int txf_kerning( const TexFont* tf, const TexGlyphInfo* left,
+                                    const TexGlyphInfo* right )
+{
+    const int16_t* table; 
     if( left->kern_index > -1 )
     {
-        table = txf->kerning + left->kern_index;
+        table = KERN(tf) + left->kern_index;
         while( *table )
         {
@@ -191 +83 @@
             */
             if( right->c == *table )
-                return ((char*) table)[1];
-            ++table;
-        }
-    }
-#else
-    (void) txf;
-    (void) left;
-    (void) right;
-#endif
+                return table[1];
+            table += 2;
+        }
+    }
     return 0;
 }
 
 
+static void swap16( uint16_t* it, uint16_t* end )
+{
+    uint8_t* bp;
+    while( it != end )
+    {
+        bp = (uint8_t*) it;
+        *it++ = (bp[0] << 8) | bp[1];
+    }
+}
+
+
+/**
+  Swap endianess of TexFont data if not native.
+*/
+void txf_swap( TexFont* tf )
+{
+    if( tf && (tf->glyph_offset == (sizeof(TexFont) << 8))  )
+    {
+        TexGlyphInfo* tgi;
+        TexGlyphInfo* end;
+        uint16_t* it;
+
+        it = &tf->glyph_offset;
+        swap16( it, it + (sizeof(TexFont) / sizeof(uint16_t)) );
+
+        tgi = GLYPHS(tf);
+        end = tgi + tf->glyph_count;
+        while( tgi != end )
+        {
+            it = &tgi->c;
+            swap16( it, it + 4 );
+            ++tgi;
+        }
+
+        it = TABLE(tf);
+        swap16( it, it + tf->table_size );
+
+        it = (uint16_t*) KERN(tf);
+        swap16( it, it + tf->kern_size );
+    }
+}
+
+
 //----------------------------------------------------------------------------
 
 
 #if DUMP
-void dumpCharMaps( FT_Face face )
+static void dumpCharMaps( FT_Face face )
 {
     FT_CharMap charmap;
@@ -230 +160 @@
 
 
-void blitGlyphToBitmap( FT_Bitmap* src, FT_Bitmap* dst, int x, int y )
+static void blitGlyphToBitmap( FT_Bitmap* src, FT_Bitmap* dst, int x, int y )
 {
     unsigned char* s;
@@ -285 +215 @@
 
 
-#ifdef KERN
 /*
    Returns index into table or -1 if there is no kerning for left_glyph.
 */
-static int _loadKerning( Array* table, FT_Face face, FT_UInt left_glyph,
+static int _loadKerning( TexFont* tf, int space,
+                         FT_Face face, FT_UInt left_glyph,
                          const char* codes )
 {
@@ -295 +225 @@
     FT_UInt right_glyph;
     const char* ci;
-    char* entry;
-    uint32_t start = table->used;
-
-    ci = codes;
+    int16_t* ktable = KERN(tf);
+    int16_t* entry;
+    uint32_t start = tf->kern_size;
+
     for( ci = codes; *ci != '\0'; ++ci )
     {
@@ -309 +239 @@
                         //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));
-
-            arrayReserve( table, table->used + 3 );
-            entry = table->ptr + table->used;
-            table->used += 2;
-
-            // NOTE: kern.y is ignored since is it almost always zero.
+
+        // NOTE: kern.y is ignored since is it almost always zero.
+        if( kern.x /*|| kern.y*/ )
+        {
+#ifdef DUMP
+            printf(" %c %ld %ld\n", *ci, FT_PIXELS(kern.x), FT_PIXELS(kern.y));
+#endif
+            if( space < 3 )
+            {
+                ktable[ tf->kern_size ] = 0;
+                fprintf( stderr, "txf_build: Kerning table full\n" );
+                return -1;
+            }
+
+            entry = ktable + tf->kern_size;
+            tf->kern_size += 2;
+            space -= 2;
+
             entry[0] = *ci;
             entry[1] = FT_PIXELS(kern.x);
@@ -323 +262 @@
     }
 
-    if( table->used > start )
+    if( tf->kern_size > start )
     {
         // Terminate entries.
-        table->ptr[ table->used ] = 0;
-        ++table->used;
-
+        ktable[ tf->kern_size ] = 0;
+        ++tf->kern_size;
         return start;
     }
@@ -334 +272 @@
     return -1;
 }
-#endif
 
 
 /**
-  Returns number of glyphs added or zero if fails.
+  Returns TexFont pointer or zero if fails.
 */
-int txf_build( TexFont* txf, const char* file,
-               const char* codes, FT_Bitmap* img, int psize, int gap,
-               int asBitmap )
+TexFont* txf_build( const char* file, const char* codes,
+                    FT_Bitmap* img, int psize, int gap, int antialias )
 {
     FT_Library library;
@@ -351 +287 @@
     FT_F26Dot6 start_x;
     FT_F26Dot6 step_y;
-    FT_F26Dot6 x, y;
-#ifdef KERN
-    Array kern;
-#endif
+    int x, y;
+    int nextX;
+    int glyph_index;
+    int gmin, gmax;
+    int ch;
+    int kern_space;
     const char* ci;
-    int count = 0;
+    uint16_t* table;
+    TexGlyphInfo* tgi;
+    TexFont* txf = 0;
+    int count;
     int loadFailed = 0;
 
@@ -362 +303 @@
     error = FT_Init_FreeType( &library );
     if( error )
-    {
         return 0;
-    }
 
     error = FT_New_Face( library, file, 0, &face );
     if( error )
-    {
-        return 0;
-    }
+        goto cleanup_lib;
 
 
 #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" );
+    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
 
@@ -390 +327 @@
     error = FT_Set_Pixel_Sizes( face, psize, psize );
     if( error )
-    {
-        return 0;
-    }
-
-#ifdef KERN
-    kern.ptr   = 0;
-    kern.avail = 0;
-    kern.used  = 0;
-#endif
+        goto cleanup;
 
     glyph = face->glyph;
@@ -404 +333 @@
 
 
-    txf_setGlyphCount( txf, face->num_glyphs );
+    // Count glyphs and find the high & low.
+    gmin = 0xffff;
+    gmax = 0;
+    ci = codes;
+    while( *ci )
+    {
+        ch = *ci++;
+        if( ch < gmin )
+            gmin = ch;
+        if( ch > gmax )
+            gmax = ch;
+    }
+    count = ci - codes;
+
+
+    // Most glyphs have no kerning adjustment, and those with it have only
+    // a handful (at least at small font sizes).
+    kern_space = count * 5;     // 5 = 2 glyphs + terminator
+
+    txf = (TexFont*) malloc(  sizeof(TexFont) +
+                             (sizeof(TexGlyphInfo) * count) +
+                             (sizeof(uint16_t) * (gmax - gmin + 1)) +
+                             (sizeof(int16_t) * kern_space) );
+
+    txf->glyph_offset = sizeof(TexFont);
+    txf->glyph_count  = count;
+    txf->table_offset = (txf->glyph_offset + (sizeof(TexGlyphInfo) * count))
+                            / sizeof(uint16_t);
+    txf->table_size   = gmax - gmin + 1;
+    txf->kern_offset  = txf->table_offset + txf->table_size;
+    txf->kern_size    = 0;
+
     //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 */
+    txf->min_glyph   = gmin;
+    txf->tex_width   = img->pitch;
+    txf->tex_height  = img->rows;
+
+    table = TABLE(txf);
+    memset( table, 0xff, sizeof(uint16_t) * txf->table_size );
+
+
+    // Clear bitmap.
     memset( img->buffer, 0, img->rows * img->pitch );
 
@@ -420 +387 @@
     y = step_y;
 
+    count = 0;
+    tgi = GLYPHS(txf);
     ci = codes;
-    for( ci = codes; *ci != '\0'; ++ci )
-    {
-        int glyph_index = FT_Get_Char_Index( face, *ci );
+    while( *ci )
+    {
+        ch = *ci++;
+
+        glyph_index = FT_Get_Char_Index( face, ch );
         if( glyph_index == 0 )
         {
-            printf( "Code 0x%x (%c) is undefined\n", (int) *ci, (char) *ci );
+            fprintf( stderr, "txf_build: Code 0x%x (%c) is undefined\n",
+                     ch, (char) ch );
             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 )
+        if( error )
+        {
+            ++loadFailed;
+            continue;
+        }
+
+        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 )
             {
-                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;
+                fprintf( stderr, "txf_build: Texture too small\n" );
+                break;
             }
 
-            _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;
+            nextX = x + FT_PIXELS(glyph->metrics.width) + gap;
+        }
+
+        _renderGlyph( img, glyph, x, y, antialias );
+
+        tgi->c       = ch;
+        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;
+
+#ifdef DUMP
+            printf( "Glyph %c %d,%d %d,%d %d %d,%d\n", ch,
+                    tgi->width, tgi->height,
+                    tgi->xoffset, tgi->yoffset,
+                    tgi->advance, tgi->x, tgi->y );
+#endif
+
+        table[ ch - txf->min_glyph ] = count++;
+
+        if( FT_HAS_KERNING( face ) )
+        {
+#ifdef DUMP
+            printf( "Kern %c\n", ch );
+#endif
+            tgi->kern_index = _loadKerning( txf,
+                                            kern_space - txf->kern_size,
+                                            face, glyph_index, codes );
+        }
+        else
+        {
             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
-        {
-            loadFailed++;
-        }
+        }
+
+        ++tgi;
+        x = nextX;
     }
 
     if( loadFailed )
-        fprintf( stderr, "Failed to load %d glyphs.\n", loadFailed );
-
-    if( count )
-    {
-        txf->num_glyphs = count;
-        _buildGlyphTable( txf );
-    }
-
-#ifdef KERN
-    if( kern.used )
-    {
-        if( txf->kerning )
-            free( txf->kerning );
-        txf->kerning = (uint8_t*) kern.ptr;
-        txf->kern_bytes = kern.used;
-    }
-    else
-    {
-        txf->kerning = 0;
-        txf->kern_bytes = 0;
-    }
-#endif
+        fprintf( stderr, "txf_build: Failed to load %d glyphs.\n", loadFailed );
+
+    txf->glyph_count = count;
+
+cleanup:
 
     FT_Done_Face( face );
+
+cleanup_lib:
+
     FT_Done_FreeType( library );
 
-    return count;
+    return txf;
 }