source: project/nondescript/gl-font/gl_font.c @ 36667

/* was example1.c from the freetype distribution with "inspiration" from fltk */

/* added by me (mt) :
 * TODO try with XftFont ?
 * TODO WIDTH and HEIGHT don't have to be fixed but computed from face size.
 *
 * to compile: cc font2ppm.c -I/usr/include/freetype2 -lfreetype -lm
 * usage example: ./a.out /usr/share/fonts/truetype/freefont/FreeMono.ttf hello > image.ppm
 */

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <wchar.h>
#include <locale.h>


#include "gl_font.h"

#define WIDTH   512
#define HEIGHT  512

static FT_Library ft_library;
static int ft_library_initialized_flag = 0;

/* The image is stored upside-down: the first byte is the
 * bottom-left corner : this is how OpenGL stores textures.
 */

void
alloc_image( unsigned char ** p, int width, int height )
{
  *p = malloc( width * height );
  memset( *p, 0, width * height );
}

void
free_image( unsigned char ** p )
{
  free( *p );
  *p = NULL;
}


void
alloc_glyphs_info( glyph_info_t ** p, int number )
{
  *p = malloc( sizeof(glyph_info_t) * number );
  memset( *p, 0, sizeof(glyph_info_t) * number );
}

void
free_glyphs_info( glyph_info_t ** p )
{
  free( *p );
  *p = NULL;
}

void
print_image_as_ppm( unsigned char * image, int width, int height )
{
  int i;
  
  printf("P3\n%d %d\n255\n", width, height);
  
  for ( i = 0 ; i < width * height ; i++ )
  {
    printf( "%d %d %d\n", image[i], image[i], image[i] );
    putchar( '\n' );
  }
}


void
render_face_to_image( FT_Face face, unsigned char * image, glyph_info_t * glyphs_info, int width, int height )
{
  // lower-left corner of next bitmap:
  int curx = 1;
  int cury = 1;
  // when a new row is started it goes here:
  int maxy = 1;

  int char_code;
  for (char_code = 0; char_code < 256; char_code++)
  {
    FT_Bitmap * bitmap;
    int w;
    int h;
    int i, j, x, y;
    glyph_info_t * glyph_info = &glyphs_info[char_code];
    
    FT_Load_Char( face, char_code, FT_LOAD_RENDER );

    glyph_info->advance = face->glyph->advance.x >> 6;  

    if ( face->glyph->format != FT_GLYPH_FORMAT_BITMAP )
    {
      glyph_info->w = 0;
      glyph_info->h = 0;
      continue;
    }
    
    bitmap = &face->glyph->bitmap;

    w = glyph_info->w = bitmap->width;
    h = glyph_info->h = bitmap->rows;

    // Skip blank bitmaps
    if (w < 1 || h < 1)
    {
      continue;
    }
    
    // figure out where we will put the bitmap
    if ( curx + w + 1 > WIDTH ) // start a new row
    {
      curx = 1;
      cury = maxy+1;
    }
      
    // figure out where next row must start
    if ( cury + h > maxy )
    {
      maxy = cury+h;
    }
      
    x = glyph_info->x = curx;
    y = glyph_info->y = cury;
    curx += w + 1;

    /* copy the pixmap */
    for (j = 0; j < h; j++)
     for (i = 0; i < w; i++)
       image[(y+j) * WIDTH + x + i] = bitmap->buffer[(h-j-1) * bitmap->pitch + i];
//       image[(y+j) * WIDTH + x + i] = bitmap->buffer[(j) * bitmap->pitch + i];

    glyph_info->left   = face->glyph->bitmap_left;
    glyph_info->bottom = face->glyph->bitmap_top - h;
  }
}

