initial commit

ftgl/FTBBox.h

@@ -0,0 +1,124 @@
+#ifndef     __FTBBox__
+#define     __FTBBox__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+//#include FT_GLYPH_H
+#include FT_OUTLINE_H
+
+#include "FTGL.h"
+#include "FTPoint.h"
+
+
+/**
+ * FTBBox is a convenience class for handling bounding boxes.
+ */
+class FTGL_EXPORT FTBBox
+{
+    public:
+        /**
+         * Default constructor. Bounding box is set to zero.
+         */
+        FTBBox()
+        :   lowerX(0.0f),
+            lowerY(0.0f),
+            lowerZ(0.0f),
+            upperX(0.0f),
+            upperY(0.0f),
+            upperZ(0.0f)
+        {}
+        
+        /**
+         * Constructor.
+         */
+        FTBBox( float lx, float ly, float lz, float ux, float uy, float uz)
+        :   lowerX(lx),
+            lowerY(ly),
+            lowerZ(lz),
+            upperX(ux),
+            upperY(uy),
+            upperZ(uz)
+        {}
+        
+        /**
+         * Constructor. Extracts a bounding box from a freetype glyph. Uses
+         * the control box for the glyph. <code>FT_Glyph_Get_CBox()</code>
+         *
+         * @param glyph A freetype glyph
+         */
+        FTBBox( FT_GlyphSlot glyph)
+        :   lowerX(0.0f),
+            lowerY(0.0f),
+            lowerZ(0.0f),
+            upperX(0.0f),
+            upperY(0.0f),
+            upperZ(0.0f)
+        {
+            FT_BBox bbox;
+            FT_Outline_Get_CBox( &(glyph->outline), &bbox);
+
+            lowerX = static_cast<float>( bbox.xMin) / 64.0f;
+            lowerY = static_cast<float>( bbox.yMin) / 64.0f;
+            lowerZ = 0.0f;
+            upperX = static_cast<float>( bbox.xMax) / 64.0f;
+            upperY = static_cast<float>( bbox.yMax) / 64.0f;
+            upperZ = 0.0f;
+            
+        }       
+
+        /**
+         * Destructor
+         */
+        ~FTBBox()
+        {}
+        
+
+        /**
+         * Move the Bounding Box by a vector.
+         *
+         * @param distance The distance to move the bbox in 3D space.
+         */
+        FTBBox& Move( FTPoint distance)
+        {
+            lowerX += distance.X();
+            lowerY += distance.Y();
+            lowerZ += distance.Z();
+            upperX += distance.X();
+            upperY += distance.Y();
+            upperZ += distance.Z();
+            return *this;
+        }
+
+        FTBBox& operator += ( const FTBBox& bbox) 
+        {
+            lowerX = bbox.lowerX < lowerX? bbox.lowerX: lowerX; 
+            lowerY = bbox.lowerY < lowerY? bbox.lowerY: lowerY;
+            lowerZ = bbox.lowerZ < lowerZ? bbox.lowerZ: lowerZ; 
+            upperX = bbox.upperX > upperX? bbox.upperX: upperX; 
+            upperY = bbox.upperY > upperY? bbox.upperY: upperY; 
+            upperZ = bbox.upperZ > upperZ? bbox.upperZ: upperZ; 
+            
+            return *this;
+        }
+        
+        void SetDepth( float depth)
+        {
+            upperZ = lowerZ + depth;
+        }
+        
+        
+        /**
+         * The bounds of the box
+         */
+        // Make these ftPoints & private
+        float lowerX, lowerY, lowerZ, upperX, upperY, upperZ;
+    protected:
+    
+    
+    private:
+
+};
+
+
+#endif  //  __FTBBox__
+

ftgl/FTBitmapGlyph.cpp

@@ -0,0 +1,65 @@
+#include    <string>
+
+#include "FTBitmapGlyph.h"
+
+FTBitmapGlyph::FTBitmapGlyph( FT_GlyphSlot glyph)
+:   FTGlyph( glyph),
+    destWidth(0),
+    destHeight(0),
+    data(0)
+{
+    err = FT_Render_Glyph( glyph, FT_RENDER_MODE_MONO);
+    if( err || ft_glyph_format_bitmap != glyph->format)
+    {
+        return;
+    }
+
+    FT_Bitmap bitmap = glyph->bitmap;
+
+    unsigned int srcWidth = bitmap.width;
+    unsigned int srcHeight = bitmap.rows;
+    unsigned int srcPitch = bitmap.pitch;
+    
+    destWidth = srcWidth;
+    destHeight = srcHeight;
+    destPitch = srcPitch;    
+
+    if( destWidth && destHeight)
+    {
+        data = new unsigned char[destPitch * destHeight];
+        unsigned char* dest = data + (( destHeight - 1) * destPitch);
+
+        unsigned char* src = bitmap.buffer;
+
+        for( unsigned int y = 0; y < srcHeight; ++y)
+        {
+            memcpy( dest, src, srcPitch);
+            dest -= destPitch;
+            src += srcPitch;
+        }
+    }
+
+    pos = FTPoint(glyph->bitmap_left, static_cast<int>(srcHeight) - glyph->bitmap_top, 0.0);
+}
+
+
+FTBitmapGlyph::~FTBitmapGlyph()
+{
+    delete [] data;
+}
+
+
+const FTPoint& FTBitmapGlyph::Render( const FTPoint& pen)
+{
+    glBitmap( 0, 0, 0.0f, 0.0f, pen.X() + pos.X(), pen.Y() - pos.Y(), (const GLubyte*)0 );
+    
+    if( data)
+    {
+        glPixelStorei( GL_UNPACK_ROW_LENGTH, destPitch * 8);
+        glBitmap( destWidth, destHeight, 0.0f, 0.0, 0.0, 0.0, (const GLubyte*)data);
+    }
+    
+    glBitmap( 0, 0, 0.0f, 0.0f, -pos.X(), pos.Y(), (const GLubyte*)0 );
+    
+    return advance;
+}

ftgl/FTBitmapGlyph.h

@@ -0,0 +1,76 @@
+#ifndef     __FTBitmapGlyph__
+#define     __FTBitmapGlyph__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTGlyph.h"
+
+
+/**
+ * FTBitmapGlyph is a specialisation of FTGlyph for creating bitmaps.
+ *
+ * It provides the interface between Freetype glyphs and their openGL
+ * Renderable counterparts. This is an abstract class and derived classes
+ * must implement the <code>Render</code> function. 
+ * 
+ * @see FTGlyphContainer
+ *
+ */
+class FTGL_EXPORT FTBitmapGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param glyph The Freetype glyph to be processed
+         */
+        FTBitmapGlyph( FT_GlyphSlot glyph);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTBitmapGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen   The current pen position.
+         * @return      The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render( const FTPoint& pen);
+        
+    private:
+        /**
+         * The width of the glyph 'image'
+         */
+        unsigned int destWidth;
+
+        /**
+         * The height of the glyph 'image'
+         */
+        unsigned int destHeight;
+
+        /**
+         * The pitch of the glyph 'image'
+         */
+        unsigned int destPitch;
+
+        /**
+         * Vector from the pen position to the topleft corner of the bitmap
+         */
+        FTPoint pos;
+        
+        /**
+         * Pointer to the 'image' data
+         */
+        unsigned char* data;
+        
+};
+
+
+#endif  //  __FTBitmapGlyph__
+

ftgl/FTCharToGlyphIndexMap.h

@@ -0,0 +1,130 @@
+#ifndef    __FTCharToGlyphIndexMap__
+#define    __FTCharToGlyphIndexMap__
+
+#include <stdlib.h>
+
+#include "FTGL.h"
+
+/**
+ * Provides a non-STL alternative to the STL map<unsigned long, unsigned long>
+ * which maps character codes to glyph indices inside FTCharmap.
+ * 
+ * Implementation:
+ *   - NumberOfBuckets buckets are considered.
+ *   - Each bucket has BucketSize entries.
+ *   - When the glyph index for the character code C has to be stored, the 
+ *     bucket this character belongs to is found using 'C div BucketSize'. 
+ *     If this bucket has not been allocated yet, do it now.
+ *     The entry in the bucked is found using 'C mod BucketSize'. 
+ *     If it is set to IndexNotFound, then the glyph entry has not been set.
+ *   - Try to mimic the calls made to the STL map API.
+ *
+ * Caveats:
+ *   - The glyph index is now a signed long instead of unsigned long, so
+ *     the special value IndexNotFound (= -1) can be used to specify that the 
+ *     glyph index has not been stored yet.
+ */
+class FTGL_EXPORT FTCharToGlyphIndexMap
+{
+    public:
+  
+        typedef unsigned long CharacterCode;
+        typedef signed long GlyphIndex;
+        
+        enum 
+        {
+            NumberOfBuckets = 256,
+            BucketSize = 256,
+            IndexNotFound = -1
+        };
+
+        FTCharToGlyphIndexMap()
+        {
+            this->Indices = 0;
+        }
+
+        virtual ~FTCharToGlyphIndexMap()
+        {
+            if( this->Indices)
+            {
+                // Free all buckets
+                this->clear();
+        
+                // Free main structure
+                delete [] this->Indices;
+                this->Indices = 0;
+            }
+        }
+  
+        void clear()
+        {
+            if(this->Indices)
+            {
+                for( int i = 0; i < FTCharToGlyphIndexMap::NumberOfBuckets; i++)
+                {
+                    if( this->Indices[i])
+                    {
+                        delete [] this->Indices[i];
+                        this->Indices[i] = 0;
+                    }
+                }
+            }
+        }
+
+        const GlyphIndex find( CharacterCode c)
+        {
+            if( !this->Indices)
+            {
+                return 0;
+            }
+        
+            // Find position of char code in buckets
+            div_t pos = div( c, FTCharToGlyphIndexMap::BucketSize);
+        
+            if( !this->Indices[pos.quot])
+            {
+                return 0;
+            }
+        
+            const FTCharToGlyphIndexMap::GlyphIndex *ptr = &this->Indices[pos.quot][pos.rem];
+            if( *ptr == FTCharToGlyphIndexMap::IndexNotFound)
+            {
+                return 0;
+            }
+        
+            return *ptr;
+        }
+
+        void insert( CharacterCode c, GlyphIndex g)
+        {
+            if( !this->Indices)
+            {
+                this->Indices = new GlyphIndex* [FTCharToGlyphIndexMap::NumberOfBuckets];
+                for( int i = 0; i < FTCharToGlyphIndexMap::NumberOfBuckets; i++)
+                {
+                    this->Indices[i] = 0;
+                }
+            }
+        
+            // Find position of char code in buckets
+            div_t pos = div(c, FTCharToGlyphIndexMap::BucketSize);
+        
+            // Allocate bucket if does not exist yet
+            if( !this->Indices[pos.quot])
+            {
+                this->Indices[pos.quot] = new GlyphIndex [FTCharToGlyphIndexMap::BucketSize];
+                for( int i = 0; i < FTCharToGlyphIndexMap::BucketSize; i++)
+                {
+                    this->Indices[pos.quot][i] = FTCharToGlyphIndexMap::IndexNotFound;
+                }
+            }
+          
+            this->Indices[pos.quot][pos.rem] = g;
+        }
+  
+    private:
+        GlyphIndex** Indices;
+};
+
+
+#endif  //  __FTCharToGlyphIndexMap__

ftgl/FTCharmap.cpp

@@ -0,0 +1,62 @@
+#include "FTFace.h"
+#include "FTCharmap.h"
+
+
+FTCharmap::FTCharmap( FTFace* face)
+:   ftFace( *(face->Face())),
+    err(0)
+{
+    if( !ftFace->charmap)
+    {
+        err = FT_Set_Charmap( ftFace, ftFace->charmaps[0]);
+    }
+    
+    ftEncoding = ftFace->charmap->encoding;
+}
+
+
+FTCharmap::~FTCharmap()
+{
+    charMap.clear();
+}
+
+
+bool FTCharmap::CharMap( FT_Encoding encoding)
+{
+    if( ftEncoding == encoding)
+    {
+        return true;
+    }
+    
+    err = FT_Select_Charmap( ftFace, encoding );
+    
+    if( !err)
+    {
+        ftEncoding = encoding;
+    }
+    else
+    {
+        ftEncoding = ft_encoding_none;
+    }
+        
+    charMap.clear();
+    return !err;
+}
+
+
+unsigned int FTCharmap::GlyphListIndex( unsigned int characterCode )
+{
+    return charMap.find( characterCode);
+}
+
+
+unsigned int FTCharmap::FontIndex( unsigned int characterCode )
+{
+    return FT_Get_Char_Index( ftFace, characterCode);
+}
+
+
+void FTCharmap::InsertIndex( const unsigned int characterCode, const unsigned int containerIndex)
+{
+    charMap.insert( characterCode, containerIndex);
+}

ftgl/FTCharmap.h

@@ -0,0 +1,136 @@
+#ifndef     __FTCharmap__
+#define     __FTCharmap__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTCharToGlyphIndexMap.h"
+
+#include "FTGL.h"
+
+
+/**
+ * FTCharmap takes care of specifying the encoding for a font and mapping
+ * character codes to glyph indices.
+ *
+ * It doesn't preprocess all indices, only on an as needed basis. This may
+ * seem like a performance penalty but it is quicker than using the 'raw'
+ * freetype calls and will save significant amounts of memory when dealing
+ * with unicode encoding
+ *
+ * @see "Freetype 2 Documentation" 
+ *
+ */
+
+class FTFace;
+
+class FTGL_EXPORT FTCharmap
+{
+    public:
+        /**
+         * Constructor
+         */
+        FTCharmap( FTFace* face);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTCharmap();
+
+        /**
+         * Queries for the current character map code.
+         *
+         * @return  The current character map code.
+         */
+        FT_Encoding Encoding() const { return ftEncoding;}
+        
+        /**
+         * Sets the character map for the face.
+         * Valid encodings as at Freetype 2.0.4
+         *      ft_encoding_none
+         *      ft_encoding_symbol
+         *      ft_encoding_unicode
+         *      ft_encoding_latin_2
+         *      ft_encoding_sjis
+         *      ft_encoding_gb2312
+         *      ft_encoding_big5
+         *      ft_encoding_wansung
+         *      ft_encoding_johab
+         *      ft_encoding_adobe_standard
+         *      ft_encoding_adobe_expert
+         *      ft_encoding_adobe_custom
+         *      ft_encoding_apple_roman
+         *
+         * @param encoding  the Freetype encoding symbol. See above.
+         * @return          <code>true</code> if charmap was valid and set
+         *                  correctly. If the requested encoding is
+         *                  unavailable it will be set to ft_encoding_none.
+         */
+        bool CharMap( FT_Encoding encoding);
+        
+        /**
+         * Get the FTGlyphContainer index of the input character.
+         *
+         * @param characterCode The character code of the requested glyph in
+         *                      the current encoding eg apple roman.
+         * @return      The FTGlyphContainer index for the character or zero
+         *              if it wasn't found
+         */
+        unsigned int GlyphListIndex( const unsigned int characterCode);
+
+        /**
+         * Get the font glyph index of the input character.
+         *
+         * @param characterCode The character code of the requested glyph in
+         *                      the current encoding eg apple roman.
+         * @return      The glyph index for the character.
+         */
+        unsigned int FontIndex( const unsigned int characterCode);
+
+        /**
+         * Set the FTGlyphContainer index of the character code.
+         *
+         * @param characterCode  The character code of the requested glyph in
+         *                       the current encoding eg apple roman.
+         * @param containerIndex The index into the FTGlyphContainer of the
+         *                       character code.
+         */
+        void InsertIndex( const unsigned int characterCode, const unsigned int containerIndex);
+
+        /**
+         * Queries for errors.
+         *
+         * @return  The current error code. Zero means no error.
+         */
+        FT_Error Error() const { return err;}
+        
+    private:
+        /**
+         * Current character map code.
+         */
+        FT_Encoding ftEncoding;
+        
+        /**
+         * The current Freetype face.
+         */
+        const FT_Face ftFace;
+        
+        /**
+         * A structure that maps glyph indices to character codes
+         *
+         * < character code, face glyph index>
+         */
+        typedef FTCharToGlyphIndexMap CharacterMap;
+        CharacterMap charMap;
+        
+        /**
+         * Current error code.
+         */
+        FT_Error err;
+        
+};
+
+
+#endif  //  __FTCharmap__

ftgl/FTContour.cpp

