tr_font.cpp

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/


#include "../idlib/precompiled.h"
#pragma hdrstop

#include "tr_local.h"

#ifdef BUILD_FREETYPE
#include "../ft2/fterrors.h"
#include "../ft2/ftsystem.h"
#include "../ft2/ftimage.h"
#include "../ft2/freetype.h"
#include "../ft2/ftoutln.h"

#define _FLOOR(x)  ((x) & -64)
#define _CEIL(x)   (((x)+63) & -64)
#define _TRUNC(x)  ((x) >> 6)

FT_Library ftLibrary = NULL;  
#endif


#ifdef BUILD_FREETYPE

/*
============
R_GetGlyphInfo
============
*/
void R_GetGlyphInfo(FT_GlyphSlot glyph, int *left, int *right, int *width, int *top, int *bottom, int *height, int *pitch) {

        *left  = _FLOOR( glyph->metrics.horiBearingX );
        *right = _CEIL( glyph->metrics.horiBearingX + glyph->metrics.width );
        *width = _TRUNC(*right - *left);

        *top    = _CEIL( glyph->metrics.horiBearingY );
        *bottom = _FLOOR( glyph->metrics.horiBearingY - glyph->metrics.height );
        *height = _TRUNC( *top - *bottom );
        *pitch  = ( qtrue ? (*width+3) & -4 : (*width+7) >> 3 );
}

/*
============
R_RenderGlyph
============
*/
FT_Bitmap *R_RenderGlyph(FT_GlyphSlot glyph, glyphInfo_t* glyphOut) {
        FT_Bitmap  *bit2;
        int left, right, width, top, bottom, height, pitch, size;

        R_GetGlyphInfo(glyph, &left, &right, &width, &top, &bottom, &height, &pitch);

        if ( glyph->format == ft_glyph_format_outline ) {
                size   = pitch*height; 

                bit2 = Mem_Alloc(sizeof(FT_Bitmap));

                bit2->width      = width;
                bit2->rows       = height;
                bit2->pitch      = pitch;
                bit2->pixel_mode = ft_pixel_mode_grays;
                //bit2->pixel_mode = ft_pixel_mode_mono;
                bit2->buffer     = Mem_Alloc(pitch*height);
                bit2->num_grays = 256;

                memset( bit2->buffer, 0, size );

                FT_Outline_Translate( &glyph->outline, -left, -bottom );

                FT_Outline_Get_Bitmap( ftLibrary, &glyph->outline, bit2 );

                glyphOut->height = height;
                glyphOut->pitch = pitch;
                glyphOut->top = (glyph->metrics.horiBearingY >> 6) + 1;
                glyphOut->bottom = bottom;

                return bit2;
        }
        else {
                common->Printf( "Non-outline fonts are not supported\n" );
        }
        return NULL;
}

