font.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_GLYPH_H
#include FT_MODULE_H
#include "linebreak.h"
#include "linebreakdef.h"
#include <wctype.h>
 
#include "naev.h"
 
#include "font.h"
 
#include "array.h"
#include "distance_field.h"
#include "log.h"
#include "ndata.h"
#include "ntracing.h"
#include "utf8.h"
 
#define MAX_EFFECT_RADIUS                                                      \
   4 
#define FONT_DISTANCE_FIELD_SIZE 55 
#define HASH_LUT_SIZE 512           
#define DEFAULT_TEXTURE_SIZE                                                   \
   1024             
#define MAX_ROWS 64 

static mat4       font_projection_mat; 
static FT_Library font_library = NULL; 
static FT_UInt
   prev_glyph_index; 
static int prev_glyph_ft_index; 

typedef struct glFontRow_s {
   int x; 
   int y; 
   int h; 
} glFontRow;

typedef struct glFontTex_s {
   GLuint    id;             
   glFontRow rows[MAX_ROWS]; 
} glFontTex;

typedef struct glFontGlyph_s {
   uint32_t codepoint; 
   GLfloat  adv_x;     
   GLfloat  m; 
   int      ft_index;  
   int      tex_index; 
   GLushort vbo_id;    
   int      next;      
} glFontGlyph;

typedef struct font_char_s {
   GLubyte *data;     
   GLfloat *dataf;    
   int      w;        
   int      h;        
   int      ft_index; 
   int      off_x;    
   int      off_y;    
   GLfloat  adv_x;    
   GLfloat  m;  
   int      tx; 
   int      ty; 
   int      tw; 
   int      th; 
} font_char_t;

typedef struct glFontFile_s {
   char    *name;     
   int      refcount; 
   FT_Byte *data;     
   size_t   datasize; 
} glFontFile;

typedef struct glFontStashFreetype_s {
   glFontFile *file; 
   FT_Face     face; 
} glFontStashFreetype;

typedef struct glFontStash_s {
   /* Core values (determine font). */
   char *fname; 
 
   /* Generated values. */
   GLint        magfilter;     
   GLint        minfilter;     
   int          h;             
   int          tw;            
   int          th;            
   glFontTex   *tex;           
   gl_vbo      *vbo_tex;       
   gl_vbo      *vbo_vert;      
   GLfloat     *vbo_tex_data;  
   GLshort     *vbo_vert_data; 
   int          nvbo;          
   int          mvbo;          
   glFontGlyph *glyphs;        
   int          lut[HASH_LUT_SIZE]; 
 
   /* Freetype stuff. */
   glFontStashFreetype *ft;
 
   int refcount; 
} glFontStash;

static glFontStash *avail_fonts =
   NULL; 
 
/* default font */
glFont gl_defFont;     
glFont gl_smallFont;   
glFont gl_defFontMono; 
 
/* Last used colour. */
static const glColour *font_lastCol =
   NULL; 
static int font_restoreLast = 0; 
 
/*
 * prototypes
 */
static int    gl_fontstashAddFallback( glFontStash *stsh, const char *fname,
                                       unsigned int h );
static size_t font_limitSize( glFontStash *stsh, int *width, const char *text,
                              const int max );
static const glColour *gl_fontGetColour( uint32_t ch );
static uint32_t        font_nextChar( const char *s, size_t *i );
/* Get unicode glyphs from cache. */
static glFontGlyph *gl_fontGetGlyph( glFontStash *stsh, uint32_t ch );
/* Render.
 * TODO this should be changed to be more like font-stash
 * (https://github.com/akrinke/Font-Stash) In particular, instead of writing
 * char by char, they should be batched up by textures and rendered when
 * gl_fontRenderEnd() is called, saving lots of opengl calls.
 */
static void gl_fontRenderStart( const glFontStash *stsh, double x, double y,
                                const glColour *c, double outlineR );
static void gl_fontRenderStartH( const glFontStash *stsh, const mat4 *H,
                                 const glColour *c, double outlineR );
static int  gl_fontRenderGlyph( glFontStash *stsh, uint32_t ch,
                                const glColour *c, int state );
static void gl_fontRenderEnd( void );
/* Fussy layout concerns. */
static void gl_fontKernStart( void );
static int  gl_fontKernGlyph( glFontStash *stsh, uint32_t ch,
                              glFontGlyph *glyph );
static void gl_fontstashftDestroy( glFontStashFreetype *ft );

static glFontStash *gl_fontGetStash( const glFont *font )
{
   return &avail_fonts[font->id];
}

