glut-font/test/test.cpp

Go to the documentation of this file.

/*
 * test.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Program to test the glut-font library.
 */

// includes --------------------------------------------------------------------
#include <iostream>

#include "glut-demo/glut-demo.h"
#include "glut-font/glut-font.h"
#include "perf/perf.h"
#include "util/file.h"



static const int s_desiredHeight                = 36;   // pixel height of line


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

static void
writeLine
(
IN glut::Font * font,
IN const char * text
)
{
        ASSERT(font, "null");
        ASSERT(text, "null");

        glut::font_rect_t fr = font->getBoundingRect(text);
        if (fr.rise > 0) {
                glTranslatef(0, fr.rise, 0);
        }

        glColor3f(0.3, 0.3, 0.3);
        glBegin(GL_LINES);
                glVertex3f(-fr.lead, 0, 0);
                glVertex3f(fr.trail, 0, 0);
                glVertex3f(0, -fr.rise, 0);
                glVertex3f(0, fr.drop, 0);
        glEnd();
        glBegin(GL_LINE_LOOP);
                glVertex3f(-fr.lead, -fr.rise, 0);
                glVertex3f(fr.trail, -fr.rise, 0);
                glVertex3f(fr.trail, fr.drop, 0);
                glVertex3f(-fr.lead, fr.drop, 0);
        glEnd();

        glColor3f(1.0, 0.6, 1.0);
        font->display(0, 0, 0, text);

        glTranslatef(0, fr.drop + 5, 0);
}



class Drawer : public glut::DemoHost {
public:
        Drawer(IN const char * dir) {
                        ASSERT(dir, "null");
                        m_fontDir = dir;
                        m_index = -2;
                }
        ~Drawer(void) throw() { }

        // glut::Host class interface methods ----------------------------------
        void onInit(void) {
                        // first, find all true type files...
                        this->addFiles("ttf");

                        // create font manager
                        m_fontMgr = glut::FontManager::create();
                        ASSERT_THROW(m_fontMgr,
                            "failed to create font manager");

                        this->updateFont(-1);   // start with default
                }

        bool displayAxes(void) { return false; }

        void onKey(IN int key, IN int mods) {
                        int deltaIndex = 0;
                        switch (key) {
                        case 'n':       deltaIndex = +1;        break;
                        case 'N':       deltaIndex = -1;        break;
                        default:
                                // ignore!
                                break;
                        }

                        int nMax = m_paths.size();
                        int newIndex = m_index + deltaIndex;
                        if (newIndex < -1) {
                                newIndex = nMax - 1;
                        } else if (newIndex >= nMax) {
                                newIndex = -1;
                        }
                        this->updateFont(newIndex);
                }

        void display2D(IN int width, IN int height) {
                        ASSERT(m_currFont, "null");

                        int nMax = m_paths.size();
                        const int bufsize = 1024;
                        char buffer[bufsize];
                        snprintf(buffer, bufsize, "font: %s",
                            m_currFont->getName());
                        glut::Font * defFont = glut::getDefaultFont();
                        defFont->display(1, 47, 0, buffer);
                        snprintf(buffer, bufsize, "font %d of %d",
                            m_index + 1, nMax);
                        defFont->display(1, 62, 0, buffer);
                        snprintf(buffer, bufsize, "font size: %4.1f point",
                            m_currFont->getFaceSize());
                        defFont->display(1, 77, 0, buffer);
                        defFont->display(1, 92, 0, "(n)ext font");
                        int yStart = 92 + 16;

                        glMatrixMode(GL_MODELVIEW);
                        glPushMatrix();
                        glTranslatef(16, yStart, 0);
                        writeLine(m_currFont, "Hello World!");
                        writeLine(m_currFont, "This is line 2...");
                        writeLine(m_currFont, "abcdefghijklmnopqrstuvwxyz");
                        writeLine(m_currFont, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
                        writeLine(m_currFont, "0123456789!@#$%^&*()-=_+");
                        writeLine(m_currFont, "{}[]|\\<>,.?/");
                        writeLine(m_currFont, "ao");
                        writeLine(m_currFont, "___");
                        writeLine(m_currFont, "You have +3 dollars to spend!");
                        writeLine(m_currFont, "This is not a true story");
                        writeLine(m_currFont, "    ...but it could be.");

                        glPopMatrix();
                }
        
private:
        // private typedefs ----------------------------------------------------

        // private helper methods ----------------------------------------------
        void addFiles(IN const char * ext) {
                        ASSERT(ext, "null extension");
                        VecString files;
                        walkDirectoryTree(m_fontDir.c_str(), ext, files);
                        int nFiles = files.size();
                        for (int i = 0; i < nFiles; ++i) {
                                const char * path = files[i].c_str();
                                DPRINTF("Font file: '%s'", path);
                                m_paths.push_back(path);
                        }

                        m_streamMgr =
                            nstream::getFilesystemManager(m_fontDir.c_str());
                        ASSERT(m_streamMgr, "null");
                }

        void updateFont(IN int newIndex) {
                        if (m_index == newIndex)
                                return;         // nothing to do!
                        m_index = newIndex;

                        int nMax = m_paths.size();
                        const char * path = NULL;
                        if (m_index >= 0 && m_index < nMax) {
                                path = m_paths[m_index].c_str();
                        }

                        // open stream here
                        smart_ptr<nstream::Stream> stream;
                        if (path) {
                                stream =
                                    nstream::openNamedStream(m_streamMgr, path);
                                ASSERT(stream,
                                    "failed to open font stream: %s", path);
                        }
                        m_currFont = m_fontMgr->getFont(stream);
                        ASSERT(m_currFont, "null font?");

                        // resize
                        scaleFontToPixelHeight(m_currFont, "M", s_desiredHeight);
                }

        // private member data -------------------------------------------------
        std::string                     m_fontDir;
        VecString                       m_paths;
        smart_ptr<glut::FontManager>    m_fontMgr;
        smart_ptr<nstream::Manager>     m_streamMgr;
        smart_ptr<glut::Font>           m_currFont;
        int                             m_index;
};



////////////////////////////////////////////////////////////////////////////////
//
//      entry point
//
////////////////////////////////////////////////////////////////////////////////

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(2 == argc, "Usage: glut-font-test <font-dir>");
        const char * font_dir = argv[1];
        DPRINTF("Using font directory: '%s'", font_dir);

        try {
                // title
                std::string title = "glut-font test: ";
                title += font_dir;

                // main loop
                smart_ptr<glut::DemoHost> host = new Drawer(font_dir);
                ASSERT(host, "out of memory");
                glut::startDemo(argc, argv, title.c_str(), host);

        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
        }

        // only reach here on error
        return -1;
}