kc3-lang/ftgl

diff --git a/include/FTPolyGlyph.h b/include/FTPolyGlyph.h
index c49d1c4..8c36c84 100644
--- a/include/FTPolyGlyph.h
+++ b/include/FTPolyGlyph.h
@@ -62,21 +62,6 @@ class FTGL_EXPORT FTPolyGlyph : public FTGlyph
 		int numPoints;
 
 		/**
-		 * The totals number of contours in the Freetype outline
-		 */
-		int numContours;
-
-		/**
-		 * An flag indicating the tesselation rules for this glyph
-		 */
-		int contourFlag; 
-
-		/**
-		 * An array containing the number of points in each outline
-		 */
-		int* contourLength;
-
-		/**
 		 * Pointer to the point data
 		 */
 		double* data;
diff --git a/include/FTVectoriser.h b/include/FTVectoriser.h
index 1e5669d..6091af2 100644
--- a/include/FTVectoriser.h
+++ b/include/FTVectoriser.h
@@ -13,6 +13,10 @@
 
 using namespace std;
 
+#ifndef CALLBACK
+#define CALLBACK
+#endif
+
 /**
  * ftPoint class is a basic 3 dimensional point for holding outline font
  * point data.
@@ -69,9 +73,55 @@ class FTGL_EXPORT ftPoint
 		/**
 		 * The point data
 		 */
-		float x, y, z; // FIXME make private
+		double x, y, z; // FIXME make private
+		
+	private:
+};
+
+
+class FTGL_EXPORT FTTesselation
+{
+	public:
+		FTTesselation();
+		~FTTesselation();
+		
+		void AddPoint( const float x, const float y, const float z);
+
+		int size() const { return pointList.size();}
+
+		GLenum meshType;
+		vector<ftPoint> pointList;
+	private:
+};
+
+
+class FTGL_EXPORT FTMesh
+{
+	public:
+		FTMesh();
+		~FTMesh();
+		
+		void AddPoint( const float x, const float y, const float z);
+		void Begin( GLenum m);
+		void End();
 		
+		double* Point();
+		int size() const;
+		
+		void Error( GLenum e) { err = e;}
+		GLenum Error() const { return err;}
+
+		/**
+		 *	The list of points in this mesh
+		 */
+		vector< FTTesselation*> tess;
+		vector< ftPoint> tempPool;
+	protected:
+	
 	private:
+		FTTesselation* tempTess;
+		GLenum err;
+
 };
 
 
@@ -169,6 +219,16 @@ class FTGL_EXPORT FTVectoriser
 		void MakeOutline( double* d);
 
 		/**
+		 * Build a mesh from the outline and copy the vertx data into a
+		 * block of <code>doubles</code>
+		 * @param d
+		 */
+		void MakeMesh();
+		void GetMesh( double* d);
+		
+		int MeshPoints() const { return mesh->size();}
+		
+		/**
 		 * Get the total count of points in this outline
 		 *
 		 * @return the number of points
@@ -233,15 +293,26 @@ class FTGL_EXPORT FTVectoriser
 		 */
 		void evaluateCurve( const int n);
 
+
+
+//void CALLBACK ftglVertex( void* data);
+
+
+
 		/**
 		 * The list of contours in this outline
 		 */
 		vector< const FTContour*> contourList;
 			
 		/**
-		 * A temporary FTContour
+		 * A Mesh for tesselations
 		 */
 		FTContour* contour;
