font_ttf.cpp

Go to the documentation of this file.

//#define WANT_TRACE

#include "SDL.h"
#include "SDL_ttf.h"
#include "SDL_opengl.h"

#include "log.h"
#include "font_ttf.h"


/* ***** SDL_UTILS **** */
inline Uint32 getpixel(SDL_Surface *surface, int x, int y)
{
    int bpp = surface->format->BytesPerPixel;
    /* Here p is the address to the pixel we want to retrieve */
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

    switch(bpp) {
    case 1:
        return *p;

    case 2:
        return *(Uint16 *)p;

    case 3:
        if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
            return p[0] << 16 | p[1] << 8 | p[2];
        else
            return p[0] | p[1] << 8 | p[2] << 16;

    case 4:
        return *(Uint32 *)p;

    default:
        return 0;       /* shouldn't happen, but avoids warnings */
    }
}

inline void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
{
    int bpp = surface->format->BytesPerPixel;
    /* Here p is the address to the pixel we want to set */
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

    switch(bpp) {
    case 1:
        *p = pixel;
        break;

    case 2:
        *(Uint16 *)p = pixel;
        break;

    case 3:
        if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
            p[0] = (pixel >> 16) & 0xff;
            p[1] = (pixel >> 8) & 0xff;
            p[2] = pixel & 0xff;
        } else {
            p[0] = pixel & 0xff;
            p[1] = (pixel >> 8) & 0xff;
            p[2] = (pixel >> 16) & 0xff;
        }
        break;

    case 4:
        *(Uint32 *)p = pixel;
        break;
    }
}

/* *** END OF UTILS *** */

FontTTF::FontTTF(const char* file, int ptsize)
{
        // Inicializing SDL_ttf
        if (!TTF_WasInit() && TTF_Init() == -1)
        {
                LOGE << "Unable to init TTF: " << TTF_GetError() << endl;
                DIE();
        }
        
        // Loading Font
        mFont = TTF_OpenFont(file, ptsize);
        if (!mFont)
        {
                LOGE << "TTF_OpenFont: " << TTF_GetError() << endl;
                DIE();
        }

        mWwidth = -1;
}

FontTTF::~FontTTF()
{
        if (mFont)
        {
                TTF_CloseFont(mFont);
                mFont = 0;
        }

        // clearing the cache
        cleanCache();
        cleanCache();
        cleanCache();
}

SDL_Surface * ConvertToRGBA(SDL_Surface *surf)
{
        TIN;
        
        SDL_PixelFormat rgba;
        rgba.palette       = 0;
        rgba.BitsPerPixel  = 32;
        rgba.BytesPerPixel = 4;
        rgba.Rloss         = 0;
        rgba.Gloss         = 0;
        rgba.Bloss         = 0;
        rgba.Aloss         = 0;
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
        rgba.Rmask  = 0x000000FF;
        rgba.Gmask  = 0x0000FF00;
        rgba.Bmask  = 0x00FF0000;
        rgba.Amask  = 0xFF000000;
        rgba.Rshift = 0;
        rgba.Gshift = 8;
        rgba.Bshift = 16;
        rgba.Ashift = 24;
#else
        rgba.Rmask  = 0xFF000000;
        rgba.Gmask  = 0x00FF0000;
        rgba.Bmask  = 0x0000FF00;
        rgba.Amask  = 0x000000FF;
        rgba.Rshift = 24;
        rgba.Gshift = 16;
        rgba.Bshift = 8;
        rgba.Ashift = 0;
#endif
        rgba.colorkey = 0;
        rgba.alpha    = 0;
        
        
        SDL_Surface *tmp = SDL_ConvertSurface(surf, &rgba, SDL_SWSURFACE);
        

        SDL_LockSurface(surf);
        SDL_LockSurface(tmp);
        
        for (int x = 0; x < tmp->w; x++)
                for (int y = 0; y < tmp->h; y++)
                {
                        Uint32 col = getpixel(surf, x, y);
                        if (col == surf->format->colorkey || col == 0)
                        {
                                col = SDL_MapRGBA(tmp->format, 250, 0, 0, 0);
                                putpixel(tmp, x, y, col);
                        }

                }

        SDL_UnlockSurface(surf);
        SDL_UnlockSurface(tmp);

        
        return tmp;
}