/*
============
RE_ConstructGlyphInfo
============
*/
glyphInfo_t *RE_ConstructGlyphInfo( unsigned char *imageOut, int *xOut, int *yOut, int *maxHeight, FT_Face face, const unsigned char c, qboolean calcHeight ) {
        int i;
        static glyphInfo_t glyph;
        unsigned char *src, *dst;
        float scaled_width, scaled_height;
        FT_Bitmap *bitmap = NULL;

        memset(&glyph, 0, sizeof(glyphInfo_t));
        // make sure everything is here
        if (face != NULL) {
                FT_Load_Glyph(face, FT_Get_Char_Index( face, c), FT_LOAD_DEFAULT );
                bitmap = R_RenderGlyph(face->glyph, &glyph);
                if (bitmap) {
                        glyph.xSkip = (face->glyph->metrics.horiAdvance >> 6) + 1;
                } else {
                        return &glyph;
                }

                if (glyph.height > *maxHeight) {
                        *maxHeight = glyph.height;
                }

                if (calcHeight) {
                        Mem_Free(bitmap->buffer);
                        Mem_Free(bitmap);
                        return &glyph;
                }

/*
                // need to convert to power of 2 sizes so we do not get 
                // any scaling from the gl upload
                for (scaled_width = 1 ; scaled_width < glyph.pitch ; scaled_width<<=1)
                        ;
                for (scaled_height = 1 ; scaled_height < glyph.height ; scaled_height<<=1)
                        ;
*/

                scaled_width = glyph.pitch;
                scaled_height = glyph.height;

                // we need to make sure we fit
                if (*xOut + scaled_width + 1 >= 255) {
                        if (*yOut + *maxHeight + 1 >= 255) {
                                *yOut = -1;
                                *xOut = -1;
                                Mem_Free(bitmap->buffer);
                                Mem_Free(bitmap);
                                return &glyph;
                        } else {
                        *xOut = 0;
                        *yOut += *maxHeight + 1;
                        }
                } else if (*yOut + *maxHeight + 1 >= 255) {
                        *yOut = -1;
                        *xOut = -1;
                        Mem_Free(bitmap->buffer);
                        Mem_Free(bitmap);
                        return &glyph;
                }

                src = bitmap->buffer;
                dst = imageOut + (*yOut * 256) + *xOut;

                if (bitmap->pixel_mode == ft_pixel_mode_mono) {
                        for (i = 0; i < glyph.height; i++) {
                                int j;
                                unsigned char *_src = src;
                                unsigned char *_dst = dst;
                                unsigned char mask = 0x80;
                                unsigned char val = *_src;
                                for (j = 0; j < glyph.pitch; j++) {
                                        if (mask == 0x80) {
                                                val = *_src++;
                                        }
                                        if (val & mask) {
                                                *_dst = 0xff;
                                        }
                                        mask >>= 1;
        
                                        if ( mask == 0 ) {
                                                mask = 0x80;
                                        }
                                        _dst++;
                                }

                                src += glyph.pitch;
                                dst += 256;

                        }
                } else {
                        for (i = 0; i < glyph.height; i++) {
                                memcpy( dst, src, glyph.pitch );
                                src += glyph.pitch;
                                dst += 256;
                        }
                }

                // we now have an 8 bit per pixel grey scale bitmap 
                // that is width wide and pf->ftSize->metrics.y_ppem tall

                glyph.imageHeight = scaled_height;
                glyph.imageWidth = scaled_width;
                glyph.s = (float)*xOut / 256;
                glyph.t = (float)*yOut / 256;
                glyph.s2 = glyph.s + (float)scaled_width / 256;
                glyph.t2 = glyph.t + (float)scaled_height / 256;

                *xOut += scaled_width + 1;
        }

        Mem_Free(bitmap->buffer);
        Mem_Free(bitmap);

        return &glyph;
}

#endif

static int fdOffset;
static byte     *fdFile;

/*
============
readInt
============
*/
int readInt( void ) {
        int i = fdFile[fdOffset]+(fdFile[fdOffset+1]<<8)+(fdFile[fdOffset+2]<<16)+(fdFile[fdOffset+3]<<24);
        fdOffset += 4;
        return i;
}

typedef union {
        byte    fred[4];
        float   ffred;
} poor;

/*
============
readFloat
============
*/
float readFloat( void ) {
        poor    me;
#ifdef __ppc__
        me.fred[0] = fdFile[fdOffset+3];
        me.fred[1] = fdFile[fdOffset+2];
        me.fred[2] = fdFile[fdOffset+1];
        me.fred[3] = fdFile[fdOffset+0];
#else
        me.fred[0] = fdFile[fdOffset+0];
        me.fred[1] = fdFile[fdOffset+1];
        me.fred[2] = fdFile[fdOffset+2];
        me.fred[3] = fdFile[fdOffset+3];
#endif
        fdOffset += 4;
        return me.ffred;
}

