effects.cpp

Go to the documentation of this file.

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

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

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



static const int s_border                       = 32;

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

static const char * s_lines                     =
        "This is a test. "
        "This is line 2. "
        "This is line 3. "
        "This is a really, really long line.  Really.  It's quite long. "
        "Short. "
        "You have found +3 dollars and +8 Euros!  Spend them wisely. "
        "0123456789 "
        "abcdefghijklmnopqrstuvwxyz That isn't really a word. "
        "Today: cloudy with showers.  High 59F.  Winds SSE at 5 to 10 mph.  Chance of rain 60%. "
        "Good bye! "
        "End of line.";

static const int s_msPerChar                    = 50;

static const glut_color_t s_color(0.5, 1.0, 0.5);


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

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");

                        m_width = 800;          // start with this
                        this->updateFont(-1);   // start with default

                        // time
                        m_time = perf::getNow();
                }

        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;
                        case ' ':       m_effect->reset();      break;
                        case 'a':       m_effect->advance();    break;
                        case 'c':       m_effect->complete();   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");
                        ASSERT(m_effect, "null");

                        m_width = width;

                        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");
                        defFont->display(width - 300, 62, 0, "(space): reset");
                        defFont->display(width - 300, 77, 0, "(a)dvance");
                        defFont->display(width - 300, 92, 0, "(c)omplete");
                        int yStart = 92 + s_border + m_currFont->getLineHeight();

                        perf::time_t now = perf::getNow();
                        perf::time_t delta = now;
                        delta.decrement(m_time);
                        m_time = now;
                        m_effect->tick(delta.getSeconds());

                        glBegin(GL_LINES);
                                glVertex3f(s_border, 0, 0);
                                glVertex3f(s_border, height, 0);
                                glVertex3f(width - s_border, 0, 0);
                                glVertex3f(width - s_border, height, 0);
                        glEnd();

                        glMatrixMode(GL_MODELVIEW);
                        glPushMatrix();
                        glTranslatef(s_border, yStart, 0);

                        m_effect->render();

                        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();
                                std::string full_path;
                                appendPath(m_fontDir.c_str(), path, full_path);
                                DPRINTF("Font file: '%s'", full_path.c_str());

                                m_paths.push_back(full_path);
                        }
                }

        void updateFont(IN int newIndex) {
                        if (m_currFont && 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();
                        }
                        m_currFont = m_fontMgr->getFont(path);
                        ASSERT(m_currFont, "null font?");

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

                        // parse into lines
                        std::string lines;
                        glut::breakLongString(s_lines, m_currFont,
                            m_width - 2 * s_border, lines);
                        DPRINTF("Lines:\n%s", lines.c_str());

                        // create font effect
                        m_effect = glut::getCharacterAdvanceEffect(m_currFont,
                                        lines.c_str(), s_msPerChar, s_color);
                }

        // private member data -------------------------------------------------
        std::string                     m_fontDir;
        VecString                       m_paths;
        smart_ptr<glut::FontManager>    m_fontMgr;
        smart_ptr<glut::Font>           m_currFont;
        smart_ptr<glut::FontEffect>     m_effect;
        int                             m_index;
        perf::time_t                    m_time;
        int                             m_width;
};



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

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

        try {
                // title
                std::string title = "glut-font FontEffect 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;
}