+			
+		/**
+		 * A Mesh for tesselations
+		 */
+		FTMesh* mesh;
 
 		/**
 		* A flag indicating the tesselation rule for this outline
diff --git a/src/FTPolyGlyph.cpp b/src/FTPolyGlyph.cpp
index 7b372cb..8aad51c 100644
--- a/src/FTPolyGlyph.cpp
+++ b/src/FTPolyGlyph.cpp
@@ -1,56 +1,11 @@
-
 #include	"FTPolyGlyph.h"
 #include	"FTVectoriser.h"
 
-#ifndef CALLBACK
-#define CALLBACK
-#endif
-
-
-void CALLBACK ftglError( GLenum errCode)
-{
-//	const GLubyte* estring;
-//	estring = gluErrorString( errCode);
-//	fprintf( stderr, "ERROR : %s\n", estring);
-//	exit(1);
-}
-
-void CALLBACK ftglVertex( void* data)
-{
-	glVertex3dv( (double*)data);
-}
-
-
-void CALLBACK ftglBegin( GLenum type)
-{
-	glBegin( type);
-}
-
-
-void CALLBACK ftglEnd()
-{
-	glEnd();
-}
-
-
-void CALLBACK ftglCombine( GLdouble coords[3], void* vertex_data[4], GLfloat weight[4], void** outData)
-{
-	double* vertex = new double[3]; // FIXME MEM LEAK
-	
-	vertex[0] = coords[0];
-	vertex[1] = coords[1];
-	vertex[2] = coords[2];
-
-	*outData = vertex;
-}
-
 
 FTPolyGlyph::FTPolyGlyph( FT_Glyph glyph)
 :	FTGlyph(),
 	vectoriser(0),
 	numPoints(0),
-	numContours(0),
-	contourLength(0),
 	data(0),
 	glList(0)
 {
@@ -60,83 +15,57 @@ FTPolyGlyph::FTPolyGlyph( FT_Glyph glyph)
 	vectoriser = new FTVectoriser( glyph);
 	
 	vectoriser->Process();
-	numContours = vectoriser->contours();
-	contourLength = new int[ numContours];
-	
-	for( int c = 0; c < numContours; ++c)
+
+	vectoriser->MakeMesh();
+	numPoints = vectoriser->MeshPoints();
+
+	if ( numPoints < 3)
 	{
-		contourLength[c] = vectoriser->contourSize( c);
+		delete vectoriser;
+		return;
 	}
 	
-	numPoints = vectoriser->points();
 	data = new double[ numPoints * 3];
-	// FIXME MakeMesh
-	vectoriser->MakeOutline( data);
+
+	vectoriser->GetMesh( data);
 	
-	contourFlag = vectoriser->ContourFlag();
 	advance = glyph->advance.x >> 16;
 
 	delete vectoriser;
-
-	if ( ( numContours < 1) || ( numPoints < 3))
-		return;
-
-	Tesselate();
-
-	// discard glyph image (bitmap or not)
-	FT_Done_Glyph( glyph); // Why does this have to be HERE
-}
-
-
-void FTPolyGlyph::Tesselate()
-{
+	
 	glList = glGenLists(1);
-	GLUtesselator* tobj = gluNewTess();
 	int d = 0;
-	
-	gluTessCallback( tobj, GLU_TESS_BEGIN, (void (CALLBACK*)())ftglBegin);
-	gluTessCallback( tobj, GLU_TESS_VERTEX, (void (CALLBACK*)())ftglVertex);
-	gluTessCallback( tobj, GLU_TESS_COMBINE, (void (CALLBACK*)())ftglCombine);
-	gluTessCallback( tobj, GLU_TESS_END, ftglEnd);
-	gluTessCallback( tobj, GLU_TESS_ERROR, (void (CALLBACK*)())ftglError);
-	
+
 	glNewList( glList, GL_COMPILE);
-	
-		if( contourFlag & ft_outline_even_odd_fill) // ft_outline_reverse_fill
-		{
-			gluTessProperty( tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
-		}
-		else
+		int BEPairs = data[0];
+		for( int i = 0; i < BEPairs; ++i)
 		{
-			gluTessProperty( tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_NONZERO);
-		}
-		
-		gluTessProperty( tobj, GLU_TESS_TOLERANCE, 0);
-		gluTessBeginPolygon( tobj, NULL);
-		
-			for( int c = 0; c < numContours; ++c)
+			int polyType = (int)data[d + 1];
+			glBegin( polyType);
+
+			int verts = (int)data[d+2];
+			d += 3;
+			for( int x = 0; x < verts; ++x)
 			{
-				gluTessBeginContour( tobj);
-					for( int p = 0; p < ( contourLength[c]); ++p)
-					{
-						gluTessVertex( tobj, data + d, data + d);
-						d += 3;
-					}
-				gluTessEndContour( tobj);
+				glVertex3dv( data + d);
+				d += 3;
 			}
-			
-		gluTessEndPolygon( tobj);
-		
+			glEnd();
+		}
 	glEndList();
 
-	gluDeleteTess( tobj);
+	delete [] data; // FIXME
+	data = 0;
+
+	// discard glyph image (bitmap or not)
+	FT_Done_Glyph( glyph); // Why does this have to be HERE
 }
 
 
 FTPolyGlyph::~FTPolyGlyph()
 {
-	delete [] data;
-	delete [] contourLength;
+//	if( data)
+//		delete [] data; // FIXME
 }
 
 
diff --git a/src/FTVectoriser.cpp b/src/FTVectoriser.cpp
index de26a18..fd45946 100644
--- a/src/FTVectoriser.cpp
+++ b/src/FTVectoriser.cpp
@@ -1,6 +1,46 @@
 #include	"FTVectoriser.h"
 #include	"FTGL.h"
 
+//#include	"mmgr.h"
+
+#ifndef CALLBACK
+#define CALLBACK
+#endif
+
+
+
+void CALLBACK ftglError( GLenum errCode, FTMesh* mesh)
+{
+	mesh->Error( errCode);
+}
+
+void CALLBACK ftglVertex( void* data, FTMesh* mesh)
+{
+	double* vertex = (double*)data;
+	mesh->AddPoint( vertex[0], vertex[1], vertex[2]);
+}
+
+
+void CALLBACK ftglBegin( GLenum type, FTMesh* mesh)
+{
+	mesh->Begin( type);
+}
+
+
+void CALLBACK ftglEnd( FTMesh* mesh)
+{
+	mesh->End();
+}
+
+
+void CALLBACK ftglCombine( GLdouble coords[3], void* vertex_data[4], GLfloat weight[4], void** outData, FTMesh* mesh)
+{
+	double* vertex = (double*)coords;
+	mesh->tempPool.push_back( ftPoint( vertex[0], vertex[1], vertex[2]));
+	
+	*outData = &mesh->tempPool[ mesh->tempPool.size() - 1].x;
+}
+
 
 FTContour::FTContour()
 :	kMAXPOINTS( 1000)
@@ -27,8 +67,81 @@ void FTContour::AddPoint( const float x, const float y)
 }
 
 
+FTTesselation::FTTesselation()
+{
+	pointList.reserve( 128);
+}
+
+
+FTTesselation::~FTTesselation()
+{
+	pointList.clear();
+}
+		
+void FTTesselation::AddPoint( const float x, const float y, const float z)
+{	
+	pointList.push_back( ftPoint( x, y, z));
+}
+
+
+FTMesh::FTMesh()
+:	err(0)
+{
+	tess.reserve( 16);
+	tempPool.reserve( 128);
+}
+
+
+FTMesh::~FTMesh()
+{
+	for( int t = 0; t < tess.size(); ++t)
+	{
+		delete tess[t];
+	}
+	tess.clear();
+
+	tempPool.clear();
+}
+
+
+void FTMesh::AddPoint( const float x, const float y, const float z)
+{
+	tempTess->AddPoint( x, y, z);
+}
+
+void FTMesh::Begin( GLenum m)
+{
+	tempTess = new FTTesselation;
+	tempTess->meshType = m;
+}
+
+
+void FTMesh::End()
+{
+	tess.push_back( tempTess);
+}
+
+double* FTMesh::Point()
+{
+	return &tempTess->pointList[ tempTess->size() - 1].x;
+
+}
+
+int FTMesh::size() const
+{
+	int s = 0;
+	for( int t = 0; t < tess.size(); ++t)
+	{
+		s += tess[t]->size();
+		++s;
+	}
+	return s;
+}
+
+
 FTVectoriser::FTVectoriser( const FT_Glyph glyph)
 :	contour(0),
+	mesh(0),
 	contourFlag(0),
 	kBSTEPSIZE( 0.2)
 {
@@ -47,6 +160,9 @@ FTVectoriser::~FTVectoriser()
 	}
 
 	contourList.clear();
+	
+	if( mesh)
+		delete mesh;
 }
 
 
@@ -226,3 +342,80 @@ void FTVectoriser::MakeOutline( double* data)
 	}
 }
 
+
+void FTVectoriser::MakeMesh()
+{
+	mesh = new FTMesh;
+	
+	GLUtesselator* tobj = gluNewTess();
+	
+	gluTessCallback( tobj, GLU_TESS_BEGIN_DATA,		(void (CALLBACK*)())ftglBegin);
+	gluTessCallback( tobj, GLU_TESS_VERTEX_DATA,	(void (CALLBACK*)())ftglVertex);
+	gluTessCallback( tobj, GLU_TESS_COMBINE_DATA,	(void (CALLBACK*)())ftglCombine);
+	gluTessCallback( tobj, GLU_TESS_END_DATA,		(void (CALLBACK*)())ftglEnd);
+	gluTessCallback( tobj, GLU_TESS_ERROR_DATA,		(void (CALLBACK*)())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);
+	gluTessBeginPolygon( tobj, mesh);
+	
+		for( int c = 0; c < contours(); ++c)
+		{
+			const FTContour* contour = contourList[c];
+			gluTessBeginContour( tobj);
+			
+				for( int p = 0; p < contour->size(); ++p)
+				{
+					double* d = &contour->pointList[p].x;
+					gluTessVertex( tobj, d, d);
+				}
+			gluTessEndContour( tobj);
+		}
+		
+	gluTessEndPolygon( tobj);
+
+	gluDeleteTess( tobj);
+	
+}
+
+
+void FTVectoriser::GetMesh( double* data)
+{
+ 	// Now write it out
+	int i = 0;
+	
+	// fill out the header
+	int msize = mesh->tess.size();
+	data[0] = msize;
+	
+	for( int p = 0; p < data[0]; ++p)
+	{
+		FTTesselation* tess = mesh->tess[p];
+		int tSize =  tess->pointList.size();
+		int tType =  tess->meshType;
+		
+		data[i+1] = tType;
+		data[i+2] = tSize;
+		i += 3;
+		for( int q = 0; q < ( tess->pointList.size()); ++q)
+		{
+			data[i] = tess->pointList[q].x / 64.0f; // is 64 correct?
+			data[i + 1] = tess->pointList[q].y / 64.0f;
+			data[i + 2] = 0.0; // static_cast<double>(mesh->pointList[p].z / 64.0f);
+			i += 3;
+		
+		}
+
+	}
+
+}