---

glt/fontasci.cpp

Go to the documentation of this file.

#include "fontasci.h"

#include <math/real.h>

#include <algorithm>
#include <cstdio>
#include <cassert>
using namespace std;

GltFontAscii::GltFontAscii(void *data)
: _width(0), _height(0), _listBase(-1)
{
    if (data)
        init(data);
}

GltFontAscii::~GltFontAscii()
{
    init(NULL);
}

void
GltFontAscii::init(void *data)
{
    clear();

    if (data)
    {
        void *font = getHeader(data,_width,_height);
        if (_width!=0 && _height!=0 && font)
        {
            _hStep = _width;
            _vStep = _height;
            compileLists(font);
            _init = true;
        }
    }
}

void 
GltFontAscii::clear()
{
    _init = false;

    if (_listBase!=-1)
    {
        glDeleteLists(_listBase,256);
        _listBase = -1;
    }
}

void
GltFontAscii::compileLists(void *data)
{
    if (_listBase==-1 && data)
    {
        GLubyte *ptr = (GLubyte *) data;
        const int bytesPerChar = ((_width+7)>>3)*_height;

        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        _listBase = glGenLists(256);
        for (int i = 0; i < 255; i++) 
        {
            glNewList(i+_listBase, GL_COMPILE);
            glBitmap(_width,_height,0,_height-1,hStep(),0,(GLubyte *) ptr);
            glEndList();
            ptr += bytesPerChar;
        }
    }
}

bool 
GltFontAscii::print(const wchar_t ch) const
{
    assert(_init);

    if (_init)
        return print(char(ch));
    else
        return false;
}

bool 
GltFontAscii::print(const wstring &str) const
{
    assert(_init);

    if (_init)
    {
        string s;
        wstring2string(s,str);
        return print(s);
    }
    else
        return false;
}

bool 
GltFontAscii::print(const char ch) const
{
    assert(_init);

    if (_init)
    {
        glCallList(_listBase + GLubyte(ch));
        return true;
    }
    else
        return false;
}

bool 
GltFontAscii::print(const string &str) const
{
    assert(_init);

    if (_init)
    {
        glPushAttrib(GL_LIST_BIT|GL_CURRENT_BIT);
            glListBase(_listBase);
            glCallLists(str.length(), GL_UNSIGNED_BYTE, (GLubyte *) str.c_str());
        glPopAttrib();

        // Advance OpenGL raster position to next line
        glBitmap(0,0,0,0,0,-_vStep,NULL);

        return true;
    }
    else
        return false;
}


// Create variable-length header for font data

bool 
GltFontAscii::makeHeader
(
    string &header,
    const int            width,
    const int            height
)
{
    // 11 characters is big enough for integer 2^32 + \0

    char buffer[5+11+11];
    sprintf(buffer,"GLTF %u %u",width,height);
    header = buffer;
    header += '\0';

    return true;
}

// Decode variable-length header for texture data

void *
GltFontAscii::getHeader
(
    const void * const data,
    int            &width,
    int            &height
)
{
    const char * const h = (const char * const) data;
    
    if (h[0]=='G' && h[1]=='L' && h[2]=='T' && h[3]=='F' && h[4]==' ')
    {
        if (sscanf(h+5,"%i %i",&width,&height)==2)
            return (void *) (h + strlen(h) + 1);
    }

    return NULL;
}

---