---

FTRenderer.cc

Go to the documentation of this file.

/*
    File:       FTRenderer.cc

    Function:   Render text into images using FreeType
                (http://www.freetype.org)

    Author:     Andrew Willmott

    Notes:      
*/

#include "gcl/FTRenderer.h"

#include <stdlib.h>

FTRenderer::FTRenderer() : glyphs(0)
{
    dpi = 96;
    pointSize = 24;
    hinted = 1;
    smooth = 1;
    border = 0;
    Init();
}

FTRenderer::~FTRenderer() 
{
    Free();
}

Void FTRenderer::SetPointSize(Int size)
{
    pointSize = size;
}

Void FTRenderer::SetupGlyphTable()
{
    TT_UShort   i, n;
    TT_UShort   platform, encoding;

    /* First, look for a Unicode charmap */

    noCharMap = true;
    n = TT_Get_CharMap_Count(face);

    for (i = 0; i < n; i++)
    {
        TT_Get_CharMap_ID(face, i, &platform, &encoding);
        if ((platform == 3 && encoding == 1) ||
                (platform == 0 && encoding == 0))
        {
            TT_Get_CharMap(face, i, &charMap);
            noCharMap = false;
            break;
        }
    }

    if (i == n)
    {
        TT_Face_Properties properties;

        TT_Get_Face_Properties(face, &properties);

        numGlyphs = properties.num_Glyphs;
    }

    /* Second, allocate the array */

    glyphs = new TT_Glyph[256];
    for (i = 0; i < 256; i++)
        glyphs[i].z = 0;
}

Void FTRenderer::FreeGlyphTable()
{
    Int i;

    if (!glyphs)
        return;

    for (i = 0; i < 256; ++i)
        TT_Done_Glyph(glyphs[i]);

    delete[] glyphs;

    glyphs = 0;
}

Void FTRenderer::LoadGlyphs(StrConst txt, Int txtlen)
// make sure all glyphs in the string are loaded
{
    TT_UShort   i, n;
    Int         code, load_flags;
    TT_Error    error;

    load_flags = TTLOAD_SCALE_GLYPH;
    if (hinted)
        load_flags |= TTLOAD_HINT_GLYPH;

    for (i = 0; i < txtlen; ++i)
    {
        unsigned char j = txt[i];

        // already loaded?
        if (glyphs[j].z)
            continue;

        if (noCharMap)
        {
            code = j - ' ' + 1;
            if (code < 0 || code >= numGlyphs)
                code = 0;
        }
        else
        {
            code = TT_Char_Index(charMap, j);
            if (code < 0)
                code = 0;   /* FIXME! default code */
        }

        (void)
        (
            (error = TT_New_Glyph(face, &glyphs[j])) ||
            (error = TT_Load_Glyph(instance, glyphs[j], code, load_flags))
        );
        if (error)
            _Warning(String().Printf("ERROR: cannot allocate and load glyph: %d\n", error));
    }
}


Void FTRenderer::SetFace(StrConst filename)
{
    TT_Error error;

    if (faceSet)
        FreeFace();

    /* load the typeface */

    error = TT_Open_Face(engine, filename, &face);
    if (error)
    {
        if (error == TT_Err_Could_Not_Open_File)
            _Error(String().Printf("ERROR: could not find/open %s\n", filename));
        else
            _Error(String().Printf("ERROR: while opening %s, error code = %x\n", filename, error));
    }

    /* create and initialize instance */

    (void)
    (
        (error = TT_New_Instance(face, &instance)) ||
        (error = TT_Set_Instance_Resolutions(instance, dpi, dpi)) ||
        (error = TT_Set_Instance_CharSize(instance, pointSize * 64))
    );
    if (error)
        _Error(String().Printf("ERROR: could not create and initialize instance: %d\n",
                error));

    faceSet = true;
    SetupGlyphTable();
}