@@ -0,0 +1,147 @@
+#include "FTContour.h"
+
+static const float BEZIER_STEP_SIZE = 0.2f;
+
+
+void FTContour::AddPoint( FTPoint point)
+{
+    if( pointList.empty() || point != pointList[pointList.size() - 1])
+    {
+        pointList.push_back( point);
+    }
+}
+
+
+void FTContour::AddPoint( float x, float y)
+{
+    AddPoint( FTPoint( x, y, 0.0f));
+}
+
+
+void FTContour::evaluateQuadraticCurve()
+{
+    for( unsigned int i = 0; i <= ( 1.0f / BEZIER_STEP_SIZE); i++)
+    {
+        float bezierValues[2][2];
+
+        float t = static_cast<float>(i) * BEZIER_STEP_SIZE;
+
+        bezierValues[0][0] = (1.0f - t) * controlPoints[0][0] + t * controlPoints[1][0];
+        bezierValues[0][1] = (1.0f - t) * controlPoints[0][1] + t * controlPoints[1][1];
+    
+        bezierValues[1][0] = (1.0f - t) * controlPoints[1][0] + t * controlPoints[2][0];
+        bezierValues[1][1] = (1.0f - t) * controlPoints[1][1] + t * controlPoints[2][1];
+        
+        bezierValues[0][0] = (1.0f - t) * bezierValues[0][0] + t * bezierValues[1][0];
+        bezierValues[0][1] = (1.0f - t) * bezierValues[0][1] + t * bezierValues[1][1];
+    
+        AddPoint( bezierValues[0][0], bezierValues[0][1]);
+    }
+}
+
+void FTContour::evaluateCubicCurve()
+{
+    for( unsigned int i = 0; i <= ( 1.0f / BEZIER_STEP_SIZE); i++)
+    {
+        float bezierValues[3][2];
+
+        float t = static_cast<float>(i) * BEZIER_STEP_SIZE;
+
+        bezierValues[0][0] = (1.0f - t) * controlPoints[0][0] + t * controlPoints[1][0];
+        bezierValues[0][1] = (1.0f - t) * controlPoints[0][1] + t * controlPoints[1][1];
+    
+        bezierValues[1][0] = (1.0f - t) * controlPoints[1][0] + t * controlPoints[2][0];
+        bezierValues[1][1] = (1.0f - t) * controlPoints[1][1] + t * controlPoints[2][1];
+        
+        bezierValues[2][0] = (1.0f - t) * controlPoints[2][0] + t * controlPoints[3][0];
+        bezierValues[2][1] = (1.0f - t) * controlPoints[2][1] + t * controlPoints[3][1];
+        
+        bezierValues[0][0] = (1.0f - t) * bezierValues[0][0] + t * bezierValues[1][0];
+        bezierValues[0][1] = (1.0f - t) * bezierValues[0][1] + t * bezierValues[1][1];
+    
+        bezierValues[1][0] = (1.0f - t) * bezierValues[1][0] + t * bezierValues[2][0];
+        bezierValues[1][1] = (1.0f - t) * bezierValues[1][1] + t * bezierValues[2][1];
+        
+        bezierValues[0][0] = (1.0f - t) * bezierValues[0][0] + t * bezierValues[1][0];
+        bezierValues[0][1] = (1.0f - t) * bezierValues[0][1] + t * bezierValues[1][1];
+    
+        AddPoint( bezierValues[0][0], bezierValues[0][1]);
+    }
+}
+
+
+FTContour::FTContour( FT_Vector* contour, char* pointTags, unsigned int numberOfPoints)
+{
+    for( unsigned int pointIndex = 0; pointIndex < numberOfPoints; ++ pointIndex)
+    {
+        char pointTag = pointTags[pointIndex];
+        
+        if( pointTag == FT_Curve_Tag_On || numberOfPoints < 2)
+        {
+            AddPoint( contour[pointIndex].x, contour[pointIndex].y);
+            continue;
+        }
+        
+        FTPoint controlPoint( contour[pointIndex]);
+        FTPoint previousPoint = ( 0 == pointIndex)
+                                ? FTPoint( contour[numberOfPoints - 1])
+                                : pointList[pointList.size() - 1];
+
+        FTPoint nextPoint = ( pointIndex == numberOfPoints - 1)
+                            ? pointList[0]
+                            : FTPoint( contour[pointIndex + 1]);
+
+        if( pointTag == FT_Curve_Tag_Conic)
+        {
+            char nextPointTag = ( pointIndex == numberOfPoints - 1)
+                                ? pointTags[0]
+                                : pointTags[pointIndex + 1];
+            
+            while( nextPointTag == FT_Curve_Tag_Conic)
+            {
+                nextPoint = ( controlPoint + nextPoint) * 0.5f;
+
+                controlPoints[0][0] = previousPoint.X(); controlPoints[0][1] = previousPoint.Y();
+                controlPoints[1][0] = controlPoint.X();  controlPoints[1][1] = controlPoint.Y();
+                controlPoints[2][0] = nextPoint.X();     controlPoints[2][1] = nextPoint.Y();
+                
+                evaluateQuadraticCurve();
+                ++pointIndex;
+                
+                previousPoint = nextPoint;
+                controlPoint = FTPoint( contour[pointIndex]);
+                nextPoint = ( pointIndex == numberOfPoints - 1)
+                            ? pointList[0]
+                            : FTPoint( contour[pointIndex + 1]);
+                nextPointTag = ( pointIndex == numberOfPoints - 1)
+                               ? pointTags[0]
+                               : pointTags[pointIndex + 1];
+            }
+            
+            controlPoints[0][0] = previousPoint.X(); controlPoints[0][1] = previousPoint.Y();
+            controlPoints[1][0] = controlPoint.X();  controlPoints[1][1] = controlPoint.Y();
+            controlPoints[2][0] = nextPoint.X();     controlPoints[2][1] = nextPoint.Y();
+            
+            evaluateQuadraticCurve();
+            continue;
+        }
+
+        if( pointTag == FT_Curve_Tag_Cubic)
+        {
+            FTPoint controlPoint2 = nextPoint;
+            
+            FTPoint nextPoint = ( pointIndex == numberOfPoints - 2)
+                                ? pointList[0]
+                                : FTPoint( contour[pointIndex + 2]);
+            
+            controlPoints[0][0] = previousPoint.X(); controlPoints[0][1] = previousPoint.Y();
+            controlPoints[1][0] = controlPoint.X();  controlPoints[1][1] = controlPoint.Y();
+            controlPoints[2][0] = controlPoint2.X(); controlPoints[2][1] = controlPoint2.Y();
+            controlPoints[3][0] = nextPoint.X();     controlPoints[3][1] = nextPoint.Y();
+        
+            evaluateCubicCurve();
+            ++pointIndex;
+            continue;
+        }
+    }
+}

ftgl/FTContour.h

@@ -0,0 +1,88 @@
+#ifndef     __FTContour__
+#define     __FTContour__
+
+#include "FTPoint.h"
+#include "FTVector.h"
+#include "FTGL.h"
+
+
+/**
+ * FTContour class is a container of points that describe a vector font
+ * outline. It is used as a container for the output of the bezier curve
+ * evaluator in FTVectoriser.
+ *
+ * @see FTOutlineGlyph
+ * @see FTPolyGlyph
+ * @see FTPoint
+ */
+class FTGL_EXPORT FTContour
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param contour
+         * @param pointTags
+         * @param numberOfPoints
+         */
+        FTContour( FT_Vector* contour, char* pointTags, unsigned int numberOfPoints);
+
+        /**
+         * Destructor
+         */
+        ~FTContour()
+        {
+            pointList.clear();
+        }
+        
+        /**
+         * Return a point at index.
+         *
+         * @param index of the point in the curve.
+         * @return const point reference
+         */
+        const FTPoint& Point( unsigned int index) const { return pointList[index];}
+
+        /**
+         * How many points define this contour
+         *
+         * @return the number of points in this contour
+         */
+        size_t PointCount() const { return pointList.size();}
+
+    private:
+        /**
+         * Add a point to this contour. This function tests for duplicate
+         * points.
+         *
+         * @param point The point to be added to the contour.
+         */
+        inline void AddPoint( FTPoint point);
+        
+        inline void AddPoint( float x, float y);
+        
+        /**
+         * De Casteljau (bezier) algorithm contributed by Jed Soane
+         * Evaluates a quadratic or conic (second degree) curve
+         */
+        inline void evaluateQuadraticCurve();
+
+        /**
+         * De Casteljau (bezier) algorithm contributed by Jed Soane
+         * Evaluates a cubic (third degree) curve
+         */
+        inline void evaluateCubicCurve();
+
+        /**
+         *  The list of points in this contour
+         */
+        typedef FTVector<FTPoint> PointVector;
+        PointVector pointList;
+        
+        /**
+         * 2D array storing values of de Casteljau algorithm.
+         */
+        float controlPoints[4][2];
+};
+
+#endif // __FTContour__

ftgl/FTExtrdGlyph.cpp

@@ -0,0 +1,173 @@
+#include <iostream>
+
+#include    <math.h>
+
+#include    "FTExtrdGlyph.h"
+#include    "FTVectoriser.h"
+
+
+FTExtrdGlyph::FTExtrdGlyph( FT_GlyphSlot glyph, float depth, bool useDisplayList)
+:   FTGlyph( glyph),
+    glList(0)
+{
+    bBox.SetDepth( -depth);
+        
+    if( ft_glyph_format_outline != glyph->format)
+    {
+        err = 0x14; // Invalid_Outline
+        return;
+    }
+
+    FTVectoriser vectoriser( glyph);
+    if( ( vectoriser.ContourCount() < 1) || ( vectoriser.PointCount() < 3))
+    {
+        return;
+    }
+
+    unsigned int tesselationIndex;
+    
+    if(useDisplayList)
+    {
+        glList = glGenLists(1);
+        glNewList( glList, GL_COMPILE);
+    }
+
+    vectoriser.MakeMesh( 1.0);
+    glNormal3d(0.0, 0.0, 1.0);
+    
+    unsigned int horizontalTextureScale = glyph->face->size->metrics.x_ppem * 64;
+    unsigned int verticalTextureScale = glyph->face->size->metrics.y_ppem * 64;        
+    
+    const FTMesh* mesh = vectoriser.GetMesh();
+    for( tesselationIndex = 0; tesselationIndex < mesh->TesselationCount(); ++tesselationIndex)
+    {
+        const FTTesselation* subMesh = mesh->Tesselation( tesselationIndex);
+        unsigned int polyonType = subMesh->PolygonType();
+
+        glBegin( polyonType);
+            for( unsigned int pointIndex = 0; pointIndex < subMesh->PointCount(); ++pointIndex)
+            {
+                FTPoint point = subMesh->Point(pointIndex);
+
+                glTexCoord2f( point.X() / horizontalTextureScale,
+                              point.Y() / verticalTextureScale);
+                
+                glVertex3f( point.X() / 64.0f,
+                            point.Y() / 64.0f,
+                            0.0f);
+            }
+        glEnd();
+    }
+    
+    vectoriser.MakeMesh( -1.0);
+    glNormal3d(0.0, 0.0, -1.0);
+    
+    mesh = vectoriser.GetMesh();
+    for( tesselationIndex = 0; tesselationIndex < mesh->TesselationCount(); ++tesselationIndex)
+    {
+        const FTTesselation* subMesh = mesh->Tesselation( tesselationIndex);
+        unsigned int polyonType = subMesh->PolygonType();
+
+        glBegin( polyonType);
+            for( unsigned int pointIndex = 0; pointIndex < subMesh->PointCount(); ++pointIndex)
+            {
+                FTPoint point = subMesh->Point(pointIndex);
+
+                glTexCoord2f( subMesh->Point(pointIndex).X() / horizontalTextureScale,
+                              subMesh->Point(pointIndex).Y() / verticalTextureScale);
+                
+                glVertex3f( subMesh->Point( pointIndex).X() / 64.0f,
+                            subMesh->Point( pointIndex).Y() / 64.0f,
+                            -depth);
+            }
+        glEnd();
+    }
+    
+    int contourFlag = vectoriser.ContourFlag();
+    
+    for( size_t c = 0; c < vectoriser.ContourCount(); ++c)
+    {
+        const FTContour* contour = vectoriser.Contour(c);
+        unsigned int numberOfPoints = contour->PointCount();
+        
+        glBegin( GL_QUAD_STRIP);
+            for( unsigned int j = 0; j <= numberOfPoints; ++j)
+            {
+                unsigned int pointIndex = ( j == numberOfPoints) ? 0 : j;
+                unsigned int nextPointIndex = ( pointIndex == numberOfPoints - 1) ? 0 : pointIndex + 1;
+                
+                FTPoint point = contour->Point(pointIndex);
+
+                FTPoint normal = GetNormal( point, contour->Point(nextPointIndex));
+                if(normal != FTPoint( 0.0f, 0.0f, 0.0f))
+                {                   
+                    glNormal3dv(static_cast<const FTGL_DOUBLE*>(normal));
+                }
+
+                if( contourFlag & ft_outline_reverse_fill)
+                {
+                    glTexCoord2f( point.X() / horizontalTextureScale,
+                                  point.X() / verticalTextureScale);
+                
+                    glVertex3f( point.X() / 64.0f, point.Y() / 64.0f, 0.0f);
+                    glVertex3f( point.X() / 64.0f, point.Y() / 64.0f, -depth);
+                }
+                else
+                {
+                    glTexCoord2f( point.X() / horizontalTextureScale,
+                                  point.Y() / verticalTextureScale);
+                
+                    glVertex3f( point.X() / 64.0f, point.Y() / 64.0f, -depth);
+                    glVertex3f( point.X() / 64.0f, point.Y() / 64.0f, 0.0f);
+                }
+            }
+        glEnd();
+    }
+        
+    if(useDisplayList)
+    {
+        glEndList();
+    }
+}
+
+
+FTExtrdGlyph::~FTExtrdGlyph()
+{
+    glDeleteLists( glList, 1);
+}
+
+
+const FTPoint& FTExtrdGlyph::Render( const FTPoint& pen)
+{
+    glTranslatef( pen.X(), pen.Y(), 0);
+    
+    if( glList)
+    {
+        glCallList( glList);    
+    }
+    
+    return advance;
+}
+
+
+FTPoint FTExtrdGlyph::GetNormal( const FTPoint &a, const FTPoint &b)
+{
+    float vectorX = a.X() - b.X();
+    float vectorY = a.Y() - b.Y();
+                              
+    float length = sqrt( vectorX * vectorX + vectorY * vectorY );
+    
+    if( length > 0.01f)
+    {
+        length = 1 / length;
+    }
+    else
+    {
+        length = 0.0f;
+    }
+    
+    return FTPoint( -vectorY * length,
+                     vectorX * length,
+                     0.0f);
+}
+

ftgl/FTExtrdGlyph.h

@@ -0,0 +1,69 @@
+#ifndef     __FTExtrdGlyph__
+#define     __FTExtrdGlyph__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTGlyph.h"
+
+class FTVectoriser;
+
+/**
+ * FTExtrdGlyph is a specialisation of FTGlyph for creating tessellated
+ * extruded polygon glyphs.
+ * 
+ * @see FTGlyphContainer
+ * @see FTVectoriser
+ *
+ */
+class FTGL_EXPORT FTExtrdGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor. Sets the Error to Invalid_Outline if the glyph isn't an outline.
+         *
+         * @param glyph The Freetype glyph to be processed
+         * @param depth The distance along the z axis to extrude the glyph
+         * @param useDisplayList Enable or disable the use of Display Lists for this glyph
+         *                       <code>true</code> turns ON display lists.
+         *                       <code>false</code> turns OFF display lists.
+         */
+        FTExtrdGlyph( FT_GlyphSlot glyph, float depth, bool useDisplayList);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTExtrdGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen   The current pen position.
+         * @return      The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render( const FTPoint& pen);
+        
+    private:
+        /**
+         * Calculate the normal vector to 2 points. This is 2D and ignores
+         * the z component. The normal will be normalised
+         *
+         * @param a
+         * @param b
+         * @return
+         */
+        FTPoint GetNormal( const FTPoint &a, const FTPoint &b);
+        
+        
+        /**
+         * OpenGL display list
+         */
+        GLuint glList;
+    
+};
+
+
+#endif  //  __FTExtrdGlyph__
+

ftgl/FTFace.cpp

