glut-font-effects.cpp

Go to the documentation of this file.

/*
 * glut-font-effects.cpp
 *
 * Copyright (C) 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.
 *
 * Some font effects.  See glut-font-effects.h
 */

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

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


namespace glut {


// interface destructors
FontEffect::~FontEffect(void) throw() { }


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


////////////////////////////////////////////////////////////////////////////////
//
//      CharStep - class that implements glut::FontEffect and advances lines one
//      character at a time.
//
////////////////////////////////////////////////////////////////////////////////

class CharStep : public FontEffect {
public:
        ~CharStep(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN smart_ptr<Font>& font,
                                IN const char * lines,
                                IN int msPerChar,
                                IN const glut_color_t& color);

        // glut::FontEffect class interface methods ----------------------------
        void tick(IN float deltaT);
        void render(void);
        void reset(void);
        void advance(void);
        void complete(void);

private:
        // private typedefs ----------------------------------------------------
        // private helper methods ----------------------------------------------
        utf8_char_t addChar(void);

        // private member data -------------------------------------------------
        smart_ptr<Font>         m_font;
        glut_color_t            m_color;
        std::string             m_text;
        VecString               m_lines;
        int                     m_msPerChar;
        float                   m_time;
        const char *            m_curr;
        int                     m_currLine;
};



void
CharStep::initialize
(
IN smart_ptr<Font>& font,
IN const char * lines,
IN int msPerChar,
IN const glut_color_t& color
)
{
        ASSERT(font, "null");
        ASSERT(lines, "null");
        ASSERT(msPerChar >= 0, "Bad ms per character: %d", msPerChar);

        m_font = font;
        m_color = color;
        m_time = 0.0;
        m_msPerChar = msPerChar;

        // save raw lines
        m_text = lines;

        this->reset();
}



void
CharStep::tick
(
IN float deltaT
)
{
        if (deltaT <= 0.0 || !m_curr)
                return;         // do nothing!
        m_time += deltaT;

//      DPRINTF("m_time = %f", m_time);
        int nChars = (int) (1000.0 * m_time / m_msPerChar);
        m_time -= 0.001 * nChars * m_msPerChar;
//      DPRINTF("  nChars = %d", nChars);

        // add these characters to our buffers
        for (int i = 0; i < nChars; ++i) {
                this->addChar();
        }
}



void
CharStep::render
(
void
)
{
        ASSERT(m_font, "null");

        glColor4f(m_color.red, m_color.green, m_color.blue, m_color.alpha);

        int dy = m_font->getLineHeight() + 2;

        int nLines = m_lines.size();
        for (int i = 0; i < nLines; ++i) {
                const char * line = m_lines[i].c_str();
                m_font->display(0, 0, 0, line);
                glTranslatef(0, dy, 0);
        }
}



void
CharStep::advance
(
void
)
{
        while (true) {
                utf8_char_t c = this->addChar();
                if (!c || c == '\n')
                        return;
        }
}



void
CharStep::complete
(
void
)
{
        while (this->addChar()) { }
}



void
CharStep::reset
(
void
)
{
        // start back at beginning of input text
        m_curr = m_text.c_str();

        // clear array of lines
        m_lines.clear();

        // start with new empty line
        m_lines.push_back("");
        m_currLine = 0;
}



utf8_char_t
CharStep::addChar
(
void
)
{
        utf8_char_t c;
        if (!m_curr)
                return c;       // end of input characters!

        m_curr = getUTF8CharacterFromString(m_curr, c);
        if (c.nBytes < 1) {
                DPRINTF("Bad UTF8 character in string?");
                m_curr = NULL;  // stop parsing...
                return c;
        }
        if (0 == c.value[0]) {
                // end of input text
                m_curr = NULL;
        } else if ('\n' == c.value[0]) {
                // newline!
                m_currLine++;
                m_lines.push_back("");  // new empty line
        } else {
                // append to line
                const char * line = m_lines[m_currLine].c_str();
                std::string newLine = line;
                newLine += c.value;     // multibyte
//              DPRINTF("Line: '%s'", newLine.c_str());
                m_lines[m_currLine] = newLine;
        }

        return c;
}



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

smart_ptr<FontEffect>
getCharacterAdvanceEffect
(
IN smart_ptr<Font>& font,
IN const char * lines,
IN int millisecondsPerCharacter,
IN const glut_color_t& color
)
{
        ASSERT(font, "null");
        ASSERT(lines, "null");
        ASSERT(millisecondsPerCharacter >= 0, "bad milliseconds: %d",
            millisecondsPerCharacter);

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

        local->initialize(font, lines, millisecondsPerCharacter, color);

        return local;
}



void
breakLongString
(
IN const char * text,
IN Font * font,
IN int maxPixelWidth,
OUT std::string& out
)
{
        ASSERT(text, "null");
        ASSERT(font, "null");
        out.clear();

        // keep looping through lines
        std::string line;
        while (*text) {
                std::string word;

                // keep parsing words
                text = getNextWord(text, word);
                if ("\n" == word) {
                        // next line
                        out += line;
                        out += "\n";
                        line.clear();
                } else if ("" == line) {
                        // line is empty, so line now becomes word
                        line = word;
                } else {
                        // see if we can add word to non-empty line
                        std::string candidate_line = line;
                        candidate_line += " ";
                        candidate_line += word;

                        // how long is this line?
                        font_rect_t fr =
                            font->getBoundingRect(candidate_line.c_str());
                        int width = fr.lead + fr.trail;
                        if (width > maxPixelWidth) {
                                // line is too long!
                                if ("" != line) {
                                        out += line;
                                        out += "\n";
                                }
                                line = word;
                        } else {
                                // line is within bounds
                                line = candidate_line;
                        }
                }
        }

        if (!line.empty()) {
                out += line;
        }
}



};      // glut namespace