void
render_glyph_to_image( FT_Face face, unsigned char * image, glyph_info_t * glyph_info, wchar_t code )
{
  // lower-left corner of next bitmap:
  int curx = 1;
  int cury = 1;
  // when a new row is started it goes here:
  int maxy = 1;

  int char_code = code; /* TODO use directly code */
  {
    FT_Bitmap * bitmap;
    int w;
    int h;
    int i, j, x, y;
    
    FT_Load_Char( face, code, FT_LOAD_RENDER );

    glyph_info->advance = face->glyph->advance.x >> 6;  

    if ( face->glyph->format != FT_GLYPH_FORMAT_BITMAP ) /* TODO draw something else */
    {
      glyph_info->w = 0;
      glyph_info->h = 0;
    }
    
    bitmap = &face->glyph->bitmap;

    w = glyph_info->w = bitmap->width;
    h = glyph_info->h = bitmap->rows;

    // Skip blank bitmaps
    if (w < 1 || h < 1)
    {
    }
    
    // figure out where we will put the bitmap
    if ( curx + w + 1 > WIDTH ) // start a new row
    {
      curx = 1;
      cury = maxy+1;
    }
      
    // figure out where next row must start
    if ( cury + h > maxy )
    {
      maxy = cury+h;
    }
      
    x = glyph_info->x = curx;
    y = glyph_info->y = cury;

    /* copy the pixmap */
    for (j = 0; j < h; j++)
     for (i = 0; i < w; i++)
       image[(y+j) * WIDTH + x + i] = bitmap->buffer[(h-j-1) * bitmap->pitch + i];
//       image[(y+j) * WIDTH + x + i] = bitmap->buffer[(j) * bitmap->pitch + i];

    glyph_info->left   = face->glyph->bitmap_left;
    glyph_info->bottom = face->glyph->bitmap_top - h;
  }
}

int
next_pow2( int a )
{
  int n;
  for (n=1 ; n<a ; n<<=1);
  return n;
}

static int listbase;
static GLuint texture;

void
create_display_lists( unsigned char * image, glyph_info_t * glyphs_info, int maxy )
{
  int width;
  int height;
  int char_code;
  float umul;
  float vmul;
  glPushAttrib(GL_TEXTURE_BIT);
  glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);

  listbase = glGenLists(256);
  
  // generate the OpenGL texture map we will use:

  height = next_pow2( maxy );
  width = WIDTH;

  glGenTextures( 1, &texture );

  glBindTexture( GL_TEXTURE_2D, texture );
  glPixelStorei( GL_UNPACK_ALIGNMENT,   1 );
  glPixelStorei( GL_UNPACK_ROW_LENGTH,  0 );
  glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0 );
  glPixelStorei( GL_UNPACK_SKIP_ROWS,   0 );
  glTexImage2D( GL_TEXTURE_2D, 0, GL_INTENSITY8, width, height, 0,
                GL_LUMINANCE, GL_UNSIGNED_BYTE, image );
  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,     GL_CLAMP );
  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,     GL_CLAMP );

  // Now build the display lists
  umul = 1.0f/width;
  vmul = 1.0f/height;
  for (char_code = 0; char_code < 256; char_code++)
  {
    glyph_info_t * t = &glyphs_info[char_code];

    // Create the display list for this character:
    glNewList(listbase + char_code, GL_COMPILE);

    // Draw a texturemapped rectangle:
    if (t->w > 0 && t->h > 0)
    {
      glBegin( GL_QUADS );
      glTexCoord2f( t->x * umul, t->y * vmul);
      glVertex2i(   t->left, t->bottom);
      glTexCoord2f((t->x + t->w) * umul, t->y * vmul);
      glVertex2i(   t->left + t->w, t->bottom);
      glTexCoord2f((t->x + t->w) * umul, (t->y + t->h) * vmul);
      glVertex2i(   t->left +t->w,t->bottom + t->h);
      glTexCoord2f( t->x * umul, (t->y + t->h) * vmul);
      glVertex2i(   t->left, t->bottom + t->h);
      glEnd();
    }
    // move the origin:
    glTranslatef(t->advance, 0, 0);

    glEndList();
  }

  glPopClientAttrib();
  glPopAttrib();
}