@@ -0,0 +1,143 @@
+#include "FTFace.h"
+#include "FTLibrary.h"
+
+#include FT_TRUETYPE_TABLES_H
+
+FTFace::FTFace( const char* fontFilePath)
+:   numGlyphs(0),
+    fontEncodingList(0),
+    err(0)
+{
+    const FT_Long DEFAULT_FACE_INDEX = 0;
+    ftFace = new FT_Face;
+
+    err = FT_New_Face( *FTLibrary::Instance().GetLibrary(), fontFilePath, DEFAULT_FACE_INDEX, ftFace);
+
+    if( err)
+    {
+        delete ftFace;
+        ftFace = 0;
+    }
+    else
+    {
+        numGlyphs = (*ftFace)->num_glyphs;
+        hasKerningTable = FT_HAS_KERNING((*ftFace));
+    }
+}
+
+
+FTFace::FTFace( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   numGlyphs(0),
+    err(0)
+{
+    const FT_Long DEFAULT_FACE_INDEX = 0;
+    ftFace = new FT_Face;
+
+    err = FT_New_Memory_Face( *FTLibrary::Instance().GetLibrary(), (FT_Byte *)pBufferBytes, bufferSizeInBytes, DEFAULT_FACE_INDEX, ftFace);
+
+    if( err)
+    {
+        delete ftFace;
+        ftFace = 0;
+    }
+    else
+    {
+        numGlyphs = (*ftFace)->num_glyphs;
+    }
+}
+
+
+FTFace::~FTFace()
+{
+    if( ftFace)
+    {
+        FT_Done_Face( *ftFace);
+        delete ftFace;
+        ftFace = 0;
+    }
+}
+
+
+bool FTFace::Attach( const char* fontFilePath)
+{
+    err = FT_Attach_File( *ftFace, fontFilePath);
+    return !err;
+}
+
+
+bool FTFace::Attach( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+{
+    FT_Open_Args open;
+
+    open.flags = FT_OPEN_MEMORY;
+    open.memory_base = (FT_Byte *)pBufferBytes;
+    open.memory_size = bufferSizeInBytes;
+
+    err = FT_Attach_Stream( *ftFace, &open);
+    return !err;
+}
+
+
+const FTSize& FTFace::Size( const unsigned int size, const unsigned int res)
+{
+    charSize.CharSize( ftFace, size, res, res);
+    err = charSize.Error();
+
+    return charSize;
+}
+
+
+unsigned int FTFace::CharMapCount()
+{
+    return (*ftFace)->num_charmaps;
+}
+
+
+FT_Encoding* FTFace::CharMapList()
+{
+    if( 0 == fontEncodingList)
+    {
+        fontEncodingList = new FT_Encoding[CharMapCount()];
+        for( size_t encodingIndex = 0; encodingIndex < CharMapCount(); ++encodingIndex)
+        {
+            fontEncodingList[encodingIndex] = (*ftFace)->charmaps[encodingIndex]->encoding;
+        }
+    }
+    
+    return fontEncodingList;
+}
+
+
+FTPoint FTFace::KernAdvance( unsigned int index1, unsigned int index2)
+{
+    float x, y;
+    x = y = 0.0f;
+
+    if( hasKerningTable && index1 && index2)
+    {
+        FT_Vector kernAdvance;
+        kernAdvance.x = kernAdvance.y = 0;
+
+        err = FT_Get_Kerning( *ftFace, index1, index2, ft_kerning_unfitted, &kernAdvance);
+        if( !err)
+        {   
+            x = static_cast<float>( kernAdvance.x) / 64.0f;
+            y = static_cast<float>( kernAdvance.y) / 64.0f;
+        }
+    }
+    
+    return FTPoint( x, y, 0.0);
+}
+
+
+FT_GlyphSlot FTFace::Glyph( unsigned int index, FT_Int load_flags)
+{
+    err = FT_Load_Glyph( *ftFace, index, load_flags);
+    if( err)
+    {
+        return NULL;
+    }
+
+    return (*ftFace)->glyph;
+}
+

ftgl/FTFace.h

@@ -0,0 +1,147 @@
+#ifndef     __FTFace__
+#define     __FTFace__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTPoint.h"
+#include "FTSize.h"
+
+/**
+ * FTFace class provides an abstraction layer for the Freetype Face.
+ *
+ * @see "Freetype 2 Documentation"
+ *
+ */
+class FTGL_EXPORT FTFace
+{
+    public:
+        /**
+         * Opens and reads a face file. Error is set.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTFace( const char* fontFilePath);
+
+        /**
+         * Read face data from an in-memory buffer. Error is set.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTFace( const unsigned char *pBufferBytes, size_t bufferSizeInBytes );
+
+        /**
+         * Destructor
+         *
+         * Disposes of the current Freetype Face.
+         */
+        virtual ~FTFace();
+
+        /**
+         * Attach auxilliary file to font (e.g., font metrics).
+         *
+         * @param fontFilePath  auxilliary font file path.
+         * @return          <code>true</code> if file has opened
+         *                  successfully.
+         */
+        bool Attach( const char* fontFilePath);
+
+        /**
+         * Attach auxilliary data to font (e.g., font metrics) from memory
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         * @return          <code>true</code> if file has opened
+         *                  successfully.
+         */
+        bool Attach( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+
+        /**
+         * Get the freetype face object..
+         *
+         * @return pointer to an FT_Face.
+         */
+        FT_Face* Face() const { return ftFace;}
+        
+        /**
+         * Sets the char size for the current face.
+         *
+         * This doesn't guarantee that the size was set correctly. Clients
+         * should check errors.
+         *
+         * @param size      the face size in points (1/72 inch)
+         * @param res       the resolution of the target device.
+         * @return          <code>FTSize</code> object
+         */
+        const FTSize& Size( const unsigned int size, const unsigned int res);
+
+        /**
+         * Get the number of character maps in this face.
+         *
+         * @return character map count.
+         */
+        unsigned int CharMapCount();
+
+        /**
+         * Get a list of character maps in this face.
+         *
+         * @return pointer to the first encoding.
+         */
+        FT_Encoding* CharMapList();
+        
+        /**
+         * Gets the kerning vector between two glyphs
+         */
+        FTPoint KernAdvance( unsigned int index1, unsigned int index2);
+
+        /**
+         * Loads and creates a Freetype glyph.
+         */
+        FT_GlyphSlot Glyph( unsigned int index, FT_Int load_flags);
+
+        /**
+         * Gets the number of glyphs in the current face.
+         */
+        unsigned int GlyphCount() const { return numGlyphs;}
+
+        /**
+         * Queries for errors.
+         *
+         * @return  The current error code.
+         */
+        FT_Error Error() const { return err; }
+        
+    private:
+        /**
+         * The Freetype face
+         */
+        FT_Face* ftFace;
+
+        /**
+         * The size object associated with this face
+         */
+        FTSize  charSize;
+        
+        /**
+         * The number of glyphs in this face
+         */
+        int numGlyphs;
+        
+        FT_Encoding* fontEncodingList;
+
+        /**
+         * This face has kerning tables
+         */
+         bool hasKerningTable;
+
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+};
+
+
+#endif  //  __FTFace__

ftgl/FTFont.cpp

@@ -0,0 +1,297 @@
+#include    "FTFace.h"
+#include    "FTFont.h"
+#include    "FTGlyphContainer.h"
+#include    "FTBBox.h"
+
+
+FTFont::FTFont( const char* fontFilePath)
+:   face( fontFilePath),
+    useDisplayLists(true),
+    glyphList(0)
+{
+    err = face.Error();
+    if( err == 0)
+    {
+        glyphList = new FTGlyphContainer( &face);
+    }
+}
+
+
+FTFont::FTFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   face( pBufferBytes, bufferSizeInBytes),
+    glyphList(0)
+{
+    err = face.Error();
+    if( err == 0)
+    {
+        glyphList = new FTGlyphContainer( &face);
+    }
+}
+
+
+FTFont::~FTFont()
+{
+    delete glyphList;
+}
+
+
+bool FTFont::Attach( const char* fontFilePath)
+{
+    if( face.Attach( fontFilePath))
+    {
+        err = 0;
+        return true;
+    }
+    else
+    {
+        err = face.Error();
+        return false;
+    }
+}
+
+
+bool FTFont::Attach( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+{
+    if( face.Attach( pBufferBytes, bufferSizeInBytes))
+    {
+        err = 0;
+        return true;
+    }
+    else
+    {
+        err = face.Error();
+        return false;
+    }
+}
+
+
+bool FTFont::FaceSize( const unsigned int size, const unsigned int res )
+{
+    charSize = face.Size( size, res);
+    err = face.Error();
+    
+    if( err != 0)
+    {
+        return false;
+    }
+    
+    if( glyphList != NULL)
+    {
+        delete glyphList;
+    }
+    
+    glyphList = new FTGlyphContainer( &face);
+    return true;
+}
+
+
+unsigned int FTFont::FaceSize() const
+{
+    return charSize.CharSize();
+}
+
+
+bool FTFont::CharMap( FT_Encoding encoding)
+{
+    bool result = glyphList->CharMap( encoding);
+    err = glyphList->Error();
+    return result;
+}
+
+
+unsigned int FTFont::CharMapCount()
+{
+    return face.CharMapCount();
+}
+
+
+FT_Encoding* FTFont::CharMapList()
+{
+    return face.CharMapList();
+}
+
+
+void FTFont::UseDisplayList( bool useList)
+{
+    useDisplayLists = useList;
+}
+
+float FTFont::Ascender() const
+{
+    return charSize.Ascender();
+}
+
+
+float FTFont::Descender() const
+{
+    return charSize.Descender();
+}
+
+float FTFont::LineHeight() const
+{
+    return charSize.Height();
+}
+
+void FTFont::BBox( const char* string,
+                   float& llx, float& lly, float& llz, float& urx, float& ury, float& urz)
+{
+    FTBBox totalBBox;
+
+    if((NULL != string) && ('\0' != *string))
+    {
+        const unsigned char* c = (unsigned char*)string;
+        float advance = 0;
+
+        if(CheckGlyph( *c))
+        {
+            totalBBox = glyphList->BBox( *c);
+            advance = glyphList->Advance( *c, *(c + 1));
+        }
+                
+        while( *++c)
+        {
+            if(CheckGlyph( *c))
+            {
+                FTBBox tempBBox = glyphList->BBox( *c);
+                tempBBox.Move( FTPoint( advance, 0.0f, 0.0f));
+                totalBBox += tempBBox;
+                advance += glyphList->Advance( *c, *(c + 1));
+            }
+        }
+    }
+
+    llx = totalBBox.lowerX;
+    lly = totalBBox.lowerY;
+    llz = totalBBox.lowerZ;
+    urx = totalBBox.upperX;
+    ury = totalBBox.upperY;
+    urz = totalBBox.upperZ;
+}
+
+
+void FTFont::BBox( const wchar_t* string,
+                   float& llx, float& lly, float& llz, float& urx, float& ury, float& urz)
+{
+    FTBBox totalBBox;
+
+    if((NULL != string) && ('\0' != *string))
+    {
+        const wchar_t* c = string;
+        float advance = 0;
+
+        if(CheckGlyph( *c))
+        {
+            totalBBox = glyphList->BBox( *c);
+            advance = glyphList->Advance( *c, *(c + 1));
+        }
+        
+        while( *++c)
+        {
+            if(CheckGlyph( *c))
+            {
+                FTBBox tempBBox = glyphList->BBox( *c);
+                tempBBox.Move( FTPoint( advance, 0.0f, 0.0f));
+                totalBBox += tempBBox;
+                advance += glyphList->Advance( *c, *(c + 1));
+            }
+        }
+    }
+
+    llx = totalBBox.lowerX;
+    lly = totalBBox.lowerY;
+    llz = totalBBox.lowerZ;
+    urx = totalBBox.upperX;
+    ury = totalBBox.upperY;
+    urz = totalBBox.upperZ;
+}
+
+
+float FTFont::Advance( const wchar_t* string)
+{
+    const wchar_t* c = string;
+    float width = 0.0f;
+
+    while( *c)
+    {
+        if(CheckGlyph( *c))
+        {
+            width += glyphList->Advance( *c, *(c + 1));
+        }
+        ++c;
+    }
+    
+    return width;
+}
+
+
+float FTFont::Advance( const char* string)
+{
+    const unsigned char* c = (unsigned char*)string;
+    float width = 0.0f;
+
+    while( *c)
+    {
+        if(CheckGlyph( *c))
+        {
+            width += glyphList->Advance( *c, *(c + 1));
+        }
+        ++c;
+    }
+    
+    return width;
+}
+
+
+void FTFont::Render( const char* string )
+{
+    const unsigned char* c = (unsigned char*)string;
+    pen.X(0); pen.Y(0);
+
+    while( *c)
+    {
+        if(CheckGlyph( *c))
+        {
+            pen = glyphList->Render( *c, *(c + 1), pen);
+        }
+        ++c;
+    }
+}
+
+
+void FTFont::Render( const wchar_t* string )
+{
+    const wchar_t* c = string;
+    pen.X(0); pen.Y(0);
+
+    while( *c)
+    {
+        if(CheckGlyph( *c))
+        {
+            pen = glyphList->Render( *c, *(c + 1), pen);
+        }
+        ++c;
+    }
+}
+
+
+bool FTFont::CheckGlyph( const unsigned int characterCode)
+{
+    if( NULL == glyphList->Glyph( characterCode))
+    {
+        unsigned int glyphIndex = glyphList->FontIndex( characterCode);
+        FTGlyph* tempGlyph = MakeGlyph( glyphIndex);
+        if( NULL == tempGlyph)
+        {
+            if( 0 == err)
+            {
+                err = 0x13;
+            }
+            
+            return false;
+        }
+        glyphList->Add( tempGlyph, characterCode);
+    }
+    
+    return true;
+}
+

ftgl/FTFont.h

@@ -0,0 +1,276 @@
+#ifndef    __FTFont__
+#define    __FTFont__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#include "FTFace.h"
+#include "FTGL.h"
+
+class FTGlyphContainer;
+class FTGlyph;
+
+
+/**
+ * FTFont is the public interface for the FTGL library.
+ *
+ * Specific font classes are derived from this class. It uses the helper
+ * classes FTFace and FTSize to access the Freetype library. This class
+ * is abstract and deriving classes must implement the protected
+ * <code>MakeGlyph</code> function to create glyphs of the
+ * appropriate type.
+ *
+ * It is good practice after using these functions to test the error
+ * code returned. <code>FT_Error Error()</code>. Check the freetype file fterrdef.h
+ * for error definitions.
+ *
+ * @see     FTFace
+ * @see     FTSize
+ * @see     FTGlyphContainer
+ * @see     FTGlyph
+ */
+class FTGL_EXPORT FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTFont( const char* fontFilePath);
+        
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         * The buffer is owned by the client and is NOT copied by FTGL. The
+         * pointer must be valid while using FTGL.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+        
+        /**
+         * Destructor
+         */
+        virtual ~FTFont();
+        
+        /**
+         * Attach auxilliary file to font e.g font metrics.
+         *
+         * Note: not all font formats implement this function.
+         *
+         * @param fontFilePath  auxilliary font file path.
+         * @return          <code>true</code> if file has been attached
+         *                  successfully.
+         */
+        bool Attach( const char* fontFilePath);
+
+        /**
+         * Attach auxilliary data to font e.g font metrics, from memory
+         *
+         * Note: not all font formats implement this function.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         * @return          <code>true</code> if file has been attached
+         *                  successfully.
+         */
+        bool Attach( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+
+        /**
+         * Set the character map for the face.
+         *
+         * @param encoding      Freetype enumerate for char map code.
+         * @return              <code>true</code> if charmap was valid and
+         *                      set correctly
+         */
+        bool CharMap( FT_Encoding encoding );
+
+        /**
+         * Get the number of character maps in this face.
+         *
+         * @return character map count.
+         */
+        unsigned int CharMapCount();
+
+        /**
+         * Get a list of character maps in this face.
+         *
+         * @return pointer to the first encoding.
+         */
+        FT_Encoding* CharMapList();
+        
+        /**
+         * Set the char size for the current face.
+         *
+         * @param size      the face size in points (1/72 inch)
+         * @param res       the resolution of the target device.
+         * @return          <code>true</code> if size was set correctly
+         */
+        virtual bool FaceSize( const unsigned int size, const unsigned int res = 72);
+        
+        /**
+         * Get the current face size in points.
+         *
+         * @return face size
+         */
+        unsigned int FaceSize() const;
+        
+        /**
+         * Set the extrusion distance for the font. Only implemented by
+         * FTGLExtrdFont
+         *
+         * @param depth  The extrusion distance.
+         */
+        virtual void Depth( float depth){}
+
+        /**
+         * Enable or disable the use of Display Lists inside FTGL
+         *
+         * @param  useList <code>true</code> turns ON display lists.
+         *                 <code>false</code> turns OFF display lists.
+         */
+        void UseDisplayList( bool useList);
+        
+        /**
+         * Get the global ascender height for the face.
+         *
+         * @return  Ascender height
+         */
+        float Ascender() const;
+        
+        /**
+         * Gets the global descender height for the face.
+         *
+         * @return  Descender height
+         */
+        float Descender() const;
+        
+        /**
+         * Gets the line spacing for the font.
+         *
+         * @return  Line height
+         */
+        float LineHeight() const;
+        
+        /**
+         * Get the bounding box for a string.
+         *
+         * @param string    a char string
+         * @param llx       lower left near x coord
+         * @param lly       lower left near y coord
+         * @param llz       lower left near z coord
+         * @param urx       upper right far x coord
+         * @param ury       upper right far y coord
+         * @param urz       upper right far z coord
+         */
+        void BBox( const char* string, float& llx, float& lly, float& llz, float& urx, float& ury, float& urz);
+
+        /**
+         * Get the bounding box for a string.
+         *
+         * @param string    a wchar_t string
+         * @param llx       lower left near x coord
+         * @param lly       lower left near y coord
+         * @param llz       lower left near z coord
+         * @param urx       upper right far x coord
+         * @param ury       upper right far y coord
+         * @param urz       upper right far z coord
+         */
+        void BBox( const wchar_t* string, float& llx, float& lly, float& llz, float& urx, float& ury, float& urz);
+
+        /**
+         * Get the advance width for a string.
+         *
+         * @param string    a wchar_t string
+         * @return      advance width
+         */
+        float Advance( const wchar_t* string);
+
+        /**
+         * Get the advance width for a string.
+         *
+         * @param string    a char string
+         * @return      advance width
+         */
+        float Advance( const char* string);
+
+        /**
+         * Render a string of characters
+         * 
+         * @param string    'C' style string to be output.   
+         */
+        virtual void Render( const char* string );
+
+        /**
+         * Render a string of characters
+         * 
+         * @param string    wchar_t string to be output.     
+         */
+        virtual void Render( const wchar_t* string );
+
+        /**
+         * Queries the Font for errors.
+         *
+         * @return  The current error code.
+         */
+        FT_Error Error() const { return err;}
+
+    protected:
+        /**
+         * Construct a glyph of the correct type.
+         *
+         * Clients must overide the function and return their specialised
+         * FTGlyph.
+         *
+         * @param g The glyph index NOT the char code.
+         * @return  An FT****Glyph or <code>null</code> on failure.
+         */
+        virtual FTGlyph* MakeGlyph( unsigned int g) = 0;
+        
+        /**
+         * Current face object
+         */
+        FTFace face;
+        
+        /**
+         * Current size object
+         */
+        FTSize charSize;
+
+        /**
+         * Flag to enable or disable the use of Display Lists inside FTGL
+         * <code>true</code> turns ON display lists.
+         * <code>false</code> turns OFF display lists.
+         */
+        bool useDisplayLists;
+
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+        
+    private:        
+        /**
+         * Check that the glyph at <code>chr</code> exist. If not load it.
+         *
+         * @param chr  character index
+         * @return <code>true</code> if the glyph can be created.
+         */
+        inline bool CheckGlyph( const unsigned int chr);
+
+        /**
+         * An object that holds a list of glyphs
+         */
+        FTGlyphContainer* glyphList;
+        
+        /**
+         * Current pen or cursor position;
+         */
+        FTPoint pen;
+        
+};
+
+
+#endif  //  __FTFont__
+

ftgl/FTGL.h

@@ -0,0 +1,86 @@
+#ifndef     __FTGL__
+#define     __FTGL__
+
+#define FTGL_LIBRARY_STATIC
+typedef double   FTGL_DOUBLE;
+typedef float    FTGL_FLOAT;
+
+// Fixes for deprecated identifiers in 2.1.5
+#ifndef FT_OPEN_MEMORY
+    #define FT_OPEN_MEMORY (FT_Open_Flags)1
+#endif
+
+#ifndef FT_RENDER_MODE_MONO
+    #define FT_RENDER_MODE_MONO ft_render_mode_mono
+#endif
+
+#ifndef FT_RENDER_MODE_NORMAL
+    #define FT_RENDER_MODE_NORMAL ft_render_mode_normal
+#endif
+
+  
+#ifdef WIN32
+
+    // Under windows avoid including <windows.h> is overrated. 
+    // Sure, it can be avoided and "name space pollution" can be
+    // avoided, but why? It really doesn't make that much difference
+    // these days.
+    #define  WIN32_LEAN_AND_MEAN
+    #include <windows.h>
+
+    #ifndef __gl_h_
+        #include <GL/gl.h>
+        #include <GL/glu.h>
+    #endif
+
+#else
+
+    // Non windows platforms - don't require nonsense as seen above :-)    
+    #ifndef __gl_h_
+        #ifdef __APPLE_CC__
+            #include <OpenGL/gl.h>
+            #include <OpenGL/glu.h>
+        #else
+            #include <GL/gl.h>
+            #include <GL/glu.h>
+        #endif                
+
+    #endif
+
+    // Required for compatibility with glext.h style function definitions of 
+    // OpenGL extensions, such as in src/osg/Point.cpp.
+    #ifndef APIENTRY
+        #define APIENTRY
+    #endif
+#endif
+
+// Compiler-specific conditional compilation
+#ifdef _MSC_VER // MS Visual C++ 
+
+    // Disable various warning.
+    // 4786: template name too long
+    #pragma warning( disable : 4251 )
+    #pragma warning( disable : 4275 )
+    #pragma warning( disable : 4786 )
+
+    // The following definitions control how symbols are exported.
+    // If the target is a static library ensure that FTGL_LIBRARY_STATIC
+    // is defined. If building a dynamic library (ie DLL) ensure the
+    // FTGL_LIBRARY macro is defined, as it will mark symbols for 
+    // export. If compiling a project to _use_ the _dynamic_ library 
+    // version of the library, no definition is required. 
+    #ifdef FTGL_LIBRARY_STATIC      // static lib - no special export required
+    #  define FTGL_EXPORT
+    #elif FTGL_LIBRARY              // dynamic lib - must export/import symbols appropriately.
+    #  define FTGL_EXPORT   __declspec(dllexport)
+    #else
+    #  define FTGL_EXPORT   __declspec(dllimport)
+    #endif 
+
+#else
+    // Compiler that is not MS Visual C++.
+    // Ensure that the export symbol is defined (and blank)
+    #define FTGL_EXPORT
+#endif  
+
+#endif  //  __FTGL__

ftgl/FTGLBitmapFont.cpp

@@ -0,0 +1,66 @@
+#include "FTGLBitmapFont.h"
+#include "FTBitmapGlyph.h"
+
+
+FTGLBitmapFont::FTGLBitmapFont( const char* fontFilePath)
+:   FTFont( fontFilePath)
+{}
+
+
+FTGLBitmapFont::FTGLBitmapFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   FTFont( pBufferBytes, bufferSizeInBytes)
+{}
+
+
+FTGLBitmapFont::~FTGLBitmapFont()
+{}
+
+
+FTGlyph* FTGLBitmapFont::MakeGlyph( unsigned int g)
+{
+    FT_GlyphSlot ftGlyph = face.Glyph( g, FT_LOAD_DEFAULT);
+
+    if( ftGlyph)
+    {
+        FTBitmapGlyph* tempGlyph = new FTBitmapGlyph( ftGlyph);
+        return tempGlyph;
+    }
+
+    err = face.Error();
+    return NULL;
+}
+
+
+void FTGLBitmapFont::Render( const char* string)
+{   
+    glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT);
+    glPushAttrib( GL_ENABLE_BIT);
+    
+    glPixelStorei( GL_UNPACK_LSB_FIRST, GL_FALSE);
+    glPixelStorei( GL_UNPACK_ALIGNMENT, 1);
+
+    glDisable( GL_BLEND);
+
+    FTFont::Render( string);
+
+    glPopAttrib();
+    glPopClientAttrib();
+}
+
+
+void FTGLBitmapFont::Render( const wchar_t* string)
+{   
+    glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT);
+    glPushAttrib( GL_ENABLE_BIT);
+    
+    glPixelStorei( GL_UNPACK_LSB_FIRST, GL_FALSE);
+    glPixelStorei( GL_UNPACK_ALIGNMENT, 1);
+    
+    glDisable( GL_BLEND);
+
+    FTFont::Render( string);
+
+    glPopAttrib();
+    glPopClientAttrib();
+}
+

ftgl/FTGLBitmapFont.h

@@ -0,0 +1,65 @@
+#ifndef __FTGLBitmapFont__
+#define __FTGLBitmapFont__
+
+#include "FTFont.h"
+#include "FTGL.h"
+
+
+class FTGlyph;
+
+/**
+ * FTGLBitmapFont is a specialisation of the FTFont class for handling
+ * Bitmap fonts
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTGLBitmapFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTGLBitmapFont( const char* fontFilePath);
+
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTGLBitmapFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+
+        /**
+         * Destructor
+         */
+        ~FTGLBitmapFont();
+        
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    'C' style string to be output.   
+         */
+        void Render( const char* string);
+
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    'C' style wide string to be output.  
+         */
+        void Render( const wchar_t* string);
+
+        // attributes
+        
+    private:
+        /**
+         * Construct a FTBitmapGlyph.
+         *
+         * @param g The glyph index NOT the char code.
+         * @return  An FTBitmapGlyph or <code>null</code> on failure.
+         */
+        inline virtual FTGlyph* MakeGlyph( unsigned int g);
+                
+};
+#endif  //  __FTGLBitmapFont__

ftgl/FTGLExtrdFont.cpp

@@ -0,0 +1,35 @@
+#include    "FTGLExtrdFont.h"
+#include    "FTExtrdGlyph.h"
+
+
+FTGLExtrdFont::FTGLExtrdFont( const char* fontFilePath)
+:   FTFont( fontFilePath),
+    depth( 0.0f)
+{}
+
+
+FTGLExtrdFont::FTGLExtrdFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   FTFont( pBufferBytes, bufferSizeInBytes),
+    depth( 0.0f)
+{}
+
+
+FTGLExtrdFont::~FTGLExtrdFont()
+{}
+
+
+FTGlyph* FTGLExtrdFont::MakeGlyph( unsigned int glyphIndex)
+{
+    FT_GlyphSlot ftGlyph = face.Glyph( glyphIndex, FT_LOAD_NO_HINTING);
+
+    if( ftGlyph)
+    {
+        FTExtrdGlyph* tempGlyph = new FTExtrdGlyph( ftGlyph, depth, useDisplayLists);
+        return tempGlyph;
+    }
+
+    err = face.Error();
+    return NULL;
+}
+
+

ftgl/FTGLExtrdFont.h

@@ -0,0 +1,63 @@
+#ifndef __FTGLExtrdFont__
+#define __FTGLExtrdFont__
+
+#include "FTFont.h"
+#include "FTGL.h"
+
+class FTGlyph;
+
+/**
+ * FTGLExtrdFont is a specialisation of the FTFont class for handling
+ * extruded Polygon fonts
+ *
+ * @see		FTFont
+ * @see		FTGLPolygonFont
+ */
+class FTGL_EXPORT FTGLExtrdFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTGLExtrdFont( const char* fontFilePath);
+
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTGLExtrdFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+
+        /**
+         * Destructor
+         */
+        ~FTGLExtrdFont();
+		
+        /**
+         * Set the extrusion distance for the font. 
+         *
+         * @param d  The extrusion distance.
+         */
+        void Depth( float d) { depth = d;}
+		
+    private:
+        /**
+         * Construct a FTPolyGlyph.
+         *
+         * @param glyphIndex The glyph index NOT the char code.
+         * @return	An FTExtrdGlyph or <code>null</code> on failure.
+         */
+        inline virtual FTGlyph* MakeGlyph( unsigned int glyphIndex);
+		
+        /**
+         * The extrusion distance for the font. 
+         */
+        float depth;
+};
+
+
+#endif	//	__FTGLExtrdFont__
+