static int gl_fontAddGlyphTex( glFontStash *stsh, font_char_t *ch,
                               glFontGlyph *glyph )
{
   int        n;
   glFontRow *gr, *lr;
   glFontTex *tex;
   GLfloat   *vbo_tex;
   GLshort   *vbo_vert;
   GLfloat    tx, ty, txw, tyh;
   GLfloat    fw, fh;
   GLshort    vx, vy, vw, vh;
   double     mx, my;
 
   /* Find free row. */
   tex = NULL;
   gr  = NULL;
   for ( int i = 0; i < array_size( stsh->tex ); i++ ) {
      for ( int j = 0; j < MAX_ROWS; j++ ) {
         glFontRow *r = &stsh->tex->rows[j];
         /* Not empty row and doesn't fit. */
         if ( ( r->h != 0 ) && ( r->h != ch->h ) )
            continue;
         if ( r->h == ch->h ) {
            /* Fits in current row, so use that. */
            if ( r->x + ch->w <= stsh->tw ) {
               tex = &stsh->tex[i];
               gr  = r;
               break;
            } else
               continue; /* Didn't fit so continue looking. */
         }
         if ( r->h != 0 )
            continue;
         /* First row. */
         if ( j == 0 ) {
            assert( ch->h <=
                    stsh->th ); /* Would be ridiculously large character... */
            r->h = ch->h;
            tex  = &stsh->tex[i];
            gr   = r;
            break;
         }
         /* See if height fits to create a new row. */
         lr = &stsh->tex->rows[j - 1];
         if ( lr->y + lr->h + ch->h <= stsh->th ) {
            r->h = ch->h;
            r->y = lr->y + lr->h;
            tex  = &stsh->tex[i];
            gr   = r;
         }
         break; /* Have to break here because either we added a new row or
                   texture is full. */
      }
      if ( gr != NULL )
         break;
   }
 
   /* Didn't fit so allocate new texture. */
   if ( gr == NULL ) {
      tex = &array_grow( &stsh->tex );
      memset( tex, 0, sizeof( glFontTex ) );
 
      /* Create new texture. */
      glGenTextures( 1, &tex->id );
      glBindTexture( GL_TEXTURE_2D, tex->id );
 
      /* Set a sane default minification and magnification filter. */
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, stsh->magfilter );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, stsh->minfilter );
 
      /* Clamp 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 );
 
      /* Initialize size. */
      glTexImage2D( GL_TEXTURE_2D, 0, GL_RED, stsh->tw, stsh->th, 0, GL_RED,
                    GL_UNSIGNED_BYTE, NULL );
 
      /* Check for errors. */
      gl_checkErr();
 
      /* Create a new entry at the beginning of the first row with our target
       * height. */
      gr    = &tex->rows[0];
      gr->h = ch->h;
   }
 
   /* Upload data. */
   glBindTexture( GL_TEXTURE_2D, tex->id );
   glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
   if ( ch->dataf != NULL )
      glTexSubImage2D( GL_TEXTURE_2D, 0, gr->x, gr->y, ch->w, ch->h, GL_RED,
                       GL_FLOAT, ch->dataf );
   else
      glTexSubImage2D( GL_TEXTURE_2D, 0, gr->x, gr->y, ch->w, ch->h, GL_RED,
                       GL_UNSIGNED_BYTE, ch->data );
   glPixelStorei( GL_UNPACK_ALIGNMENT, 4 );
 
   /* Check for error. */
   gl_checkErr();
 
   /* Update VBOs. */
   stsh->nvbo++;
   if ( stsh->nvbo > stsh->mvbo ) {
      stsh->mvbo *= 2;
      stsh->vbo_tex_data =
         realloc( stsh->vbo_tex_data, 8 * stsh->mvbo * sizeof( GLfloat ) );
      stsh->vbo_vert_data =
         realloc( stsh->vbo_vert_data, 8 * stsh->mvbo * sizeof( GLshort ) );
   }
   n        = 8 * stsh->nvbo;
   vbo_tex  = &stsh->vbo_tex_data[n - 8];
   vbo_vert = &stsh->vbo_vert_data[n - 8];
   /* We do something like the following for vertex coordinates.
    *
    *
    *  +----------------- top reference   \  <------- font->h
    *  |                                  |
    *  |                                  | --- off_y
    *  +----------------- glyph top       /
    *  |
    *  |
    *  +----------------- glyph bottom
    *  |
    *  v   y
    *
    *
    *  +----+------------->  x
    *  |    |
    *  |    glyph start
    *  |
    *  side reference
    *
    *  \----/
    *   off_x
    */
   /* Temporary variables. */
   fw  = (GLfloat)stsh->tw;
   fh  = (GLfloat)stsh->th;
   mx  = 1. / fw;
   my  = 1. / fh;
   tx  = (GLfloat)( gr->x + 1. ) / fw;
   ty  = (GLfloat)( gr->y + 1. ) / fh;
   txw = (GLfloat)( gr->x + ch->w - 1. ) / fw;
   tyh = (GLfloat)( gr->y + ch->h - 1. ) / fh;
   vx  = ch->off_x + mx;
   vy  = ch->off_y - ch->h + mx;
   vw  = ch->w - mx;
   vh  = ch->h - my;
   /* Texture coords. */
   vbo_tex[0] = tx; /* Top left. */
   vbo_tex[1] = ty;
   vbo_tex[2] = txw; /* Top right. */
   vbo_tex[3] = ty;
   vbo_tex[4] = tx; /* Bottom left. */
   vbo_tex[5] = tyh;
   vbo_tex[6] = txw; /* Bottom right. */
   vbo_tex[7] = tyh;
   /* Vertex coords. */
   vbo_vert[0] = vx; /* Top left. */
   vbo_vert[1] = vy + vh;
   vbo_vert[2] = vx + vw; /* Top right. */
   vbo_vert[3] = vy + vh;
   vbo_vert[4] = vx; /* Bottom left. */
   vbo_vert[5] = vy;
   vbo_vert[6] = vx + vw; /* Bottom right. */
   vbo_vert[7] = vy;
   /* Update vbos. */
   gl_vboData( stsh->vbo_tex, sizeof( GLfloat ) * n, stsh->vbo_tex_data );
   gl_vboData( stsh->vbo_vert, sizeof( GLshort ) * n, stsh->vbo_vert_data );
 
   /* Add space for the new character. */
   gr->x += ch->w;
 
   /* Save glyph data. */
   glyph->vbo_id    = ( n - 8 ) / 2;
   glyph->tex_index = tex - stsh->tex;
 
   /* Since the VBOs have possibly changed, we have to reset the data. */
   gl_vboActivateAttribOffset( stsh->vbo_vert, shaders.font.vertex, 0, 2,
                               GL_SHORT, 0 );
   gl_vboActivateAttribOffset( stsh->vbo_tex, shaders.font.tex_coord, 0, 2,
                               GL_FLOAT, 0 );
 
   return 0;
}

void gl_printRestoreClear( void )
{
   font_lastCol = NULL;
}

void gl_printRestoreLast( void )
{
   if ( font_lastCol != NULL )
      font_restoreLast = 1;
}

void gl_printRestoreInit( glFontRestore *restore )
{
   memset( restore, 0, sizeof( glFontRestore ) );
}

void gl_printRestore( const glFontRestore *restore )
{
   if ( restore->col != NULL ) {
      font_lastCol     = restore->col;
      font_restoreLast = 1;
   }
}

void gl_printStoreMax( glFontRestore *restore, const char *text, int max )
{
   const glColour *col = restore->col; /* Use whatever is there. */
   for ( int i = 0; ( text[i] != '\0' ) && ( i <= max ); i++ ) {
      /* Only want escape sequences. */
      if ( text[i] != FONT_COLOUR_CODE )
         continue;
 
      /* Get colour. */
      if ( ( i + 1 <= max ) && ( text[i + 1] != '\0' ) ) {
         col = gl_fontGetColour( text[i + 1] );
         i += 1;
      }
   }
 
   restore->col = col;
}

void gl_printStore( glFontRestore *restore, const char *text )
{
   gl_printStoreMax( restore, text, INT_MAX );
}

