glut-font.h

Go to the documentation of this file.

/*
 * glut-font.h
 *
 * 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.
 *
 */

#ifndef WAVE_GLUT_GLUT_FONT_H__
#define WAVE_GLUT_GLUT_FONT_H__

// includes --------------------------------------------------------------------
#include "common/common.h"
#include "geometry/geometry_2d.h"
#include "nstream/nstream.h"
#include "threadsafe/smart_ptr.h"


namespace glut {

////////////////////////////////////////////////////////////////////////////////
///
/// \ingroup wave_glut
/// \defgroup glut_font Glut Font Library
///
/// A font helper library.  Keeps other code abstracted from the details of
/// font implementation.  Currently this is a wrapper on top of the FTGL
/// library.
///
/// \b WARNING: this library is used for 2D font rendering.  That is, it assumes
/// that we are in 2D rendering mode (see the glut::push2D() and pop2D()
/// methods).  This library uses the wavepacket convention for 2D coordinates:
/// y=0 is the TOP of the screen, and y=height is the BOTTOM of the screen.
/// That is a bit unusual: OpenGL flips that convention (and OpenGL's convention
/// is probably better).  But for legacy reasons, this library uses the
/// wavepacket convention.
///
/// This means, for instance, that it is *very* awkward to attempt to use these
/// routines to render while in 3D rendering mode.
///
////////////////////////////////////////////////////////////////////////////////

/*@{*/


/// standard 2D pixel rect
typedef rect2d_t<int> pixel_rect_t;



/// font sizing information
struct font_rect_t {
        // constructor, manipulators
        font_rect_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        lead = trail = drop = rise = 0;
                }
        void getPixelRect(OUT pixel_rect_t& pr) const throw() {
                        pr.left = -lead;
                        pr.right = trail;
                        pr.top = -rise;
                        pr.bottom = drop;
                }

        // data fields
        int     lead;           ///< pixels leading (to left of) draw origin
        int     trail;          ///< pixels trailing (to right of) draw origin
        int     drop;           ///< pixels falling below draw origin
        int     rise;           ///< pixels above draw origin
};



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

/// a basic font class.  Mostly delegates to the actual FTGL implementation
///     (see \ref ftgl)
class Font {
public:
        // virtual destructor --------------------------------------------------
        virtual ~Font(void) throw();

        // glut::Font class interface methods ----------------------------------
        virtual const char * getName(void) const throw() = 0;
        virtual font_rect_t getBoundingRect(IN const char * text) = 0;
        virtual void display(IN float x, IN float y, IN float z,
                                IN const char * text) = 0;
        virtual bool canScale(void) const throw() = 0;
        virtual bool setFaceSize(IN float pointSize) = 0;
        virtual float getFaceSize(void) const throw() = 0;
        virtual int getLineHeight(void) const throw() = 0;
};



/// the font manager
class FontManager {
public:
        // virtual destructor --------------------------------------------------
        virtual ~FontManager(void) throw();

        // glut::FontManager class interface methods ---------------------------

        /// retrieve (and create if necessary) a font from the given true type
        ///     font file (.ttf) stream.  If stream is null, a default font will
        ///     be used (if available).  Always returns non-null (throws an
        ///     exception on any error).
        virtual smart_ptr<Font> getFont(IN nstream::Stream * stream) = 0;

        // static factory methods ----------------------------------------------
        static smart_ptr<FontManager> create(void);
};



/// retrieve the default font (throws if there isn't one)
smart_ptr<Font> getDefaultFont(void);


/// scale the given font to the specified height in pixels.  Returns false if
///     this was not possible (for instance, the font isn't scalable).  Caller
///     must specify what text they are scaling for (capital M is common)
bool scaleFontToPixelHeight(IO Font * font,
                        IN const char * textToScale,
                        IN int desiredPixelHeight);


};      // glut namespace

#endif  // WAVE_GLUT_GLUT_FONT_H__