kc3-lang/ftgl

diff --git a/README.txt b/README.txt
new file mode 100755
index 0000000..8811c05
--- /dev/null
+++ b/README.txt
@@ -0,0 +1,62 @@
+FTGL 1.0a1 (gltt 3.0a1)
+
+
+USAGE:
+
+	FTGLPixmapFont font;
+	
+	font.Open("HenrysHD:System Folder:Fonts:Arial");
+	font.FaceSize( 72);
+	
+	font.render("Hello World!");
+
+
+
+Things to think about...
+If a font is defined uniquely by it's face and size ie
+font.Open("HenrysHD:System Folder:Fonts:Arial", 72);
+Then we don't need FTFace and FTSize, their functionality could be internal
+to FTFont. Alternatively if we allow multiple faces and sizes how should
+they be handled.
+At the moment if you call font.CharSize( x) the glyph list is destroyed and
+rebuilt, which will be really inefficient if you change sizes often. Will
+the freetype cache stuff help here or should we cache internally?
+multiple glyphlists. glyphlist manager.
+
+When is the best time to construct the glyphList? After the call to Size(x)
+is the earliest but what happens if the client doesn't set the char size?
+
+
+
+TODO:
+	- Finish!!
+	- Error handling - fail gracefully - return FT_Error codes.
+	- What happens with 2 obj of the same font type
+	- Kerning. The position stuff now seems OK but needs checking. (lower
+	  case 'y's seem to be 1 pixel too low?)
+	- check and confirm the glPixelStore stuff. Data Alignment. Tightly
+	  packed at the moment.
+	- FTOutlineGlyph
+	- FTPolygonGlyph
+	- Fix the FTSize class. The internal FT_Size is never assigned
+	- Change glDrawPixels to use GL_ALPHA instead of GL_RGBA. This may not
+	  work, read red book.
+	- Coloured Pixmaps/ bitmaps
+	- Optimise performance!! and mem usage.
+	- Use the Freetype Cache mechanism. See above. FTC_xxx
+	- Sort out the pixel storage modes.
+	- Pixmaps as textures. FTTextureGlyph
+	- Is this FTGL or GLTT?
+	- Vertical formats
+	
+	
+BUGS:
+	MAC OS:
+		- Exits with some fonts at large sizes. Memory?
+		
+
+
+July 22 2001
+	- First ALPHA Release 1.0a1
+
+
diff --git a/include/FTBitmapGlyph.h b/include/FTBitmapGlyph.h
new file mode 100755
index 0000000..018eae6
--- /dev/null
+++ b/include/FTBitmapGlyph.h
@@ -0,0 +1,33 @@
+#ifndef		__FTBitmapGlyph__
+#define		__FTBitmapGlyph__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include	"FTGlyph.h"
+
+
+class	FTBitmapGlyph : public FTGlyph
+{
+	public:
+		// methods
+		FTBitmapGlyph( FT_Glyph glyph, int glyphIndex);
+		virtual ~FTBitmapGlyph();
+		virtual float Render( FT_Vector v);
+		
+		// attributes
+		
+	private:
+		// methods
+		
+		// attributes
+		int destWidth;
+		int destHeight;
+		
+		unsigned char* data;
+		
+};
+
+
+#endif	//	__FTBitmapGlyph__
diff --git a/include/FTFace.h b/include/FTFace.h
new file mode 100755
index 0000000..5f08829
--- /dev/null
+++ b/include/FTFace.h
@@ -0,0 +1,42 @@
+#ifndef		__FTFace__
+#define		__FTFace__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTSize.h"
+
+#include "FTGL.h"
+
+
+class	FTFace
+{
+	public:
+		// methods
+		FTFace();
+		virtual ~FTFace();
+		bool Open( const char* filename);
+		void Close();
+		FTSize& Size( const int size, const int res );
+		bool CharMap( CHARMAP encoding );
+		FT_Glyph Glyph( int index );
+		FT_Vector KernAdvance( int index1, int index2 );
+		FT_Face* Face() const { return ftFace;}
+		
+		// attributes
+		
+	private:
+		// methods
+		
+		// attributes
+//		FONTTYPE	fontType;
+		FTSize	charSize;
+		FT_Face* ftFace;
+		int	numCharMaps;
+		int	numGlyphs;
+		
+};
+
+
+#endif	//	__FTFace__
diff --git a/include/FTFont.h b/include/FTFont.h
new file mode 100755
index 0000000..2c20268
--- /dev/null
+++ b/include/FTFont.h
@@ -0,0 +1,68 @@
+#ifndef		__FTFont__
+#define		__FTFont__
+
+#include <string>
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#include "FTFace.h"
+
+//#include "FTGL.h"
+
+
+//class FTGlyph;
+class FTGlyphContainer;
+
+using namespace std;
+
+
+class	FTFont
+{
+	public:
+		// methods
+		FTFont();
+		virtual ~FTFont();
+		virtual bool Open( const char* fontname );
+		void Close();
+		bool FaceSize( const int size, const int res = 72 );
+		virtual bool CharMap( CHARMAP encoding );
+//		virtual FTGlyph*	Glyph( unsigned char code );
+//		virtual FTGlyph*	Glyph( unsigned char thisCode, unsigned char nextCode );
+		int	Ascender() const;
+		int	Descender() const;
+		void	BBox( const char* text, int& llx, int& lly, int& urx, int& ury ) const;
+		bool	render( const char* string );
+		
+		FT_Error Error() const { return err;}
+		
+		// attributes
+		
+	protected:
+		// methods
+		virtual bool MakeGlyphList() = 0;
+		
+		// attributes
+		FT_Error err;
+		
+		// list of faces
+		FTFace face;
+		int	numFaces;
+		
+		// list of sizes
+		FTSize charSize;
+		
+		int numGlyphs;
+		
+		string fontName;
+		
+		FTGlyphContainer*	glyphList;
+		
+	private:
+		// methods
+		
+		// attributes
+};
+
+
+#endif	//	__FTFont__
diff --git a/include/FTGL.h b/include/FTGL.h
new file mode 100755
index 0000000..53580be
--- /dev/null
+++ b/include/FTGL.h
@@ -0,0 +1,20 @@
+#ifndef		__FTGL__
+#define		__FTGL__
+
+// define some symbols
+	enum CHARMAP
+	{
+		ASCII,
+		UNICODE
+	};
+		
+	enum FONTTYPE
+	{
+		BITMAP,
+		VECTOR
+	};
+		
+
+
+
+#endif	//	__FTGL__
diff --git a/include/FTGLBitmapFont.h b/include/FTGLBitmapFont.h
new file mode 100755
index 0000000..427054e
--- /dev/null
+++ b/include/FTGLBitmapFont.h
@@ -0,0 +1,26 @@
+#ifndef		__FTGLBitmapFont
+#define		__FTGLBitmapFont
+
+
+#include	"FTFont.h"
+
+class FTBitmapGlyph;
+
+class	FTGLBitmapFont : public FTFont
+{
+	public:
+		// methods
+		FTGLBitmapFont();
+		~FTGLBitmapFont();
+		
+		// attributes
+		
+	private:
+		// methods
+		bool MakeGlyphList();
+		
+		// attributes
+		FTBitmapGlyph* tempGlyph;
+		
+};
+#endif
diff --git a/include/FTGLOutlineFont.h b/include/FTGLOutlineFont.h
new file mode 100755
index 0000000..33dbc96
--- /dev/null
+++ b/include/FTGLOutlineFont.h
@@ -0,0 +1,21 @@
+#ifndef		__FTGLOutlineFont
+#define		__FTGLOutlineFont
+#include	"FTFont.h"
+
+#include "FTGL.h"
+
+class	FTGLOutlineFont : public FTFont
+{
+	public:
+		// methods
+		FTGLOutlineFont();
+		~FTGLOutlineFont();
+		
+		// attributes
+		
+	private:
+		// methods
+		bool MakeGlyphList();
+		
+};
+#endif
diff --git a/include/FTGLPixmapFont.h b/include/FTGLPixmapFont.h
new file mode 100755
index 0000000..68f4759
--- /dev/null
+++ b/include/FTGLPixmapFont.h
@@ -0,0 +1,26 @@
+#ifndef		__FTGLPixmapFont__
+#define		__FTGLPixmapFont__
+
+
+#include	"FTFont.h"
+
+class FTPixmapGlyph;
+
+class	FTGLPixmapFont : public FTFont
+{
+	public:
+		// methods
+		FTGLPixmapFont();
+		~FTGLPixmapFont();
+		
+	private:
+		// methods
+		bool MakeGlyphList();
+		
+		// attributes
+		FTPixmapGlyph* tempGlyph;
+		
+};
+
+
+#endif	//	__FTGLPixmapFont__
diff --git a/include/FTGLPolygonFont.h b/include/FTGLPolygonFont.h
new file mode 100755
index 0000000..4b7407a
--- /dev/null
+++ b/include/FTGLPolygonFont.h
@@ -0,0 +1,21 @@
+#ifndef		__FTGLPolygonFont
+#define		__FTGLPolygonFont
+#include	"FTFont.h"
+
+#include "FTGL.h"
+
+class	FTGLPolygonFont : public FTFont
+{
+	public:
+		// methods
+		FTGLPolygonFont();
+		~FTGLPolygonFont();
+		
+		// attributes
+		
+	private:
+		// methods
+		bool MakeGlyphList();
+		
+};
+#endif
diff --git a/include/FTGLTextureFont.h b/include/FTGLTextureFont.h
new file mode 100755
index 0000000..87a578b
--- /dev/null
+++ b/include/FTGLTextureFont.h
@@ -0,0 +1,31 @@
+#ifndef		__FTGLTextureFont
+#define		__FTGLTextureFont
+#include	"FTFont.h"
+
+#include "FTGL.h"
+
+class	FTGLTextureFont : public FTFont
+{
+	public:
+		// methods
+		FTGLTextureFont();
+		~FTGLTextureFont();
+		
+		bool CreateTexture();
+		
+		bool TextureSize();
+		
+		// attributes
+		int textureSize;
+		
+		int glTextureID;
+		unsigned char* textMem;
+		
+		int padding;
+		
+	private:
+		// methods
+		bool MakeGlyphList();
+		
+};
+#endif
diff --git a/include/FTGlyph.h b/include/FTGlyph.h
new file mode 100755
index 0000000..56f4b61
--- /dev/null
+++ b/include/FTGlyph.h
@@ -0,0 +1,42 @@
+#ifndef		__FTGlyph__
+#define		__FTGlyph__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+//#include "FTGL.h"
+
+
+class FTGlyph
+{
+	public:
+		// methods
+		FTGlyph( int glyphIndex);
+		virtual ~FTGlyph();
+		virtual float Render( FT_Vector v) = 0;
+		
+		FT_Error Error() const { return err;}
+		
+		// attributes
+		const int glyphIndex;
+		
+	protected:
+		// methods
+		
+		// attributes
+		FT_Error err;
+		
+		float advance;
+		FT_Vector pos;
+		FT_Glyph ftGlyph;
+		
+	private:
+		// methods
+		
+		// attributes
+		
+};
+
+
+#endif	//	__FTGlyph__
diff --git a/include/FTGlyphContainer.h b/include/FTGlyphContainer.h
new file mode 100755
index 0000000..c995571
--- /dev/null
+++ b/include/FTGlyphContainer.h
@@ -0,0 +1,47 @@
+#ifndef		__FTGlyphContainer__
+#define		__FTGlyphContainer__
+
+#include <vector>
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+//#include "FTGL.h"
+
+class FTGlyph;
+
+using namespace std;
+
+class	FTGlyphContainer
+{
+	public:
+		// methods
+		FTGlyphContainer( FT_Face* face, int numGlyphs, bool p = false);
+		~FTGlyphContainer();
+
+		bool Add( FTGlyph* tempGlyph);
+
+		bool render( int index, int next = 0);
+		
+		// attributes
+		
+	private:
+		// methods
+//		bool	MakeGlyphList( FT_Face* face);
+		
+		// attributes
+//		FONTTYPE fontType;
+		bool preCache;
+		int numGlyphs;
+		FTGlyph* tempGlyph;
+		FT_Face* face;
+		
+//		typedef pair<int, FTGlyph*> CHARREF;
+//		vector<CHARREF> glyphs;
+		vector<FTGlyph*> glyphs;
+		
+};
+
+
+#endif	//	__FTGlyphContainer__
diff --git a/include/FTLibrary.h b/include/FTLibrary.h
new file mode 100755
index 0000000..5bb3a8c
--- /dev/null
+++ b/include/FTLibrary.h
@@ -0,0 +1,36 @@
+#ifndef		__FTLibrary__
+#define		__FTLibrary__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+//#include FT_CACHE_H
+
+#include "FTGL.h"
+
+// OPSignature: FTLibrary
+class	FTLibrary
+{
+	public:
+		// methods
+		static FTLibrary& Instance();
+		FT_Library*	GetLibrary() const { return lib;}
+		
+		virtual  ~FTLibrary();
+		
+		// attributes
+		
+	private:
+		// methods
+		FTLibrary();
+		FTLibrary( const& FT_Library ){}
+		FTLibrary&	operator=( const& FT_Library ){}
+		bool Init();
+		
+		// attributes
+		FT_Library*	lib;
+//		FTC_Manager* manager;      /* the cache manager               */
+
+		
+};
+#endif	//	__FTLibrary__
diff --git a/include/FTPixmapGlyph.h b/include/FTPixmapGlyph.h
new file mode 100755
index 0000000..57582d4
--- /dev/null
+++ b/include/FTPixmapGlyph.h
@@ -0,0 +1,35 @@
+#ifndef		__FTPixmapGlyph__
+#define		__FTPixmapGlyph__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include	"FTGlyph.h"
+
+
+class FTPixmapGlyph : public FTGlyph
+{
+	public:
+		// methods
+		FTPixmapGlyph( FT_Glyph glyph, int glyphIndex);
+		virtual ~FTPixmapGlyph();
+		virtual float Render( FT_Vector v);
+		
+		// attributes
+
+	private:
+		// methods
+		
+		// attributes
+		int destWidth;
+		int destHeight;
+		
+		int numGreys;
+
+		unsigned char* data;
+		
+};
+
+
+#endif	//	__FTPixmapGlyph__
diff --git a/include/FTSize.h b/include/FTSize.h
new file mode 100755
index 0000000..995fb6d
--- /dev/null
+++ b/include/FTSize.h
@@ -0,0 +1,31 @@
+#ifndef		__FTSize__
+#define		__FTSize__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#include "FTGL.h"
+
+
+class	FTSize
+{
+	public:
+		// methods
+		FTSize();
+		virtual ~FTSize();
+		bool CharSize( FT_Face* face, int point_size, int x_resolution, int y_resolution );
+		int	Ascender() const;
+		int	Descender() const;
+		
+		// attributes
+		
+	private:
+		// methods
+		
+		// attributes
+		FT_Size   ftSize;
+		int	size;
+		
+};
+
+#endif	//	__FTSize__
diff --git a/include/FTTextureGlyph.h b/include/FTTextureGlyph.h
new file mode 100755
index 0000000..31571da
--- /dev/null
+++ b/include/FTTextureGlyph.h
@@ -0,0 +1,31 @@
+#ifndef		__FTTextureGlyph__
+#define		__FTTextureGlyph__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include	"FTGlyph.h"
+
+
+class	FTTextureGlyph : public FTGlyph
+{
+	public:
+		// methods
+		FTTextureGlyph( FT_Glyph glyph, int glyphIndex);
+		virtual ~FTTextureGlyph();
+		virtual float Render( FT_Vector v);
+		
+		// attributes
+		int destWidth;
+		int destHeight;
+		
+		int numGreys;
+
+		unsigned char* data;
+		
+		FT_Vector uv[4];
+};
+
+
+#endif	//	__FTTextureGlyph__
diff --git a/src/FTBitmapGlyph.cpp b/src/FTBitmapGlyph.cpp
new file mode 100755
index 0000000..422a506
--- /dev/null
+++ b/src/FTBitmapGlyph.cpp
@@ -0,0 +1,83 @@
+#include	"gl.h"
+
+#include	"FTBitmapGlyph.h"
+#include	"FTGL.h"
+
+
+FTBitmapGlyph::FTBitmapGlyph( FT_Glyph glyph, int gi)
+:	FTGlyph( gi)
+{
+	if( !glyph->format == ft_glyph_format_bitmap)
+	{ return;}
+	
+	// This function will always fail if the glyph's format isn't scalable????
+	FT_Error err = FT_Glyph_To_Bitmap( &glyph, ft_render_mode_mono, 0, 1);
+	if( err)
+	{return;}
+
+	FT_BitmapGlyph  bitmap = (FT_BitmapGlyph)glyph;
+	FT_Bitmap*      source = &bitmap->bitmap;
+
+	//check the pixel mode
+	//ft_pixel_mode_grays
+	    
+	int srcWidth = source->width;
+	int srcHeight = source->rows;
+	int srcPitch = source->pitch;
+    
+	advance = glyph->advance.x >> 16; // this is 6 in the freetype docs!!!!!!
+
+ 	pos.x = bitmap->left;
+	pos.y = srcHeight - bitmap->top;
+	
+   // FIXME The buffer is upside down. What about dest alignment?
+    destWidth = srcWidth;
+    destHeight = srcHeight;
+    
+    data = new unsigned char[srcPitch * destHeight];
+    
+    for(int y = 0; y < srcHeight; ++y)
+    {
+    	--destHeight;
+    	for(int x = 0; x < srcPitch; ++x)
+    	{
+			*( data + ( destHeight * srcPitch + x)) = *( source->buffer + ( y * srcPitch) + x);
+    	}    	
+    }
+
+    destHeight = srcHeight;
+
+	// discard glyph image (bitmap or not)
+	// Is this the right place to do this?
+	FT_Done_Glyph( glyph );
+}
+
+
+FTBitmapGlyph::~FTBitmapGlyph()
+{
+	delete[] data;
+}
+
+
+float FTBitmapGlyph::Render( FT_Vector v)
+{
+	int adv = advance - pos.x + ( v.x >> 16); // FIXME ??? pos.x = bearing X
+	if( data != 0 )
+	{
+		glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT);
+		
+		// doing this every frame is a bad?
+		glPixelStorei( GL_UNPACK_LSB_FIRST, GL_FALSE);
+		glPixelStorei( GL_UNPACK_ROW_LENGTH, 0);
+		glPixelStorei( GL_UNPACK_ALIGNMENT, 1);
+
+		glBitmap( destWidth, destHeight, 0.0f, pos.y, (float)adv, (double)0.0, (const GLubyte *)data);
+
+		glPopClientAttrib();
+	}
+	
+	// Advance the raster pos.
+//	glBitmap( 0, 0, 0.0, 0.0, adv, 0, (const GLubyte *)0 );
+
+	return advance;
+}
diff --git a/src/FTFace.cpp b/src/FTFace.cpp
new file mode 100755
index 0000000..16d4b4d
--- /dev/null
+++ b/src/FTFace.cpp
@@ -0,0 +1,98 @@
+#include	"assert.h"
+
+#include	"FTFace.h"
+#include	"FTLibrary.h"
+#include	"FTGL.h"
+
+
+// OPSignature:  FTFace:FTFace() 
+FTFace::FTFace()
+:	ftFace(0),
+	numCharMaps(0),
+	numGlyphs(0)
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+// OPSignature:  FTFace:~FTFace() 
+FTFace::~FTFace()
+{
+	if( ftFace)
+	{
+		Close();
+		delete ftFace; // is this a prob?
+		ftFace = 0;
+	}
+}
+
+
+// OPSignature: bool FTFace:open( const char*:filename  FONTTYPE:fontType ) 
+bool	FTFace::Open( const char* filename)
+{
+	ftFace = new FT_Face;
+	FT_Error err = FT_New_Face( *FTLibrary::Instance().GetLibrary(), filename, 0, ftFace);
+	
+	if( err == FT_Err_Unknown_File_Format)
+    {
+//      ... the font file could be opened and read, but it appears
+//      ... that its font format is unsupported
+		delete ftFace;
+		ftFace = 0;
+	    return false;
+    }
+    else if( err)
+    {
+//      ... another error code means that the font file could not
+//      ... be opened or read, or simply that it is broken...
+		delete ftFace;
+		ftFace = 0;
+	    return false;
+    }
+    
+    return true;
+}
+
+
+// OPSignature: bool FTFace:open( const char*:filename  FONTTYPE:fontType ) 
+void FTFace::Close()
+{
+	FT_Done_Face( *ftFace);
+}
+
+
+// OPSignature: bool FTFace:SetSize( const int:size  const int:res ) 
+FTSize& FTFace::Size( const int size, const int res )
+{
+	charSize.CharSize( ftFace, size, res, res);
+	return charSize;
+}
+
+
+// OPSignature: void FTFace:SetCharMap( CHARMAP:encoding ) 
+bool FTFace::CharMap( CHARMAP encoding )
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+// OPSignature: FT_Glyph FTFace:GetGlyph( int:index ) 
+FT_Glyph	FTFace::Glyph( int index )
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+// OPSignature: FT_Vector FTFace:GetKernAdvance( int:index1  int:index2 ) 
+FT_Vector	FTFace::KernAdvance( int index1, int index2 )
+{
+//Insert your own code here.
+
+//End of user code.         
+}
diff --git a/src/FTFont.cpp b/src/FTFont.cpp
new file mode 100755
index 0000000..45017a6
--- /dev/null
+++ b/src/FTFont.cpp
@@ -0,0 +1,135 @@
+#include	"FTFace.h"
+#include	"FTFont.h"
+#include	"FTGlyphContainer.h"
+//#include	"FTGL.h"
+
+
+
+
+// OPSignature:  FTFont:FTFont() 
+FTFont::FTFont()
+:	fontName(0),
+	numFaces(0),
+	glyphList(0)
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+// OPSignature:  FTFont:~FTFont() 
+FTFont::~FTFont()
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+// OPSignature: bool FTFont:Open( const char*:fontname ) 
+bool	FTFont::Open( const char* fontname )
+{
+	//FIXME first check map to see if it's already open.
+//	FTFace face; // When we have a list of faces
+
+	if( face.Open( fontname))
+	{
+//		faceList.insert( FaceMap::value_type( string( fontname), face));
+		FT_Face* ftFace = face.Face();
+		
+		numGlyphs = (*ftFace)->num_glyphs;
+		
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+	
+
+}
+
+
+// OPSignature: void FTFont:Close() 
+void	FTFont::Close()
+{
+	face.Close();
+	delete glyphList;
+	
+}
+
+
+// OPSignature: bool FTFont:SetFaceSize( const int:size  const int:res ) 
+bool FTFont::FaceSize( const int size, const int res )
+{
+	charSize = face.Size( size, res);
+
+	if( glyphList)
+		delete glyphList;
+	
+	glyphList = new FTGlyphContainer( face.Face(), numGlyphs);	
+	
+	MakeGlyphList();
+
+	
+	return true;
+}
+
+bool FTFont::CharMap( CHARMAP encoding)
+{
+	face.CharMap( encoding);
+//	assert( face);
+
+	//FIXME
+	if( glyphList)
+		delete glyphList;
+		
+	glyphList = new FTGlyphContainer( face.Face(), numGlyphs);
+	
+	MakeGlyphList();
+}
+
+
+//FTGlyph* FTFont::Glyph( unsigned char code )
+//{}
+//
+//
+//FTGlyph* FTFont::Glyph( unsigned char thisCode, unsigned char nextCode )
+//{}
+
+
+// OPSignature: int FTFont:getAscender() 
+int	FTFont::Ascender() const
+{
+	return charSize.Ascender();
+}
+
+
+// OPSignature: int FTFont:getDescender() 
+int	FTFont::Descender() const
+{
+	return charSize.Descender();
+}
+
+
+// OPSignature: void FTFont:getBBox( const char*:text  int&:llx  int&:lly  int&:urx  int&:ury ) 
+void	FTFont::BBox( const char* text, int& llx, int& lly, int& urx, int& ury ) const
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+// OPSignature: bool FTFont:render( const char*:string ) 
+bool FTFont::render( const char* string )
+{
+	char* c = string;
+
+	while( *c)
+	{
+		glyphList->render( *c, *(c + 1));
+		++c;
+	}
+}
diff --git a/src/FTGLBitmapFont.cpp b/src/FTGLBitmapFont.cpp
new file mode 100755
index 0000000..ead744a
--- /dev/null
+++ b/src/FTGLBitmapFont.cpp
@@ -0,0 +1,54 @@
+#include	"FTGLBitmapFont.h"
+#include	"FTGlyphContainer.h"
+#include	"FTBitmapGlyph.h"
+
+
+FTGLBitmapFont::FTGLBitmapFont()
+//Insert your own initialization here.
+
+//End of user initialization.         
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+FTGLBitmapFont::~FTGLBitmapFont()
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+// OPSignature: bool FTGlyphContainer:MakeGlyphList() 
+bool FTGLBitmapFont::MakeGlyphList()
+{
+//	if( preCache)
+
+	FT_Face* ftFace = face.Face();
+	long glyphIndex;
+	FT_Error err;
+	
+	for( int c = 0; c < numGlyphs; ++c)
+	{
+		glyphIndex = FT_Get_Char_Index( *ftFace, c );
+		
+		err = FT_Load_Glyph( *ftFace, glyphIndex, FT_LOAD_DEFAULT);
+		if( err)
+		{}
+
+		FT_Glyph ftGlyph;
+		
+		err = FT_Get_Glyph( (*ftFace)->glyph, &ftGlyph);
+		if( err)
+		{}
+
+//		FT_HAS_VERTICAL(face)
+
+		tempGlyph = new FTBitmapGlyph( ftGlyph, glyphIndex);
+		glyphList->Add( tempGlyph);
+		
+	}
+}
diff --git a/src/FTGLOutlineFont.cpp b/src/FTGLOutlineFont.cpp
new file mode 100755
index 0000000..7a31d65
--- /dev/null
+++ b/src/FTGLOutlineFont.cpp
@@ -0,0 +1,25 @@
+// Code generated by Object Plant
+
+#include	"FTGLOutlineFont.h"
+#include	"FTGlyphContainer.h"
+#include	"FTGL.h"
+
+
+FTGLOutlineFont::FTGLOutlineFont()
+//Insert your own initialization here.
+
+//End of user initialization.         
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+FTGLOutlineFont::~FTGLOutlineFont()
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
diff --git a/src/FTGLPixmapFont.cpp b/src/FTGLPixmapFont.cpp
new file mode 100755
index 0000000..7f9da7e
--- /dev/null
+++ b/src/FTGLPixmapFont.cpp
@@ -0,0 +1,53 @@
+#include	"FTGLPixmapFont.h"
+#include	"FTGlyphContainer.h"
+#include	"FTPixmapGlyph.h"
+
+
+FTGLPixmapFont::FTGLPixmapFont()
+//Insert your own initialization here.
+
+//End of user initialization.         
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+FTGLPixmapFont::~FTGLPixmapFont()
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+// OPSignature: bool FTGlyphContainer:MakeGlyphList() 
+bool FTGLPixmapFont::MakeGlyphList()
+{
+//	if( preCache)
+
+	FT_Face* ftFace = face.Face();
+	long glyphIndex;
+	
+	for( int c = 0; c < numGlyphs; ++c)
+	{
+		glyphIndex = FT_Get_Char_Index( *ftFace, c );
+		
+		err = FT_Load_Glyph( *ftFace, glyphIndex, FT_LOAD_DEFAULT);
+		if( err)
+		{ }
+
+		FT_Glyph ftGlyph;
+		
+		err = FT_Get_Glyph( (*ftFace)->glyph, &ftGlyph);
+		if( err)
+		{}
+
+//		FT_HAS_VERTICAL(face)
+
+		tempGlyph = new FTPixmapGlyph( ftGlyph, glyphIndex);
+		glyphList->Add( tempGlyph);
+		
+	}
+}
diff --git a/src/FTGLPolygonFont.cpp b/src/FTGLPolygonFont.cpp
new file mode 100755
index 0000000..c3a0dbd
--- /dev/null
+++ b/src/FTGLPolygonFont.cpp
@@ -0,0 +1,20 @@
+#include	"FTGLPolygonFont.h"
+#include	"FTGlyphContainer.h"
+#include	"FTGL.h"
+
+
+	FTGLPolygonFont::FTGLPolygonFont()
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+FTGLPolygonFont::~FTGLPolygonFont()
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
diff --git a/src/FTGLTextureFont.cpp b/src/FTGLTextureFont.cpp
new file mode 100755
index 0000000..c3a6996
--- /dev/null
+++ b/src/FTGLTextureFont.cpp
@@ -0,0 +1,90 @@
+#include	"gl.h"
+
+#include	"FTGLTextureFont.h"
+#include	"FTGlyphContainer.h"
+#include	"FTGL.h"
+
+
+inline UInt32 NextPowerOf2( UInt32 in)
+{
+     in -= 1;
+
+     in |= in >> 16;
+     in |= in >> 8;
+     in |= in >> 4;
+     in |= in >> 2;
+     in |= in >> 1;
+
+     return in + 1;
+}
+
+
+FTGLTextureFont::FTGLTextureFont()
+:	glTextureID(0),
+	textMem(0)
+{
+	glGetIntegerv( GL_MAX_TEXTURE_SIZE, &maxTextSize);
+	glGenTextures( 1, &glTextureID);
+
+}
+
+
+FTGLTextureFont::~FTGLTextureFont()
+{
+	glDeleteTextures( 1, &glTextureID);
+	delete [] texMem;
+}
+
+
+bool FTGLTextureFont::CreateTexture()
+{
+	// calc the area required for this font
+	int glyphHeight = ftFace->size->metrics-> + padding;
+	int glyphWidth = ftFace->size->metrics-> + padding;
+	
+	// calc the smallest texture size to fit the glyphs
+	// this is bit naff!!
+	for(int s = 64; s < maxTextSize; s = s * s)
+	{
+		int size = s -padding - padding;
+		horizGlyphs = static_cast<int>( size / glyphWidth);
+		
+		vertGlyphs = static_cast<int>( numGlyphs / horizGlyphs);
+		
+		if( vertGlyphs * glyphHeight < size)
+			break;
+	}
+
+	vertGlyphs = static_cast<int>( ( textureSize - padding) / glyphHeight);
+	horizGlyphs = static_cast<int>( ( textureSize - padding) / glyphWidth);
+	
+	// build the texture.
+	textMem = unsigned char[ s * s]; // GL_ALPHA texture;
+}
+
+
+bool FTGLTextureFont::MakeGlyphList()
+{
+	FT_Face* ftFace = face.Face();
+	
+	CreateTexture();
+
+	int currentTextX = padding;
+	int currentTextY = padding;
+	
+	currGlyph = 0;
+	
+	for( int y = 0; y < horizGlyphs; ++y)
+	{
+		for( int x = 0; x < vertGlyphs; ++x)
+		{
+
+		}
+	}
+}
+
+
+
+
+
+
diff --git a/src/FTGlyph.cpp b/src/FTGlyph.cpp
new file mode 100755
index 0000000..d23ae72
--- /dev/null
+++ b/src/FTGlyph.cpp
@@ -0,0 +1,19 @@
+#include	"FTGlyph.h"
+
+
+// OPSignature:  FTGlyph:FTGlyph( FT_Face:face  int:glyphIndex ) 
+FTGlyph::FTGlyph( int gi)
+:	advance(0),
+	glyphIndex(gi),
+	ftGlyph(0)
+{
+	pos.x = 0;
+	pos.y = 0;
+}
+
+
+// OPSignature:  FTGlyph:~FTGlyph() 
+FTGlyph::~FTGlyph()
+{
+	FT_Done_Glyph(ftGlyph); // Is this OK?
+}
diff --git a/src/FTGlyphContainer.cpp b/src/FTGlyphContainer.cpp
new file mode 100755
index 0000000..994b2b2
--- /dev/null
+++ b/src/FTGlyphContainer.cpp
@@ -0,0 +1,86 @@
+#include	"FTGlyphContainer.h"
+#include	"FTGlyph.h"
+//#include	"FTBitmapGlyph.h"
+//#include	"FTPixmapGlyph.h"
+//#include	"FTVectorGlyph.h"
+
+
+FTGlyphContainer::FTGlyphContainer( FT_Face* f, int g, bool p)
+:	preCache( p),
+	numGlyphs(g),
+	tempGlyph(0),
+	face(f)
+{
+	glyphs.reserve( g);
+
+//	numGlyphs = (*face)->num_glyphs;
+	
+//	MakeGlyphList( face);
+}
+
+
+// OPSignature:  FTGlyphContainer:~FTGlyphContainer() 
+FTGlyphContainer::~FTGlyphContainer()
+{
+	vector<FTGlyph*>::iterator iter;
+	for( iter = glyphs.begin(); iter != glyphs.end(); ++iter)
+	{
+		delete *iter;
+	}
+	
+	glyphs.clear();
+}
+
+
+bool FTGlyphContainer::Add( FTGlyph* tempGlyph)
+{
+	glyphs.push_back( tempGlyph);
+}
+
+
+// OPSignature: bool FTGlyphContainer:MakeGlyphList() 
+//bool FTGlyphContainer::MakeGlyphList( FT_Face* face)
+//{
+//	if( preCache)
+//
+//	glyphs.reserve( numGlyphs);
+//
+//	for( int c = 0; c < numGlyphs; ++c)
+//	{
+//		long glyphIndex = FT_Get_Char_Index( *face, c );
+//		FT_Error err = FT_Load_Glyph( *face, glyphIndex, FT_LOAD_DEFAULT);
+//		if( err)
+//		{}
+//
+//		FT_Glyph ftglyph;
+//		
+//		err = FT_Get_Glyph( (*face)->glyph, &ftglyph);
+//		if( err)
+//		{}
+//
+//		FT_HAS_VERTICAL(face)
+//
+//		tempGlyph = new FTPixmapGlyph( ftglyph, glyphIndex);
+//		glyphs.push_back( tempGlyph);
+//		
+//	}
+//}
+
+
+// OPSignature: bool FTGlyphContainer:render( int:index ) 
+bool FTGlyphContainer::render( int index, int next)
+{
+	FT_Vector kernAdvance;
+	kernAdvance.x = 0; kernAdvance.y = 0;
+	
+	if( index > glyphs.size())
+		return false;
+	
+	if( 0 < next <=  glyphs.size())
+	{
+		FT_Error err = FT_Get_Kerning( *face, glyphs[index]->glyphIndex, glyphs[next]->glyphIndex, ft_kerning_default, &kernAdvance);
+	}
+	
+//	glyphs[index].second->Render( kernAdvance);
+	glyphs[index]->Render( kernAdvance);
+}
diff --git a/src/FTLibrary.cpp b/src/FTLibrary.cpp
new file mode 100755
index 0000000..b847543
--- /dev/null
+++ b/src/FTLibrary.cpp
@@ -0,0 +1,68 @@
+#include	"FTLibrary.h"
+#include	"FTGL.h"
+
+
+// OPSignature: FTLibrary& FTLibrary:Instance() 
+FTLibrary&	FTLibrary::Instance()
+{
+	static FTLibrary ftlib;
+	return ftlib;
+}
+
+
+// OPSignature:  FTLibrary:~FTLibrary() 
+FTLibrary::~FTLibrary()
+{
+	if( lib != 0)
+	{
+		FT_Done_FreeType( *lib);
+
+		delete lib;
+		lib= 0;
+	}
+
+//	if( manager != 0)
+//	{
+//		FTC_Manager_Done( manager );
+//
+//		delete manager;
+//		manager= 0;
+//	}
+}
+
+
+// OPSignature:  FTLibrary:FTLibrary() 
+FTLibrary::FTLibrary()
+: lib(0)
+{
+	Init();
+}
+
+
+// OPSignature: bool FTLibrary:Init() 
+bool	FTLibrary::Init()
+{
+	if( lib != 0 )
+		return true;
+
+	lib = new FT_Library;
+
+	if( FT_Init_FreeType( lib)) // false = no error
+	{
+		delete lib;
+		lib= 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;
+}
diff --git a/src/FTPixmapGlyph.cpp b/src/FTPixmapGlyph.cpp
new file mode 100755
index 0000000..87651ab
--- /dev/null
+++ b/src/FTPixmapGlyph.cpp
@@ -0,0 +1,90 @@
+#include	"gl.h"
+
+#include	"FTPixmapGlyph.h"
+#include	"FTGL.h"
+
+
+FTPixmapGlyph::FTPixmapGlyph( FT_Glyph glyph, int gi)
+:	FTGlyph(gi)
+{
+	if( !glyph->format == ft_glyph_format_bitmap)
+	{ return;}
+	
+	// This function will always fail if the glyph's format isn't scalable????
+	FT_Error err = FT_Glyph_To_Bitmap( &glyph, ft_render_mode_normal, 0, 1);
+	if( err)
+	{return;}
+
+	FT_BitmapGlyph  bitmap = (FT_BitmapGlyph)glyph;
+	FT_Bitmap*      source = &bitmap->bitmap;
+
+	//check the pixel mode
+	//ft_pixel_mode_grays
+	    
+	int srcWidth = source->width;
+	int srcHeight = source->rows;
+	int srcPitch = source->pitch;
+    
+	numGreys = source->num_grays;
+	advance = glyph->advance.x >> 16; // this is 6 in the freetype docs!!!!!!
+
+ 	pos.x = bitmap->left;
+	pos.y = srcHeight - bitmap->top;
+	
+   // FIXME The buffer is upside down. What about dest alignment?
+    destWidth = srcWidth;
+    destHeight = srcHeight;
+    
+    data = new unsigned char[destWidth * destHeight * 4];
+    
+    for(int y = 0; y < srcHeight; ++y)
+    {
+    	--destHeight;
+    	for(int x = 0; x < srcWidth; ++x)
+    	{
+			*( data + ( destHeight * destWidth  + x) * 4 + 0) = 0xFF;
+			*( data + ( destHeight * destWidth  + x) * 4 + 1) = 0xFF;
+			*( data + ( destHeight * destWidth  + x) * 4 + 2) = 0xFF;
+			*( data + ( destHeight * destWidth  + x) * 4 + 3) = *( source->buffer + ( y * srcPitch) + x);
+    	}    	
+    }
+
+    destHeight = srcHeight;
+
+	// discard glyph image (bitmap or not)
+	// Is this the right place to do this?
+	FT_Done_Glyph( glyph );
+}
+
+
+FTPixmapGlyph::~FTPixmapGlyph()
+{
+	delete[] data;
+}
+
+
+float FTPixmapGlyph::Render( FT_Vector v)
+{
+	int adv = advance - pos.x + ( v.x >> 16); // FIXME ??? pos.x = bearing X
+	if( data != 0 )
+	{
+		glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT);
+		
+		// Move the glyph origin
+		glBitmap( 0, 0, 0.0, 0.0, 0, -pos.y, (const GLubyte *)0 );
+
+		glPixelStorei( GL_UNPACK_ROW_LENGTH, destWidth);
+
+		glDrawPixels( destWidth, destHeight, GL_RGBA, GL_UNSIGNED_BYTE, (const GLvoid*)data );
+
+		// Restore the glyph origin
+		glBitmap( 0, 0, 0.0, 0.0, 0, pos.y, (const GLubyte *)0 );
+
+		glPopClientAttrib();
+	}
+	
+	// Advance the raster pos.
+	glBitmap( 0, 0, 0.0, 0.0, adv, 0, (const GLubyte *)0 );
+
+	return advance;
+}
diff --git a/src/FTSize.cpp b/src/FTSize.cpp
new file mode 100755
index 0000000..3fea49e
--- /dev/null
+++ b/src/FTSize.cpp
@@ -0,0 +1,53 @@
+// Code generated by Object Plant
+
+#include	"FTSize.h"
+#include	"FTGL.h"
+//Insert your own code here.
+
+//End of user code.         
+
+// OPSignature:  FTSize:FTSize() 
+FTSize::FTSize()
+:	size(0)
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+// OPSignature:  FTSize:~FTSize() 
+FTSize::~FTSize()
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+// OPSignature: bool FTSize:SetCharSize( FT_Face:face  int:point_size  int:x_resolution  int:y_resolution ) 
+bool	FTSize::CharSize( FT_Face* face, int point_size, int x_resolution, int y_resolution )
+{
+	size = point_size;
+	FT_Error err = FT_Set_Char_Size( *face, 0L, point_size * 64, x_resolution, y_resolution);
+
+	return !err;
+}
+
+
+// OPSignature: int FTSize:GetAscender() 
+int	FTSize::Ascender() const
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+// OPSignature: int FTSize:GetDescender() 
+int	FTSize::Descender() const
+{
+//Insert your own code here.
+
+//End of user code.         
+}
diff --git a/src/FTTextureGlyph.cpp b/src/FTTextureGlyph.cpp
new file mode 100755
index 0000000..72b61e6
--- /dev/null
+++ b/src/FTTextureGlyph.cpp
@@ -0,0 +1,86 @@
+#include	"gl.h"
+
+#include	"FTTextureGlyph.h"
+#include	"FTGL.h"
+
+
+FTTextureGlyph::FTTextureGlyph( FT_Glyph glyph, int gi, pointer to data location, stride)
+:	FTGlyph(gi)
+{
+	if( !glyph->format == ft_glyph_format_bitmap)
+	{ return;}
+	
+	// This function will always fail if the glyph's format isn't scalable????
+	err = FT_Glyph_To_Bitmap( &glyph, ft_render_mode_normal, 0, 1);
+	if( err)
+	{return;}
+
+	FT_BitmapGlyph  bitmap = (FT_BitmapGlyph)glyph;
+	FT_Bitmap*      source = &bitmap->bitmap;
+
+	//check the pixel mode
+	//ft_pixel_mode_grays
+	    
+	int srcWidth = source->width;
+	int srcHeight = source->rows;
+	int srcPitch = source->pitch;
+    
+	numGreys = source->num_grays;
+	advance = glyph->advance.x >> 16; // this is 6 in the freetype docs!!!!!!
+
+ 	pos.x = bitmap->left;
+	pos.y = srcHeight - bitmap->top;
+	
+   // FIXME The buffer is upside down. What about dest alignment?
+    destWidth = srcWidth;
+    destHeight = srcHeight;
+    
+    data = new unsigned char[destWidth * destHeight * 4];
+    
+    for(int y = 0; y < srcHeight; ++y)
+    {
+    	--destHeight;
+    	for(int x = 0; x < srcWidth; ++x)
+    	{
+			*( data + ( destHeight * destWidth  + x) * 4 + 0) = 0xFF;
+			*( data + ( destHeight * destWidth  + x) * 4 + 1) = 0xFF;
+			*( data + ( destHeight * destWidth  + x) * 4 + 2) = 0xFF;
+			*( data + ( destHeight * destWidth  + x) * 4 + 3) = *( source->buffer + ( y * srcPitch) + x);
+    	}    	
+    }
+
+    destHeight = srcHeight;
+
+	// discard glyph image (bitmap or not)
+	// Is this the right place to do this?
+	FT_Done_Glyph( glyph );
+}
+
+
+FTTextureGlyph::~FTTextureGlyph()
+{
+	delete[] data;
+}
+
+
+float FTTextureGlyph::Render( FT_Vector v)
+{
+	int adv = advance/* + pos.x */+ ( v.x >> 16); // FIXME ??? pos.x = bearing X
+	if( data != 0 )
+	{
+		// Move the glyph origin
+		glBitmap( 0, 0, 0.0, 0.0, 0, -pos.y, (const GLubyte *)0 );
+
+		glPixelStorei( GL_UNPACK_ROW_LENGTH, destWidth);
+
+		glDrawPixels( destWidth, destHeight, GL_RGBA, GL_UNSIGNED_BYTE, (const GLvoid*)data );
+
+		// Restore the glyph origin
+		glBitmap( 0, 0, 0.0, 0.0, 0, pos.y, (const GLubyte *)0 );
+	}
+	
+	// Advance the raster pos.
+	glBitmap( 0, 0, 0.0, 0.0, adv, 0, (const GLubyte *)0 );
+
+	return advance;
+}
diff --git a/src/FTVectorGlyph.cpp b/src/FTVectorGlyph.cpp
new file mode 100755
index 0000000..eeb348e
--- /dev/null
+++ b/src/FTVectorGlyph.cpp
@@ -0,0 +1,25 @@
+#include	"FTVectorGlyph.h"
+#include	"FTGL.h"
+
+
+FTVectorGlyph::FTVectorGlyph( FT_Glyph glyph, int gi)
+:	FTGlyph(gi)
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+FTVectorGlyph::~FTVectorGlyph()
+{
+//Insert your own code here.
+
+//End of user code.         
+}
+
+
+float FTVectorGlyph::Render()
+{
+	return advance;
+}
diff --git a/src/FTVectorGlyph.h b/src/FTVectorGlyph.h
new file mode 100755
index 0000000..7cc4198
--- /dev/null
+++ b/src/FTVectorGlyph.h
@@ -0,0 +1,24 @@
+#ifndef		__FTVectorGlyph__
+#define		__FTVectorGlyph__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGlyph.h"
+
+
+class	FTVectorGlyph : public FTGlyph
+{
+	public:
+		// methods
+		FTVectorGlyph( FT_Glyph glyph, int glyphIndex);
+		virtual ~FTVectorGlyph();
+		virtual float Render();
+		
+		// attributes
+		
+};
+
+
+#endif	//	__FTVectorGlyph__