static size_t font_limitSize( glFontStash *stsh, int *width, const char *text,
                              const int max )
{
   GLfloat  n;
   size_t   i;
   uint32_t ch;
 
   /* Avoid segfaults. */
   if ( ( text == NULL ) || ( text[0] == '\0' ) )
      return 0;
 
   /* limit size */
   gl_fontKernStart();
   i = 0;
   n = 0.;
   while ( ( ch = u8_nextchar( text, &i ) ) ) {
      int adv_x;
 
      /* Ignore escape sequence. */
      if ( ch == FONT_COLOUR_CODE ) {
         if ( text[i] != '\0' )
            i++;
         continue;
      }
 
      /* Count length. */
      glFontGlyph *glyph = gl_fontGetGlyph( stsh, ch );
      adv_x              = gl_fontKernGlyph( stsh, ch, glyph ) + glyph->adv_x;
 
      /* See if enough room. */
      n += adv_x;
      if ( (int)round( n ) > max ) {
         u8_dec( text, &i );
         n -= adv_x; /* actual size */
         break;
      }
   }
 
   if ( width != NULL )
      ( *width ) = (int)round( n );
   return i;
}

void gl_printLineIteratorInit( glPrintLineIterator *iter, const glFont *ft_font,
                               const char *text, int width )
{
   memset( iter, 0, sizeof( glPrintLineIterator ) );
   iter->text    = text;
   iter->ft_font = ( ft_font == NULL ? &gl_defFont : ft_font );
   iter->width   = width;
}
 
typedef struct _linepos_t_ {
   size_t   i;  
   uint32_t ch; 
   GLfloat
      w; 
} _linepos_t;

int gl_printLineIteratorNext( glPrintLineIterator *iter )
{
   glFontStash *stsh = gl_fontGetStash( iter->ft_font );
   int          brk, can_break, can_fit, any_char_fit = 0, any_word_fit;
   size_t       char_end = iter->l_next;
   struct LineBreakContext lbc;
 
   if ( iter->dead )
      return 0;
 
   /* limit size per line */
   gl_fontKernStart();
 
   /* Initialize line break stuff. */
   iter->l_begin  = iter->l_next;
   iter->l_end    = iter->l_begin;
   _linepos_t pos = { .i = char_end, .w = 0. };
   pos.ch         = font_nextChar( iter->text, &char_end );
   lb_init_break_context( &lbc, pos.ch, gettext_getLanguage() );
 
   while ( pos.ch != '\0' ) {
      glFontGlyph *glyph = gl_fontGetGlyph( stsh, pos.ch );
      GLfloat      glyph_w =
         glyph == NULL ? 0
                            : gl_fontKernGlyph( stsh, pos.ch, glyph ) + glyph->adv_x;
      _linepos_t nextpos = { .i = char_end, .w = pos.w + glyph_w };
      nextpos.ch         = font_nextChar( iter->text, &char_end );
      brk                = lb_process_next_char( &lbc, nextpos.ch );
      can_break = ( brk == LINEBREAK_ALLOWBREAK && !iter->no_soft_breaks ) ||
                  brk == LINEBREAK_MUSTBREAK;
      can_fit      = ( iter->width >= (int)round( nextpos.w ) );
      any_word_fit = ( iter->l_end != iter->l_begin );
      /* Emergency situations: */
      can_break |= !can_fit && !any_word_fit;
      can_fit |= !any_char_fit;
 
      if ( can_break && iswspace( pos.ch ) ) {
         iter->l_width = (int)round( pos.w );
         /* IMPORTANT: when eating a space, we can't backtrack to a previous
          * position, because there might be a skipped font markup sequence in
          * between. */
         iter->l_end = iter->l_next = nextpos.i;
         u8_dec( iter->text, &iter->l_end );
      } else if ( can_break && can_fit ) {
         iter->l_width = (int)round( nextpos.w );
         iter->l_end = iter->l_next = nextpos.i;
      } else if ( !can_fit && !any_word_fit ) {
         iter->l_width = (int)round( pos.w );
         iter->l_end = iter->l_next = pos.i;
      }
 
      if ( !can_fit || brk == LINEBREAK_MUSTBREAK )
         return 1;
 
      any_char_fit = 1;
      pos          = nextpos;
   }
 
   /* Ran out of text. */
   iter->l_width = (int)round( pos.w );
   iter->l_end = iter->l_next = char_end;
   iter->dead                 = 1;
   return 1;
}

static uint32_t font_nextChar( const char *s, size_t *i )
{
   uint32_t ch = s[*i]; /* To be corrected: the character starting at byte *i.
                           Whether it's zero or not is already correct. */
   while ( ch != 0 ) {
      ch = u8_nextchar( s, i );
      if ( ch != FONT_COLOUR_CODE )
         return ch;
      ch = u8_nextchar( s, i ); /* Skip the operand and try again. */
      if ( ch == FONT_COLOUR_CODE )
         return ch; /* Doubled escape char represents the escape char itself. */
   }
   return 0;
}

void gl_printRaw( const glFont *ft_font, double x, double y, const glColour *c,
                  double outlineR, const char *text )
{
   int      s;
   size_t   i;
   uint32_t ch;
   NTracingZone( _ctx, 1 );
 
   if ( ft_font == NULL )
      ft_font = &gl_defFont;
   glFontStash *stsh = gl_fontGetStash( ft_font );
 
   /* Render it. */
   s = 0;
   i = 0;
   gl_fontRenderStart( stsh, x, y, c, outlineR );
   while ( ( ch = u8_nextchar( text, &i ) ) )
      s = gl_fontRenderGlyph( stsh, ch, c, s );
   gl_fontRenderEnd();
 
   NTracingZoneEnd( _ctx );
}

void gl_printRawH( const glFont *ft_font, const mat4 *H, const glColour *c,
                   const double outlineR, const char *text )
{
   int      s;
   size_t   i;
   uint32_t ch;
   NTracingZone( _ctx, 1 );
 
   if ( ft_font == NULL )
      ft_font = &gl_defFont;
   glFontStash *stsh = gl_fontGetStash( ft_font );
 
   /* Render it. */
   s = 0;
   i = 0;
   gl_fontRenderStartH( stsh, H, c, outlineR );
   while ( ( ch = u8_nextchar( text, &i ) ) )
      s = gl_fontRenderGlyph( stsh, ch, c, s );
   gl_fontRenderEnd();
 
   NTracingZoneEnd( _ctx );
}

void gl_printMarkerRaw( const glFont *ft_font, double x, double y,
                        const glColour *c, const char *text )
{
   gl_printRaw( ft_font, x, y, c, 1, text );
}