void
draw_glyph( unsigned char * image, font_unicode_t * font, glyph_info_t * glyph_info, int maxy, wchar_t char_code )
{
  int width;
  int height;
  float umul;
  float vmul;
  glPushAttrib(GL_TEXTURE_BIT);
  glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
  glyph_info_t * t = glyph_info;

  // generate the OpenGL texture map we will use:

  height = next_pow2( maxy );
  width = WIDTH;

  glBindTexture( GL_TEXTURE_2D, font->texture_id );
  glPixelStorei( GL_UNPACK_ALIGNMENT,   1 );
  glPixelStorei( GL_UNPACK_ROW_LENGTH,  0 );
  glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0 );
  glPixelStorei( GL_UNPACK_SKIP_ROWS,   0 );
  glTexImage2D( GL_TEXTURE_2D, 0, GL_INTENSITY8, width, height, 0,
                GL_LUMINANCE, GL_UNSIGNED_BYTE, image );
  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,     GL_CLAMP );
  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,     GL_CLAMP );

  umul = 1.0f/width;
  vmul = 1.0f/height;
  
  // Draw a texturemapped rectangle:
  if (t->w > 0 && t->h > 0)
  {
    glBegin( GL_QUADS );
    glTexCoord2f( t->x * umul, t->y * vmul);
    glVertex2i(   t->left, t->bottom);
    glTexCoord2f((t->x + t->w) * umul, t->y * vmul);
    glVertex2i(   t->left + t->w, t->bottom);
    glTexCoord2f((t->x + t->w) * umul, (t->y + t->h) * vmul);
    glVertex2i(   t->left +t->w,t->bottom + t->h);
    glTexCoord2f( t->x * umul, (t->y + t->h) * vmul);
    glVertex2i(   t->left, t->bottom + t->h);
    glEnd();
  }
  // move the origin:
  glTranslatef(t->advance, 0, 0);

  glPopClientAttrib();
  glPopAttrib();
}

/* version of gl_print that handles ANSI escape sequences */
void
gl_print_ansi( char * text )
{
  char * c;
  
  glPushMatrix();
  glEnable( GL_TEXTURE_2D );
  glBindTexture( GL_TEXTURE_2D, texture );
  glListBase(listbase);
  for ( c = text ; *c ; c++ )
  {
    switch ( *c )
    {
      case 0x1b :
              ++c;
              if ( 0 == strncmp( c, "[1;33m", 6 ) ) /* yellow */
              {
                glColor3f( 1.0f, 1.0f, 0.0f );
                c += 5;
                break;
              }
              if ( 0 == strncmp( c, "[0m", 3 ) )    /* nothing */
              {
                glColor3f( 1.0f, 1.0f, 1.0f ); /* TODO default */
                c += 2;
                break;
              }
      case '\n' :
              glPopMatrix();
              glTranslatef(0, -18, 0); /* TODO 18 depends on the font... */
              glPushMatrix();
              break;
      default:
              /* glCallList( *c ); FIXME why doesn't it work ? */ 
              glCallLists( 1, GL_UNSIGNED_BYTE, c );
    }
  }
  glDisable( GL_TEXTURE_2D );
  glPopMatrix();
    
}

void
gl_print_ascii( char * text )
{
  int len; /* length of the current line ('till the next \n). */
  int rem; /* length of the not yet printed text. */
  char * current;
  char * next;

  current = text;
  rem = strlen( text );
  do 
  {
    next = strchr( current, '\n' );
    if ( next ) {
      len  = next - current;

      glPushMatrix();
      glEnable( GL_TEXTURE_2D );
      glBindTexture( GL_TEXTURE_2D, texture );
      glListBase(listbase);
      glCallLists( len, GL_UNSIGNED_BYTE, current );
      glDisable( GL_TEXTURE_2D );
      glPopMatrix();
    
      glTranslatef(0, -18, 0); /* TODO 18 depends on the font... */

      current = next + 1;
      rem -= len + 1;
    }
    else
    {
      len = strlen( current );
      
      glEnable( GL_TEXTURE_2D );
      glBindTexture( GL_TEXTURE_2D, texture );
      glListBase(listbase);
      glCallLists( len, GL_UNSIGNED_BYTE, current );
      glDisable( GL_TEXTURE_2D );

      rem = 0;
    }
  } while ( rem );
}

