glut-font.cpp

Go to the documentation of this file.

/*
 * glut-font.cpp
 *
 * Copyright (C) 2008,2010  Thomas A. Vaughan
 * 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 <organization> 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 THOMAS A. VAUGHAN ''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 THOMAS A. VAUGHAN 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.
 *
 * Basic font support.  See glut-font.h
 */

// includes --------------------------------------------------------------------
#include "glut-font.h"          // always include our own header first

// define these to force static linking
#define FREETYPE2_STATIC
#define FTGL_LIBRARY_STATIC
//#define FT2_BUILD_LIBRARY

#include "ftgl.h"

#include "perf/perf.h"
#include "wave-glut/wave-glut.h"


namespace glut {


// interface destructors
Font::~Font(void) throw() { }
FontManager::~FontManager(void) throw() { }


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////


// used when path=NULL
class DefaultFont : public Font {
public:
        ~DefaultFont(void) throw() { }

        // glut::Font class interface methods ----------------------------------
        const char * getName(void) const throw() { return "(default font)"; }
        font_rect_t getBoundingRect(IN const char * text) {
                        ASSERT(text, "null");

                        int lh = this->getLineHeight();

                        int drop = 3;   // letters hang 3 pixels below baseline

                        font_rect_t box;
                        box.lead = 0;
                        box.drop = drop;
                        box.rise = lh - drop;
                        box.trail = glutBitmapLength(GLUT_BITMAP_9_BY_15,
                            (const byte_t *) text);

                        return box;
                }

        void display(IN float x, IN float y, IN float z, IN const char * text) {
                        ASSERT(text, "null");

                        glRasterPos3f(x, y, z);
                        for (; *text; ++text) {
                                glutBitmapCharacter(GLUT_BITMAP_9_BY_15, *text);
                        }
                }

        bool canScale(void) const throw() { return false; }
        bool setFaceSize(IN float size) { return false; }
        float getFaceSize(void) const throw() { return -1; }
        int getLineHeight(void) const throw() { return 15; }

private:
};



class FtglFont : public Font {
public:
        ~FtglFont(void) throw() {
                        if (m_data) {
                                delete[] m_data;
                        }
                }

        // glut::Font class interface methods ----------------------------------
        const char * getName(void) const throw() { return m_name.c_str(); }
        font_rect_t getBoundingRect(IN const char * text) {
                        ASSERT(text, "null");

                        //DPRINTF("Sizing: '%s'", text);
                        FTBBox box = m_font->BBox(text);
                        font_rect_t fr;
                        FTPoint u = box.Upper();
                        FTPoint l = box.Lower();
                        //DPRINTF("  l: (%f, %f, %f)", l.X(), l.Y(), l.Z());
                        //DPRINTF("  u: (%f, %f, %f)", u.X(), u.Y(), u.Z());

                        fr.lead = -l.X();
                        fr.drop = -l.Y() + 1;

                        fr.trail = u.X();
                        fr.rise = u.Y();

                        //DPRINTF("  lead:%d  trail:%d", fr.lead, fr.trail);
                        //DPRINTF("  rise:%d  drop:%d", fr.rise, fr.drop);

                        return fr;
                }
        void display(IN float x, IN float y, IN float z, IN const char * text) {
                        ASSERT(text, "null");

                        glMatrixMode(GL_MODELVIEW);
                        glPushMatrix();
                        glTranslatef(x, y, z);
                        glScalef(1, -1, 1);
                        m_font->Render(text);
                        glPopMatrix();
                }

        bool canScale(void) const throw() { return true; }
        bool setFaceSize(IN float pointSize) {
                        if (pointSize < 0.5) {
                                return false;
                        }
                        m_font->FaceSize(pointSize);
                        return true;
                }
        float getFaceSize(void) const throw() {
                        return m_font->FaceSize();
                }
        int getLineHeight(void) const throw() { return m_font->LineHeight(); }

        // static factory methods ----------------------------------------------
        static smart_ptr<FtglFont> create(IN const char * name,
                                        IN byte_t * data,
                                        IN smart_ptr<FTFont>& font) {
                        ASSERT(name, "null");
                        ASSERT(font, "null");
                        // ASSERT(data) -- optional

                        smart_ptr<FtglFont> local = new FtglFont;
                        ASSERT(local, "out of memory");

                        local->m_name = name;
                        local->m_font = font;
                        local->m_data = data;

                        return local;
                }

private:
        // private constructor -------------------------------------------------
        FtglFont(void) throw() { m_data = NULL; }

