MercuryText.cpp

Go to the documentation of this file.

// FreeType Headers
#include <ft2build.h>
#include <freetype/freetype.h>
#include <freetype/ftglyph.h>
#include <freetype/ftoutln.h>
#include <freetype/fttrigon.h>

#include "global.h"
#include "MercuryUtil.h"
#include "MercuryText.h"
#include "MercuryLog.h"
#include "MercuryDisplay.h"
#include "MercuryInput.h"
#include "MercuryTextureManager.h"
#include "MercuryFiles.h"
#include "MercuryObjectFactory.h"
#include "MercuryVector.h"
#include "BMPWriter.h"

GlobalFontHash FONTHASH;

#define     MC_DISPLAYRESIZED       1       //convention: MESSAGE CODE  

MercuryText::MercuryText()
:MercuryObject()
{
    m_glState.Disable(MGLS_ALL);
    m_glState.Enable(MGLS_COLORWRITE | MGLS_BLEND | MGLS_TEXTURING | MGLS_OPAQUE);
}

MercuryText::~MercuryText()
{
    Clear();
}

void MercuryText::Init()
{
    MercuryObject::Init();

    m_h = m_fontheight = 16;
    m_tabwidth = 64;
    m_maxwidth = -1;

    m_width = 0;
    m_fontFileData = NULL;
    m_mtgd = NULL;
    SetupSizing(DISPLAY->GetDimensions());

    RegisterMessage( MC_DISPLAYRESIZED, "DisplayResized" );
}

void MercuryText::SetSize(unsigned int px)
{
    m_fontheight = px;
    SetupSizing(DISPLAY->GetDimensions());
}

void MercuryText::SetFont(const MString& font)
{
    if( m_font == font)
        return;

    m_font = font;
}

bool MercuryText::New_Face(FT_Library library, const MString& filepathname, FT_Long face_index, FT_Face *aface )
{
    FT_Open_Args_ a;
    unsigned int length;

    MercuryFile* f = FILEMAN.Open(filepathname);

    if(!f)
        return false;

    length = f->Length();
    SAFE_DELETE(m_fontFileData);
    m_fontFileData = new char[length];
    f->Read(m_fontFileData, length);
    SAFE_DELETE(f);
    a.flags = FT_OPEN_MEMORY;
    a.memory_base = (const FT_Byte*)m_fontFileData;
    a.memory_size = length;

    FT_Open_Face(library, &a, face_index, aface);

    return true;
};

void MercuryText::Clear()
{
//  for (unsigned int i = 0; i < m_characters.size(); i++)
//      SAFE_DELETE(m_characters[i]);

    m_characters.clear();
    m_width = 0;
}

void MercuryText::SetText(const MString& text)
{
    if (m_text == text)
        return;

    m_text = text;
    BuildFontDisplay();
}

MercuryTextChar* MercuryText::BuildCharSprite(const char ch, int& x, int& y)
{
    MercuryTextChar* textChar = NULL;

    if (!m_mtgd)
        BuildGlyphData();

    textChar = new MercuryTextChar;

    MercuryTextCharData mtcd = m_mtgd->charDatas[ int(ch) ];

    textChar->vertices[0].x = 0;
    textChar->vertices[0].y = 0;
    textChar->vertices[0].SetU( mtcd.left_u );
    textChar->vertices[0].SetV( mtcd.top_v );

    textChar->vertices[1].x = 0;
    textChar->vertices[1].y = float(mtcd.height_px);
    textChar->vertices[1].SetU( mtcd.left_u );
    textChar->vertices[1].SetV( mtcd.bottom_v );

    textChar->vertices[2].x = float(mtcd.width_px);
    textChar->vertices[2].y = float(mtcd.height_px);
    textChar->vertices[2].SetU( mtcd.right_u );
    textChar->vertices[2].SetV( mtcd.bottom_v );

    textChar->vertices[3].x = float(mtcd.width_px);
    textChar->vertices[3].y = 0;
    textChar->vertices[3].SetU( mtcd.right_u );
    textChar->vertices[3].SetV( mtcd.top_v );

    textChar->advance_x = mtcd.advance_x;
    textChar->advance_y = mtcd.advance_y;
    textChar->position.x = float(mtcd.left_px);
    textChar->position.y = float(m_mtgd->height_px-mtcd.top_px);

    return textChar;
}