void
gl_print( font_unicode_t * font, char * text )
{
  static unsigned char image[WIDTH * HEIGHT];
  wchar_t wtext[512]; /* TODO make it depends on text length */
  int i;
  wchar_t * c;
  if (!setlocale(LC_CTYPE, ""))
  {
    fprintf(stderr, "Can't set the specified locale! "
        "Check LANG, LC_CTYPE, LC_ALL.\n");
    return;
  }
  mbstowcs( wtext, text, 512 );
  glPushMatrix();
  glEnable( GL_TEXTURE_2D );
  glBindTexture( GL_TEXTURE_2D, texture );
  for ( c = wtext ; *c ; c++ )
  {
    switch ( *c )
    {
      case 0x1b :
              ++c;
              if ( 0 == wcsncmp( c, L"[1;33m", 6 ) ) /* yellow */
              {
                glColor3f( 1.0f, 1.0f, 0.0f );
                c += 5;
                break;
              }
              if ( 0 == wcsncmp( c, L"[0m", 3 ) )    /* nothing */
              {
                glColor3f( 1.0f, 1.0f, 1.0f ); /* TODO default */
                c += 2;
                break;
              }
      case '\n' :
              glPopMatrix();
              glTranslatef(0, -18, 0); /* TODO 18 depends on the font... */
              glPushMatrix();
              break;
      default:
              render_glyph_to_image( font->face, image, &font->glyph_info, *c ); /* remove glyph_info from the struct */
              draw_glyph( image, font, &font->glyph_info, 64, 0 ); /* TODO where does 64 come from ?, remove the 0 */
    }
  }
  glDisable( GL_TEXTURE_2D );
  glPopMatrix();
}

#define FONT_PATH "/usr/share/fonts/truetype/ttf-dejavu/DejaVuSansMono.ttf"

void
create_font_from_path_ascii( char * font_path )
{
  FT_Library library;
  FT_Face    face;
  unsigned char * image;
  glyph_info_t *  glyphs_info;

  if ( FT_Init_FreeType( &library ) )
  {
    fprintf( stderr, "error when setting char size\n" );
    exit( 1 );
  }

  if ( FT_New_Face( library, font_path, 0, &face ) )
  {
    fprintf( stderr, "error when reading new face\n" );
    exit( 1 );
  }

  /* use 16pt at 72dpi */
  if ( FT_Set_Char_Size( face, 16 * 64, 0, 72, 72 ) )
  {
    fprintf( stderr, "error when setting char size\n" );
    exit( 1 );
  }
  
  alloc_image( &image, WIDTH, HEIGHT );
  alloc_glyphs_info( &glyphs_info, 256 );
  
  render_face_to_image( face, image, glyphs_info, WIDTH, HEIGHT );
  //print_image_as_ppm( image, WIDTH, HEIGHT );
  create_display_lists( image, glyphs_info, 64 );

  free_image( &image );
  free_glyphs_info( &glyphs_info );

  FT_Done_Face( face );
  FT_Done_FreeType( library );
}

font_unicode_t *
create_font_from_path( char * font_path )
{
  font_unicode_t * font = (font_unicode_t *)malloc( sizeof(font_unicode_t) );

  if ( !ft_library_initialized_flag )
  {
    if ( FT_Init_FreeType( &ft_library ) )
    {
      fprintf( stderr, "error when setting char size\n" );
      exit( 1 );
    }
    ft_library_initialized_flag = 1;
  }

  if ( FT_New_Face( ft_library, font_path, 0, &font->face ) )
  {
    fprintf( stderr, "error when reading new face\n" );
    exit( 1 );
  }

  /* use 16pt at 72dpi */
  if ( FT_Set_Char_Size( font->face, 16 * 64, 0, 72, 72 ) )
  {
    fprintf( stderr, "error when setting char size\n" );
    exit( 1 );
  }
  
  alloc_image( &font->image, WIDTH, HEIGHT ); /* TODO no need for that much here. */
  
  /* free_image( &font->image ); TODO when writing code for freeing ressource

  FT_Done_Face( font->face );
  FT_Done_FreeType( ft_library );
  ft_library_initialized_flag = 0;
  */

  glGenTextures( 1, &font->texture_id ); /* TODO release it */
  return font;
}

/* TODO Use Xft here */
void
create_font( void )
{
  create_font_from_path_ascii( FONT_PATH );
}