ftgl/FTGLOutlineFont.cpp

@@ -0,0 +1,66 @@
+#include    "FTGLOutlineFont.h"
+#include    "FTOutlineGlyph.h"
+
+
+FTGLOutlineFont::FTGLOutlineFont( const char* fontFilePath)
+:   FTFont( fontFilePath)
+{}
+
+
+FTGLOutlineFont::FTGLOutlineFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   FTFont( pBufferBytes, bufferSizeInBytes)
+{}
+
+
+FTGLOutlineFont::~FTGLOutlineFont()
+{}
+
+
+FTGlyph* FTGLOutlineFont::MakeGlyph( unsigned int g)
+{
+    FT_GlyphSlot ftGlyph = face.Glyph( g, FT_LOAD_NO_HINTING);
+
+    if( ftGlyph)
+    {
+        FTOutlineGlyph* tempGlyph = new FTOutlineGlyph( ftGlyph, useDisplayLists);
+        return tempGlyph;
+    }
+
+    err = face.Error();
+    return NULL;
+}
+
+
+void FTGLOutlineFont::Render( const char* string)
+{   
+    glPushAttrib( GL_ENABLE_BIT | GL_HINT_BIT | GL_LINE_BIT | GL_COLOR_BUFFER_BIT);
+    
+    glDisable( GL_TEXTURE_2D);
+    
+    glEnable( GL_LINE_SMOOTH);
+    glHint( GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
+    glEnable(GL_BLEND);
+    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // GL_ONE
+
+    FTFont::Render( string);
+
+    glPopAttrib();
+}
+
+
+void FTGLOutlineFont::Render( const wchar_t* string)
+{   
+    glPushAttrib( GL_ENABLE_BIT | GL_HINT_BIT | GL_LINE_BIT | GL_COLOR_BUFFER_BIT);
+    
+    glDisable( GL_TEXTURE_2D);
+    
+    glEnable( GL_LINE_SMOOTH);
+    glHint( GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
+    glEnable(GL_BLEND);
+    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // GL_ONE
+
+    FTFont::Render( string);
+
+    glPopAttrib();
+}
+

ftgl/FTGLOutlineFont.h

@@ -0,0 +1,64 @@
+#ifndef     __FTGLOutlineFont__
+#define     __FTGLOutlineFont__
+
+
+#include "FTFont.h"
+#include "FTGL.h"
+
+class FTGlyph;
+
+
+/**
+ * FTGLOutlineFont is a specialisation of the FTFont class for handling
+ * Vector Outline fonts
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTGLOutlineFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTGLOutlineFont( const char* fontFilePath);
+        
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTGLOutlineFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+        
+        /**
+         * Destructor
+         */
+        ~FTGLOutlineFont();
+        
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    'C' style string to be output.   
+         */
+        void Render( const char* string);
+        
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    wchar_t string to be output.     
+         */
+        void Render( const wchar_t* string);
+
+    private:
+        /**
+         * Construct a FTOutlineGlyph.
+         *
+         * @param g The glyph index NOT the char code.
+         * @return  An FTOutlineGlyph or <code>null</code> on failure.
+         */
+        inline virtual FTGlyph* MakeGlyph( unsigned int g);
+        
+};
+#endif // __FTGLOutlineFont__

ftgl/FTGLPixmapFont.cpp

@@ -0,0 +1,83 @@
+#include    "FTGLPixmapFont.h"
+#include    "FTPixmapGlyph.h"
+
+
+FTGLPixmapFont::FTGLPixmapFont( const char* fontFilePath)
+:   FTFont( fontFilePath)
+{}
+
+
+FTGLPixmapFont::FTGLPixmapFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   FTFont( pBufferBytes, bufferSizeInBytes)
+{}
+
+
+FTGLPixmapFont::~FTGLPixmapFont()
+{}
+
+
+FTGlyph* FTGLPixmapFont::MakeGlyph( unsigned int g)
+{
+    FT_GlyphSlot ftGlyph = face.Glyph( g, FT_LOAD_NO_HINTING);
+
+    if( ftGlyph)
+    {
+        FTPixmapGlyph* tempGlyph = new FTPixmapGlyph( ftGlyph);
+        return tempGlyph;
+    }
+
+    err = face.Error();
+    return NULL;
+}
+
+
+void FTGLPixmapFont::Render( const char* string)
+{   
+    glPushAttrib( GL_ENABLE_BIT | GL_PIXEL_MODE_BIT | GL_COLOR_BUFFER_BIT);
+    glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT);
+
+    glEnable(GL_BLEND);
+    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    glDisable( GL_TEXTURE_2D);
+
+    GLfloat ftglColour[4];
+    glGetFloatv( GL_CURRENT_RASTER_COLOR, ftglColour);
+
+    glPixelTransferf(GL_RED_SCALE, ftglColour[0]);
+    glPixelTransferf(GL_GREEN_SCALE, ftglColour[1]);
+    glPixelTransferf(GL_BLUE_SCALE, ftglColour[2]);
+    glPixelTransferf(GL_ALPHA_SCALE, ftglColour[3]);
+
+    FTFont::Render( string);
+
+    glPopClientAttrib();
+    glPopAttrib();
+}
+
+
+void FTGLPixmapFont::Render( const wchar_t* string)
+{   
+    glPushAttrib( GL_ENABLE_BIT | GL_PIXEL_MODE_BIT | GL_COLOR_BUFFER_BIT);
+    glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT);
+        
+    glEnable(GL_BLEND);
+    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    
+    glDisable( GL_TEXTURE_2D);
+
+    GLfloat ftglColour[4];
+    glGetFloatv( GL_CURRENT_RASTER_COLOR, ftglColour);
+
+    glPixelTransferf(GL_RED_SCALE, ftglColour[0]);
+    glPixelTransferf(GL_GREEN_SCALE, ftglColour[1]);
+    glPixelTransferf(GL_BLUE_SCALE, ftglColour[2]);
+    glPixelTransferf(GL_ALPHA_SCALE, ftglColour[3]);
+
+    FTFont::Render( string);
+
+    glPopClientAttrib();
+    glPopAttrib();
+}
+
+

ftgl/FTGLPixmapFont.h

@@ -0,0 +1,68 @@
+#ifndef     __FTGLPixmapFont__
+#define     __FTGLPixmapFont__
+
+
+#include "FTFont.h"
+#include "FTGL.h"
+
+
+class FTGlyph;
+
+
+/**
+ * FTGLPixmapFont is a specialisation of the FTFont class for handling
+ * Pixmap (Grey Scale) fonts
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTGLPixmapFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTGLPixmapFont( const char* fontFilePath);
+        
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTGLPixmapFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+        
+        /**
+         * Destructor
+         */
+        ~FTGLPixmapFont();
+        
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    'C' style string to be output.   
+         */
+        void Render( const char* string);
+        
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    wchar_t string to be output.     
+         */
+        void Render( const wchar_t* string);
+
+    private:
+        /**
+         * Construct a FTPixmapGlyph.
+         *
+         * @param g The glyph index NOT the char code.
+         * @return  An FTPixmapGlyph or <code>null</code> on failure.
+         */
+        inline virtual FTGlyph* MakeGlyph( unsigned int g);
+        
+};
+
+
+#endif  //  __FTGLPixmapFont__
+