/*
============
RegisterFont

Loads 3 point sizes, 12, 24, and 48
============
*/
bool idRenderSystemLocal::RegisterFont( const char *fontName, fontInfoEx_t &font ) {
#ifdef BUILD_FREETYPE
        FT_Face face;
        int j, k, xOut, yOut, lastStart, imageNumber;
        int scaledSize, newSize, maxHeight, left, satLevels;
        unsigned char *out, *imageBuff;
        glyphInfo_t *glyph;
        idImage *image;
        idMaterial *h;
        float max;
#endif
        void *faceData;
        ID_TIME_T ftime;
        int i, len, fontCount;
        char name[1024];

        int pointSize = 12;
/*
        if ( registeredFontCount >= MAX_FONTS ) {
                common->Warning( "RegisterFont: Too many fonts registered already." );
                return false;
        }

        int pointSize = 12;
        idStr::snPrintf( name, sizeof(name), "%s/fontImage_%i.dat", fontName, pointSize );
        for ( i = 0; i < registeredFontCount; i++ ) {
                if ( idStr::Icmp(name, registeredFont[i].fontInfoSmall.name) == 0 ) {
                        memcpy( &font, &registeredFont[i], sizeof( fontInfoEx_t ) );
                        return true;
                }
        }
*/

        memset( &font, 0, sizeof( font ) );

        for ( fontCount = 0; fontCount < 3; fontCount++ ) {

                if ( fontCount == 0) {
                        pointSize = 12;
                } else if ( fontCount == 1 ) {
                        pointSize = 24;
                } else {
                        pointSize = 48;
                }
                // we also need to adjust the scale based on point size relative to 48 points as the ui scaling is based on a 48 point font
                float glyphScale = 1.0f;                // change the scale to be relative to 1 based on 72 dpi ( so dpi of 144 means a scale of .5 )
                glyphScale *= 48.0f / pointSize;

                idStr::snPrintf( name, sizeof(name), "%s/fontImage_%i.dat", fontName, pointSize );

                fontInfo_t *outFont;
                if ( fontCount == 0 ) {
                        outFont = &font.fontInfoSmall;
                }
                else if ( fontCount == 1 ) {
                        outFont = &font.fontInfoMedium;
                }
                else {
                        outFont = &font.fontInfoLarge;
                }

                idStr::Copynz( outFont->name, name, sizeof( outFont->name ) );

                len = fileSystem->ReadFile( name, NULL, &ftime );
                if ( len != sizeof( fontInfo_t ) ) {
                        common->Warning( "RegisterFont: couldn't find font: '%s'", name );
                        return false;
                }

                fileSystem->ReadFile( name, &faceData, &ftime );
                fdOffset = 0;
                fdFile = reinterpret_cast<unsigned char*>(faceData);
                for( i = 0; i < GLYPHS_PER_FONT; i++ ) {
                        outFont->glyphs[i].height               = readInt();
                        outFont->glyphs[i].top                  = readInt();
                        outFont->glyphs[i].bottom               = readInt();
                        outFont->glyphs[i].pitch                = readInt();
                        outFont->glyphs[i].xSkip                = readInt();
                        outFont->glyphs[i].imageWidth   = readInt();
                        outFont->glyphs[i].imageHeight  = readInt();
                        outFont->glyphs[i].s                    = readFloat();
                        outFont->glyphs[i].t                    = readFloat();
                        outFont->glyphs[i].s2                   = readFloat();
                        outFont->glyphs[i].t2                   = readFloat();
                        int junk /* font.glyphs[i].glyph */             = readInt();
                        //FIXME: the +6, -6 skips the embedded fonts/ 
                        memcpy( outFont->glyphs[i].shaderName, &fdFile[fdOffset + 6], 32 - 6 );
                        fdOffset += 32;
                }
                outFont->glyphScale = readFloat();

                int mw = 0;
                int mh = 0;
                for (i = GLYPH_START; i < GLYPH_END; i++) {
                        idStr::snPrintf(name, sizeof(name), "%s/%s", fontName, outFont->glyphs[i].shaderName);
                        outFont->glyphs[i].glyph = declManager->FindMaterial(name);
                        outFont->glyphs[i].glyph->SetSort( SS_GUI );
                        if (mh < outFont->glyphs[i].height) {
                                mh = outFont->glyphs[i].height;
                        }
                        if (mw < outFont->glyphs[i].xSkip) {
                                mw = outFont->glyphs[i].xSkip;
                        }
                }
                if (fontCount == 0) {
                        font.maxWidthSmall = mw;
                        font.maxHeightSmall = mh;
                } else if (fontCount == 1) {
                        font.maxWidthMedium = mw;
                        font.maxHeightMedium = mh;
                } else {
                        font.maxWidthLarge = mw;
                        font.maxHeightLarge = mh;
                }
                fileSystem->FreeFile( faceData );
        }

        //memcpy( &registeredFont[registeredFontCount++], &font, sizeof( fontInfoEx_t ) );

        return true ;

#ifndef BUILD_FREETYPE
    common->Warning( "RegisterFont: couldn't load FreeType code %s", name );
#else

        if (ftLibrary == NULL) {
                common->Warning( "RegisterFont: FreeType not initialized." );
                return;
        }

        len = fileSystem->ReadFile(fontName, &faceData, &ftime);
        if ( len <= 0 ) {
                common->Warning( "RegisterFont: Unable to read font file" );
                return;
        }

        // allocate on the stack first in case we fail
        if ( FT_New_Memory_Face( ftLibrary, faceData, len, 0, &face ) ) {
                common->Warning( "RegisterFont: FreeType2, unable to allocate new face." );
                return;
        }


        if ( FT_Set_Char_Size( face, pointSize << 6, pointSize << 6, dpi, dpi) ) {
                common->Warning( "RegisterFont: FreeType2, Unable to set face char size." );
                return;
        }

        // font = registeredFonts[registeredFontCount++];

        // make a 256x256 image buffer, once it is full, register it, clean it and keep going 
        // until all glyphs are rendered

        out = Mem_Alloc( 1024*1024 );
        if ( out == NULL ) {
                common->Warning( "RegisterFont: Mem_Alloc failure during output image creation." );
                return;
        }
        memset( out, 0, 1024*1024 );

        maxHeight = 0;

        for (i = GLYPH_START; i < GLYPH_END; i++) {
                glyph = RE_ConstructGlyphInfo(out, &xOut, &yOut, &maxHeight, face, (unsigned char)i, qtrue);
        }

        xOut = 0;
        yOut = 0;
        i = GLYPH_START;
        lastStart = i;
        imageNumber = 0;

        while ( i <= GLYPH_END ) {

                glyph = RE_ConstructGlyphInfo(out, &xOut, &yOut, &maxHeight, face, (unsigned char)i, qfalse);

                if (xOut == -1 || yOut == -1 || i == GLYPH_END)  {
                        // ran out of room
                        // we need to create an image from the bitmap, set all the handles in the glyphs to this point
                        // 

                        scaledSize = 256*256;
                        newSize = scaledSize * 4;
                        imageBuff = Mem_Alloc(newSize);
                        left = 0;
                        max = 0;
                        satLevels = 255;
                        for ( k = 0; k < (scaledSize) ; k++ ) {
                                if (max < out[k]) {
                                        max = out[k];
                                }
                        }

                        if (max > 0) {
                                max = 255/max;
                        }

                        for ( k = 0; k < (scaledSize) ; k++ ) {
                                imageBuff[left++] = 255;
                                imageBuff[left++] = 255;
                                imageBuff[left++] = 255;
                                imageBuff[left++] = ((float)out[k] * max);
                        }

                        idStr::snprintf( name, sizeof(name), "fonts/fontImage_%i_%i.tga", imageNumber++, pointSize );
                        if (r_saveFontData->integer) { 
                                R_WriteTGA(name, imageBuff, 256, 256);
                        }

                        //idStr::snprintf( name, sizeof(name), "fonts/fontImage_%i_%i", imageNumber++, pointSize );
                        image = R_CreateImage(name, imageBuff, 256, 256, qfalse, qfalse, GL_CLAMP);
                        h = RE_RegisterShaderFromImage(name, LIGHTMAP_2D, image, qfalse);
                        for (j = lastStart; j < i; j++) {
                                font.glyphs[j].glyph = h;
                                idStr::Copynz( font.glyphs[j].shaderName, name, sizeof( font.glyphs[j].shaderName ) );
                        }
                        lastStart = i;
                        memset( out, 0, 1024*1024 );
                        xOut = 0;
                        yOut = 0;
                        Mem_Free( imageBuff );
                        i++;
                } else {
                        memcpy( &font.glyphs[i], glyph, sizeof( glyphInfo_t ) );
                        i++;
                }
        }

        registeredFont[registeredFontCount].glyphScale = glyphScale;
        font.glyphScale = glyphScale;
        memcpy( &registeredFont[registeredFontCount++], &font, sizeof( fontInfo_t ) );

        if ( r_saveFontData->integer ) { 
                fileSystem->WriteFile( va( "fonts/fontImage_%i.dat", pointSize), &font, sizeof( fontInfo_t ) );
        }

        Mem_Free( out );

        fileSystem->FreeFile( faceData );
#endif
        return true;
}

/*
============
R_InitFreeType
============
*/
void R_InitFreeType( void ) {
#ifdef BUILD_FREETYPE
        if ( FT_Init_FreeType( &ftLibrary ) ) {
                common->Printf( "R_InitFreeType: Unable to initialize FreeType.\n" );
        }
#endif
//      registeredFontCount = 0;
}

/*
============
R_DoneFreeType
============
*/
void R_DoneFreeType( void ) {
#ifdef BUILD_FREETYPE
        if ( ftLibrary ) {
                FT_Done_FreeType( ftLibrary );
                ftLibrary = NULL;
        }
#endif
//      registeredFontCount = 0;
}