---

ttf.cpp

//FILE:         ttf.cpp
//AUTHOR:       Nathan Cournia <nathan@cournia.com>

#include "image.h"
#include "utils.h"
#include "ttf.h"

unsigned int gl::ttf::s_library_refs = 0;
FT_Library gl::ttf::s_library = NULL;

gl::ttf::ttf( void ): m_face( NULL )
{ 
        //increase ref to freetype library
        ++s_library_refs;
}

gl::ttf::ttf( const gl::ttf& cpy ):
        m_texture( cpy.m_texture ),
        m_name( cpy.m_name )
{ }

gl::ttf::~ttf( void )
{ 
        //delete glyph hash data
        glyph_hash::iterator i = m_glyphs.begin( );
        while( i != m_glyphs.end( ) ) {
                delete i->second;
                m_glyphs.erase( i );
                i = m_glyphs.begin( );
        }

        //we no longer need freetype library, decrease ref count
        --s_library_refs;

        //delete freetype face info
        FT_Done_Face( m_face );
        
        //check if we should should shutdown freetype
        if( s_library_refs < 1 ) {
                FT_Done_FreeType( s_library );
        }
}



void
gl::ttf::render_string( real_t &x, real_t &y, real_t size, 
        const std::string& text ) const
{
        //bind the texture
        m_texture.bind( );
        
        //for each character in the string
        const glyph *ch;
        glyph_hash::const_iterator gi;
        for( unsigned int i = 0; i < text.length( ); ++i ) {
                //is the glyph a space
                if( text[ i ] == ' ' ) {
                        x += size / 2.0;
                }
                
                //get the glyph
                gi = m_glyphs.find( text[ i ] );
                if( gi == m_glyphs.end( ) ) {
                        //unknown glyph
                        continue;
                }
                ch = gi->second;

                /*
                std::cerr << text[ i ] << ": bottom left: " << ch->bx << " " << ch->by
                        << " top right: " << ch->tx << " " << ch->ty
                        << " aspect: " << ch->aspect << std::endl;
                */
                
                //render the glyph as a triangle strip
                glBegin( GL_TRIANGLE_STRIP );
                        //upper left
                        glTexCoord2f( ch->bx, ch->ty );
                        glVertex2f( x, y + size );
                        
                        //lower left
                        glTexCoord2f( ch->bx, ch->by );
                        glVertex2f( x, y );
        
                        
                        //upper right
                        x += ch->aspect * size;
                        glTexCoord2f( ch->tx, ch->ty );
                        glVertex2f( x, y + size );
        
                        //lower right
                        glTexCoord2f( ch->tx, ch->by );
                        glVertex2f( x, y );
                glEnd( );
        }

        //update y
        y = y + size;
}