void MercuryText::BuildFontDisplay()
{
    unsigned int i;
    MercuryTextChar* letter = NULL;
    int w_place = 0;

    if ( m_font.empty() )
        return;

    m_width = 0;

    Clear();

    MVector<LetterHolder> vTempSprites;

    int x, y;
    x = y = 0;
    for ( i = 0; i < m_text.size(); ++i)
    {
        if( m_text[i] == '\n' )
        {
            vTempSprites.push_back( LetterHolder( 0, 0, 0, 0, 0, 0, 1 ) );
            continue;
        }
        if( m_text[i] == '\0' || m_text[i] == '\r' )
            continue;
        letter = BuildCharSprite(m_text[i], x, y);
        if (letter != NULL)
        {
            m_characters.push_back(letter);
            vTempSprites.push_back( LetterHolder( letter, 
                letter->advance_x,
                0, 0, (m_text[i] == ' '), (m_text[i] == '\t'), 0 ) );
        }
    }

    //Ok, now we have a vector of all of the sprites, vTempSprites.  We just have to
    //move them to the right place.

    int iCurLine = 0;
    int iLastLineBreak = 0;

    for( i = 0; i < vTempSprites.size(); ++i )
    {
        LetterHolder &cur = vTempSprites[i];
        
        cur.iPixCol = w_place;
        w_place += cur.iWidth;
        cur.iLine = iCurLine;

        if( cur.bEnter )
        {
            ++iCurLine;
            m_width = (m_width>w_place)?m_width:w_place;
            iLastLineBreak = i;
            w_place = 0;
            continue;
        }

        //We've gone over the line's maximum width
        if( (w_place > m_maxwidth) && (m_maxwidth > 0) )
        {
            int j;
            for( j = i; j > iLastLineBreak; --j )
            {
                //let's see if we've found somewhere that we can split
                if( vTempSprites[j].bTab || vTempSprites[j].bSpace )
                    break;
            }

            if( j == iLastLineBreak )
            {
                //We couldn't find any breaks; chop this character onto next line
                ++iCurLine;
                iLastLineBreak = i;
                m_width = (m_width>w_place)?m_width:w_place;
                cur.iLine = iCurLine;
                w_place = 0;
                cur.iPixCol = w_place;
                w_place = cur.iWidth;
            } else {
                //otherwise, we found a suitable chop spot.
                ++iCurLine;
                iLastLineBreak = j;
                m_width = (m_width>w_place)?m_width:w_place;
                cur.iLine = iCurLine;
                w_place = 0;
                for( unsigned k = j+1; k <= i; ++k )
                {
                    vTempSprites[k].iLine = iCurLine;
                    vTempSprites[k].iPixCol = w_place;
                    w_place += vTempSprites[k].iWidth;
                }
            }
        }

        if( cur.bTab )
        {
            int iNextTabPlace = w_place/m_tabwidth+m_tabwidth;
            if ( (iNextTabPlace > m_maxwidth) && (m_maxwidth > 0) )
            {
                m_width = (m_width>w_place)?m_width:w_place;
                ++iCurLine;
                iLastLineBreak = i;
                w_place = 0;
                w_place = cur.iWidth;
            } else
                w_place = iNextTabPlace;
        }
    }

    m_width = (m_width>w_place)?m_width:w_place;

    for( i = 0; i < vTempSprites.size(); ++i )
    {
        LetterHolder cur = vTempSprites[i];
        if( cur.pSprite )
        {
            cur.pSprite->position.x += ( float( cur.iPixCol ) );
            cur.pSprite->position.y += ( float( cur.iLine * m_fontheight * 1.5 ) );
        }
        if( i == vTempSprites.size() - 1 ) 
            m_height = (int)((cur.iLine+1) * m_fontheight * 1.5);
    }
}

void MercuryText::Message( int Message, PStack & data, const MString & name )
{
    switch ( Message ) 
    {
    case MC_DISPLAYRESIZED:
        DisplayDimensions g;
        g.height = data.PopItem().GetValueF();
        g.width = data.PopItem().GetValueF();
        SetupSizing(g);
        break;
    };
}