void gl_print( const glFont *ft_font, const double x, const double y,
               const glColour *c, const char *fmt, ... )
{
   if ( fmt == NULL )
      return;
 
   char    text[STRMAX_SHORT]; /* holds the string */
   va_list ap;
   va_start( ap, fmt );
   vsnprintf( text, sizeof( text ), fmt, ap );
   va_end( ap );
 
   gl_printRaw( ft_font, x, y, c, -1., text );
}

int gl_printMaxRaw( const glFont *ft_font, const int max, double x, double y,
                    const glColour *c, double outlineR, const char *text )
{
   int      s;
   size_t   ret, i;
   uint32_t ch;
   NTracingZone( _ctx, 1 );
 
   if ( ft_font == NULL )
      ft_font = &gl_defFont;
   glFontStash *stsh = gl_fontGetStash( ft_font );
 
   /* Limit size. */
   ret = font_limitSize( stsh, NULL, text, max );
 
   /* Render it. */
   s = 0;
   gl_fontRenderStart( stsh, x, y, c, outlineR );
   i = 0;
   while ( ( ch = u8_nextchar( text, &i ) ) && ( i <= ret ) )
      s = gl_fontRenderGlyph( stsh, ch, c, s );
   gl_fontRenderEnd();
 
   NTracingZoneEnd( _ctx );
   return ret;
}

int gl_printMax( const glFont *ft_font, const int max, double x, double y,
                 const glColour *c, const char *fmt, ... )
{
   if ( fmt == NULL )
      return -1;
 
   char    text[STRMAX_SHORT]; /* holds the string */
   va_list ap;
   va_start( ap, fmt );
   vsnprintf( text, sizeof( text ), fmt, ap );
   va_end( ap );
 
   return gl_printMaxRaw( ft_font, max, x, y, c, -1., text );
}

int gl_printMidRaw( const glFont *ft_font, int width, double x, double y,
                    const glColour *c, double outlineR, const char *text )
{
   int      n, s;
   size_t   ret, i;
   uint32_t ch;
   NTracingZone( _ctx, 1 );
 
   if ( ft_font == NULL )
      ft_font = &gl_defFont;
   glFontStash *stsh = gl_fontGetStash( ft_font );
 
   /* limit size */
   n   = 0;
   ret = font_limitSize( stsh, &n, text, width );
   x += (double)( width - n ) / 2.;
 
   /* Render it. */
   s = 0;
   gl_fontRenderStart( stsh, x, y, c, outlineR );
   i = 0;
   while ( ( ch = u8_nextchar( text, &i ) ) && ( i <= ret ) )
      s = gl_fontRenderGlyph( stsh, ch, c, s );
   gl_fontRenderEnd();
 
   NTracingZoneEnd( _ctx );
   return ret;
}

int gl_printMid( const glFont *ft_font, const int width, double x, double y,
                 const glColour *c, const char *fmt, ... )
{
   if ( fmt == NULL )
      return -1;
 
   char    text[STRMAX_SHORT]; /* holds the string */
   va_list ap;
   va_start( ap, fmt );
   vsnprintf( text, sizeof( text ), fmt, ap );
   va_end( ap );
 
   return gl_printMidRaw( ft_font, width, x, y, c, -1., text );
}

int gl_printTextRaw( const glFont *ft_font, const int width, const int height,
                     double bx, double by, int line_height, const glColour *c,
                     double outlineR, const char *text )
{
   glPrintLineIterator iter;
   int                 s;
   double              x, y;
   uint32_t            ch;
   NTracingZone( _ctx, 1 );
 
   if ( ft_font == NULL )
      ft_font = &gl_defFont;
   glFontStash *stsh = gl_fontGetStash( ft_font );
 
   x = bx;
   y = by + height - (double)ft_font->h; /* y is top left corner */
 
   /* Default to 1.5 line height. */
   if ( line_height == 0 )
      line_height = 1.5 * (double)ft_font->h;
 
   /* Clears restoration. */
   gl_printRestoreClear();
 
   s = 0;
   gl_printLineIteratorInit( &iter, ft_font, text, width );
   while ( ( y - by > -DOUBLE_TOL ) && gl_printLineIteratorNext( &iter ) ) {
      /* Must restore stuff. */
      gl_printRestoreLast();
 
      /* Render it. */
      gl_fontRenderStart( stsh, x, y, c, outlineR );
      for ( size_t i = iter.l_begin; i < iter.l_end; ) {
         ch = u8_nextchar( text, &i );
         s  = gl_fontRenderGlyph( stsh, ch, c, s );
      }
      gl_fontRenderEnd();
 
      y -= line_height; /* move position down */
   }
 
   NTracingZoneEnd( _ctx );
   return 0;
}

int gl_printText( const glFont *ft_font, const int width, const int height,
                  double bx, double by, int line_height, const glColour *c,
                  const char *fmt, ... )
{
   char text[STRMAX]; /* holds the string */
 
   if ( fmt == NULL )
      return -1;
   else { /* convert the symbols to text */
      va_list ap;
      va_start( ap, fmt );
      vsnprintf( text, sizeof( text ), fmt, ap );
      va_end( ap );
   }
 
   return gl_printTextRaw( ft_font, width, height, bx, by, line_height, c, -1.,
                           text );
}

int gl_printWidthRaw( const glFont *ft_font, const char *text )
{
   GLfloat  n, nmax;
   size_t   i;
   uint32_t ch;
   NTracingZone( _ctx, 1 );
 
   if ( ft_font == NULL )
      ft_font = &gl_defFont;
   glFontStash *stsh = gl_fontGetStash( ft_font );
 
   gl_fontKernStart();
   nmax = n = 0.;
   i        = 0;
   while ( ( ch = font_nextChar( text, &i ) ) ) {
      /* Newline. */
      if ( ch == '\n' ) {
         gl_fontKernStart();
         nmax = MAX( nmax, n );
         n    = 0.;
         continue;
      }
 
      /* Increment width. */
      glFontGlyph *glyph = gl_fontGetGlyph( stsh, ch );
      n += gl_fontKernGlyph( stsh, ch, glyph ) + glyph->adv_x;
   }
   nmax = MAX( nmax, n );
 
   NTracingZoneEnd( _ctx );
   return (int)round( nmax );
}

int gl_printWidth( const glFont *ft_font, const char *fmt, ... )
{
   if ( fmt == NULL )
      return 0;
 
   char    text[STRMAX_SHORT]; /* holds the string */
   va_list ap;
   va_start( ap, fmt );
   vsnprintf( text, sizeof( text ), fmt, ap );
   va_end( ap );
 
   return gl_printWidthRaw( ft_font, text );
}