ftgl/FTGLPolygonFont.cpp

@@ -0,0 +1,33 @@
+#include    "FTGLPolygonFont.h"
+#include    "FTPolyGlyph.h"
+
+
+FTGLPolygonFont::FTGLPolygonFont( const char* fontFilePath)
+:   FTFont( fontFilePath)
+{}
+
+
+FTGLPolygonFont::FTGLPolygonFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+:   FTFont( pBufferBytes, bufferSizeInBytes)
+{}
+
+
+FTGLPolygonFont::~FTGLPolygonFont()
+{}
+
+
+FTGlyph* FTGLPolygonFont::MakeGlyph( unsigned int g)
+{
+    FT_GlyphSlot ftGlyph = face.Glyph( g, FT_LOAD_NO_HINTING);
+
+    if( ftGlyph)
+    {
+        FTPolyGlyph* tempGlyph = new FTPolyGlyph( ftGlyph, useDisplayLists);
+        return tempGlyph;
+    }
+
+    err = face.Error();
+    return NULL;
+}
+
+

ftgl/FTGLPolygonFont.h

@@ -0,0 +1,53 @@
+#ifndef     __FTGLPolygonFont__
+#define     __FTGLPolygonFont__
+
+
+#include "FTFont.h"
+#include "FTGL.h"
+
+class FTGlyph;
+
+
+/**
+ * FTGLPolygonFont is a specialisation of the FTFont class for handling
+ * tesselated Polygon Mesh fonts
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTGLPolygonFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTGLPolygonFont( const char* fontFilePath);
+        
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTGLPolygonFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes);
+        
+        /**
+         * Destructor
+         */
+        ~FTGLPolygonFont();
+        
+    private:
+        /**
+         * Construct a FTPolyGlyph.
+         *
+         * @param g The glyph index NOT the char code.
+         * @return  An FTPolyGlyph or <code>null</code> on failure.
+         */
+        inline virtual FTGlyph* MakeGlyph( unsigned int g);
+        
+};
+
+
+#endif  //  __FTGLPolygonFont__
+

ftgl/FTGLTextureFont.cpp

@@ -0,0 +1,183 @@
+#include <cassert>
+#include <string> // For memset
+
+#include "FTGLTextureFont.h"
+#include "FTTextureGlyph.h"
+
+
+inline GLuint NextPowerOf2( GLuint in)
+{
+     in -= 1;
+
+     in |= in >> 16;
+     in |= in >> 8;
+     in |= in >> 4;
+     in |= in >> 2;
+     in |= in >> 1;
+
+     return in + 1;
+}
+
+
+FTGLTextureFont::FTGLTextureFont( const char* fontFilePath)
+:   FTFont( fontFilePath),
+    maximumGLTextureSize(0),
+    textureWidth(0),
+    textureHeight(0),
+    glyphHeight(0),
+    glyphWidth(0),
+    padding(3),
+    xOffset(0),
+    yOffset(0)
+{
+    remGlyphs = numGlyphs = face.GlyphCount();
+}
+
+
+FTGLTextureFont::FTGLTextureFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes, bool _hinting)
+:   FTFont( pBufferBytes, bufferSizeInBytes),
+    maximumGLTextureSize(0),
+    textureWidth(0),
+    textureHeight(0),
+    glyphHeight(0),
+    glyphWidth(0),
+    padding(3),
+    xOffset(0),
+    yOffset(0),
+    hinting( _hinting )
+{
+    remGlyphs = numGlyphs = face.GlyphCount();
+}
+
+
+FTGLTextureFont::~FTGLTextureFont()
+{
+    glDeleteTextures( textureIDList.size(), (const GLuint*)&textureIDList[0]);
+}
+
+
+FTGlyph* FTGLTextureFont::MakeGlyph( unsigned int glyphIndex)
+{
+    FT_GlyphSlot ftGlyph = face.Glyph( glyphIndex, hinting ? 0 : FT_LOAD_NO_HINTING );
+    
+    if( ftGlyph)
+    {
+        glyphHeight = static_cast<int>( charSize.Height());
+        glyphWidth = static_cast<int>( charSize.Width());
+        
+        if( textureIDList.empty())
+        {
+            textureIDList.push_back( CreateTexture());
+            xOffset = yOffset = padding;
+        }
+        
+        if( xOffset > ( textureWidth - glyphWidth))
+        {
+            xOffset = padding;
+            yOffset += glyphHeight;
+            
+            if( yOffset > ( textureHeight - glyphHeight))
+            {
+                textureIDList.push_back( CreateTexture());
+                yOffset = padding;
+            }
+        }
+        
+        FTTextureGlyph* tempGlyph = new FTTextureGlyph( ftGlyph, textureIDList[textureIDList.size() - 1],
+                                                        xOffset, yOffset, textureWidth, textureHeight);
+        xOffset += static_cast<int>( tempGlyph->BBox().upperX - tempGlyph->BBox().lowerX + padding);
+        
+        --remGlyphs;
+        return tempGlyph;
+    }
+    
+    err = face.Error();
+    return NULL;
+}
+
+
+void FTGLTextureFont::CalculateTextureSize()
+{
+    if( !maximumGLTextureSize)
+    {
+        glGetIntegerv( GL_MAX_TEXTURE_SIZE, (GLint*)&maximumGLTextureSize);
+        assert(maximumGLTextureSize); // If you hit this then you have an invalid OpenGL context.
+    }
+    
+    textureWidth = NextPowerOf2( (remGlyphs * glyphWidth) + ( padding * 2));
+    textureWidth = textureWidth > maximumGLTextureSize ? maximumGLTextureSize : textureWidth;
+    
+    int h = static_cast<int>( (textureWidth - ( padding * 2)) / glyphWidth);
+        
+    textureHeight = NextPowerOf2( (( numGlyphs / h) + 1) * glyphHeight);
+    textureHeight = textureHeight > maximumGLTextureSize ? maximumGLTextureSize : textureHeight;
+}
+
+
+GLuint FTGLTextureFont::CreateTexture()
+{   
+    CalculateTextureSize();
+    
+    int totalMemory = textureWidth * textureHeight;
+    unsigned char* textureMemory = new unsigned char[totalMemory];
+    memset( textureMemory, 0, totalMemory);
+
+    GLuint textID;
+    glGenTextures( 1, (GLuint*)&textID);
+
+    glBindTexture( GL_TEXTURE_2D, textID);
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+    glTexImage2D( GL_TEXTURE_2D, 0, GL_ALPHA, textureWidth, textureHeight, 0, GL_ALPHA, GL_UNSIGNED_BYTE, textureMemory);
+
+    delete [] textureMemory;
+
+    return textID;
+}
+
+
+bool FTGLTextureFont::FaceSize( const unsigned int size, const unsigned int res)
+{
+    if( !textureIDList.empty())
+    {
+        glDeleteTextures( textureIDList.size(), (const GLuint*)&textureIDList[0]);
+        textureIDList.clear();
+        remGlyphs = numGlyphs = face.GlyphCount();
+    }
+
+    return FTFont::FaceSize( size, res);
+}
+
+
+void FTGLTextureFont::Render( const char* string)
+{   
+    glPushAttrib( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT);
+    
+    glEnable(GL_BLEND);
+    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // GL_ONE
+
+    FTTextureGlyph::ResetActiveTexture();
+    
+    FTFont::Render( string);
+
+    glPopAttrib();
+}
+
+
+void FTGLTextureFont::Render( const wchar_t* string)
+{   
+    glPushAttrib( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT);
+    
+    glEnable(GL_BLEND);
+    glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // GL_ONE
+    
+    FTTextureGlyph::ResetActiveTexture();
+    
+    FTFont::Render( string);
+    
+    glPopAttrib();
+}
+

ftgl/FTGLTextureFont.h

@@ -0,0 +1,152 @@
+#ifndef     __FTGLTextureFont__
+#define     __FTGLTextureFont__
+
+#include "FTFont.h"
+#include "FTVector.h"
+#include "FTGL.h"
+
+class FTTextureGlyph;
+
+
+/**
+ * FTGLTextureFont is a specialisation of the FTFont class for handling
+ * Texture mapped fonts
+ *
+ * @see     FTFont
+ */
+class  FTGL_EXPORT FTGLTextureFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTGLTextureFont( const char* fontFilePath);
+        
+        /**
+         * Open and read a font from a buffer in memory. Sets Error flag.
+         *
+         * @param pBufferBytes  the in-memory buffer
+         * @param bufferSizeInBytes  the length of the buffer in bytes
+         */
+        FTGLTextureFont( const unsigned char *pBufferBytes, size_t bufferSizeInBytes, bool _hinting );
+        
+        /**
+         * Destructor
+         */
+        virtual ~FTGLTextureFont();
+
+        /**
+            * Set the char size for the current face.
+         *
+         * @param size      the face size in points (1/72 inch)
+         * @param res       the resolution of the target device.
+         * @return          <code>true</code> if size was set correctly
+         */
+        virtual bool FaceSize( const unsigned int size, const unsigned int res = 72);
+
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    'C' style string to be output.   
+         */
+        virtual void Render( const char* string);
+        
+        /**
+         * Renders a string of characters
+         * 
+         * @param string    wchar_t string to be output.     
+         */
+        virtual void Render( const wchar_t* string);
+
+        
+    private:
+        /**
+         * Construct a FTTextureGlyph.
+         *
+         * @param glyphIndex The glyph index NOT the char code.
+         * @return  An FTTextureGlyph or <code>null</code> on failure.
+         */
+        inline virtual FTGlyph* MakeGlyph( unsigned int glyphIndex);
+                
+        /**
+         * Get the size of a block of memory required to layout the glyphs
+         *
+         * Calculates a width and height based on the glyph sizes and the
+         * number of glyphs. It over estimates.
+         */
+        inline void CalculateTextureSize();
+
+        /**
+         * Creates a 'blank' OpenGL texture object.
+         *
+         * The format is GL_ALPHA and the params are
+         * GL_TEXTURE_WRAP_S = GL_CLAMP
+         * GL_TEXTURE_WRAP_T = GL_CLAMP
+         * GL_TEXTURE_MAG_FILTER = GL_LINEAR
+         * GL_TEXTURE_MIN_FILTER = GL_LINEAR
+         * Note that mipmapping is NOT used
+         */
+        inline GLuint CreateTexture();
+        
+        /**
+         * The maximum texture dimension on this OpenGL implemetation
+         */
+        GLsizei maximumGLTextureSize;
+        
+        /**
+         * The minimum texture width required to hold the glyphs
+         */
+        GLsizei textureWidth;
+        
+        /**
+         * The minimum texture height required to hold the glyphs
+         */
+        GLsizei textureHeight;
+        
+        /**
+         *An array of texture ids
+         */
+         FTVector<GLuint> textureIDList;
+        
+        /**
+         * The max height for glyphs in the current font
+         */
+        int glyphHeight;
+
+        /**
+         * The max width for glyphs in the current font
+         */
+        int glyphWidth;
+
+        /**
+         * A value to be added to the height and width to ensure that
+         * glyphs don't overlap in the texture
+         */
+        unsigned int padding;
+        
+        /**
+         *
+         */
+         unsigned int numGlyphs;
+        
+        /**
+         */
+        unsigned int remGlyphs;
+
+        /**
+         */
+        int xOffset;
+
+        /**
+         */
+        int yOffset;
+
+		bool hinting;
+};
+
+
+#endif // __FTGLTextureFont__
+
+

ftgl/FTGlyph.cpp

@@ -0,0 +1,17 @@
+#include    "FTGlyph.h"
+
+
+FTGlyph::FTGlyph( FT_GlyphSlot glyph, bool useList)
+:   useDisplayList(useList),
+    err(0)  
+{
+    if( glyph)
+    {
+        bBox = FTBBox( glyph);
+        advance = FTPoint( glyph->advance.x / 64.0f, glyph->advance.y / 64.0f, 0.0f);
+    }
+}
+
+
+FTGlyph::~FTGlyph()
+{}

ftgl/FTGlyph.h

@@ -0,0 +1,101 @@
+#ifndef     __FTGlyph__
+#define     __FTGlyph__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTBBox.h"
+#include "FTPoint.h"
+#include "FTGL.h"
+
+
+/**
+ * FTGlyph is the base class for FTGL glyphs.
+ *
+ * It provides the interface between Freetype glyphs and their openGL
+ * renderable counterparts. This is an abstract class and derived classes
+ * must implement the <code>render</code> function. 
+ * 
+ * @see FTGlyphContainer
+ * @see FTBBox
+ * @see FTPoint
+ *
+ */
+class FTGL_EXPORT FTGlyph
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param glyph The Freetype glyph to be processed
+         * @param useDisplayList Enable or disable the use of Display Lists for this glyph
+         *                       <code>true</code> turns ON display lists.
+         *                       <code>false</code> turns OFF display lists.
+         */
+        FTGlyph( FT_GlyphSlot glyph, bool useDisplayList = true);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen   The current pen position.
+         * @return      The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render( const FTPoint& pen) = 0;
+        
+        /**
+         * Return the advance width for this glyph.
+         *
+         * @return  advance width.
+         */
+        const FTPoint& Advance() const { return advance;}
+        
+        /**
+         * Return the bounding box for this glyph.
+         *
+         * @return  bounding box.
+         */
+        const FTBBox& BBox() const { return bBox;}
+        
+        /**
+         * Queries for errors.
+         *
+         * @return  The current error code.
+         */
+        FT_Error Error() const { return err;}
+        
+    protected:
+        /**
+         * The advance distance for this glyph
+         */
+        FTPoint advance;
+
+        /**
+         * The bounding box of this glyph.
+         */
+        FTBBox bBox;
+        
+        /**
+         * Flag to enable or disable the use of Display Lists inside FTGL
+         * <code>true</code> turns ON display lists.
+         * <code>false</code> turns OFF display lists.
+         */
+        bool useDisplayList;
+        
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+        
+    private:
+
+};
+
+
+#endif  //  __FTGlyph__
+

ftgl/FTGlyphContainer.cpp

@@ -0,0 +1,91 @@
+#include    "FTGlyphContainer.h"
+#include    "FTGlyph.h"
+#include    "FTFace.h"
+#include    "FTCharmap.h"
+
+
+FTGlyphContainer::FTGlyphContainer( FTFace* f)
+:   face(f),
+    err(0)
+{
+    glyphs.push_back( NULL);
+    charMap = new FTCharmap( face);
+}
+
+
+FTGlyphContainer::~FTGlyphContainer()
+{
+    GlyphVector::iterator glyphIterator;
+    for( glyphIterator = glyphs.begin(); glyphIterator != glyphs.end(); ++glyphIterator)
+    {
+        delete *glyphIterator;
+    }
+    
+    glyphs.clear();
+    delete charMap;
+}
+
+
+bool FTGlyphContainer::CharMap( FT_Encoding encoding)
+{
+    bool result = charMap->CharMap( encoding);
+    err = charMap->Error();
+    return result;
+}
+
+
+unsigned int FTGlyphContainer::FontIndex( const unsigned int characterCode) const
+{
+    return charMap->FontIndex( characterCode);
+}
+
+
+void FTGlyphContainer::Add( FTGlyph* tempGlyph, const unsigned int characterCode)
+{
+    charMap->InsertIndex( characterCode, glyphs.size());
+    glyphs.push_back( tempGlyph);
+}
+
+
+const FTGlyph* const FTGlyphContainer::Glyph( const unsigned int characterCode) const
+{
+    signed int index = charMap->GlyphListIndex( characterCode);
+    return glyphs[index];
+}
+
+
+FTBBox FTGlyphContainer::BBox( const unsigned int characterCode) const
+{
+    return glyphs[charMap->GlyphListIndex( characterCode)]->BBox();
+}
+
+
+float FTGlyphContainer::Advance( const unsigned int characterCode, const unsigned int nextCharacterCode)
+{
+    unsigned int left = charMap->FontIndex( characterCode);
+    unsigned int right = charMap->FontIndex( nextCharacterCode);
+
+    float width = face->KernAdvance( left, right).X();
+    width += glyphs[charMap->GlyphListIndex( characterCode)]->Advance().X();
+    
+    return width;
+}
+
+
+FTPoint FTGlyphContainer::Render( const unsigned int characterCode, const unsigned int nextCharacterCode, FTPoint penPosition)
+{
+    FTPoint kernAdvance, advance;
+    
+    unsigned int left = charMap->FontIndex( characterCode);
+    unsigned int right = charMap->FontIndex( nextCharacterCode);
+
+    kernAdvance = face->KernAdvance( left, right);
+        
+    if( !face->Error())
+    {
+        advance = glyphs[charMap->GlyphListIndex( characterCode)]->Render( penPosition);
+    }
+    
+    kernAdvance += advance;
+    return kernAdvance;
+}

ftgl/FTGlyphContainer.h

