moOGLFT.h

Ir a la documentación de este archivo.

// -*- c++ -*-
/*
 * OGLFT: A library for drawing text with OpenGL using the FreeType library
 * Copyright (C) 2002 lignum Computing, Inc. <oglft@lignumcomputing.com>
 * $Id: OGLFT.h,v 1.15 2003/10/01 14:41:09 allen Exp $
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
#include <moTypes.h>

#ifndef OGLFT_H
#define OGLFT_H

#define OGLFT_NO_QT 1
#ifdef MO_MACOSX
    #define OGLFT_NO_SOLID 1
#endif

#ifdef MO_USING_VC
    #define OGLFT_NO_SOLID 1
#endif

#include <iostream>
#include <iomanip>

#ifdef HAVE_CONFIG_H
//#include <m_Config.h>
#endif
#ifndef OGLFT_NO_QT
#include <qregexp.h>
#endif

#include <cmath>
#include <map>
#include <list>
#include <vector>
#ifdef HAVE_MPATROL
#include <mpdebug.h>
#endif

#ifndef OGLFT_NO_SOLID
#include <GL/gle.h>
#endif

#ifndef OGLFT_NO_QT
#include <qstring.h>
#include <qcolor.h>
#endif

#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_GLYPH_H
#include FT_OUTLINE_H
#include FT_TRIGONOMETRY_H


namespace OGLFT
{

    enum Coordinates
    {
        X,                       
        Y,                       
        Z,                       
        W                        
    };

    enum ColorSpace
    {
        R,                       
        G,                       
        B,                       
        A,                       
    };

    //typedef void (*GLUTessCallback)();
    #ifdef WIN32
    typedef void (__stdcall * GLUTessCallback) (void);
    #else
    typedef void (*GLUTessCallback) (void);
    #endif


    class LIBMOLDEO_API Library
    {
        public:
            static FT_Library & instance (void);

        protected:
            Library (void);
            ~Library (void);

        private:
            static Library library;
            static FT_Library library_;
    };

    struct Advance
    {
        float dx_;               
        float dy_;               

        Advance (float dx = 0, float dy = 0):dx_ (dx), dy_ (dy)
        {
        }

        Advance (FT_Vector v)
        {
            dx_ = v.x / 64.;
            dy_ = v.y / 64.;
        }

        Advance & operator+= (const FT_Vector v)
        {
            dx_ += v.x / 64.;
            dy_ += v.y / 64.;
            return *this;
        }
    };

    struct BBox
    {
        float x_min_;            
        float y_min_;            
        float x_max_;            
        float y_max_;            
        Advance advance_;        

        BBox ():x_min_ (0), y_min_ (0), x_max_ (0), y_max_ (0)
        {
        }

        BBox (FT_BBox ft_bbox)
        {
            x_min_ = ft_bbox.xMin / 64.;
            y_min_ = ft_bbox.yMin / 64.;
            x_max_ = ft_bbox.xMax / 64.;
            y_max_ = ft_bbox.yMax / 64.;
        }

        BBox & operator*= (double k)
        {
            x_min_ *= k;
            y_min_ *= k;
            x_max_ *= k;
            y_max_ *= k;
            advance_.dx_ *= k;
            advance_.dy_ *= k;

            return *this;
        }

        BBox & operator+= (const BBox & b)
        {
            float new_value;

            new_value = b.x_min_ + advance_.dx_;
            if (new_value < x_min_)
                x_min_ = new_value;

            new_value = b.y_min_ + advance_.dy_;
            if (new_value < y_min_)
                y_min_ = new_value;

            new_value = b.x_max_ + advance_.dx_;
            if (new_value > x_max_)
                x_max_ = new_value;

            new_value = b.y_max_ + advance_.dy_;
            if (new_value > y_max_)
                y_max_ = new_value;

            advance_.dx_ += b.advance_.dx_;
            advance_.dy_ += b.advance_.dy_;

            return *this;
        }
    };

    class ColorTess
    {
        public:

            virtual ~ ColorTess ()
            {
            };
            virtual MOfloat *color (MOdouble * p) = 0;
    };

    class TextureTess
    {
        public:
            virtual ~ TextureTess ()
            {
            };
            virtual MOfloat *texCoord (MOdouble * p) = 0;
    };

    typedef std::vector < GLuint > DisplayLists;

    typedef DisplayLists::const_iterator DLCI;

    typedef DisplayLists::iterator DLI;


    class Face
    {
        public:
            enum HorizontalJustification
            {
                LEFT,            
                ORIGIN,          
                CENTER,          
                RIGHT            
            };

            enum VerticalJustification
            {
                BOTTOM,          
                BASELINE,        
                MIDDLE,          
                TOP              
            };

            enum GlyphCompileMode
            {
                COMPILE,         
                IMMEDIATE        
            };

        private:
            struct FaceData
            {
                FT_Face face_;
                bool free_on_exit_;
                FaceData (FT_Face face, bool free_on_exit = true):face_ (face),
                    free_on_exit_
                    (free_on_exit)
                {
                }
            };
        protected:
            std::vector < FaceData > faces_;

            bool valid_;

            enum GlyphCompileMode compile_mode_;

            float point_size_;

            FT_UInt resolution_;

            bool advance_;

            GLfloat foreground_color_[4];

            GLfloat background_color_[4];

            enum HorizontalJustification horizontal_justification_;

            enum VerticalJustification vertical_justification_;

            GLfloat string_rotation_;

            FT_UInt rotation_reference_glyph_;

            FT_Face rotation_reference_face_;

            GLfloat rotation_offset_y_;

            typedef std::map < FT_UInt, GLuint > GlyphDLists;

            typedef GlyphDLists::const_iterator GDLCI;

            typedef GlyphDLists::iterator GDLI;

            GlyphDLists glyph_dlists_;

            DisplayLists character_display_lists_;

        public:
            Face (const char *filename, float point_size = 12, FT_UInt resolution =
                100);

            Face (FT_Face face, float point_size = 12, FT_UInt resolution = 100);

            virtual ~ Face (void);

            bool isValid (void) const
            {
                return valid_;
            }

            bool addAuxiliaryFace (const char *filename);

            bool addAuxiliaryFace (FT_Face face);

            void setCompileMode (enum GlyphCompileMode compile_mode)
            {
                compile_mode_ = compile_mode;
            }

            enum GlyphCompileMode compileMode (void) const
            {
                return compile_mode_;
            }

            void setPointSize (float point_size);

            float pointSize (void)
            {
                return point_size_;
            }

            void setResolution (FT_UInt resolution);

            FT_UInt resolution (void)
            {
                return resolution_;
            }

            void setAdvance (bool advance)
            {
                advance_ = advance;
            }

            bool advance (void) const
            {
                return advance_;
            }

            void setForegroundColor (GLfloat red = 0.0,
                GLfloat green = 0.0,
                GLfloat blue = 0.0, GLfloat alpha = 1.0);

            void setForegroundColor (const GLfloat foreground_color[4]);
        #ifndef OGLFT_NO_QT

            void setForegroundColor (const QRgb foreground_color);
        #endif                   /* OGLFT_NO_QT */

            GLfloat foregroundRed (void) const
            {
                return foreground_color_[R];
            }
            GLfloat foregroundGreen (void) const
            {
                return foreground_color_[G];
            }
            GLfloat foregroundBlue (void) const
            {
                return foreground_color_[B];
            }
            GLfloat foregroundAlpha (void) const
            {
                return foreground_color_[A];
            }

            void setBackgroundColor (GLfloat red = 1.0,
                GLfloat green = 1.0,
                GLfloat blue = 1.0, GLfloat alpha = 0.0);

            void setBackgroundColor (const GLfloat background_color[4]);
        #ifndef OGLFT_NO_QT

            void setBackgroundColor (const QRgb background_color);
        #endif                   /* OGLFT_NO_QT */

            GLfloat backgroundRed (void) const
            {
                return background_color_[R];
            }
            GLfloat backgroundGreen (void) const
            {
                return background_color_[G];
            }
            GLfloat backgroundBlue (void) const
            {
                return background_color_[B];
            }
            GLfloat backgroundAlpha (void) const
            {
                return background_color_[A];
            }

            virtual void setCharacterRotationZ (GLfloat character_rotation_z) = 0;

            virtual GLfloat characterRotationZ (void) const = 0;

            void setCharacterRotationReference (unsigned char c);

            void setStringRotation (GLfloat string_rotation);

            GLfloat stringRotation (void) const
            {
                return string_rotation_;
            }

            void setHorizontalJustification (enum HorizontalJustification
            horizontal_justification)
            {
                horizontal_justification_ = horizontal_justification;
            }

            enum HorizontalJustification horizontalJustification (void) const
            {
                return horizontal_justification_;
            }

            void setVerticalJustification (enum VerticalJustification
            vertical_justification)
            {
                vertical_justification_ = vertical_justification;
            }

            enum VerticalJustification verticaljustification (void) const
            {
                return vertical_justification_;
            }

            void setCharacterDisplayLists (const DisplayLists & character_display_lists)
            {
                character_display_lists_ = character_display_lists;
            }

            DisplayLists & characterDisplayLists (void)
            {
                return character_display_lists_;
            }

            virtual double height (void) const = 0;

            virtual BBox measure (unsigned char c) = 0;
        #ifndef OGLFT_NO_QT

            virtual BBox measure (QChar c) = 0;
        #endif                   /* OGLFT_NO_QT */

            virtual BBox measure (const char *s);
            virtual BBox measureRaw (const char *s);
        #ifndef OGLFT_NO_QT

            virtual BBox measure (const QString & s);
            virtual BBox measure (const QString & format, double number);
            virtual BBox measureRaw (const QString & s);
        #endif                   /* OGLFT_NO_QT */

            GLuint compile (const char *s);
        #ifndef OGLFT_NO_QT

            GLuint compile (const QString & s);
        #endif                   /* OGLFT_NO_QT */

            GLuint compile (unsigned char c);
        #ifndef OGLFT_NO_QT

            GLuint compile (const QChar c);
        #endif                   /* OGLFT_NO_QT */

            void draw (const char *s);
        #ifndef OGLFT_NO_QT

            void draw (const QString & s);
        #endif                   /* OGLFT_NO_QT */

            void draw (unsigned char c);

        #ifndef OGLFT_NO_QT

            void draw (const QChar c);
        #endif                   /* OGLFT_NO_QT */

            void draw (GLfloat x, GLfloat y, unsigned char c);
            void draw (GLfloat x, GLfloat y, GLfloat z, unsigned char c);
        #ifndef OGLFT_NO_QT

            void draw (GLfloat x, GLfloat y, QChar c);
            void draw (GLfloat x, GLfloat y, GLfloat z, QChar c);
        #endif                   /* OGLFT_NO_QT */

            void draw (GLfloat x, GLfloat y, const char *s);
            void draw (GLfloat x, GLfloat y, GLfloat z, const char *s);
        #ifndef OGLFT_NO_QT

            void draw (GLfloat x, GLfloat y, const QString & s);
            void draw (GLfloat x, GLfloat y, GLfloat z, const QString & s);
            void draw (GLfloat x, GLfloat y, const QString & format, double number);
            void draw (GLfloat x, GLfloat y, GLfloat z, const QString & format,
                double number);
        #endif                   /* OGLFT_NO_QT */

            int ascender (void)
            {
                return faces_.front ().face_->ascender;
            }

            int descender (void)
            {
                return faces_.front ().face_->descender;
            }

        protected:
            // The various styles override these routines

            virtual GLuint compileGlyph (FT_Face face, FT_UInt glyph_index) = 0;

            virtual void renderGlyph (FT_Face face, FT_UInt glyph_index) = 0;

            virtual void setCharSize (void) = 0;

            virtual void clearCaches (void) = 0;

            virtual void setRotationOffset (void) = 0;

        private:
            void init (void);
            BBox measure_nominal (const char *s);
        #ifndef OGLFT_NO_QT
            BBox measure_nominal (const QString & s);
            QString format_number (const QString & format, double number);
        #endif                   /* OGLFT_NO_QT */
    };


    class Polygonal:public Face
    {
        protected:
            struct
            {
                bool active_;
                GLfloat x_, y_, z_;
            } character_rotation_;

            unsigned int tessellation_steps_;

            double delta_, delta2_, delta3_;

            double vector_scale_;

            FT_Outline_Funcs interface_;

            static const unsigned int DEFAULT_TESSELLATION_STEPS = 4;

            struct LIBMOLDEO_API VertexInfo
            {
                double v_[3];    

                ColorTess *color_tess_;

                TextureTess *texture_tess_;

                VertexInfo (ColorTess * color_tess = 0, TextureTess * texture_tess = 0):color_tess_ (color_tess),
                    texture_tess_
                    (texture_tess)
                {
                    v_[X] = v_[Y] = v_[Z] = 0.;
                }

                VertexInfo (FT_Vector * ft_v, ColorTess * color_tess = 0, TextureTess * texture_tess = 0):color_tess_ (color_tess),
                    texture_tess_
                    (texture_tess)
                {
                    v_[X] = (double) (ft_v->x / 64) + (double) (ft_v->x % 64) / 64.;
                    v_[Y] = (double) (ft_v->y / 64) + (double) (ft_v->y % 64) / 64.;
                    v_[Z] = 0.;
                }

                VertexInfo (double p[2], ColorTess * color_tess = 0, TextureTess * texture_tess = 0):color_tess_ (color_tess),
                    texture_tess_
                    (texture_tess)
                {
                    v_[X] = p[X];
                    v_[Y] = p[Y];
                    v_[Z] = 0.;
                }

                VertexInfo (double x, double y, ColorTess * color_tess = 0, TextureTess * texture_tess = 0):color_tess_ (color_tess),
                    texture_tess_
                    (texture_tess)
                {
                    v_[X] = x;
                    v_[Y] = y;
                    v_[Z] = 0.;
                }

                void normalize (void)
                {
                    double length = sqrt (v_[X] * v_[X] + v_[Y] * v_[Y] + v_[Z] * v_[Z]);
                    v_[X] /= length;
                    v_[Y] /= length;
                    v_[Z] /= length;
                }
            };

            VertexInfo last_vertex_;

            typedef std::list < VertexInfo * >VertexInfoList;

            typedef VertexInfoList::const_iterator VILCI;

            typedef VertexInfoList::iterator VILI;

            VertexInfoList vertices_;

            bool contour_open_;

            ColorTess *color_tess_;

            TextureTess *texture_tess_;

        public:
            Polygonal (const char *filename, float point_size = 12,
                FT_UInt resolution = 100);

            Polygonal (FT_Face face, float point_size = 12, FT_UInt resolution = 100);

            virtual ~ Polygonal (void);

            void setTessellationSteps (unsigned int tessellation_steps);

            unsigned int tessellationSteps (void) const
            {
                return tessellation_steps_;
            }

            void setCharacterRotationX (GLfloat character_rotation_x);

            void setCharacterRotationY (GLfloat character_rotation_y);

            void setCharacterRotationZ (GLfloat character_rotation_z);

            GLfloat characterRotationX (void) const
            {
                return character_rotation_.x_;
            }

            GLfloat characterRotationY (void) const
            {
                return character_rotation_.y_;
            }

            GLfloat characterRotationZ (void) const
            {
                return character_rotation_.z_;
            }

            void setColorTess (ColorTess * color_tess);
            ColorTess *colorTess (void) const
            {
                return color_tess_;
            }
            void setTextureTess (TextureTess * texture_tess);
            TextureTess *textureTess (void) const
            {
                return texture_tess_;
            }

            double height (void) const;

            BBox measure (unsigned char c);
        #ifndef OGLFT_NO_QT

            BBox measure (const QChar c);
        #endif                   /* OGLFT_NO_QT */

            BBox measure (const char *s)
            {
                return Face::measure (s);
            }
        #ifndef OGLFT_NO_QT

            BBox measure (const QString & format, double number)
            {
                return Face::measure (format, number);
            }
        #endif                   /* OGLFT_NO_QT */

        private:
            void init (void);
            void setCharSize (void);
            void setRotationOffset (void);
            GLuint compileGlyph (FT_Face face, FT_UInt glyph_index);
        protected:
            void clearCaches (void);
    };


    class Outline:public Polygonal
    {
        public:
            Outline (const char *filename, float point_size = 12,
                FT_UInt resolution = 100);
            Outline (FT_Face face, float point_size = 12, FT_UInt resolution = 100);

            ~Outline (void);
        private:
            void init (void);
            void renderGlyph (FT_Face face, FT_UInt glyph_index);
            static int moveToCallback (FT_Vector * to, Outline * outline);
            static int lineToCallback (FT_Vector * to, Outline * outline);
            static int conicToCallback (FT_Vector * control, FT_Vector * to,
                Outline * outline);
            static int cubicToCallback (FT_Vector * control1, FT_Vector * control2,
                FT_Vector * to, Outline * outline);
    };


    class Filled:public Polygonal
    {
        GLUtesselator *tess_obj_;

        VertexInfoList extra_vertices_;

        protected:
            GLfloat depth_offset_;

        public:
            Filled (const char *filename, float point_size = 12,
                FT_UInt resolution = 100);
            Filled (FT_Face face, float point_size = 12, FT_UInt resolution = 100);
            virtual ~ Filled (void);

            VertexInfoList & extraVertices (void)
            {
                return extra_vertices_;
            }

        protected:
            void renderGlyph (FT_Face face, FT_UInt glyph_index);
        private:
            void init (void);
            static int moveToCallback (FT_Vector * to, Filled * filled);
            static int lineToCallback (FT_Vector * to, Filled * filled);
            static int conicToCallback (FT_Vector * control, FT_Vector * to,
                Filled * filled);
            static int cubicToCallback (FT_Vector * control1, FT_Vector * control2,
                FT_Vector * to, Filled * filled);
            static void vertexCallback (VertexInfo * vertex);
            static void beginCallback (GLenum which);
            static void endCallback (void);
            static void combineCallback (GLdouble coords[3], void *vertex_data[4],
                GLfloat weight[4], void **out_data,
                Filled * filled);
            static void errorCallback (GLenum error_code);
    };

    #ifndef OGLFT_NO_SOLID

    class Solid:public Filled
    {
        private:

            FT_Outline_Funcs interface_;

            static const unsigned int N_POLYLINE_PTS = 4;

            struct glePoint2D
            {
                double p_[2];
                glePoint2D (double p[2])
                {
                    p_[X] = p[X];
                    p_[Y] = p[Y];
                }
                glePoint2D (double x, double y)
                {
                    p_[X] = x;
                    p_[Y] = y;
                }
                glePoint2D (const VertexInfo & v)
                {
                    p_[X] = v.v_[X];
                    p_[Y] = v.v_[Y];
                }
            };

            struct
            {
                double depth_;
                struct
                {
                    int x_, y_;
                } normal_sign_;
                std::vector < glePoint2D > contour_;
                std::vector < glePoint2D > contour_normals_;
                gleDouble up_[3];
                int n_polyline_pts_;
                gleDouble point_array_[N_POLYLINE_PTS][3];
            } extrusion_;

        public:
            Solid (const char *filename, float point_size = 12, FT_UInt resolution =
                100);

            Solid (FT_Face face, float point_size = 12, FT_UInt resolution = 100);

            ~Solid (void);
            void setDepth (double depth);

            double depth (void) const
            {
                return extrusion_.depth_;
            }

        private:
            // It would be nice if C/C++ had real matrix notation (like Perl!)
            void assign (gleDouble a[3], double x, double y, double z)
            {
                a[X] = x;
                a[Y] = y;
                a[Z] = z;
            }

            void init (void);
            void renderGlyph (FT_Face face, FT_UInt glyph_index);
            static int moveToCallback (FT_Vector * to, Solid * solid);
            static int lineToCallback (FT_Vector * to, Solid * solid);
            static int conicToCallback (FT_Vector * control, FT_Vector * to,
                Solid * solid);
            static int cubicToCallback (FT_Vector * control1, FT_Vector * control2,
                FT_Vector * to, Solid * solid);
    };
    #endif                       /* OGLFT_NO_SOLID */

    class Raster:public Face
    {
        protected:
            GLfloat character_rotation_z_;
        public:
            Raster (const char *filename, float point_size = 12, FT_UInt resolution =
                100);
            Raster (FT_Face face, float point_size = 12, FT_UInt resolution = 100);
            virtual ~ Raster (void);
            void setCharacterRotationZ (GLfloat character_rotation_z);
            GLfloat characterRotationZ (void) const
            {
                return character_rotation_z_;
            }

            double height (void) const;

            BBox measure (unsigned char c);
        #ifndef OGLFT_NO_QT

            BBox measure (const QChar c);
        #endif                   /* OGLFT_NO_QT */

            BBox measure (const char *s)
            {
                return Face::measure (s);
            }
        #ifndef OGLFT_NO_QT

            BBox measure (const QString & format, double number)
            {
                return Face::measure (format, number);
            }
        #endif                   /* OGLFT_NO_QT */

        private:
            void init (void);
            GLuint compileGlyph (FT_Face face, FT_UInt glyph_index);
            void setCharSize (void);
            void setRotationOffset (void);
            void clearCaches (void);
    };


    class Monochrome:public Raster
    {
        public:
            Monochrome (const char *filename, float point_size = 12,
                FT_UInt resolution = 100);
            Monochrome (FT_Face face, float point_size = 12, FT_UInt resolution =
                100);
            ~Monochrome (void);
        private:
            GLubyte * invertBitmap (const FT_Bitmap & bitmap);
            void renderGlyph (FT_Face face, FT_UInt glyph_index);
    };


    class Grayscale:public Raster
    {
        public:
            Grayscale (const char *filename, float point_size = 12,
                FT_UInt resolution = 100);
            Grayscale (FT_Face face, float point_size = 12, FT_UInt resolution = 100);
            ~Grayscale (void);
        private:
            GLubyte * invertPixmap (const FT_Bitmap & bitmap);
            void renderGlyph (FT_Face face, FT_UInt glyph_index);
    };


    class Translucent:public Raster
    {
        public:
            Translucent (const char *filename, float point_size = 12,
                FT_UInt resolution = 100);
            Translucent (FT_Face face, float point_size = 12, FT_UInt resolution =
                100);

            ~Translucent (void);

        private:
            GLubyte * invertPixmapWithAlpha (const FT_Bitmap & bitmap);
            void renderGlyph (FT_Face face, FT_UInt glyph_index);
    };

    class Texture:public Face
    {
        protected:
            struct
            {
                bool active_;    
                GLfloat x_,      
                    y_,          
                    z_;          
            } character_rotation_;

            struct TextureInfo
            {
                GLuint texture_name_;
                FT_Int left_bearing_,
                    bottom_bearing_;
                int width_,      
                    height_;     
                GLfloat texture_s_,
                    texture_t_;  
                FT_Vector advance_;
            };

            typedef std::map < FT_UInt, TextureInfo > GlyphTexObjs;

            typedef GlyphTexObjs::const_iterator GTOCI;

            typedef GlyphTexObjs::iterator GTOI;

            GlyphTexObjs glyph_texobjs_;

        public:
            Texture (const char *filename, float point_size = 12,
                FT_UInt resolution = 100);

            Texture (FT_Face face, float point_size = 12, FT_UInt resolution = 100);

            virtual ~ Texture (void);
            void setCharacterRotationX (GLfloat character_rotation_x);

            void setCharacterRotationY (GLfloat character_rotation_y);

            void setCharacterRotationZ (GLfloat character_rotation_z);

            GLfloat characterRotationX (void) const
            {
                return character_rotation_.x_;
            }

            GLfloat characterRotationY (void) const
            {
                return character_rotation_.y_;
            }

            GLfloat characterRotationZ (void) const
            {
                return character_rotation_.z_;
            }

            double height (void) const;

            BBox measure (unsigned char c);
        #ifndef OGLFT_NO_QT

            BBox measure (const QChar c);
        #endif                   /* OGLFT_NO_QT */

            BBox measure (const char *s)
            {
                return Face::measure (s);
            }
        #ifndef OGLFT_NO_QT

            BBox measure (const QString & format, double number)
            {
                return Face::measure (format, number);
            }
        #endif                   /* OGLFT_NO_QT */

        protected:
            unsigned int nearestPowerCeil (unsigned int a);
            virtual void bindTexture (FT_Face face, FT_UInt glyph_index) = 0;

        private:
            void init (void);
            void setCharSize (void);
            void setRotationOffset (void);
            GLuint compileGlyph (FT_Face face, FT_UInt glyph_index);
            void renderGlyph (FT_Face face, FT_UInt glyph_index);
            void clearCaches (void);
    };


    class MonochromeTexture:public Texture
    {
        public:
            MonochromeTexture (const char *filename, float point_size = 12,
                FT_UInt resolution = 100);
            MonochromeTexture (FT_Face face, float point_size = 12,
                FT_UInt resolution = 100);
            ~MonochromeTexture (void);
        private:
            GLubyte * invertBitmap (const FT_Bitmap & bitmap, int *width,
                int *height);
            void bindTexture (FT_Face face, FT_UInt glyph_index);
    };


    class GrayscaleTexture:public Texture
    {
        public:
            GrayscaleTexture (const char *filename, float point_size = 12,
                FT_UInt resolution = 100);
            GrayscaleTexture (FT_Face face, float point_size = 12,
                FT_UInt resolution = 100);
            ~GrayscaleTexture (void);
        private:
            GLubyte * invertPixmap (const FT_Bitmap & bitmap, int *width,
                int *height);
            void bindTexture (FT_Face face, FT_UInt glyph_index);
    };


    class TranslucentTexture:public Texture
    {
        public:
            TranslucentTexture (const char *filename, float point_size = 12,
                FT_UInt resolution = 100);
            TranslucentTexture (FT_Face face, float point_size = 12,
                FT_UInt resolution = 100);
            ~TranslucentTexture (void);
        private:
            GLubyte * invertPixmap (const FT_Bitmap & bitmap, int *width,
                int *height);
            void bindTexture (FT_Face face, FT_UInt glyph_index);
    };
}                                // Close OGLFT namespace
#endif                           /* OGLFT_H */