int gl_printHeightRaw( const glFont *ft_font, const int width,
                       const char *text )
{
   glPrintLineIterator iter;
   int                 line_height;
   double              y = 0.;
 
   /* Check 0 length strings. */
   if ( text[0] == '\0' )
      return 0;
 
   if ( ft_font == NULL )
      ft_font = &gl_defFont;
 
   line_height = 1.5 * (double)ft_font->h;
   gl_printLineIteratorInit( &iter, ft_font, text, width );
   while ( gl_printLineIteratorNext( &iter ) )
      y += line_height;
 
   return (int)y - line_height + ft_font->h + 1;
}

int gl_printHeight( const glFont *ft_font, const int width, const char *fmt,
                    ... )
{
   if ( fmt == NULL )
      return -1;
 
   char    text[STRMAX_SHORT]; /* holds the string */
   va_list ap;
   va_start( ap, fmt );
   vsnprintf( text, sizeof( text ), fmt, ap );
   va_end( ap );
 
   return gl_printHeightRaw( ft_font, width, text );
}

int gl_printEndRaw( int *xo, int *yo, const glFont *ft_font, int width,
                    const char *text )
{
   glPrintLineIterator iter;
   int                 s;
   double              x, y;
   uint32_t            ch;
   NTracingZone( _ctx, 1 );
 
   if ( ft_font == NULL )
      ft_font = &gl_defFont;
   glFontStash *stsh = gl_fontGetStash( ft_font );
 
   /* Default to 1.5 line height. */
   int line_height = 1.5 * (double)ft_font->h;
   y               = -line_height;
 
   /* Clears restoration. */
   gl_printRestoreClear();
 
   x = 0;
   s = 0;
   gl_printLineIteratorInit( &iter, ft_font, text, width );
   while ( gl_printLineIteratorNext( &iter ) ) {
      /* Must restore stuff. */
      gl_printRestoreLast();
 
      /* Start counting. */
      x = 0;
      gl_fontKernStart();
      for ( size_t i = iter.l_begin; i < iter.l_end; ) {
         ch = u8_nextchar( text, &i );
 
         /* Handle escape sequences. */
         if ( ( ch == FONT_COLOUR_CODE ) && ( s == 0 ) ) { /* Start sequence. */
            s = 1;
            continue;
         }
         if ( ( s == 1 ) && ( ch != FONT_COLOUR_CODE ) ) {
            font_lastCol = gl_fontGetColour( ch ); /* Need non-NULL value. */
            s            = 0;
            continue;
         }
 
         glFontGlyph *glyph      = gl_fontGetGlyph( stsh, ch );
         int          kern_adv_x = gl_fontKernGlyph( stsh, ch, glyph );
 
         x += glyph->adv_x + kern_adv_x;
      }
 
      y += line_height; /* move position down */
   }
 
   *xo = round( x );
   *yo = round( MAX( y, 0 ) );
 
   NTracingZoneEnd( _ctx );
   return 0;
}

PRINTF_FORMAT( 5, 6 )
int gl_printEnd( int *x, int *y, const glFont *ft_font, int width,
                 const char *fmt, ... )
{
   if ( fmt == NULL )
      return -1;
 
   char    text[STRMAX_SHORT]; /* holds the string */
   va_list ap;
   va_start( ap, fmt );
   vsnprintf( text, sizeof( text ), fmt, ap );
   va_end( ap );
 
   return gl_printEndRaw( x, y, ft_font, width, text );
}

int gl_printLinesRaw( const glFont *ft_font, const int width, const char *text )
{
   glPrintLineIterator iter;
   int                 n = 0;
 
   /* Check 0 length strings. */
   if ( text[0] == '\0' )
      return 0;
 
   if ( ft_font == NULL )
      ft_font = &gl_defFont;
 
   gl_printLineIteratorInit( &iter, ft_font, text, width );
   while ( gl_printLineIteratorNext( &iter ) )
      n++;
 
   return n;
}

int gl_printLines( const glFont *ft_font, const int width, const char *fmt,
                   ... )
{
   if ( fmt == NULL )
      return -1;
 
   char    text[STRMAX_SHORT]; /* holds the string */
   va_list ap;
   va_start( ap, fmt );
   vsnprintf( text, sizeof( text ), fmt, ap );
   va_end( ap );
 
   return gl_printLinesRaw( ft_font, width, text );
}
 
/*
 *
 * G L _ F O N T
 *
 */
static int font_makeChar( glFontStash *stsh, font_char_t *c, uint32_t ch )
{
   int len = array_size( stsh->ft );
   for ( int i = 0; i < len; i++ ) {
      FT_UInt              glyph_index;
      int                  w, h, rw, rh, b;
      double               vmax;
      FT_Bitmap            bitmap;
      FT_GlyphSlot         slot;
      glFontStashFreetype *ft = &stsh->ft[i];
 
      /* Get glyph index. */
      glyph_index = FT_Get_Char_Index( ft->face, ch );
      /* Skip missing unless last font. */
      if ( glyph_index == 0 ) {
         if ( i < len - 1 )
            continue;
         else {
            WARN( _( "Font '%s' unicode character '%#x' not found in font! "
                     "Using missing glyph." ),
                  ft->file->name, ch );
            ft = &stsh->ft[0]; /* Fallback to first font. */
         }
      }
 
      /* Load the glyph. */
      if ( FT_Load_Glyph( ft->face, glyph_index,
                          FT_LOAD_RENDER | FT_LOAD_NO_BITMAP |
                             FT_LOAD_TARGET_NORMAL ) ) {
         WARN( _( "FT_Load_Glyph failed." ) );
         return -1;
      }
 
      slot   = ft->face->glyph; /* Small shortcut. */
      bitmap = slot->bitmap;    /* to simplify */
      if ( bitmap.pixel_mode != FT_PIXEL_MODE_GRAY )
         WARN( _( "Font '%s' not using FT_PIXEL_MODE_GRAY!" ), ft->file->name );
 
      w = bitmap.width;
      h = bitmap.rows;
 
      /* Store data. */
      c->data  = NULL;
      c->dataf = NULL;
      if ( bitmap.buffer == NULL ) {
         /* Space characters tend to have no buffer. */
         b       = 0;
         rw      = w;
         rh      = h;
         c->data = malloc( sizeof( GLubyte ) * w * h );
         memset( c->data, 0, sizeof( GLubyte ) * w * h );
         vmax = 1.0; /* arbitrary */
      } else {
         GLubyte *buffer;
         /* Create a larger image using an extra border and center glyph. */
         b = 1 + ( ( MAX_EFFECT_RADIUS + 1 ) * FONT_DISTANCE_FIELD_SIZE - 1 ) /
                    stsh->h;
         rw     = w + b * 2;
         rh     = h + b * 2;
         buffer = calloc( rw * rh, sizeof( GLubyte ) );
         for ( int v = 0; v < h; v++ )
            for ( int u = 0; u < w; u++ )
               buffer[( b + v ) * rw + ( b + u )] = bitmap.buffer[v * w + u];
         /* Compute signed fdistance field with buffered glyph. */
         c->dataf = make_distance_mapbf( buffer, rw, rh, &vmax );
         free( buffer );
      }
      c->w        = rw;
      c->h        = rh;
      c->m        = ( 2. * vmax * stsh->h ) / FONT_DISTANCE_FIELD_SIZE;
      c->off_x    = slot->bitmap_left - b;
      c->off_y    = slot->bitmap_top + b;
      c->adv_x    = (GLfloat)slot->metrics.horiAdvance / 64.;
      c->ft_index = i;
 
      return 0;
   }
   WARN( _( "Unable to load character '%#x'!" ), ch );
   return -1;
}