Void FTRenderer::FreeFace()
{
    FreeGlyphTable();
    TT_Done_Instance(instance);
    TT_Close_Face(face);
}

Void FTRenderer::SetupImage(StrConst txt, Int txtlen)
{
    Int                     i, upm, ascent, descent;
    TT_Face_Properties      properties;
    TT_Instance_Metrics     imetrics;
    TT_Glyph_Metrics        gmetrics;
    Int                     width, height;
    TT_F26Dot6              widthx;
    
    /* allocate the large bitmap */

    TT_Get_Face_Properties( face, &properties );
    TT_Get_Instance_Metrics( instance, &imetrics );

    upm = properties.header->Units_Per_EM;
    ascent = ( properties.horizontal->Ascender * imetrics.y_ppem ) / upm;
    descent = ( properties.horizontal->Descender * imetrics.y_ppem ) / upm;

    width = 2 * border;
    height = 2 * border + ascent - descent;
    widthx = 64 * width;
    
    for (i = 0; i < txtlen; i++)
    {
        unsigned char j = txt[i];

        if (!glyphs[j].z)
            continue;

        TT_Get_Glyph_Metrics(glyphs[j], &gmetrics);
        widthx += gmetrics.advance;
    }

    width = (widthx + 63) / 64;
    width = (width + 3) & ~0x3;
    image.SetSize(width, height);
    image.Clear(cWhite);

    pixmap.rows = height;
    pixmap.width = width;
    pixmap.flow = TT_Flow_Up;
    pixmap.cols = width;
    pixmap.size = width * height;
    pixmap.bitmap = image.ByteData();

    xShift = border;
    yShift = border - descent;
}


Void FTRenderer::RenderGlyph(TT_Glyph glyph, TT_F26Dot6 x_off, TT_F26Dot6 y_off,
                              TT_Glyph_Metrics *gmetrics)
{
    if (!smooth)
    {
        TT_Get_Glyph_Bitmap(glyph, &pixmap, x_off, y_off);
    }
    else
    {
        TT_F26Dot6 xmin, ymin, xmax, ymax;

        xmin = gmetrics->bbox.xMin & ~0x3F;
        ymin = gmetrics->bbox.yMin & ~0x3F;
        xmax = (gmetrics->bbox.xMax + 63) & ~0x3F;
        ymax = (gmetrics->bbox.yMax + 63) & ~0x3F;

        TT_Get_Glyph_Pixmap(glyph, &pixmap, x_off, y_off);
    }
}

Void FTRenderer::RenderAllGlyphs(StrConst txt, Int txtlen)
{
    Int                 i;
    TT_F26Dot6          x, y;
    TT_Glyph_Metrics    gmetrics;

    x = xShift * 64;
    y = yShift * 64;

    for (i = 0; i < txtlen; i++)
    {
        unsigned char j = txt[i];

        if (!glyphs[j].z)
            continue;

        TT_Get_Glyph_Metrics(glyphs[j], &gmetrics);

        RenderGlyph(glyphs[j], x, y, &gmetrics);

        x += gmetrics.advance;
    }
}

Void FTRenderer::Init()
{
    TT_Error    error;
    TT_Byte     palette[5] = 
                {
                    255,
                    192,
                    128,
                    64,
                    0
                };

    error = TT_Init_FreeType(&engine);
    if (error)
        _Error(String().Printf("ERROR: While initializing engine, code = %d\n", error));

    TT_Set_Raster_Gray_Palette(engine, palette);

    faceSet = false;
}

Void FTRenderer::Free()
{
    if (faceSet)
        FreeFace();

    TT_Done_FreeType(engine);
}

Void FTRenderer::RenderText(StrConst txt)
{
    if (!faceSet)
        _Error("(FTRenderer) No font set yet");
    Int txtlen = txt.Length();
    LoadGlyphs(txt, txtlen);
    SetupImage(txt, txtlen);
    RenderAllGlyphs(txt, txtlen);
}

---