        // private helper methods ----------------------------------------------
        // private member data -------------------------------------------------
        byte_t *                m_data;
        std::string             m_name;
        smart_ptr<FTFont>       m_font;
};



class Mgr : public FontManager {
public:
        ~Mgr(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(void);

        // glut::FontManager class interface methods ---------------------------
        smart_ptr<Font> getFont(IN nstream::Stream * stream);

private:
        // private typedefs ----------------------------------------------------
        typedef std::map<std::string, smart_ptr<FtglFont> > font_map_t;

        // private helper methods ----------------------------------------------
        // private member data -------------------------------------------------
        font_map_t                      m_fonts;
};


void
Mgr::initialize
(
void
)
{
}



smart_ptr<Font>
Mgr::getFont
(
IN nstream::Stream * stream
)
{
        // ASSERT(stream) -- can be null!
        if (!stream) {
                return getDefaultFont();
        }

        // get full name to use as cache key
        smart_ptr<nstream::File> file = stream->getFile();
        ASSERT(file, "null");
        const char * path = file->getName();
        ASSERT(path, "null");
        smart_ptr<nstream::Manager> mgr = file->getManager();
        ASSERT(mgr, "null");
        std::string name = mgr->getFullName(path);
        //DPRINTF("path '%s' --> name '%s'", path, name.c_str());

        // already have this font?
        font_map_t::iterator i = m_fonts.find(name);
        if (m_fonts.end() != i) {
                smart_ptr<Font> font = i->second;
                ASSERT(font, "null font in map?");
                return font;
        }

        // don't have this loaded yet
        perf::Timer timer("loadFont");
        DPRINTF("Need to load font: %s", name.c_str());

        // FTGL can't read from streams, have to populate buffer and hold on
        std::istream& in = stream->getStream();
        ASSERT_THROW(in.good(), "bad font stream? " << name);
        std::streampos currPos = in.tellg();
        in.seekg(0, std::ios::end);
        std::streampos endPos = in.tellg();
        long bytes = (long) (endPos - currPos);
        //DPRINTF("Stream is %ld bytes", bytes);
        in.seekg(currPos, std::ios::beg);

        // allocate big data array and copy stream data into it
        byte_t * data = new byte_t[bytes];
        ASSERT(data, "out of memory");
        in.read((char *) data, bytes);
        ASSERT_THROW(!in.fail(), "failed to read all bytes: " << bytes);

        smart_ptr<FTGLTextureFont> texFont = new FTGLTextureFont(data, bytes);
        ASSERT_THROW(texFont, "failed to create texture font: " << name);
        texFont->FaceSize(40);
        smart_ptr<FTFont> ftglFont = texFont;   // downcast
        ASSERT(ftglFont, "can't downcast to FTFont from FTGLTextureFont?");
        smart_ptr<FtglFont> font = FtglFont::create(path, data, ftglFont);
        ASSERT_THROW(font, "failed to create glut::Font: " << path);

        // cache font and return
        m_fonts[name] = font;
        return font;
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<FontManager>
FontManager::create
(
void
)
{
        smart_ptr<Mgr> local = new Mgr;
        ASSERT(local, "out of memory");

        local->initialize();

        return local;
}



smart_ptr<Font>
getDefaultFont
(
void
)
{
        static smart_ptr<Font> g_defaultFont = NULL;
        if (!g_defaultFont) {
                g_defaultFont = new DefaultFont;
                ASSERT(g_defaultFont, "out of memory");
        }
        return g_defaultFont;
}



bool
scaleFontToPixelHeight
(
IO Font * font,
IN const char * text,
IN int H
)
{
        perf::Timer timer("scaleFont");
        ASSERT(font, "null");
        ASSERT(text, "null");
        ASSERT(H > 0, "Bad desired pixel height: %d", H);

        if (!font->canScale()) {
                return false;
        }

        float startScale = font->getFaceSize();

        float leftSize = 0.0;
        float rightSize = 72.0;
        while (true) {
                ASSERT_THROW(font->setFaceSize(rightSize),
                    "Font is supposed to be scalable");
                font_rect_t fr = font->getBoundingRect(text);
                int y = fr.rise + fr.drop;
//              DPRINTF("Point size %f --> line height %d", rightSize, y);
                if (rightSize > 200 && y < 2) {
                        // font isn't scaling!
                        font->setFaceSize(startScale);
                        return false;
                }
                if (y > H) {
                        break;
                }
                rightSize *= 2;
        }

        // okay, binary search between left and right
        while (true) {
                float midSize = 0.5 * (leftSize + rightSize);
                ASSERT_THROW(font->setFaceSize(midSize),
                    "font is supposed to be scalable");
                font_rect_t fr = font->getBoundingRect(text);
                int y = fr.rise + fr.drop;
        //      DPRINTF("Point size %f --> line height %d", midSize, y);
                if (rightSize - leftSize < 0.25)
                        return true;
                if (y == H)
                        return true;
                if (y < H) {
                        // mid is too small --> go right
                        leftSize = midSize;
                } else {
                        // mid is too big --> go left
                        rightSize = midSize;
                }
        }

        return false;
}



};      // glut namespace