static void gl_fontRenderStart( const glFontStash *stsh, double x, double y,
                                const glColour *c, double outlineR )
{
   /* OpenGL has pixel centers at 0.5 offset. */
   mat4 H = gl_view_matrix;
   mat4_translate_xy( &H, x + 0.5 * gl_screen.wscale,
                      y + 0.5 * gl_screen.hscale );
   gl_fontRenderStartH( stsh, &H, c, outlineR );
}
static void gl_fontRenderStartH( const glFontStash *stsh, const mat4 *H,
                                 const glColour *c, double outlineR )
{
   double          a, scale;
   const glColour *col;
 
   outlineR = ( outlineR == -1 ) ? 1 : MAX( outlineR, 0 );
 
   /* Handle colour. */
   a = ( c == NULL ) ? 1. : c->a;
   if ( font_restoreLast )
      col = ( font_lastCol == NULL ) ? &cWhite : font_lastCol;
   else if ( c == NULL )
      col = &cWhite;
   else
      col = c;
 
   glUseProgram( shaders.font.program );
   gl_uniformAColour( shaders.font.colour, col, a );
   if ( outlineR == 0. )
      gl_uniformAColour( shaders.font.outline_colour, col, 0. );
   else
      gl_uniformAColour( shaders.font.outline_colour, &cGrey10, a );
 
   scale               = (double)stsh->h / FONT_DISTANCE_FIELD_SIZE;
   font_projection_mat = *H;
   mat4_scale( &font_projection_mat, scale, scale, 1 );
 
   font_restoreLast = 0;
   gl_fontKernStart();
 
   /* Activate the appropriate VBOs. */
   glEnableVertexAttribArray( shaders.font.vertex );
   gl_vboActivateAttribOffset( stsh->vbo_vert, shaders.font.vertex, 0, 2,
                               GL_SHORT, 0 );
   glEnableVertexAttribArray( shaders.font.tex_coord );
   gl_vboActivateAttribOffset( stsh->vbo_tex, shaders.font.tex_coord, 0, 2,
                               GL_FLOAT, 0 );
 
   /* Depth testing is used to draw the outline under the glyph. */
   if ( outlineR > 0. )
      glEnable( GL_DEPTH_TEST );
}

static const glColour *gl_fontGetColour( uint32_t ch )
{
   const glColour *col;
   switch ( ch ) {
   /* TOP SECRET COLOUR CONVENTION
    * FOR YOUR EYES ONLY
    *
    * Lowercase characters represent base colours.
    * Uppercase characters reperesent fancy game related colours.
    * Digits represent states.
    */
   /* Colours. */
   case 'r':
      col = &cFontRed;
      break;
   case 'g':
      col = &cFontGreen;
      break;
   case 'b':
      col = &cFontBlue;
      break;
   case 'o':
      col = &cFontOrange;
      break;
   case 'y':
      col = &cFontYellow;
      break;
   case 'w':
      col = &cFontWhite;
      break;
   case 'p':
      col = &cFontPurple;
      break;
   case 'n':
      col = &cFontGrey;
      break;
   /* Fancy states. */
   case 'F':
      col = &cFriend;
      break; 
   case 'H':
      col = &cHostile;
      break; 
   case 'N':
      col = &cNeutral;
      break; 
   case 'I':
      col = &cInert;
      break; 
   case 'R':
      col = &cRestricted;
      break; 
   case 'C':
      col = &cFontGreen;
      break; 
   case '0':
      col = NULL;
      break;
   default:
      WARN( "Unknown font escape code '%c'", ch );
      col = NULL;
      break;
   }
   return col;
}

static uint32_t hashint( uint32_t a )
{
   a += ~( a << 15 );
   a ^= ( a >> 10 );
   a += ( a << 3 );
   a ^= ( a >> 6 );
   a += ~( a << 11 );
   a ^= ( a >> 16 );
   return a;
}

static glFontGlyph *gl_fontGetGlyph( glFontStash *stsh, uint32_t ch )
{
   int          i;
   unsigned int h;
 
   /* Use hash table and linked lists to find the glyph. */
   h = hashint( ch ) & ( HASH_LUT_SIZE - 1 );
   i = stsh->lut[h];
   while ( i != -1 ) {
      if ( stsh->glyphs[i].codepoint == ch )
         return &stsh->glyphs[i];
      i = stsh->glyphs[i].next;
   }
 
   /* Glyph not found, have to generate. */
   glFontGlyph *glyph;
   font_char_t  ft_char;
   int          idx;
 
   /* Load data from freetype. */
   if ( font_makeChar( stsh, &ft_char, ch ) )
      return NULL;
 
   /* Create new character. */
   glyph            = &array_grow( &stsh->glyphs );
   glyph->codepoint = ch;
   glyph->adv_x     = ft_char.adv_x;
   glyph->m         = ft_char.m;
   glyph->ft_index  = ft_char.ft_index;
   glyph->next      = -1;
   idx              = glyph - stsh->glyphs;
 
   /* Insert in linked list. */
   i = stsh->lut[h];
   if ( i == -1 ) {
      stsh->lut[h] = idx;
   } else {
      while ( i != -1 ) {
         if ( stsh->glyphs[i].next == -1 ) {
            stsh->glyphs[i].next = idx;
            break;
         }
         i = stsh->glyphs[i].next;
      }
   }
 
   /* Find empty texture and render char. */
   gl_fontAddGlyphTex( stsh, &ft_char, glyph );
 
   free( ft_char.data );
   free( ft_char.dataf );
 
   return glyph;
}