@@ -0,0 +1,127 @@
+#ifndef     __FTGlyphContainer__
+#define     __FTGlyphContainer__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTBBox.h"
+#include "FTPoint.h"
+#include "FTVector.h"
+
+class FTFace;
+class FTGlyph;
+class FTCharmap;
+
+/**
+ * FTGlyphContainer holds the post processed FTGlyph objects.
+ *
+ * @see FTGlyph
+ */
+class FTGL_EXPORT FTGlyphContainer
+{
+        typedef FTVector<FTGlyph*> GlyphVector;
+    public:
+        /**
+         * Constructor
+         *
+         * @param face      The Freetype face
+         */
+        FTGlyphContainer( FTFace* face);
+
+        /**
+         * Destructor
+         */
+        ~FTGlyphContainer();
+
+        /**
+         * Sets the character map for the face.
+         *
+         * @param encoding      the Freetype encoding symbol. See above.
+         * @return              <code>true</code> if charmap was valid
+         *                      and set correctly
+         */
+        bool CharMap( FT_Encoding encoding);
+
+        /**
+         * Get the font index of the input character.
+         *
+         * @param characterCode The character code of the requested glyph in the
+         *                      current encoding eg apple roman.
+         * @return      The font index for the character.
+         */
+        unsigned int FontIndex( const unsigned int characterCode ) const;
+        
+        /**
+         * Adds a glyph to this glyph list.
+         *
+         * @param glyph         The FTGlyph to be inserted into the container
+         * @param characterCode The char code of the glyph NOT the glyph index.
+         */
+        void Add( FTGlyph* glyph, const unsigned int characterCode);
+
+        /**
+         * Get a glyph from the glyph list
+         *
+         * @param characterCode The char code of the glyph NOT the glyph index      
+         * @return              An FTGlyph or <code>null</code> is it hasn't been
+         * loaded.
+         */
+        const FTGlyph* const Glyph( const unsigned int characterCode) const;
+
+        /**
+         * Get the bounding box for a character.
+         * @param characterCode The char code of the glyph NOT the glyph index      
+         */
+        FTBBox BBox( const unsigned int characterCode) const;
+        
+        /**
+        * Returns the kerned advance width for a glyph.
+        *
+        * @param characterCode     glyph index of the character
+        * @param nextCharacterCode the next glyph in a string
+        * @return                  advance width
+        */
+        float Advance( const unsigned int characterCode, const unsigned int nextCharacterCode);
+        
+        /**
+         * Renders a character
+         * @param characterCode      the glyph to be Rendered
+         * @param nextCharacterCode  the next glyph in the string. Used for kerning.
+         * @param penPosition        the position to Render the glyph
+         * @return                   The distance to advance the pen position after Rendering
+         */
+        FTPoint Render( const unsigned int characterCode, const unsigned int nextCharacterCode, FTPoint penPosition);
+        
+        /**
+         * Queries the Font for errors.
+         *
+         * @return  The current error code.
+         */
+        FT_Error Error() const { return err;}
+
+    private:
+        /**
+         * The FTGL face
+         */
+        FTFace* face;
+
+        /**
+         * The Character Map object associated with the current face
+         */
+        FTCharmap* charMap;
+
+        /**
+         * A structure to hold the glyphs
+         */
+        GlyphVector glyphs;
+
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+};
+
+
+#endif  //  __FTGlyphContainer__

ftgl/FTLibrary.cpp

@@ -0,0 +1,64 @@
+#include    "FTLibrary.h"
+
+
+const FTLibrary&  FTLibrary::Instance()
+{
+    static FTLibrary ftlib;
+    return ftlib;
+}
+
+
+FTLibrary::~FTLibrary()
+{
+    if( library != 0)
+    {
+        FT_Done_FreeType( *library);
+
+        delete library;
+        library= 0;
+    }
+
+//  if( manager != 0)
+//  {
+//      FTC_Manager_Done( manager );
+//
+//      delete manager;
+//      manager= 0;
+//  }
+}
+
+
+FTLibrary::FTLibrary()
+:   library(0),
+    err(0)
+{
+    Initialise();
+}
+
+
+bool FTLibrary::Initialise()
+{
+    if( library != 0)
+        return true;
+
+    library = new FT_Library;
+    
+    err = FT_Init_FreeType( library);
+    if( err)
+    {
+        delete library;
+        library = 0;
+        return false;
+    }
+    
+//  FTC_Manager* manager;
+//  
+//  if( FTC_Manager_New( lib, 0, 0, 0, my_face_requester, 0, manager )
+//  {
+//      delete manager;
+//      manager= 0;
+//      return false;
+//  }
+
+    return true;
+}

ftgl/FTLibrary.h

@@ -0,0 +1,97 @@
+#ifndef     __FTLibrary__
+#define     __FTLibrary__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+//#include FT_CACHE_H
+
+#include "FTGL.h"
+
+
+/**
+ * FTLibrary class is the global accessor for the Freetype library.
+ *
+ * This class encapsulates the Freetype Library. This is a singleton class
+ * and ensures that only one FT_Library is in existence at any one time.
+ * All constructors are private therefore clients cannot create or
+ * instantiate this class themselves and must access it's methods via the
+ * static <code>FTLibrary::Instance()</code> function.
+ *
+ * Just because this class returns a valid <code>FTLibrary</code> object
+ * doesn't mean that the Freetype Library has been successfully initialised.
+ * Clients should check for errors. You can initialse the library AND check
+ * for errors using the following code...
+ * <code>err = FTLibrary::Instance().Error();</code>
+ *
+ * @see "Freetype 2 Documentation"
+ *
+ */
+class FTGL_EXPORT FTLibrary
+{
+    public:
+        /**
+         * Global acces point to the single FTLibrary object.
+         * 
+         * @return  The global <code>FTLibrary</code> object.
+         */
+        static const FTLibrary& Instance();
+
+        /**
+         * Gets a pointer to the native Freetype library.
+         * 
+         * @return A handle to a FreeType library instance. 
+         */
+        const FT_Library* const GetLibrary() const { return library;}
+        
+        /**
+         * Queries the library for errors.
+         *
+         * @return  The current error code.
+         */
+        FT_Error Error() const { return err;}
+        
+        /**
+         * Destructor
+         *
+         * Disposes of the Freetype library
+         */
+        ~FTLibrary();
+        
+    private:
+        /**
+         * Default constructors.
+         *
+         * Made private to stop clients creating there own FTLibrary
+         * objects.
+         */
+        FTLibrary();
+        FTLibrary( const FT_Library&){}
+        FTLibrary& operator=( const FT_Library&) { return *this; }
+        
+        /**
+         * Initialises the Freetype library
+         *
+         * Even though this function indicates success via the return value,
+         * clients can't see this so must check the error codes. This function
+         * is only ever called by the default c_stor
+         *
+         * @return  <code>true</code> if the Freetype library was
+         *          successfully initialised, <code>false</code>
+         *          otherwise.
+         */
+        bool Initialise();
+        
+        /**
+         * Freetype library handle.
+         */
+        FT_Library* library;
+//      FTC_Manager* manager;
+
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+        
+};
+
+#endif  //  __FTLibrary__

ftgl/FTList.h

@@ -0,0 +1,112 @@
+#ifndef    __FTList__
+#define    __FTList__
+
+#include "FTGL.h"
+
+/**
+* Provides a non-STL alternative to the STL list
+ */
+template <typename FT_LIST_ITEM_TYPE>
+class FTGL_EXPORT FTList
+{
+    public:
+        typedef FT_LIST_ITEM_TYPE value_type;
+        typedef value_type& reference;
+        typedef const value_type& const_reference;
+        typedef size_t size_type;
+
+        /**
+         * Constructor
+         */
+        FTList()
+        :   listSize(0),
+            tail(0)
+        {
+            tail = NULL;
+            head = new Node;
+        }
+
+        /**
+         * Destructor
+         */
+        ~FTList()
+        {
+            Node* next;
+            
+            for( Node *walk = head; walk; walk = next)
+            {
+                next = walk->next;
+                delete walk;
+            }
+        }
+
+        /**
+         * Get the number of items in the list
+         */
+        size_type size() const
+        {
+            return listSize;
+        }
+
+        /**
+         * Add an item to the end of the list
+         */
+        void push_back( const value_type& item)
+        {
+            Node* node = new Node( item);
+            
+            if( head->next == NULL)
+            {
+                head->next = node;
+            }
+
+            if( tail)
+            {
+                tail->next = node;
+            }
+            tail = node;
+            ++listSize;
+        }
+        
+        /**
+         * Get the item at the front of the list
+         */
+        reference front() const
+        {
+            return head->next->payload;
+        }
+
+        /**
+         * Get the item at the end of the list
+         */
+        reference back() const
+        {
+            return tail->payload;
+        }
+
+    private:
+        struct Node
+        {
+            Node()
+            :	next(NULL)
+            {}
+
+            Node( const value_type& item)
+            :	next(NULL)
+            {
+                payload = item;
+            }
+            
+            Node* next;
+            
+            value_type payload;
+        };
+        
+        size_type listSize;
+
+        Node* head;
+        Node* tail;
+};
+
+#endif // __FTList__
+

ftgl/FTOutlineGlyph.cpp

@@ -0,0 +1,66 @@
+#include    "FTOutlineGlyph.h"
+#include    "FTVectoriser.h"
+
+
+FTOutlineGlyph::FTOutlineGlyph( FT_GlyphSlot glyph, bool useDisplayList)
+:   FTGlyph( glyph),
+    glList(0)
+{
+    if( ft_glyph_format_outline != glyph->format)
+    {
+        err = 0x14; // Invalid_Outline
+        return;
+    }
+
+    FTVectoriser vectoriser( glyph);
+
+    size_t numContours = vectoriser.ContourCount();
+    if ( ( numContours < 1) || ( vectoriser.PointCount() < 3))
+    {
+        return;
+    }
+
+    if(useDisplayList)
+    {
+        glList = glGenLists(1);
+        glNewList( glList, GL_COMPILE);
+    }
+    
+    for( unsigned int c = 0; c < numContours; ++c)
+    {
+        const FTContour* contour = vectoriser.Contour(c);
+        
+        glBegin( GL_LINE_LOOP);
+            for( unsigned int pointIndex = 0; pointIndex < contour->PointCount(); ++pointIndex)
+            {
+                FTPoint point = contour->Point(pointIndex);
+                glVertex2f( point.X() / 64.0f, point.Y() / 64.0f);
+            }
+        glEnd();
+    }
+
+    if(useDisplayList)
+    {
+        glEndList();
+    }
+}
+
+
+FTOutlineGlyph::~FTOutlineGlyph()
+{
+    glDeleteLists( glList, 1);
+}
+
+
+const FTPoint& FTOutlineGlyph::Render( const FTPoint& pen)
+{
+    glTranslatef( pen.X(), pen.Y(), 0.0f);
+
+    if( glList)
+    {
+        glCallList( glList);
+    }
+    
+    return advance;
+}
+

ftgl/FTOutlineGlyph.h

@@ -0,0 +1,57 @@
+#ifndef		__FTOutlineGlyph__
+#define		__FTOutlineGlyph__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTGlyph.h"
+
+class FTVectoriser;
+
+
+/**
+ * FTOutlineGlyph is a specialisation of FTGlyph for creating outlines.
+ * 
+ * @see FTGlyphContainer
+ * @see FTVectoriser
+ *
+ */
+class FTGL_EXPORT FTOutlineGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor. Sets the Error to Invalid_Outline if the glyphs isn't an outline.
+         *
+         * @param glyph The Freetype glyph to be processed
+         * @param useDisplayList Enable or disable the use of Display Lists for this glyph
+         *                       <code>true</code> turns ON display lists.
+         *                       <code>false</code> turns OFF display lists.
+         */
+        FTOutlineGlyph( FT_GlyphSlot glyph, bool useDisplayList);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTOutlineGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen	The current pen position.
+         * @return		The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render( const FTPoint& pen);
+        
+    private:		
+        /**
+         * OpenGL display list
+         */
+        GLuint glList;
+	
+};
+
+
+#endif	//	__FTOutlineGlyph__
+

ftgl/FTPixmapGlyph.cpp

@@ -0,0 +1,73 @@
+#include    "FTPixmapGlyph.h"
+
+FTPixmapGlyph::FTPixmapGlyph( FT_GlyphSlot glyph)
+:   FTGlyph( glyph),
+    destWidth(0),
+    destHeight(0),
+    data(0)
+{
+    err = FT_Render_Glyph( glyph, FT_RENDER_MODE_NORMAL);
+    if( err || ft_glyph_format_bitmap != glyph->format)
+    {
+        return;
+    }
+
+    FT_Bitmap bitmap = glyph->bitmap;
+
+    //check the pixel mode
+    //ft_pixel_mode_grays
+        
+    int srcWidth = bitmap.width;
+    int srcHeight = bitmap.rows;
+    
+    destWidth = srcWidth;
+    destHeight = srcHeight;
+    
+    if( destWidth && destHeight)
+    {
+        data = new unsigned char[destWidth * destHeight * 2];
+        unsigned char* src = bitmap.buffer;
+
+        unsigned char* dest = data + ((destHeight - 1) * destWidth * 2);
+        size_t destStep = destWidth * 2 * 2;
+
+        for( int y = 0; y < srcHeight; ++y)
+        {
+            for( int x = 0; x < srcWidth; ++x)
+            {
+                *dest++ = static_cast<unsigned char>(255);
+                *dest++ = *src++;
+            }
+            dest -= destStep;
+        }
+
+        destHeight = srcHeight;
+    }
+
+    pos.X(glyph->bitmap_left);
+    pos.Y(srcHeight - glyph->bitmap_top);
+}
+
+
+FTPixmapGlyph::~FTPixmapGlyph()
+{
+    delete [] data;
+}
+
+
+const FTPoint& FTPixmapGlyph::Render( const FTPoint& pen)
+{
+    glBitmap( 0, 0, 0.0f, 0.0f, pen.X() + pos.X(), pen.Y() - pos.Y(), (const GLubyte*)0);
+    
+    if( data)
+    {
+        glPixelStorei( GL_UNPACK_ROW_LENGTH, 0);
+        glPixelStorei( GL_UNPACK_ALIGNMENT, 2);
+
+        glDrawPixels( destWidth, destHeight, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, (const GLvoid*)data);
+    }
+        
+    glBitmap( 0, 0, 0.0f, 0.0f, -pos.X(), pos.Y(), (const GLubyte*)0);
+
+    return advance;
+}

ftgl/FTPixmapGlyph.h

@@ -0,0 +1,68 @@
+#ifndef     __FTPixmapGlyph__
+#define     __FTPixmapGlyph__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTGlyph.h"
+
+
+/**
+ * FTPixmapGlyph is a specialisation of FTGlyph for creating pixmaps.
+ * 
+ * @see FTGlyphContainer
+ *
+ */
+class  FTGL_EXPORT FTPixmapGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param glyph The Freetype glyph to be processed
+         */
+        FTPixmapGlyph( FT_GlyphSlot glyph);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTPixmapGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen   The current pen position.
+         * @return      The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render( const FTPoint& pen);
+        
+        // attributes
+
+    private:
+        /**
+         * The width of the glyph 'image'
+         */
+        int destWidth;
+
+        /**
+         * The height of the glyph 'image'
+         */
+        int destHeight;
+        
+        /**
+         * Vector from the pen position to the topleft corner of the pixmap
+         */
+        FTPoint pos;
+        
+        /**
+         * Pointer to the 'image' data
+         */
+        unsigned char* data;
+        
+};
+
+
+#endif  //  __FTPixmapGlyph__

ftgl/FTPoint.cpp

@@ -0,0 +1,19 @@
+#include "FTPoint.h"
+
+
+bool operator == ( const FTPoint &a, const FTPoint &b) 
+{
+    return((a.values[0] == b.values[0]) && (a.values[1] == b.values[1]) && (a.values[2] == b.values[2]));
+}
+
+bool operator != ( const FTPoint &a, const FTPoint &b) 
+{
+    return((a.values[0] != b.values[0]) || (a.values[1] != b.values[1]) || (a.values[2] != b.values[2]));
+}
+
+
+FTPoint operator*( double multiplier, FTPoint& point)
+{
+    return point * multiplier;
+}
+        

ftgl/FTPoint.h