gl::ttf*
gl::ttf::load( const std::string& filename, unsigned int size )
{
        //for all errors
        FT_Error error;

        //do we need to init free type
        if( s_library_refs < 1 ) {
                //init freetype
                error =  FT_Init_FreeType( &s_library );
                if( error ) return NULL;
        }

        //open font
        FT_Face face;
        error = FT_New_Face( s_library, filename.c_str( ), 0, &face );
        if( error ) {
                return NULL;
        }

        //make sure the font is scalable
        if( !FT_IS_SCALABLE( face ) ) {
                FT_Done_Face( face );
                return NULL;
        }

        //set character size
        error = FT_Set_Pixel_Sizes( face, 0, size );
        if( error ) {
                FT_Done_Face( face );
                return NULL;
        }

        //kerning info
        //FT_Bool kerning = FT_HAS_KERNING( face );
        
        //create ttf object
        ttf *font = new ttf;

        //set freetype face data
        font->m_face = face;

        //set font name
        font->m_name = filename;

        //set font size
        //font->m_size = size;

        //set baseline
        //font->m_baseline = -((GLfloat)face->descender) / 
        //      ((GLfloat)face->height) * size;
        //std::cerr << "baseline: " << font->m_baseline << std::endl;

        //get glyph info from freetype
        FT_GlyphSlot slot = face->glyph;
        FT_UInt glyph_index;

        //ready pen position
        recti pen;
        pen.set_xy( 0, 0 );

        //create an image
        image::image_t img( 512, 512, image::image_t::RGBA, image::image_t::BYTE );
        memset( (void*)img.get_pixels( ), 0, 512 * 512 * 4 ); //aiieeee! evil

        //character to cache
        static std::string text = "()ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*_+-={}|[]\\:;\"'<,>.?/~`";
        
        int above_max = -100;
        int below_max = -100;

        for( unsigned int i = 0; i < text.length( ); ++i ) {
                char c = text[ i ];
                glyph_index = FT_Get_Char_Index( face, c );

                //convert the glyph to a bitmap
                error = FT_Load_Glyph( face, glyph_index, FT_LOAD_RENDER );
                if( error ) {
                        continue;
                }

                if( slot->bitmap_top > above_max ) {
                        above_max = slot->bitmap_top;
                }

                if( (slot->bitmap.rows - slot->bitmap_top) > below_max ) {
                        below_max = slot->bitmap.rows - slot->bitmap_top;
                }
        }

        int line_height = above_max + below_max; //how many pixels (height) a line of text is
        int line = line_height + 2; //current draw position (y) in pixels
        int width, top;
        glyph *pglyph;

        for( unsigned int i = 0; i < text.length( ); ++i ) {
                char c = text[ i ];
                glyph_index = FT_Get_Char_Index( face, c );

                //convert the glyph to a bitmap
                error = FT_Load_Glyph( face, glyph_index, FT_LOAD_RENDER );
                if( error ) {
                        std::cerr << "error: '" << filename << "': could not render glyph: '" << c << "'" << std::endl;
                        continue;
                }
                
                if( (slot->bitmap.width < 1) || (slot->bitmap.rows < 1) ) {
                        std::cerr << "error: '" << filename << "': could not render glyph: '" << c << "'" << std::endl;
                        continue;
                }

                //create new glyph
                pglyph = new glyph;

                //create a tempory image to store the glyph for blitting
                image::image_t tmp( slot->bitmap.width, slot->bitmap.rows,
                        image::image_t::RGBA, image::image_t::BYTE );

                //copy the glyph bitmap to the new image
                tmp.seek( 0, 0 ); //set draw position

                //for each row in source image
                for( unsigned int j = 0; j < slot->bitmap.rows; ++j ) {
                        //move current position to the proper row, account for padding (pitch)
                        unsigned char *p = slot->bitmap.buffer + ( slot->bitmap.pitch * j );

                        //for each column in row
                        for( unsigned int k = 0; k < slot->bitmap.width; ++k ) {
                                //write white pixel with alpha value
                                //tmp.write( 255, 0, 0, 255 - *(p++) );
                                tmp.write( 255, 255, 255, *(p++) );
                        }
                }

                //will the glyph not fit on this line
                //width = slot->bitmap_left + (slot->advance.x >> 6);
                //std::cerr << "left: " << slot->bitmap_left << std::endl;
                if( slot->bitmap_left > 0 ) {
                        width = slot->bitmap_left + slot->bitmap_left + slot->bitmap.width;
                } else {
                        width = slot->bitmap.width;
                }

                if( pen.x + width >= 512 ) {
                        //the glyph wont fit on line, move to next line
                        line += line_height + 1;
                        pen.x = 0;
                }

                //compute top drawing position
                //std::cerr << "top: " << slot->bitmap_top << " rows: " << slot->bitmap.rows << std::endl;
                //top = line - slot->bitmap_top;

                /*
                if( slot->bitmap_top > above_max ) {
                        above_max = slot->bitmap_top;
                }

                if( (slot->bitmap.rows - slot->bitmap_top) > below_max ) {
                        below_max = slot->bitmap.rows - slot->bitmap_top;
                }
                */

                //set glyph width
                //pglyph->width = width;

                //std::cerr << "under hang: " << c << ": " << slot->bitmap.rows - slot->bitmap_top << std::endl;

                //set glyph uv info
                /*
                pglyph->bx = ((GLfloat)(pen.x)) / 512.0;
                pglyph->by = 1.0 - (((GLfloat)(top + slot->bitmap.rows)) / 512.0);
                pglyph->tx = ((GLfloat)(pen.x + width)) / 512.0;
                pglyph->ty = 1.0 - (((GLfloat)(top)) / 512.0);
                pglyph->aspect = ((GLfloat)(width)) / ((GLfloat)(slot->bitmap.rows));
                */

                pglyph->bx = pen.x;
                pglyph->by = line;

                //std::cerr << c << ": bx: " << pglyph->bx << std::endl;

                //setting blitting position
                if( slot->bitmap_left > 0 ) {
                        pen.x += slot->bitmap_left;
                }
                pen.y = line - slot->bitmap_top;

                //blit the glyph onto the master image
                img.blit( tmp, pen );

                //move to the pen in the x dir to next draw position
                pen.x += (slot->advance.x >> 6) + 2;
                //pen.x += slot->bitmap_left + slot->bitmap.width;

                //set the glyph info internally
                font->m_glyphs[ c ] = pglyph;

                pglyph->tx = pen.x;
                
                //std::cerr << c << ": width: " << slot->bitmap.width << " pitch: " << slot->bitmap.pitch << " height: " << slot->bitmap.rows << std::endl;
        }

        //compute uv coords
        glyph_hash::iterator i = font->m_glyphs.begin( );
        float w, h, max;
        //float max = above_max + below_max;
        if( max < 0.0 ) max = 1.0;
        while( i != font->m_glyphs.end( ) ) {
                pglyph = i->second;

                //get width
                w = pglyph->tx - pglyph->bx;
                
                //std::cerr << i->first << ": bx2: " << pglyph->bx << std::endl;
                //compute u
                pglyph->bx /= 512.0;
                pglyph->tx /= 512.0;

                //compute v
                pglyph->ty = pglyph->by - static_cast<GLfloat>( above_max );
                pglyph->by = pglyph->by + static_cast<GLfloat>( below_max );
                h = pglyph->by - pglyph->ty;
                pglyph->ty = 1.0 - (pglyph->ty / 512.0);
                pglyph->by = 1.0 - (pglyph->by / 512.0);

                //aspect
                pglyph->aspect = w / h;

                //next glyph
                ++i;
        }

        //std::cerr << "line: " << size << " actual: " << above_max + below_max << std::endl;

        //set baseline
        if( below_max > 0.0 ) {
                font->m_baseline = (above_max + below_max) / below_max;
        } else {
                font->m_baseline = below_max;
        }

        //flip the image for opengl
        img.flip_horizontal( );

        //load the image with all glyphs on it into opengl
        font->m_texture = gl::texture::load( &img, false, GL_LINEAR, GL_LINEAR );
        if( !font->m_texture ) {
                //something went wrong when sending the image to opengl
                //deleting font will ensure proper destruction of font data
                delete font;
        }

        /*
        i = font->m_glyphs.begin( );
        //glyph_hash::iterator i = font->m_glyphs.begin( );
        while( i != font->m_glyphs.end( ) ) {
                pglyph = i->second;
                std::cerr << i->first << ": bottom left: " << pglyph->bx << " " << pglyph->by
                        << " top right: " << pglyph->tx << " " << pglyph->ty
                        << " aspect: " << pglyph->aspect << std::endl;
                ++i;
        }
        */
        
        //return the loaded font
        return font;
}
                

        
        
        

---