static void gl_fontKernStart( void )
{
   prev_glyph_index = 0;
}

static int gl_fontKernGlyph( glFontStash *stsh, uint32_t ch,
                             glFontGlyph *glyph )
{
   FT_Face ft_face;
   FT_UInt ft_glyph_index;
   int     kern_adv_x = 0;
 
   ft_face        = stsh->ft[glyph->ft_index].face;
   ft_glyph_index = FT_Get_Char_Index( ft_face, ch );
   if ( prev_glyph_index && prev_glyph_ft_index == glyph->ft_index ) {
      FT_Vector kerning;
      FT_Get_Kerning( ft_face, prev_glyph_index, ft_glyph_index,
                      FT_KERNING_DEFAULT, &kerning );
      kern_adv_x = kerning.x / 64;
   }
   prev_glyph_index    = ft_glyph_index;
   prev_glyph_ft_index = glyph->ft_index;
   return kern_adv_x;
}

static int gl_fontRenderGlyph( glFontStash *stsh, uint32_t ch,
                               const glColour *c, int state )
{
   double       scale;
   int          kern_adv_x;
   glFontGlyph *glyph;
 
   /* Handle escape sequences. */
   if ( ( ch == FONT_COLOUR_CODE ) && ( state == 0 ) ) { /* Start sequence. */
      return 1;
   }
   if ( ( state == 1 ) && ( ch != FONT_COLOUR_CODE ) ) {
      const glColour *col = gl_fontGetColour( ch );
      double          a   = ( c == NULL ) ? 1. : c->a;
      if ( col != NULL )
         gl_uniformAColour( shaders.font.colour, col, a );
      else if ( c == NULL )
         gl_uniformColour( shaders.font.colour, &cWhite );
      else
         gl_uniformColour( shaders.font.colour, c );
      font_lastCol = col;
      return 0;
   }
 
   /* Unicode goes here.
    * First try to find the glyph. */
   glyph = gl_fontGetGlyph( stsh, ch );
   if ( glyph == NULL ) {
      WARN( _( "Unable to find glyph '%d'!" ), ch );
      return -1;
   }
 
   /* Kern if possible. */
   scale      = (double)stsh->h / FONT_DISTANCE_FIELD_SIZE;
   kern_adv_x = gl_fontKernGlyph( stsh, ch, glyph );
   if ( kern_adv_x )
      mat4_translate_x( &font_projection_mat, kern_adv_x / scale );
 
   /* Activate texture. */
   glBindTexture( GL_TEXTURE_2D, stsh->tex[glyph->tex_index].id );
 
   glUniform1f( shaders.font.m, glyph->m );
   gl_uniformMat4( shaders.font.projection, &font_projection_mat );
 
   /* Draw the element. */
   glDrawArrays( GL_TRIANGLE_STRIP, glyph->vbo_id, 4 );
 
   /* Translate matrix. */
   mat4_translate_x( &font_projection_mat, glyph->adv_x / scale );
 
   return 0;
}

static void gl_fontRenderEnd( void )
{
   glDisableVertexAttribArray( shaders.font.vertex );
   glDisableVertexAttribArray( shaders.font.tex_coord );
   glUseProgram( 0 );
 
   glDisable( GL_DEPTH_TEST );
 
   /* Check for errors. */
   gl_checkErr();
}

void gl_fontSetFilter( const glFont *ft_font, GLint min, GLint mag )
{
   glFontStash *stsh = gl_fontGetStash( ft_font );
   stsh->minfilter   = min;
   stsh->magfilter   = mag;
 
   for ( int i = 0; i < array_size( stsh->tex ); i++ ) {
      glBindTexture( GL_TEXTURE_2D, stsh->tex[i].id );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, stsh->magfilter );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, stsh->minfilter );
   }
 
   gl_checkErr();
}

int gl_fontInit( glFont *font, const char *fname, const unsigned int h,
                 const char *prefix, unsigned int flags )
{
   size_t       len, plen;
   glFontStash *stsh, *reusable_stsh_slot;
   int          ch;
   char         fullname[PATH_MAX];
 
   /* Initialize FreeType. */
   if ( font_library == NULL ) {
      if ( FT_Init_FreeType( &font_library ) ) {
         WARN( _( "FT_Init_FreeType failed with font %s." ), fname );
         return -1;
      }
   }
 
   /* Replace name if NULL. */
   if ( fname == NULL )
      fname = FONT_DEFAULT_PATH;
 
   /* Get font stash. */
   if ( avail_fonts == NULL )
      avail_fonts = array_create( glFontStash );
 
   /* Check if available. */
   reusable_stsh_slot = NULL;
   if ( !( flags & FONT_FLAG_DONTREUSE ) ) {
      for ( int i = 0; i < array_size( avail_fonts ); i++ ) {
         stsh = &avail_fonts[i];
         if ( stsh->fname == NULL ) {
            /* This glFontStash must have been zeroed by gl_freeFont after its
             * refcount dropped to zero. */
            reusable_stsh_slot = stsh;
            continue;
         }
         if ( strcmp( stsh->fname, fname ) != 0 || stsh->h != (int)h )
            continue;
         /* Found a match! */
         stsh->refcount++;
         font->id = stsh - avail_fonts;
         font->h  = h;
         return 0;
      }
   }
 
   /* Create new font. */
   if ( reusable_stsh_slot != NULL )
      stsh = reusable_stsh_slot;
   else
      stsh = &array_grow( &avail_fonts );
   memset( stsh, 0, sizeof( glFontStash ) );
   stsh->refcount = 1; /* Initialize refcount. */
   stsh->fname    = strdup( fname );
   font->id       = stsh - avail_fonts;
   font->h        = h;
 
   /* Default stuff. */
   stsh->magfilter = GL_LINEAR;
   stsh->minfilter = GL_LINEAR;
   stsh->tw        = DEFAULT_TEXTURE_SIZE;
   stsh->th        = DEFAULT_TEXTURE_SIZE;
   stsh->h         = h;
 
   /* Set up font stuff for next glyphs. */
   stsh->ft = array_create( glFontStashFreetype );
   ch       = 0;
   len      = strlen( fname );
   plen     = strlen( prefix );
   for ( size_t i = 0; i <= len; i++ ) {
      if ( ( fname[i] == '\0' ) || ( fname[i] == ',' ) ) {
         strncpy( fullname, prefix, sizeof( fullname ) - 1 );
         strncat( fullname, &fname[ch],
                  MIN( sizeof( fullname ) - 1 - plen, i - ch ) );
         gl_fontstashAddFallback( stsh, fullname, h );
         ch = i;
         if ( fname[i] == ',' )
            ch++;
      }
   }
 
   /* Initialize the unicode support. */
   for ( int i = 0; i < HASH_LUT_SIZE; i++ )
      stsh->lut[i] = -1;
   stsh->glyphs = array_create( glFontGlyph );
   stsh->tex    = array_create( glFontTex );
 
   /* Set up VBOs. */
   stsh->mvbo          = 256;
   stsh->vbo_tex_data  = calloc( 8 * stsh->mvbo, sizeof( GLfloat ) );
   stsh->vbo_vert_data = calloc( 8 * stsh->mvbo, sizeof( GLshort ) );
   stsh->vbo_tex       = gl_vboCreateStatic( sizeof( GLfloat ) * 8 * stsh->mvbo,
                                             stsh->vbo_tex_data );
   stsh->vbo_vert      = gl_vboCreateStatic( sizeof( GLshort ) * 8 * stsh->mvbo,
                                             stsh->vbo_vert_data );
 
   return 0;
}

