xrb_asciifont.hpp

// ///////////////////////////////////////////////////////////////////////////
// xrb_asciifont.hpp by Victor Dods, created 2005/06/05
// ///////////////////////////////////////////////////////////////////////////
// Unless a different license was explicitly granted in writing by the
// copyright holder (Victor Dods), this software is freely distributable under
// the terms of the GNU General Public License, version 2.  Any works deriving
// from this work must also be released under the GNU GPL.  See the included
// file LICENSE for details.
// ///////////////////////////////////////////////////////////////////////////

#if !defined(_XRB_ASCIIFONT_HPP_)
#define _XRB_ASCIIFONT_HPP_

#include "xrb.hpp"

#include <string>

#include "xrb_font.hpp"
#include "xrb_screencoord.hpp"

namespace Xrb
{

class GLTexture;
class RenderContext;
class Serializer;
class Texture;

class AsciiFont : public Font
{
public:

    virtual ~AsciiFont ()
    {
        Delete(m_gl_texture);
    }

    // ///////////////////////////////////////////////////////////////////////
    // font metrics and font bitmap rendering stuff
    // ///////////////////////////////////////////////////////////////////////

    enum
    {
        TAB_SIZE = 4,

        RENDERED_GLYPH_LOWEST = ' ',
        RENDERED_GLYPH_HIGHEST = '~',

        RENDERED_GLYPH_COUNT = RENDERED_GLYPH_HIGHEST - RENDERED_GLYPH_LOWEST + 1
    };

    struct GlyphSpecification
    {
        char m_ascii;
        ScreenCoordVector2 m_size;
        FontCoordVector2 m_bearing_26_6;
        FontCoord m_advance_26_6;
        ScreenCoordVector2 m_texture_coordinates;

        void Read (Serializer &serializer);
        void Write (Serializer &serializer) const;

        static int SortByWidthFirst (
            void const *left_operand,
            void const *right_operand);
        static int SortByHeightFirst (
            void const *left_operand,
            void const *right_operand);
    }; // end of class GlyphSpecification

    static Uint32 GlyphIndex (char ascii)
    {
        if (ascii >= RENDERED_GLYPH_LOWEST && ascii <= RENDERED_GLYPH_HIGHEST)
            return ascii - RENDERED_GLYPH_LOWEST;
        else
            return ms_error_glyph - RENDERED_GLYPH_LOWEST;
    }
    static char AsciiValue (Uint32 glyph_index)
    {
        if (glyph_index >= RENDERED_GLYPH_COUNT)
            return char(ms_error_glyph);
        else
            return glyph_index + RENDERED_GLYPH_LOWEST;
    }

    static AsciiFont *CreateFromCache (
        std::string const &font_face_path,
        ScreenCoord pixel_height);

    static AsciiFont *Create (
        std::string const &font_face_path,
        ScreenCoord pixel_height,
        bool has_kerning,
        ScreenCoord baseline_height,
        GlyphSpecification sorted_glyph_specification[RENDERED_GLYPH_COUNT],
        FontCoord kern_pair_26_6[RENDERED_GLYPH_COUNT*RENDERED_GLYPH_COUNT],
        Texture *font_texture);

    bool CacheToDisk (Texture *font_texture) const;

    // ///////////////////////////////////////////////////////////////////////
    // public Font interface methods
    // ///////////////////////////////////////////////////////////////////////

    virtual void MoveThroughGlyph (
        FontCoordVector2 *pen_position_26_6,
        ScreenCoordVector2 const &initial_pen_position,
        char const *current_glyph,
        char const *next_glyph,
        Uint32 *remaining_glyph_count = NULL,
        FontCoord *major_space_26_6 = NULL) const;

    virtual void GenerateWordWrappedString (
        std::string const &source_string,
        std::string *dest_string,
        ScreenCoordVector2 const &text_area) const;

protected:

    AsciiFont (std::string const &font_face_path, ScreenCoord pixel_height)
        :
        Font(font_face_path, pixel_height)
    {
        m_gl_texture = NULL;
    }

    // ///////////////////////////////////////////////////////////////////////
    // protected Font interface methods
    // ///////////////////////////////////////////////////////////////////////

    virtual void DrawGlyphSetup (RenderContext const &render_context) const;
    virtual void DrawGlyphShutdown (RenderContext const &render_context) const;
    virtual void DrawGlyph (
        RenderContext const &render_context,
        char const *glyph,
        FontCoordVector2 const &pen_position_26_6) const;

private:

    // for a simple check against cache corruption / stale cache data
    Uint32 Hash () const;
    FontCoord KernPair_26_6 (char left, char right) const;

    // ///////////////////////////////////////////////////////////////////////
    // text justification stuff
    // ///////////////////////////////////////////////////////////////////////

    enum TokenClass
    {
        WHITESPACE = 0,
        WORD,
        NEWLINE,
        NULLCHAR
    }; // end of enum TokenClass

    static TokenClass GetTokenClass (char const c);
    static char const *StartOfNextToken (char const *string);
    FontCoord TokenWidth_26_6 (char const *string) const;

    // ///////////////////////////////////////////////////////////////////////
    // member vars
    // ///////////////////////////////////////////////////////////////////////

    // the unicode value of the "error glyph"
    static Uint32 const ms_error_glyph = '?';

    // true iff the font has kerning enabled
    bool m_has_kerning;
    // height from bottom of font glyph coordinates
    ScreenCoord m_baseline_height;
    // metadata for each glyph (texture coordinates, etc)
    GlyphSpecification m_glyph_specification[RENDERED_GLYPH_COUNT];
    // cached kerning data -- all possible pairs of glyphs
    FontCoord m_kern_pair_26_6[RENDERED_GLYPH_COUNT*RENDERED_GLYPH_COUNT];
    // pointer to the GLTexture containing the font bitmap
    GLTexture *m_gl_texture;
}; // end of class AsciiFont

} // end of namespace Xrb

#endif // !defined(_XRB_ASCIIFONT_HPP_)

---