void SwapRows(SDL_Surface *surf)
{
        TIN;

        Uint8 *hi_row, *lo_row, *tmp_row;

        tmp_row = new Uint8[surf->pitch];

        if (SDL_LockSurface(surf) == -1)
        {
                LOGE << "Unable to lock surface" << endl;
                DIE();
        }
        
        hi_row = (Uint8 *)surf->pixels;
        lo_row = hi_row + (surf->h*surf->pitch) - surf->pitch;


        for(int i = 0; i < surf->h / 2; i++)
        {
                memcpy(tmp_row, hi_row, surf->pitch);
                memcpy(hi_row,  lo_row, surf->pitch);
                memcpy(lo_row, tmp_row, surf->pitch);

                hi_row += surf->pitch;
                lo_row -= surf->pitch;
        }

        SDL_UnlockSurface(surf);

        delete [] tmp_row;
}

void FontTTF::RenderUTF8(const std::string &utf8str, float x, float y)
{
        TIN;
        
        
        SCacheMember *scm;
        
        // searching in cache
        TStringHash::iterator it = mRenderedCache.find(utf8str);
        
        // Create new string not foutn on cache
        if (it == mRenderedCache.end())
        {
                LOGT << "creating new text" << endl;
                
                // TTF_Render has problem with empty strings
                if (utf8str.empty()) return;
                
                // creating new record if not found
                SDL_Color col = {255,255,255};
//              SDL_Surface *surf = TTF_RenderUTF8_Blended(mFont, utf8str.c_str(), col);
//              SDL_Surface *surf = TTF_RenderUTF8_Solid(mFont, utf8str.c_str(), col);
                SDL_Surface *surf = TTF_RenderUTF8_Solid(mFont, utf8str.c_str(), col);
                if (!surf)
                {
                        LOGE << "Unable to render '" << utf8str << "': " << TTF_GetError() << endl;
                        return;
        //              DIE();
                }
        
                // Upgrading the surface :-)
                SwapRows(surf);
        
                // convert to texture
                scm = new SCacheMember;
                if (!scm)
                {
                        DIE("new failed");
                }
                scm->usages  = 0;
                scm->w       = surf->w;
                scm->h       = surf->h;
                scm->surface = ConvertToRGBA(surf);
                // scm.texture = TextureManager::getInstance()->add(surf);

                SDL_FreeSurface(surf);

                mRenderedCache.insert(make_pair(utf8str, scm));
        }
        else
        {
                scm = it->second;
        }
        
        
        // Draw the text 
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        
        glRasterPos2f(x, y);

        SDL_LockSurface(scm->surface);
        glDrawPixels( scm->w, scm->h, GL_RGBA, GL_UNSIGNED_BYTE, scm->surface->pixels);
        SDL_UnlockSurface(scm->surface);

        glDisable(GL_BLEND);

        scm->usages++;
}

void FontTTF::cleanCache()
{
        LOGT << "Cleaning TTF chache. Size before: " << mRenderedCache.size() << endl;

        TStringHash::iterator it  = mRenderedCache.begin();
        
        while(it != mRenderedCache.end())
        {
                if (it->second->usages == 0)
                {
                // Removing cache
                
                        // 1. Free SDL_Surface
                        if (it->second->surface)
                        {
                                SDL_FreeSurface(it->second->surface);
                                it->second->surface = 0;
                        }
                        
                        // 2. Remove from hash table
                        if (it == mRenderedCache.begin())
                        {
                                mRenderedCache.erase(it);
                                it = mRenderedCache.begin();
                        }
                        else
                        {
                                TStringHash::iterator it2 = it;
                                ++it2; 
                                mRenderedCache.erase(it);
                                it = it2;
                        }

                }
                else
                {
                        // Just reset usages to zero
                        it->second->usages = 0;
                        ++it;
                }
        }
        
        LOGT << "Cleaning TTF chache. Size after: " << mRenderedCache.size() << endl;
}


int     FontTTF::Ascent()
{
        assertL(mFont);
        
        return TTF_FontAscent(mFont);
}

int FontTTF::getWwidth()
{
        assertL(mFont);

        if (mWwidth == -1)
        {
                TTF_SizeText(mFont, "W", &mWwidth, 0);
        }

        return mWwidth;
}
        
int FontTTF::getTextWidth(const std::string &utf8str)
{
        assertL(mFont);

        if (utf8str.empty()) return 0;

        int w;
        TTF_SizeUTF8(mFont, utf8str.c_str(), &w, 0);

        return w;
}

---