@@ -0,0 +1,162 @@
+#ifndef     __FTPoint__
+#define     __FTPoint__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+
+/**
+ * FTPoint class is a basic 3 dimensional point or vector.
+ */
+class FTGL_EXPORT FTPoint
+{
+    public:
+        /**
+         * Default constructor. Point is set to zero.
+         */
+        FTPoint()
+        {
+            values[0] = 0;
+            values[1] = 0;
+            values[2] = 0;
+        }
+        
+        /**
+         * Constructor.
+         *
+         * @param x First component
+         * @param y Second component
+         * @param z Third component
+         */
+        FTPoint( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z)
+        {
+            values[0] = x;
+            values[1] = y;
+            values[2] = z;
+        }
+        
+        /**
+         * Constructor. This converts an FT_Vector to an FT_Point
+         *
+         * @param ft_vector A freetype vector
+         */
+        FTPoint( const FT_Vector& ft_vector)
+        {
+            values[0] = ft_vector.x;
+            values[1] = ft_vector.y;
+            values[2] = 0;
+        }
+        
+        /**
+         * Operator += In Place Addition.
+         *
+         * @param point
+         * @return this plus point.
+         */
+        FTPoint& operator += ( const FTPoint& point)
+        {
+            values[0] += point.values[0];
+            values[1] += point.values[1];
+            values[2] += point.values[2];
+
+            return *this;
+        }
+
+        /**
+         * Operator +
+         *
+         * @param point
+         * @return this plus point.
+         */
+        FTPoint operator + ( const FTPoint& point)
+        {
+            FTPoint temp;
+            temp.values[0] = values[0] + point.values[0];
+            temp.values[1] = values[1] + point.values[1];
+            temp.values[2] = values[2] + point.values[2];
+
+            return temp;
+        }
+        
+        
+        /**
+         * Operator *
+         *
+         * @param multiplier
+         * @return <code>this</code> multiplied by <code>multiplier</code>.
+         */
+        FTPoint operator * ( double multiplier)
+        {
+            FTPoint temp;
+            temp.values[0] = values[0] * multiplier;
+            temp.values[1] = values[1] * multiplier;
+            temp.values[2] = values[2] * multiplier;
+
+            return temp;
+        }
+        
+        
+        /**
+         * Operator *
+         *
+         * @param point
+         * @param multiplier
+         * @return <code>multiplier</code> multiplied by <code>point</code>.
+         */
+        friend FTPoint operator*( double multiplier, FTPoint& point);
+
+
+        /**
+         * Operator == Tests for eqaulity
+         *
+         * @param a
+         * @param b
+         * @return true if a & b are equal
+         */
+        friend bool operator == ( const FTPoint &a, const FTPoint &b);
+
+        /**
+         * Operator != Tests for non equality
+         *
+         * @param a
+         * @param b
+         * @return true if a & b are not equal
+         */
+        friend bool operator != ( const FTPoint &a, const FTPoint &b);
+        
+        
+        /**
+         * Cast to FTGL_DOUBLE*
+         */
+        operator const FTGL_DOUBLE*() const
+        {
+            return values;
+        }
+        
+
+        /**
+         * Setters
+         */
+        void X( FTGL_DOUBLE x) { values[0] = x;};
+        void Y( FTGL_DOUBLE y) { values[1] = y;};
+        void Z( FTGL_DOUBLE z) { values[2] = z;};
+
+
+        /**
+         * Getters
+         */
+        FTGL_DOUBLE X() const { return values[0];};
+        FTGL_DOUBLE Y() const { return values[1];};
+        FTGL_DOUBLE Z() const { return values[2];};
+        
+    private:
+        /**
+         * The point data
+         */
+        FTGL_DOUBLE values[3];
+};
+
+#endif  //  __FTPoint__
+

ftgl/FTPolyGlyph.cpp

@@ -0,0 +1,77 @@
+#include "FTPolyGlyph.h"
+#include "FTVectoriser.h"
+
+
+FTPolyGlyph::FTPolyGlyph( FT_GlyphSlot glyph, bool useDisplayList)
+:   FTGlyph( glyph),
+    glList(0)
+{
+    if( ft_glyph_format_outline != glyph->format)
+    {
+        err = 0x14; // Invalid_Outline
+        return;
+    }
+
+    FTVectoriser vectoriser( glyph);
+
+    if(( vectoriser.ContourCount() < 1) || ( vectoriser.PointCount() < 3))
+    {
+        return;
+    }
+    
+    unsigned int horizontalTextureScale = glyph->face->size->metrics.x_ppem * 64;
+    unsigned int verticalTextureScale = glyph->face->size->metrics.y_ppem * 64;        
+        
+    vectoriser.MakeMesh( 1.0);
+    
+    if( useDisplayList)
+    {
+        glList = glGenLists( 1);
+        glNewList( glList, GL_COMPILE);
+    }
+
+    const FTMesh* mesh = vectoriser.GetMesh();
+    for( unsigned int index = 0; index < mesh->TesselationCount(); ++index)
+    {
+        const FTTesselation* subMesh = mesh->Tesselation( index);
+        unsigned int polyonType = subMesh->PolygonType();
+
+        glBegin( polyonType);
+            for( unsigned int pointIndex = 0; pointIndex < subMesh->PointCount(); ++pointIndex)
+            {
+                FTPoint point = subMesh->Point(pointIndex);
+                
+                glTexCoord2f( point.X() / horizontalTextureScale,
+                              point.Y() / verticalTextureScale);
+                
+                glVertex3f( point.X() / 64.0f,
+                            point.Y() / 64.0f,
+                            0.0f);
+            }
+        glEnd();
+    }
+
+    if(useDisplayList)
+    {
+        glEndList();
+    }
+}
+
+
+FTPolyGlyph::~FTPolyGlyph()
+{
+    glDeleteLists( glList, 1);
+}
+
+
+const FTPoint& FTPolyGlyph::Render( const FTPoint& pen)
+{
+    glTranslatef(  pen.X(),  pen.Y(), 0.0f);
+
+    if( glList)
+    {
+        glCallList( glList);    
+    }
+    
+    return advance;
+}

ftgl/FTPolyGlyph.h

@@ -0,0 +1,59 @@
+#ifndef     __FTPolyGlyph__
+#define     __FTPolyGlyph__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTGlyph.h"
+
+class FTVectoriser;
+
+/**
+ * FTPolyGlyph is a specialisation of FTGlyph for creating tessellated
+ * polygon glyphs.
+ * 
+ * @see FTGlyphContainer
+ * @see FTVectoriser
+ *
+ */
+class FTGL_EXPORT FTPolyGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor. Sets the Error to Invalid_Outline if the glyphs isn't an outline.
+         *
+         * @param glyph The Freetype glyph to be processed
+         * @param glyph The Freetype glyph to be processed
+         * @param useDisplayList Enable or disable the use of Display Lists for this glyph
+         *                       <code>true</code> turns ON display lists.
+         *                       <code>false</code> turns OFF display lists.
+         */
+        FTPolyGlyph( FT_GlyphSlot glyph, bool useDisplayList);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTPolyGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen   The current pen position.
+         * @return      The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render( const FTPoint& pen);
+        
+    private:
+        /**
+         * OpenGL display list
+         */
+        GLuint glList;
+    
+};
+
+
+#endif  //  __FTPolyGlyph__
+

ftgl/FTSize.cpp

@@ -0,0 +1,104 @@
+#include    "FTSize.h"
+
+
+FTSize::FTSize()
+:   ftFace(0),
+    ftSize(0),
+    size(0),
+    xResolution(0),
+    yResolution(0),
+    err(0)
+{}
+
+
+FTSize::~FTSize()
+{}
+
+
+bool FTSize::CharSize( FT_Face* face, unsigned int pointSize, unsigned int xRes, unsigned int yRes )
+{
+    if( size != pointSize || xResolution != xRes || yResolution != yRes)
+    {
+        err = FT_Set_Char_Size( *face, 0L, pointSize * 64, xResolution, yResolution);
+
+        if( !err)
+        {
+            ftFace = face;
+            size = pointSize;
+            xResolution = xRes;
+            yResolution = yRes;
+            ftSize = (*ftFace)->size;
+        }
+        else
+        {
+            ftFace = 0;
+            size = 0;
+            xResolution = 0;
+            yResolution = 0;
+            ftSize = 0;
+        }
+    }
+    
+    return !err;
+}
+
+
+unsigned int FTSize::CharSize() const
+{
+    return size;
+}
+
+
+float FTSize::Ascender() const
+{
+    return ftSize == 0 ? 0.0f : static_cast<float>( ftSize->metrics.ascender) / 64.0f;
+}
+
+
+float FTSize::Descender() const
+{
+    return ftSize == 0 ? 0.0f : static_cast<float>( ftSize->metrics.descender) / 64.0f;
+}
+
+
+float FTSize::Height() const
+{
+    if( 0 == ftSize)
+    {
+        return 0.0f;
+    }
+    
+    if( FT_IS_SCALABLE((*ftFace)))
+    {
+        return ( (*ftFace)->bbox.yMax - (*ftFace)->bbox.yMin) * ( (float)ftSize->metrics.y_ppem / (float)(*ftFace)->units_per_EM);
+    }
+    else
+    {
+        return static_cast<float>( ftSize->metrics.height) / 64.0f;
+    }
+}
+
+
+float FTSize::Width() const
+{
+    if( 0 == ftSize)
+    {
+        return 0.0f;
+    }
+    
+    if( FT_IS_SCALABLE((*ftFace)))
+    {
+        return ( (*ftFace)->bbox.xMax - (*ftFace)->bbox.xMin) * ( static_cast<float>(ftSize->metrics.x_ppem) / static_cast<float>((*ftFace)->units_per_EM));
+    }
+    else
+    {
+        return static_cast<float>( ftSize->metrics.max_advance) / 64.0f;
+    }
+}
+
+
+float FTSize::Underline() const
+{
+    return 0.0f;
+}
+

ftgl/FTSize.h

@@ -0,0 +1,138 @@
+#ifndef     __FTSize__
+#define     __FTSize__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#include "FTGL.h"
+
+
+
+/**
+ * FTSize class provides an abstraction layer for the Freetype Size.
+ *
+ * @see "Freetype 2 Documentation"
+ *
+ */
+class FTGL_EXPORT FTSize
+{
+    public:
+        /**
+         * Default Constructor
+         */
+         FTSize();
+        
+        /**
+         * Destructor
+         */
+        virtual ~FTSize();
+        
+        /**
+         * Sets the char size for the current face.
+         *
+         * This doesn't guarantee that the size was set correctly. Clients
+         * should check errors.
+         *
+         * @param face           Parent face for this size object
+         * @param point_size     the face size in points (1/72 inch)
+         * @param x_resolution   the horizontal resolution of the target device.
+         * @param y_resolution   the vertical resolution of the target device.
+         * @return          <code>true</code> if the size has been set. Clients should check Error() for more information if this function returns false()
+         */
+        bool CharSize( FT_Face* face, unsigned int point_size, unsigned int x_resolution, unsigned int y_resolution);
+        
+        /**
+         * get the char size for the current face.
+         *
+         * @return The char size in points
+         */
+        unsigned int CharSize() const;
+        
+        /**
+         * Gets the global ascender height for the face in pixels.
+         *
+         * @return  Ascender height
+         */
+        float Ascender() const;
+        
+        /**
+         * Gets the global descender height for the face in pixels.
+         *
+         * @return  Ascender height
+         */
+        float Descender() const;
+        
+        /**
+         * Gets the global face height for the face.
+         *
+         * If the face is scalable this returns the height of the global
+         * bounding box which ensures that any glyph will be less than or
+         * equal to this height. If the font isn't scalable there is no
+         * guarantee that glyphs will not be taller than this value.
+         *
+         * @return  height in pixels.
+         */
+        float Height() const;
+        
+        /**
+         * Gets the global face width for the face.
+         *
+         * If the face is scalable this returns the width of the global
+         * bounding box which ensures that any glyph will be less than or
+         * equal to this width. If the font isn't scalable this value is
+         * the max_advance for the face.
+         *
+         * @return  width in pixels.
+         */
+        float Width() const;
+        
+        /**
+         * Gets the underline position for the face.
+         *
+         * @return  underline position in pixels
+         */
+        float Underline() const;
+
+        /**
+         * Queries for errors.
+         *
+         * @return  The current error code.
+         */
+        FT_Error Error() const { return err; }
+        
+    private:
+        /**
+         * The current Freetype face that this FTSize object relates to.
+         */
+        FT_Face* ftFace;
+        
+        /**
+         *  The Freetype size.
+         */
+        FT_Size ftSize;
+        
+        /**
+         *  The size in points.
+         */
+        unsigned int size;
+
+        /**
+         *  The horizontal resolution.
+         */
+        unsigned int xResolution;
+
+        /**
+         *  The vertical resolution.
+         */
+        unsigned int yResolution;
+
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+        
+};
+
+#endif  //  __FTSize__
+

ftgl/FTTextureGlyph.cpp

@@ -0,0 +1,84 @@
+#include    "FTTextureGlyph.h"
+
+GLint FTTextureGlyph::activeTextureID = 0;
+ 
+FTTextureGlyph::FTTextureGlyph( FT_GlyphSlot glyph, int id, int xOffset, int yOffset, GLsizei width, GLsizei height)
+:   FTGlyph( glyph),
+    destWidth(0),
+    destHeight(0),
+    glTextureID(id)
+{
+    err = FT_Render_Glyph( glyph, FT_RENDER_MODE_NORMAL);
+    if( err || glyph->format != ft_glyph_format_bitmap)
+    {
+        return;
+    }
+
+    FT_Bitmap      bitmap = glyph->bitmap;
+
+    destWidth  = bitmap.width;
+    destHeight = bitmap.rows;
+    
+    if( destWidth && destHeight)
+    {
+        glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT);
+        glPixelStorei( GL_UNPACK_LSB_FIRST, GL_FALSE);
+        glPixelStorei( GL_UNPACK_ROW_LENGTH, 0);
+        glPixelStorei( GL_UNPACK_ALIGNMENT, 1);
+
+        glBindTexture( GL_TEXTURE_2D, glTextureID);
+        glTexSubImage2D( GL_TEXTURE_2D, 0, xOffset, yOffset, destWidth, destHeight, GL_ALPHA, GL_UNSIGNED_BYTE, bitmap.buffer);
+
+        glPopClientAttrib();
+    }
+
+
+//      0    
+//      +----+
+//      |    |
+//      |    |
+//      |    |
+//      +----+
+//           1
+    
+    uv[0].X( static_cast<float>(xOffset) / static_cast<float>(width));
+    uv[0].Y( static_cast<float>(yOffset) / static_cast<float>(height));
+    uv[1].X( static_cast<float>( xOffset + destWidth) / static_cast<float>(width));
+    uv[1].Y( static_cast<float>( yOffset + destHeight) / static_cast<float>(height));
+    
+    pos.X( glyph->bitmap_left);
+    pos.Y( glyph->bitmap_top);
+}
+
+
+FTTextureGlyph::~FTTextureGlyph()
+{}
+
+
+const FTPoint& FTTextureGlyph::Render( const FTPoint& pen)
+{
+    if( activeTextureID != glTextureID)
+    {
+        glBindTexture( GL_TEXTURE_2D, (GLuint)glTextureID);
+        activeTextureID = glTextureID;
+    }
+    
+    glTranslatef( pen.X(),  pen.Y(), 0.0f);
+
+    glBegin( GL_QUADS);
+        glTexCoord2f( uv[0].X(), uv[0].Y());
+        glVertex2f( pos.X(), pos.Y());
+
+        glTexCoord2f( uv[0].X(), uv[1].Y());
+        glVertex2f( pos.X(), pos.Y() - destHeight);
+
+        glTexCoord2f( uv[1].X(), uv[1].Y());
+        glVertex2f( destWidth + pos.X(), pos.Y() - destHeight);
+        
+        glTexCoord2f( uv[1].X(), uv[0].Y());
+        glVertex2f( destWidth + pos.X(), pos.Y());
+    glEnd();
+
+    return advance;
+}
+

ftgl/FTTextureGlyph.h

@@ -0,0 +1,94 @@
+#ifndef     __FTTextureGlyph__
+#define     __FTTextureGlyph__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL.h"
+#include "FTGlyph.h"
+
+
+/**
+ * FTTextureGlyph is a specialisation of FTGlyph for creating texture
+ * glyphs.
+ * 
+ * @see FTGlyphContainer
+ *
+ */
+class FTGL_EXPORT FTTextureGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param glyph     The Freetype glyph to be processed
+         * @param id        The id of the texture that this glyph will be
+         *                  drawn in
+         * @param xOffset   The x offset into the parent texture to draw
+         *                  this glyph
+         * @param yOffset   The y offset into the parent texture to draw
+         *                  this glyph
+         * @param width     The width of the parent texture
+         * @param height    The height (number of rows) of the parent texture
+         */
+        FTTextureGlyph( FT_GlyphSlot glyph, int id, int xOffset, int yOffset, GLsizei width, GLsizei height);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTTextureGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen   The current pen position.
+         * @return      The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render( const FTPoint& pen);
+        
+        /**
+         * Reset the currently active texture to zero to get into a known state before
+         * drawing a string. This is to get round possible threading issues.
+         */
+        static void ResetActiveTexture(){ activeTextureID = 0;}
+        
+    private:
+        /**
+         * The width of the glyph 'image'
+         */
+        int destWidth;
+
+        /**
+         * The height of the glyph 'image'
+         */
+        int destHeight;
+
+        /**
+         * Vector from the pen position to the topleft corner of the pixmap
+         */
+        FTPoint pos;
+        
+        /**
+         * The texture co-ords of this glyph within the texture.
+         */
+        FTPoint uv[2];
+        
+        /**
+         * The texture index that this glyph is contained in.
+         */
+        int glTextureID;
+
+        /**
+         * The texture index of the currently active texture
+         *
+         * We keep track of the currently active texture to try to reduce the number
+         * of texture bind operations.
+         */
+        static GLint activeTextureID;
+        
+};
+
+
+#endif  //  __FTTextureGlyph__

ftgl/FTVector.h