void MercuryText::SetupSizing(const DisplayDimensions& d)
{
    DisplayDimensions based = DISPLAY->GetBasedDimensions();
//  float r_w = based.width / d.width;
    float r_h = based.height / d.height;
    m_h = (unsigned int)(m_fontheight / r_h);
    SetScaleX(r_h);
    SetScaleY(r_h);

    m_id = m_font + ssprintf("%d", m_h) + "Glyphs";
    m_mtgd = NULL; //Forget our last glyph map so that we either find or generate a new one
    //If we have a font we may have rendered something, so we should update it
    BuildFontDisplay();
}

bool MercuryText::Command( PStack & ret, const char * command, PStack & args )
{
    if ( strcmp( command, "SetText" ) == 0 )
    {
        MString Parameter = args.PopItem().GetValueS();
        while( args.GetSize() )
            Parameter = args.PopItem().GetValueS() + "," + Parameter;
        this->SetText( Parameter );
        return true;
    }
    return MercuryObject::Command( ret, command, args );
}

void MercuryText::EnumerateCommands( MVector< MString > & toAdd )
{
    toAdd.push_back( "SetText" );
    MercuryObject::EnumerateCommands( toAdd );
}

void MercuryText::BuildGlyphData()
{
    m_mtgd = (*FONTHASH).get(m_id);
    if (!m_mtgd)
    {
        (*FONTHASH).insert(m_id, MercuryTextGlyphData());
        m_mtgd = (*FONTHASH).get(m_id);
    }
    else
        return; //glyph already exists

    FT_LibraryRec_* m_library;
    FT_FaceRec_* m_face;
    FT_Glyph glyph;
    FT_BitmapGlyph bitmap_glyph;
    int glyph_height;
    int glyph_width;
    bool restart = true;
//  SAFE_DELETE(m_mtgd->image_data.data);
    m_mtgd->image_data = new RawImageData;

    unsigned int image_width_height = 256;

    if (FT_Init_FreeType( &m_library ))
    {
        LOG.Warn("FT_Init_FreeType failed");
        SAFE_DELETE(m_fontFileData);
        FT_Done_FreeType(m_library);
        throw;
    }

    if (!New_Face( m_library, m_font.c_str(), 0, &m_face ))
        ASSERT(!"FT_New_Face failed (there is probably a problem with your font file)");

    //Setup the image_data
    while ( restart )
    {
        restart = false;

        m_mtgd->image_data->attrs.m_width = image_width_height;
        m_mtgd->image_data->attrs.m_height = image_width_height;
        m_mtgd->image_data->attrs.m_ColorByteType = RGBA;
        unsigned int bpp = ColorBytesToSize(m_mtgd->image_data->attrs.m_ColorByteType);
        unsigned int image_size = image_width_height * image_width_height * bpp;
        SAFE_DELETE(m_mtgd->image_data->data);
        m_mtgd->image_data->data = new unsigned char[image_size];
        m_mtgd->image_data->attrs.m_dpi_x = 72;
        m_mtgd->image_data->attrs.m_dpi_y = 72;
        memset(m_mtgd->image_data->data, 0, image_size); //Make the bitmap white

        m_mtgd->height_px = m_h;
        m_mtgd->point_size = m_h*64;
        FT_Set_Char_Size( m_face, m_mtgd->point_size, m_mtgd->point_size, 96, 96);

        // Load The Glyph For Our Character.
        for (unsigned int ch = 32; ch < 256; ++ch)
        {
            if(FT_Load_Glyph( m_face, FT_Get_Char_Index( m_face, ch ), FT_LOAD_DEFAULT ))
            {
                LOG.Warn("FT_Load_Glyph failed");
                FT_Done_Face(m_face);
                SAFE_DELETE(m_fontFileData);
                FT_Done_FreeType(m_library);
                return;
            }
            
            // Move The Face's Glyph Into A Glyph Object.
            if(FT_Get_Glyph( m_face->glyph, &glyph))
            {
                LOG.Warn("FT_Get_Glyph failed");
                FT_Done_Face(m_face);
                SAFE_DELETE(m_fontFileData);
                FT_Done_FreeType(m_library);
                return;
            }
            
            FT_Glyph_To_Bitmap( &glyph, FT_RENDER_MODE_NORMAL, 0, 1 );
            bitmap_glyph = (FT_BitmapGlyph)glyph;
            
            // This Reference Will Make Accessing The Bitmap Easier.
            FT_Bitmap& bitmap = bitmap_glyph->bitmap;

            //Build from the bottom up, not the top down.
            //FT bitmap data is 8 bits per pixel we must expand to 16 bits per pixel
            int xCell = ch % 16;
            int yCell = (int)floorf(ch/16.0f);

            int xPixelsPerCell = (image_width_height/16);
            int yPixelsPerCell = (image_width_height/16);

            int xByteOffset = (xPixelsPerCell*bpp) * xCell;
            int yByteOffset = ((image_width_height*bpp) * yPixelsPerCell) * yCell;

            m_mtgd->charDatas[ch].left_u = (xCell * xPixelsPerCell)/float(image_width_height);
            m_mtgd->charDatas[ch].right_u = ( (xCell * xPixelsPerCell)+bitmap.width )/float(image_width_height);
            m_mtgd->charDatas[ch].top_v = (yCell * yPixelsPerCell)/float(image_width_height);
            m_mtgd->charDatas[ch].bottom_v = ( (yCell * yPixelsPerCell)+bitmap.rows )/float(image_width_height);
            m_mtgd->charDatas[ch].left_px = bitmap_glyph->left;
            m_mtgd->charDatas[ch].top_px = bitmap_glyph->top;
            m_mtgd->charDatas[ch].advance_x = m_face->glyph->advance.x/64;
            m_mtgd->charDatas[ch].advance_y = m_face->glyph->advance.y/64;
            m_mtgd->charDatas[ch].width_px = glyph_width = bitmap.width;
            m_mtgd->charDatas[ch].height_px = glyph_height = bitmap.rows;

            //If a character goes outside its cell, we need a bigger texture
            if ((glyph_width > xPixelsPerCell) || (glyph_height > yPixelsPerCell))
                restart = true;

            if (restart)
            {
                image_width_height = nextPow2(image_width_height);
                break;
            }

            for(int j = 0; j < glyph_height; ++j)
                for(int i = 0; i < glyph_width; ++i)
                {
                    unsigned int color = bitmap.buffer[i + glyph_width*(j)];
                    unsigned int bytePosition = (yByteOffset) + xByteOffset + ((bpp*(i+j*image_width_height)));

                    m_mtgd->image_data->data[ bytePosition + 0] = 255;
                    m_mtgd->image_data->data[ bytePosition + 1] = 255;
                    m_mtgd->image_data->data[ bytePosition + 2] = 255;
                    m_mtgd->image_data->data[ bytePosition + 3] = color;
                }
    /*
            //show the grid
            for(unsigned int j = 0; j < image_height; ++j)
                for(unsigned int i = 0; i < image_width; ++i)
                    if ((j%(image_width/16) == 0) || (i%(image_height/16) == 0))
                    {
                        unsigned int bytePosition = bpp*(i+j*image_width);
                        m_mtgd->image_data->data[ bytePosition + 0] = 0;
                        m_mtgd->image_data->data[ bytePosition + 1] = 0;
                        m_mtgd->image_data->data[ bytePosition + 2] = 255;
                    }
                    */
        }
    }

    m_mtgd->textureData.SetPath(m_id);
    m_mtgd->textureData.SendLoadFromRaw(m_mtgd->image_data); //takes owner of image_data

//  WriteBMP("TestGlyph.bmp", m_mtgd->image_data);

    FT_Done_Face(m_face);
    SAFE_DELETE(m_fontFileData);
    FT_Done_FreeType(m_library);
}

void MercuryText::CustomRender()
{
    if (m_mtgd)
    {
        if (m_mtgd->textureData.GetState() == LOADED)
        {
            DISPLAY->SetStates( GetInheritedGLState() );
            DISPLAY->SetMaterial(&m_finalMaterial);
            DISPLAY->SendMatrixData(GetFinalMatrix());
            DISPLAY->RenderText(*this);
        }
    }
}

REGISTER_OBJECT_TYPE( MercuryText );

/* 
 * Copyright (c) 2005-2006, Joshua Allen
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by