int gl_fontAddFallback( glFont *font, const char *fname, const char *prefix )
{
   size_t       len, plen;
   int          ch, ret;
   glFontStash *stsh = gl_fontGetStash( font );
 
   ret  = 0;
   ch   = 0;
   len  = strlen( fname );
   plen = strlen( prefix );
   for ( size_t i = 0; i <= len; i++ ) {
      if ( ( fname[i] == '\0' ) || ( fname[i] == ',' ) ) {
         char fullname[PATH_MAX];
         strncpy( fullname, prefix, sizeof( fullname ) - 1 );
         strncat( fullname, &fname[ch],
                  MIN( sizeof( fullname ) - 1 - plen, i - ch ) );
         ret |= gl_fontstashAddFallback( stsh, fullname, font->h );
         ch = i;
         if ( fname[i] == ',' )
            ch++;
      }
   }
 
   return ret;
}

static int gl_fontstashAddFallback( glFontStash *stsh, const char *fname,
                                    unsigned int h )
{
   glFontStashFreetype ft = { .file = NULL, .face = NULL };
 
   /* Set up file data. Reference a loaded copy if we have one. */
   for ( int i = 0; i < array_size( avail_fonts ); i++ ) {
      if ( avail_fonts[i].ft == NULL )
         continue;
      for ( int j = 0; j < array_size( avail_fonts[i].ft ); j++ )
         if ( !strcmp( fname, avail_fonts[i].ft[j].file->name ) )
            ft.file = avail_fonts[i].ft[j].file;
      if ( ft.file != NULL ) {
         ft.file->refcount++;
         break;
      }
   }
 
   if ( ft.file == NULL ) {
      /* Read font file. */
      ft.file           = malloc( sizeof( glFontFile ) );
      ft.file->name     = strdup( fname );
      ft.file->refcount = 1;
      ft.file->data     = (FT_Byte *)ndata_read( fname, &ft.file->datasize );
      if ( ft.file->data == NULL ) {
         WARN( _( "Unable to read font: %s" ), fname );
         gl_fontstashftDestroy( &ft );
         return -1;
      }
   }
 
   /* Object which freetype uses to store font info. */
   if ( FT_New_Memory_Face( font_library, ft.file->data, ft.file->datasize, 0,
                            &ft.face ) ) {
      WARN( _( "FT_New_Memory_Face failed loading library from %s" ), fname );
      gl_fontstashftDestroy( &ft );
      return -1;
   }
 
   /* Try to resize. */
   if ( FT_IS_SCALABLE( ft.face ) ) {
      FT_Matrix scale;
      if ( FT_Set_Char_Size( ft.face, 0, /* Same as width. */
                             h * 64, 96, /* Create at 96 DPI */
                             96 ) )      /* Create at 96 DPI */
         WARN( _( "FT_Set_Char_Size failed." ) );
      scale.xx = scale.yy = (FT_Fixed)FONT_DISTANCE_FIELD_SIZE * 0x10000 / h;
      scale.xy = scale.yx = 0;
      FT_Set_Transform( ft.face, &scale, NULL );
   } else
      WARN( _( "Font isn't resizable!" ) );
 
   /* Select the character map. */
   if ( FT_Select_Charmap( ft.face, FT_ENCODING_UNICODE ) )
      WARN( _( "FT_Select_Charmap failed to change character mapping." ) );
 
   /* Save stuff. */
   array_push_back( &stsh->ft, ft );
 
   /* Success. */
   return 0;
}

void gl_freeFont( glFont *font )
{
   if ( font == NULL )
      font = &gl_defFont;
   glFontStash *stsh = gl_fontGetStash( font );
 
   /* Check references. */
   stsh->refcount--;
   if ( stsh->refcount > 0 )
      return;
   /* Not references and must eliminate. */
 
   for ( int i = 0; i < array_size( stsh->ft ); i++ )
      gl_fontstashftDestroy( &stsh->ft[i] );
   array_free( stsh->ft );
 
   free( stsh->fname );
   for ( int i = 0; i < array_size( stsh->tex ); i++ )
      glDeleteTextures( 1, &stsh->tex->id );
   array_free( stsh->tex );
 
   array_free( stsh->glyphs );
   gl_vboDestroy( stsh->vbo_tex );
   gl_vboDestroy( stsh->vbo_vert );
   free( stsh->vbo_tex_data );
   free( stsh->vbo_vert_data );
 
   memset( stsh, 0, sizeof( glFontStash ) );
   /* Font stash will get reused when possible, and we can't erase because IDs
    * will get messed up. */
}

static void gl_fontstashftDestroy( glFontStashFreetype *ft )
{
   if ( --ft->file->refcount == 0 ) {
      free( ft->file->name );
      free( ft->file->data );
      free( ft->file );
   }
   FT_Done_Face( ft->face );
}

void gl_fontExit( void )
{
   FT_Done_FreeType( font_library );
   font_library = NULL;
   array_free( avail_fonts );
   avail_fonts = NULL;
}