@@ -0,0 +1,190 @@
+#ifndef    __FTVector__
+#define    __FTVector__
+
+#include "FTGL.h"
+
+/**
+ * Provides a non-STL alternative to the STL vector
+ */
+template <typename FT_VECTOR_ITEM_TYPE>
+class FTGL_EXPORT FTVector
+{
+    public:
+        typedef FT_VECTOR_ITEM_TYPE value_type;
+        typedef value_type& reference;
+        typedef const value_type& const_reference;
+        typedef value_type* iterator;
+        typedef const value_type* const_iterator;
+        typedef size_t size_type;
+        
+        FTVector()
+        {
+            Capacity = Size = 0;
+            Items = 0;
+        }
+
+        
+        virtual ~FTVector()
+        {
+            clear();
+        }
+        
+        FTVector& operator =(const FTVector& v)
+        {
+            reserve(v.capacity());
+            
+            iterator ptr = begin();
+            const_iterator vbegin = v.begin();
+            const_iterator vend = v.end();
+            
+            while( vbegin != vend)
+            {
+                *ptr++ = *vbegin++;
+            }
+            
+            Size = v.size();
+            return *this;
+        }
+        
+        size_type size() const
+        {
+            return Size;
+        }
+        
+        size_type capacity() const
+        {
+            return Capacity;
+        }
+        
+        iterator begin()
+        {
+            return Items;
+        }
+        
+        const_iterator begin() const
+        {
+            return Items;
+        }
+        
+        iterator end()
+        {
+            return begin() + size(); 
+        }
+        
+        const_iterator end() const
+        {
+            return begin() + size(); 
+        }
+        
+        bool empty() const 
+        { 
+            return size() == 0; 
+        }
+
+        reference operator [](size_type pos) 
+        { 
+            return( *(begin() + pos)); 
+        }
+
+        const_reference operator []( size_type pos) const 
+        { 
+            return( *(begin() + pos)); 
+        }
+        
+        void clear()
+        {
+            if( Capacity)
+            {
+                delete [] Items;
+                Capacity = Size = 0;
+                Items = 0;
+            }
+        }
+
+        void reserve( size_type n)
+        {
+            if( capacity() < n)
+            {
+                expand(n);
+            }
+        }
+
+        void push_back(const value_type& x)
+        {
+            if( size() == capacity())
+            {
+                expand();
+            }
+           
+           ( *this)[size()] = x;
+            ++Size;
+        }
+
+        void resize(size_type n, value_type x)
+        {
+            if( n == size())
+            {
+                return;
+            }
+            
+            reserve(n);
+            iterator begin, end;
+            
+            if( n >= Size)
+            {
+                begin = this->end();
+                end = this->begin() + n;
+            }
+            else
+            {
+                begin = this->begin() + n;
+                end = this->end();
+            }
+        
+            while( begin != end)
+            {
+                *begin++ = x;
+            }
+        
+            Size = n;
+        }
+
+        
+    private:
+        void expand(size_type capacity_hint = 0)
+        {
+            size_type new_capacity =( capacity() == 0) ? 256 : capacity()* 2;
+            if( capacity_hint)
+            {
+                while( new_capacity < capacity_hint)
+                {
+                    new_capacity *= 2;
+                }
+            }
+            
+            value_type *new_items = new value_type[new_capacity];
+            
+            iterator begin = this->begin();
+            iterator end = this->end();
+            value_type *ptr = new_items;
+            
+            while( begin != end)
+            {
+                *ptr++ = *begin++;
+            }
+            
+            if( Capacity)
+            {
+                delete [] Items;
+            }
+        
+            Items = new_items;
+            Capacity = new_capacity;
+        }
+
+        size_type Capacity;
+        size_type Size;
+        value_type* Items;
+};
+
+#endif  //  __FTVector__

ftgl/FTVectoriser.cpp

@@ -0,0 +1,225 @@
+#include    "FTVectoriser.h"
+#include    "FTGL.h"
+
+#ifndef CALLBACK
+#define CALLBACK
+#endif
+
+#ifdef __APPLE_CC__    
+    typedef GLvoid (*GLUTesselatorFunction)(...);
+#elif defined( __mips ) || defined( __linux__ ) || defined( __FreeBSD__ ) || defined( __OpenBSD__ ) || defined( __sun ) || defined (__CYGWIN__)
+    typedef GLvoid (*GLUTesselatorFunction)();
+#elif defined ( WIN32)
+    typedef GLvoid (CALLBACK *GLUTesselatorFunction)( );
+#else
+    #error "Error - need to define type GLUTesselatorFunction for this platform/compiler"
+#endif
+
+
+void CALLBACK ftglError( GLenum errCode, FTMesh* mesh)
+{
+    mesh->Error( errCode);
+}
+
+
+void CALLBACK ftglVertex( void* data, FTMesh* mesh)
+{
+    FTGL_DOUBLE* vertex = static_cast<FTGL_DOUBLE*>(data);
+    mesh->AddPoint( vertex[0], vertex[1], vertex[2]);
+}
+
+
+void CALLBACK ftglCombine( FTGL_DOUBLE coords[3], void* vertex_data[4], GLfloat weight[4], void** outData, FTMesh* mesh)
+{
+    const FTGL_DOUBLE* vertex = static_cast<const FTGL_DOUBLE*>(coords);
+    *outData = const_cast<FTGL_DOUBLE*>(mesh->Combine( vertex[0], vertex[1], vertex[2]));
+}
+        
+
+void CALLBACK ftglBegin( GLenum type, FTMesh* mesh)
+{
+    mesh->Begin( type);
+}
+
+
+void CALLBACK ftglEnd( FTMesh* mesh)
+{
+    mesh->End();
+}
+
+
+FTMesh::FTMesh()
+:	currentTesselation(0),
+    err(0)
+{
+    tesselationList.reserve( 16);
+}
+
+
+FTMesh::~FTMesh()
+{
+    for( size_t t = 0; t < tesselationList.size(); ++t)
+    {
+        delete tesselationList[t];
+    }
+    
+    tesselationList.clear();
+}
+
+
+void FTMesh::AddPoint( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z)
+{
+    currentTesselation->AddPoint( x, y, z);
+}
+
+
+const FTGL_DOUBLE* FTMesh::Combine( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z)
+{
+    tempPointList.push_back( FTPoint( x, y,z));
+    return static_cast<const FTGL_DOUBLE*>(tempPointList.back());
+}
+
+
+void FTMesh::Begin( GLenum meshType)
+{
+    currentTesselation = new FTTesselation( meshType);
+}
+
+
+void FTMesh::End()
+{
+    tesselationList.push_back( currentTesselation);
+}
+
+
+const FTTesselation* const FTMesh::Tesselation( unsigned int index) const
+{
+    return ( index < tesselationList.size()) ? tesselationList[index] : NULL;
+}
+
+
+FTVectoriser::FTVectoriser( const FT_GlyphSlot glyph)
+:   contourList(0),
+    mesh(0),
+    ftContourCount(0),
+    contourFlag(0)
+{
+    if( glyph)
+    {
+        outline = glyph->outline;
+        
+        ftContourCount = outline.n_contours;
+        contourList = 0;
+        contourFlag = outline.flags;
+        
+        ProcessContours();
+    }
+}
+
+
+FTVectoriser::~FTVectoriser()
+{
+    for( size_t c = 0; c < ContourCount(); ++c)
+    {
+        delete contourList[c];
+    }
+
+    delete [] contourList;
+    delete mesh;
+}
+
+
+void FTVectoriser::ProcessContours()
+{
+    short contourLength = 0;
+    short startIndex = 0;
+    short endIndex = 0;
+    
+    contourList = new FTContour*[ftContourCount];
+    
+    for( short contourIndex = 0; contourIndex < ftContourCount; ++contourIndex)
+    {
+        FT_Vector* pointList = &outline.points[startIndex];
+        char* tagList = &outline.tags[startIndex];
+        
+        endIndex = outline.contours[contourIndex];
+        contourLength =  ( endIndex - startIndex) + 1;
+
+        FTContour* contour = new FTContour( pointList, tagList, contourLength);
+        
+        contourList[contourIndex] = contour;
+        
+        startIndex = endIndex + 1;
+    }
+}
+
+
+size_t FTVectoriser::PointCount()
+{
+    size_t s = 0;
+    for( size_t c = 0; c < ContourCount(); ++c)
+    {
+        s += contourList[c]->PointCount();
+    }
+    
+    return s;
+}
+
+
+const FTContour* const FTVectoriser::Contour( unsigned int index) const
+{
+    return ( index < ContourCount()) ? contourList[index] : NULL;
+}
+
+
+void FTVectoriser::MakeMesh( FTGL_DOUBLE zNormal)
+{
+    if( mesh)
+    {
+        delete mesh;
+    }
+        
+    mesh = new FTMesh;
+    
+    GLUtesselator* tobj = gluNewTess();
+
+    gluTessCallback( tobj, GLU_TESS_BEGIN_DATA,     (GLUTesselatorFunction)ftglBegin);
+    gluTessCallback( tobj, GLU_TESS_VERTEX_DATA,    (GLUTesselatorFunction)ftglVertex);
+    gluTessCallback( tobj, GLU_TESS_COMBINE_DATA,   (GLUTesselatorFunction)ftglCombine);
+    gluTessCallback( tobj, GLU_TESS_END_DATA,       (GLUTesselatorFunction)ftglEnd);
+    gluTessCallback( tobj, GLU_TESS_ERROR_DATA,     (GLUTesselatorFunction)ftglError);
+    
+    if( contourFlag & ft_outline_even_odd_fill) // ft_outline_reverse_fill
+    {
+        gluTessProperty( tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
+    }
+    else
+    {
+        gluTessProperty( tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_NONZERO);
+    }
+    
+    
+    gluTessProperty( tobj, GLU_TESS_TOLERANCE, 0);
+    gluTessNormal( tobj, 0.0f, 0.0f, zNormal);
+    gluTessBeginPolygon( tobj, mesh);
+    
+        for( size_t c = 0; c < ContourCount(); ++c)
+        {
+            const FTContour* contour = contourList[c];
+
+            gluTessBeginContour( tobj);
+            
+                for( size_t p = 0; p < contour->PointCount(); ++p)
+                {
+                    const FTGL_DOUBLE* d = contour->Point(p);
+                    gluTessVertex( tobj, (GLdouble*)d, (GLdouble*)d);
+                }
+
+            gluTessEndContour( tobj);
+        }
+        
+    gluTessEndPolygon( tobj);
+
+    gluDeleteTess( tobj);
+}
+

ftgl/FTVectoriser.h

@@ -0,0 +1,275 @@
+#ifndef     __FTVectoriser__
+#define     __FTVectoriser__
+
+
+#include "FTContour.h"
+#include "FTList.h"
+#include "FTPoint.h"
+#include "FTVector.h"
+#include "FTGL.h"
+
+
+#ifndef CALLBACK
+#define CALLBACK
+#endif
+
+
+/**
+ * FTTesselation captures points that are output by OpenGL's gluTesselator.
+ */
+class FTGL_EXPORT FTTesselation
+{
+    public:
+        /**
+         * Default constructor
+         */
+        FTTesselation( GLenum m)
+        :	meshType(m)
+        {
+            pointList.reserve( 128);
+        }
+
+        /**
+         *  Destructor
+         */
+        ~FTTesselation()
+        {
+            pointList.clear();
+        }
+
+        /**
+         * Add a point to the mesh.
+         */
+        void AddPoint( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z)
+        {   
+            pointList.push_back( FTPoint( x, y, z));
+        }
+
+        /**
+         * The number of points in this mesh
+         */
+        size_t PointCount() const { return pointList.size();}
+        
+        /**
+         *
+         */
+        const FTPoint& Point( unsigned int index) const { return pointList[index];}
+        
+        /**
+         * Return the OpenGL polygon type.
+         */
+        GLenum PolygonType() const { return meshType;}
+        
+    private:
+        /**
+         * Points generated by gluTesselator.
+         */
+        typedef FTVector<FTPoint> PointVector;
+        PointVector pointList;
+
+        /**
+         * OpenGL primitive type from gluTesselator.
+         */
+        GLenum meshType;
+};
+
+
+/**
+ * FTMesh is a container of FTTesselation's that make up a polygon glyph
+ */
+class FTGL_EXPORT FTMesh
+{
+	typedef FTVector<FTTesselation*> TesselationVector;
+	typedef FTList<FTPoint> PointList;
+
+    public:
+        /**
+         * Default constructor
+         */
+        FTMesh();
+
+        /**
+         *  Destructor
+         */
+        ~FTMesh();
+        
+        /**
+         * Add a point to the mesh
+         */
+        void AddPoint( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z);
+        
+        /**
+         *  Create a combine point for the gluTesselator
+         */
+        const FTGL_DOUBLE* Combine( const FTGL_DOUBLE x, const FTGL_DOUBLE y, const FTGL_DOUBLE z);
+        
+        /**
+         * Begin a new polygon
+         */
+        void Begin( GLenum meshType);
+        
+        /**
+         * End a polygon
+         */
+        void End();
+        
+        /**
+         * Record a gluTesselation error
+         */
+        void Error( GLenum e) { err = e;}
+        
+        /**
+         * The number of tesselations in the mesh
+         */
+        unsigned int TesselationCount() const { return tesselationList.size();}
+
+        /**
+         * Get a tesselation by index
+         */
+        const FTTesselation* const Tesselation( unsigned int index) const;
+        
+        /**
+         * Return the temporary point list. For testing only.
+         */
+        const PointList& TempPointList() const { return tempPointList;}
+
+        /**
+         * Get the GL ERROR returned by the glu tesselator
+         */
+        GLenum Error() const { return err;}
+
+    private:
+        /**
+         * The current sub mesh that we are constructing.
+         */
+        FTTesselation* currentTesselation;
+        
+        /**
+         * Holds each sub mesh that comprises this glyph.
+         */
+        TesselationVector tesselationList;
+        
+        /**
+         * Holds extra points created by gluTesselator. See ftglCombine.
+         */
+        PointList tempPointList;
+        
+        /**
+         * GL ERROR returned by the glu tesselator
+         */
+        GLenum err;
+
+};
+
+const FTGL_DOUBLE FTGL_FRONT_FACING = 1.0;
+const FTGL_DOUBLE FTGL_BACK_FACING = -1.0;
+
+/**
+ * FTVectoriser class is a helper class that converts font outlines into
+ * point data.
+ *
+ * @see FTExtrdGlyph
+ * @see FTOutlineGlyph
+ * @see FTPolyGlyph
+ * @see FTContour
+ * @see FTPoint
+ *
+ */
+class FTGL_EXPORT FTVectoriser
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param glyph The freetype glyph to be processed
+         */
+        FTVectoriser( const FT_GlyphSlot glyph);
+
+        /**
+         *  Destructor
+         */
+        virtual ~FTVectoriser();
+
+        /**
+         * Build an FTMesh from the vector outline data. 
+         *
+         * @param zNormal   The direction of the z axis of the normal
+         *                  for this mesh
+         */
+        void MakeMesh( FTGL_DOUBLE zNormal = FTGL_FRONT_FACING);
+        
+        /**
+         * Get the current mesh.
+         */
+        const FTMesh* const GetMesh() const { return mesh;}
+        
+        /**
+         * Get the total count of points in this outline
+         *
+         * @return the number of points
+         */
+        size_t PointCount();
+
+        /**
+         * Get the count of contours in this outline
+         *
+         * @return the number of contours
+         */
+        size_t ContourCount() const { return ftContourCount;}
+
+        /**
+         * Return a contour at index
+         *
+         * @return the number of contours
+         */
+         const FTContour* const Contour( unsigned int index) const;
+
+        /**
+         * Get the number of points in a specific contour in this outline
+         *
+         * @param c     The contour index
+         * @return      the number of points in contour[c]
+         */
+        size_t ContourSize( int c) const { return contourList[c]->PointCount();}
+
+        /**
+         * Get the flag for the tesselation rule for this outline
+         *
+         * @return The contour flag
+         */
+        int ContourFlag() const { return contourFlag;}
+        
+    private:
+        /**
+         * Process the freetype outline data into contours of points
+         */
+        void ProcessContours();
+
+        /**
+         * The list of contours in the glyph
+         */
+        FTContour** contourList;
+
+        /**
+         * A Mesh for tesselations
+         */
+        FTMesh* mesh;
+        
+        /**
+         * The number of contours reported by Freetype
+         */
+        short ftContourCount;
+
+        /**
+         * A flag indicating the tesselation rule for the glyph
+         */
+        int contourFlag;
+
+        /**
+         * A Freetype outline
+         */
+        FT_Outline outline;
+};
+
+
+#endif  //  __FTVectoriser__

ftgl/Makefile

@@ -0,0 +1,17 @@
+include ../Makefile.common
+
+OBJ = $(patsubst %.cpp,%.o,$(wildcard *.cpp))
+LIBNAME = libftgl.a
+CXXFLAGS += -I../freetype/include
+
+all: $(LIBNAME)
+
+$(LIBNAME): $(OBJ)
+	@echo Creating archive $@
+	@ar -crsu $@ $(OBJ)
+	@echo
+		
+clean:
+	-@$(RM) *.o
+	-@$(RM) *.d
+	-@$(RM) $(LIBNAME)