*** empty log message ***

88 files changed, 13921 insertions, 9 deletions

diff --git a/src/cd_ftgl.mak b/src/cd_ftgl.mak
new file mode 100644
index 0000000..fa0833d
--- /dev/null
+++ b/src/cd_ftgl.mak
@@ -0,0 +1,63 @@
+PROJNAME = cd
+LIBNAME = ftgl
+OPT = YES
+
+ftglyph_sources = \
+    FTGlyph/FTGlyph.cpp \
+    FTGlyph/FTGlyphGlue.cpp \
+    FTGlyph/FTBitmapGlyph.cpp \
+    FTGlyph/FTBufferGlyph.cpp \
+    FTGlyph/FTExtrudeGlyph.cpp \
+    FTGlyph/FTOutlineGlyph.cpp \
+    FTGlyph/FTPixmapGlyph.cpp \
+    FTGlyph/FTPolygonGlyph.cpp \
+    FTGlyph/FTTextureGlyph.cpp
+
+ftfont_sources = \
+    FTFont/FTFont.cpp \
+    FTFont/FTFontGlue.cpp \
+    FTFont/FTBitmapFont.cpp \
+    FTFont/FTBufferFont.cpp \
+    FTFont/FTExtrudeFont.cpp \
+    FTFont/FTOutlineFont.cpp \
+    FTFont/FTPixmapFont.cpp \
+    FTFont/FTPolygonFont.cpp \
+    FTFont/FTTextureFont.cpp
+
+ftlayout_sources = \
+    FTLayout/FTLayout.cpp \
+    FTLayout/FTLayoutGlue.cpp \
+    FTLayout/FTSimpleLayout.cpp
+    
+libftgl_la_SOURCES = \
+    FTBuffer.cpp \
+    FTCharmap.cpp \
+    FTContour.cpp \
+    FTFace.cpp \
+    FTGlyphContainer.cpp \
+    FTLibrary.cpp \
+    FTPoint.cpp \
+    FTSize.cpp \
+    FTVectoriser.cpp \
+    $(ftglyph_sources) \
+    $(ftfont_sources) \
+    $(ftlayout_sources)
+SRC := $(addprefix ftgl/, $(libftgl_la_SOURCES))
+    
+INCLUDES := ftgl freetype2
+DEFINES = FTGL_LIBRARY_STATIC
+USE_OPENGL = Yes
+LIBS = freetype
+
+ifneq ($(findstring dll, $(TEC_UNAME)), )
+  DEFINES = FTGL_LIBRARY
+  SRC += cd_ftgl.rc
+endif
+
+ifneq ($(findstring Win, $(TEC_SYSNAME)), )
+  LIBS = freetype6
+endif
+
+ifneq ($(findstring cygw, $(TEC_UNAME)), )
+  LIBS = freetype-6
+endif
diff --git a/src/cdgl.def b/src/cdgl.def
new file mode 100644
index 0000000..aea263b
--- /dev/null
+++ b/src/cdgl.def
@@ -0,0 +1,2 @@
+EXPORTS
+  cdContextGL
diff --git a/src/cdgl.mak b/src/cdgl.mak
new file mode 100644
index 0000000..47b15e4
--- /dev/null
+++ b/src/cdgl.mak
@@ -0,0 +1,16 @@
+PROJNAME = cd
+LIBNAME = cdgl
+OPT = YES
+
+DEFINES = CD_NO_OLD_INTERFACE
+SRC = drv/cdgl.c
+
+INCLUDES = . sim ftgl freetype2
+LIBS = ftgl
+ifneq ($(findstring Win, $(TEC_SYSNAME)), )
+  LIBS += iconv
+endif
+
+USE_OPENGL = YES
+USE_CD = YES
+CD = ..
diff --git a/src/drv/cdgl.c b/src/drv/cdgl.c
new file mode 100644
index 0000000..daec6f0
--- /dev/null
+++ b/src/drv/cdgl.c
@@ -0,0 +1,1398 @@
+/** \file
+ * \brief OpenGL Base Driver
+ *
+ * See Copyright Notice in cd.h
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#ifdef WIN32
+#include <windows.h>
+#else
+#include <iconv.h>
+#endif
+
+#include <GL/gl.h>
+#include <GL/glu.h>
+
+#include <FTGL/ftgl.h>
+
+#include "cd.h"
+#include "cd_private.h"
+#include "cdgl.h"
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+#define NUM_HATCHES  6
+#define HATCH_WIDTH  8
+#define HATCH_HEIGHT 8
+
+/* 
+** 6 predefined patterns to be accessed through cdHatch(
+CD_HORIZONTAL | CD_VERTICAL | CD_FDIAGONAL | CD_BDIAGONAL |
+CD_CROSS      | CD_DIAGCROSS)
+
+*/
+static char hatches[NUM_HATCHES][8] = {
+  {0x00,0x00,0xFF,0x00,0x00,0x00,0xFF,0x00},  /* HORIZONTAL */
+  {0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22},  /* VERTICAL */
+  {0x08,0x10,0x20,0x40,0x80,0x01,0x02,0x04},  /* FDIAGONAL */
+  {0x10,0x08,0x04,0x02,0x01,0x80,0x40,0x20},  /* BDIAGONAL */
+  {0x22,0x22,0xFF,0x22,0x22,0x22,0xFF,0x22},  /* CROSS */
+  {0x18,0x18,0x24,0x42,0x81,0x81,0x42,0x24}   /* DIAGCROSS */
+};
+
+struct _cdCtxImage
+{
+  unsigned int w, h, depth;
+  GLubyte* img;
+};
+
+struct _cdCtxCanvas
+{
+  cdCanvas* canvas;
+
+  FTGLfont *font;
+  char fontfilename[10240];
+
+  char* glLastConvertUTF8;
+
+  float rotate_angle;
+  int rotate_center_x;
+  int rotate_center_y;
+
+  int poly_holes[500];
+  int holes;
+};
+
+/******************************************************/
+
+static char* cdglStrConvertToUTF8(cdCtxCanvas *ctxcanvas, const char* str, unsigned int len)
+{
+  if (ctxcanvas->glLastConvertUTF8)
+    free(ctxcanvas->glLastConvertUTF8);
+
+#ifdef WIN32
+  {
+    wchar_t* toUnicode;
+
+    toUnicode = (wchar_t*)malloc((len+1) * sizeof(wchar_t));
+    MultiByteToWideChar(CP_ACP, 0, str, len+1, toUnicode, (len+1));
+
+    len = WideCharToMultiByte(CP_UTF8, 0, toUnicode, -1, NULL, 0, NULL, NULL);
+    if(!len)
+      return (char*)str;
+
+    ctxcanvas->glLastConvertUTF8 = (char*)malloc(len * sizeof(char));
+    WideCharToMultiByte(CP_UTF8, 0, toUnicode, -1, ctxcanvas->glLastConvertUTF8, len, NULL, NULL);
+
+    free(toUnicode);
+  }
+#else
+  {
+	  /* Based on http://www.lemoda.net/c/iconv-example/iconv-example.html
+		   Last access: June 15th, 2010. */
+    iconv_t cd;
+    unsigned int utf8len = len*2;
+    char* utf8 = calloc(utf8len, 1);
+
+    cd = iconv_open("UTF-8", "ISO-8859-1");
+    if(cd == (iconv_t)-1)
+      return (char*)str;
+
+    ctxcanvas->glLastConvertUTF8 = utf8;
+		iconv(cd, (char**)&str, &len, &utf8, &utf8len);
+
+		iconv_close(cd);
+  }
+#endif
+
+  return ctxcanvas->glLastConvertUTF8;
+}
+
+/******************************************************/
+
+static void cdkillcanvas(cdCtxCanvas *ctxcanvas)
+{
+  if(ctxcanvas->font)
+    ftglDestroyFont(ctxcanvas->font);
+
+  if (ctxcanvas->glLastConvertUTF8)
+    free(ctxcanvas->glLastConvertUTF8);
+
+  free(ctxcanvas);
+}
+
+/******************************************************/
+
+static void cdflush(cdCtxCanvas *ctxcanvas)
+{
+  glFlush();
+  (void)ctxcanvas;
+}
+
+/******************************************************/
+
+static int cdclip(cdCtxCanvas *ctxcanvas, int clip_mode)
+{
+  switch (clip_mode)
+  {
+  case CD_CLIPOFF:
+    if(glIsEnabled(GL_SCISSOR_TEST))
+      glDisable(GL_SCISSOR_TEST);
+    break;
+  case CD_CLIPAREA:
+    {
+      glEnable(GL_SCISSOR_TEST);
+      glScissor(ctxcanvas->canvas->clip_rect.xmin, ctxcanvas->canvas->clip_rect.ymin,
+                (ctxcanvas->canvas->clip_rect.xmax - ctxcanvas->canvas->clip_rect.xmin),
+                (ctxcanvas->canvas->clip_rect.ymax - ctxcanvas->canvas->clip_rect.ymin));
+      break;
+    }
+  case CD_CLIPPOLYGON:
+    break;
+  case CD_CLIPREGION:
+    break;
+  }
+
+  return clip_mode;
+}
+
+static void cdfcliparea(cdCtxCanvas *ctxcanvas, double xmin, double xmax, double ymin, double ymax)
+{
+  if (ctxcanvas->canvas->clip_mode == CD_CLIPAREA) 
+  {
+    ctxcanvas->canvas->clip_rect.xmin = (int)xmin;
+    ctxcanvas->canvas->clip_rect.ymin = (int)ymin;
+    ctxcanvas->canvas->clip_rect.xmax = (int)xmax;
+    ctxcanvas->canvas->clip_rect.ymax = (int)ymax;
+    cdclip(ctxcanvas, CD_CLIPAREA);
+  }
+}
+
+static void cdcliparea(cdCtxCanvas *ctxcanvas, int xmin, int xmax, int ymin, int ymax)
+{
+  cdfcliparea(ctxcanvas, (double)xmin, (double)xmax, (double)ymin, (double)ymax);
+}
+
+/******************************************************/
+
+static int cdwritemode(cdCtxCanvas *ctxcanvas, int write_mode)
+{
+  if(glIsEnabled(GL_COLOR_LOGIC_OP))
+    glDisable(GL_COLOR_LOGIC_OP);
+
+  switch (write_mode)
+  {
+  case CD_REPLACE:
+    glLogicOp(GL_COPY);
+    break;
+  case CD_XOR:
+    glLogicOp(GL_XOR);
+    break;
+  case CD_NOT_XOR:
+    glLogicOp(GL_EQUIV);
+    break;
+  }
+
+  glEnable(GL_COLOR_LOGIC_OP);
+
+  (void)ctxcanvas;
+  return write_mode;
+}
+
+static int cdhatch(cdCtxCanvas *ctxcanvas, int hatch_style)
+{
+  GLubyte pattern[128];
+  int x, y, pos = 0;
+ 
+  glEnable(GL_POLYGON_STIPPLE);
+ 
+  for (y = 0; y < 128; y+=8)
+  {
+    for (x = 0; x < 8; x++)
+      pattern[x+y] = hatches[hatch_style][pos];
+    pos++;
+
+    if(pos > 7) /* repeat the pattern */
+      pos = 0;
+  }
+  glPolygonStipple(pattern);
+
+  (void)ctxcanvas;
+  return hatch_style;
+}
+
+static void cdglEnableBackOpacity(cdCtxCanvas* ctxcanvas)
+{
+  if (ctxcanvas->canvas->back_opacity == CD_OPAQUE)
+  {
+    glColor4ub(cdRed(ctxcanvas->canvas->foreground), cdGreen(ctxcanvas->canvas->foreground), cdBlue(ctxcanvas->canvas->foreground), 255);
+
+    glDepthMask(GL_TRUE);
+
+    if(glIsEnabled(GL_DEPTH_TEST))
+      glDisable(GL_DEPTH_TEST);
+
+    if(glIsEnabled(GL_BLEND))
+      glDisable(GL_BLEND);
+  }
+  else
+  {
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    glEnable(GL_DEPTH_TEST);
+    glDepthMask(GL_FALSE);
+
+    glColor4ub(cdRed(ctxcanvas->canvas->foreground), cdGreen(ctxcanvas->canvas->foreground), cdBlue(ctxcanvas->canvas->foreground), 0);
+  }
+}
+
+static int cdinteriorstyle(cdCtxCanvas *ctxcanvas, int style)
+{
+  switch (style)
+  {
+  case CD_HOLLOW:
+    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+    break;
+  case CD_SOLID:
+  case CD_HATCH :
+  case CD_STIPPLE:
+  case CD_PATTERN:
+    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+    break;
+  }
+
+  switch (style)
+  {
+  case CD_HOLLOW:
+  case CD_SOLID:
+    if(glIsEnabled(GL_POLYGON_STIPPLE))
+      glDisable(GL_POLYGON_STIPPLE);
+    break;
+  case CD_HATCH:
+    cdglEnableBackOpacity(ctxcanvas);
+    cdhatch(ctxcanvas, ctxcanvas->canvas->hatch_style);
+    break;
+  case CD_STIPPLE:
+  case CD_PATTERN:
+    break;
+  }
+
+  return style;
+}
+
+static int cdlinestyle(cdCtxCanvas *ctxcanvas, int style)
+{
+  switch (style)
+  {
+  case CD_CONTINUOUS:
+    if(glIsEnabled(GL_LINE_STIPPLE))
+      glDisable(GL_LINE_STIPPLE);
+    return style;
+    break;
+  case CD_DASHED:
+  case CD_DOTTED:
+  case CD_DASH_DOT:
+  case CD_DASH_DOT_DOT:
+  case CD_CUSTOM:
+    glEnable(GL_LINE_STIPPLE);
+    cdglEnableBackOpacity(ctxcanvas);
+    break;
+  }
+
+  switch (style)
+  {
+  case CD_DASHED:
+    glLineStipple(1, 0x3F);
+    break;
+  case CD_DOTTED:
+    glLineStipple(1, 0x33);
+    break;
+  case CD_DASH_DOT:
+    glLineStipple(1, 0x33F);
+    break;
+  case CD_DASH_DOT_DOT:
+    glLineStipple(1, 0x333F);
+    break;
+  case CD_CUSTOM:
+    /* style patterns more than 16 bits are not completely drawed */
+    glLineStipple(1, (GLushort)*ctxcanvas->canvas->line_dashes);
+    break;
+  }
+
+  return style;
+}
+
+static int cdlinewidth(cdCtxCanvas *ctxcanvas, int width)
+{
+  if (width == 0) 
+    width = 1;
+
+  glLineWidth((GLfloat)width);
+
+  (void)ctxcanvas;
+  return width;
+}
+
+static int cdbackopacity(cdCtxCanvas *ctxcanvas, int opaque)
+{
+  ctxcanvas->canvas->back_opacity = opaque;
+  cdinteriorstyle(ctxcanvas, ctxcanvas->canvas->interior_style);
+  cdlinestyle(ctxcanvas, ctxcanvas->canvas->line_style);
+  return opaque;
+}
+
+/***********************************************************************************/
+/* Functions to get the font name path                                             */
+/* Base source = https://www.h3dapi.org:8090/H3DAPI/trunk/H3DAPI/src/FontStyle.cpp */
+/***********************************************************************************/
+#ifdef WIN32
+static LONG cdglWGetNextNameValue(HKEY key, LPCTSTR subkey, LPTSTR szName, LPTSTR szData)
+{
+  static HKEY hkey = NULL;
+  static DWORD dwIndex = 0;
+  LONG retval;
+
+  if (subkey == NULL && szName == NULL && szData == NULL)
+  {
+    if (hkey)
+      RegCloseKey(hkey);
+  
+    hkey = NULL;
+    return ERROR_SUCCESS;
+  }
+
+  if (subkey && subkey[0] != 0)
+  {
+    retval = RegOpenKeyEx(key, subkey, 0, KEY_READ, &hkey);
+    if (retval != ERROR_SUCCESS)
+      return retval;
+
+    dwIndex = 0;
+  }
+  else
+    dwIndex++;
+
+  *szName = 0;
+  *szData = 0;
+
+  {
+    char szValueName[MAX_PATH];
+    DWORD dwValueNameSize = sizeof(szValueName)-1;
+    BYTE szValueData[MAX_PATH];
+    DWORD dwValueDataSize = sizeof(szValueData)-1;
+    DWORD dwType = 0;
+
+    retval = RegEnumValue(hkey, dwIndex, szValueName, &dwValueNameSize, NULL, &dwType, szValueData, &dwValueDataSize);
+    if (retval == ERROR_SUCCESS)
+    {
+      lstrcpy(szName, (char *)szValueName);
+      lstrcpy(szData, (char *)szValueData);
+    }
+  }
+
+  return retval;
+}
+
+static int cdglWGetFontFileName(LPCTSTR lpszFontName, int bold, int italic, char* fileName)
+{
+  TCHAR szName[2 * MAX_PATH];
+  TCHAR szData[2 * MAX_PATH];
+  TCHAR displayName[2 * MAX_PATH];
+  LPCTSTR strFont = "Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts";
+  char localFontName[256];
+  int bResult = 0;
+
+  sprintf(localFontName, "%s", lpszFontName);
+
+  if( bold )
+    strcat(localFontName, " Bold");
+
+  if( italic )
+    strcat(localFontName, " Italic");
+
+  while (cdglWGetNextNameValue(HKEY_LOCAL_MACHINE, strFont, szName, szData) == ERROR_SUCCESS)
+  {
+    if (_strnicmp(localFontName, szName, strlen(localFontName)) == 0)
+    {
+      sprintf(displayName, "%s", szName);
+      sprintf(fileName, "%s", szData);
+      bResult = 1;
+      break;
+    }
+    strFont = "";
+  }
+  /* close the registry key */
+  cdglWGetNextNameValue(HKEY_LOCAL_MACHINE, NULL, NULL, NULL);
+
+  return bResult;
+}
+#else
+#include <fontconfig/fontconfig.h>
+
+static int cdglXGetFontFileName(const char *font_name, int bold, int italic, char* fileName)
+{
+  char styles[4][20];
+  int style_size;
+  FcObjectSet *os = 0;
+  FcFontSet *fs;
+  FcPattern *pat;
+  int bResult = 0;
+
+  if( bold && italic )
+  {
+    sprintf(styles[0], "%s", "BoldItalic");
+    sprintf(styles[1], "%s", "Bold Italic");
+    sprintf(styles[2], "%s", "Bold Oblique");
+    sprintf(styles[3], "%s", "BoldOblique");
+    style_size = 4;
+  }
+  else if( bold )
+  {
+    sprintf(styles[0], "%s", "Bold");
+    style_size = 1;
+  }
+  else if( italic )
+  {
+    sprintf(styles[0], "%s", "Italic");
+    sprintf(styles[1], "%s", "Oblique");
+    style_size = 2;
+  }
+  else
+  {
+    sprintf(styles[0], "%s", "Regular");
+    sprintf(styles[1], "%s", "Normal");
+    sprintf(styles[2], "%s", "Medium");
+    style_size = 3;
+  }
+
+  pat = FcPatternCreate();
+  os = FcObjectSetBuild(FC_FAMILY, FC_FILE, FC_STYLE, NULL);
+  fs = FcFontList(NULL, pat, os);
+  if (pat)
+    FcPatternDestroy(pat);
+
+  if(fs)
+  {
+    int j, s;
+
+    for (j = 0; j < fs->nfont; j++)
+    {
+      FcChar8 *file;
+      FcChar8 *style;
+      FcChar8 *family;
+
+      FcPatternGetString(fs->fonts[j], FC_FILE, 0, &file); 
+      FcPatternGetString(fs->fonts[j], FC_STYLE, 0, &style );
+      FcPatternGetString(fs->fonts[j], FC_FAMILY, 0, &family );
+
+      if (strncasecmp(font_name, (char*)family, strlen(font_name)) == 0)
+      {
+        /* check if the font is of the correct type. */
+        for(s = 0; s < style_size; s++ )
+        {
+          if (strcasecmp(styles[s], (char*)style ) == 0)
+          {
+            sprintf(fileName, "%s", (char*)file);
+            bResult = 1;
+            FcFontSetDestroy (fs);
+
+            return bResult;
+          }
+
+          /* set value to use if no more correct font of same family is found. */
+          sprintf(fileName, "%s", (char*)file);
+          bResult = 1;
+        }
+      }
+    }
+    FcFontSetDestroy (fs);
+  }
+
+  return bResult;
+}
+#endif
+
+static int cdfont(cdCtxCanvas *ctxcanvas, const char *typeface, int style, int size)
+{
+  int is_italic = 0, is_bold = 0;   /* default is CD_PLAIN */
+  char strFontFileName[256];
+
+  if (style & CD_BOLD)
+    is_bold = 1;
+
+  if (style & CD_ITALIC)
+    is_italic = 1;
+
+#ifdef WIN32
+  if (cdStrEqualNoCase(typeface, "Courier") || cdStrEqualNoCase(typeface, "Monospace"))
+    typeface = "Courier New";
+  else if (cdStrEqualNoCase(typeface, "Times") || cdStrEqualNoCase(typeface, "Serif"))
+    typeface = "Times New Roman";
+  else if (cdStrEqualNoCase(typeface, "Helvetica") || cdStrEqualNoCase(typeface, "Sans"))
+    typeface = "Arial";
+
+  if(!cdglWGetFontFileName(typeface, is_bold, is_italic, strFontFileName))
+    return 0;
+
+  sprintf(ctxcanvas->fontfilename, "%s\\fonts\\%s", getenv("windir"), strFontFileName);
+#else
+  if (cdStrEqualNoCase(typeface, "Courier") || cdStrEqualNoCase(typeface, "Courier New") || cdStrEqualNoCase(typeface, "Monospace"))
+    typeface = "freemono";
+  else if (cdStrEqualNoCase(typeface, "Times") || cdStrEqualNoCase(typeface, "Times New Roman")|| cdStrEqualNoCase(typeface, "Serif"))
+    typeface = "freeserif";
+  else if (cdStrEqualNoCase(typeface, "Helvetica") || cdStrEqualNoCase(typeface, "Arial") || cdStrEqualNoCase(typeface, "Sans"))
+    typeface = "freesans";
+
+  if(!cdglXGetFontFileName(typeface, is_bold, is_italic, strFontFileName))
+    return 0;
+
+  sprintf(ctxcanvas->fontfilename, "%s", strFontFileName);
+#endif
+
+  ctxcanvas->font = ftglCreateBufferFont(ctxcanvas->fontfilename);
+  
+  if (!ctxcanvas->font)
+    return 0;
+
+  if (size < 0)
+    size = cdGetFontSizePoints(ctxcanvas->canvas, size);
+
+  ftglSetFontFaceSize(ctxcanvas->font, size, 72);
+  ftglSetFontCharMap(ctxcanvas->font, ft_encoding_unicode);
+
+  return 1;
+}
+
+static void cdgetfontdim(cdCtxCanvas *ctxcanvas, int *max_width, int *height, int *ascent, int *descent)
+{
+  if(!ctxcanvas->font)
+    return;
+
+  if (max_width) *max_width = (int)ftglGetFontAdvance(ctxcanvas->font, "W");
+  if (height)    *height    = (int)ftglGetFontLineHeight(ctxcanvas->font);
+  if (ascent)    *ascent    = (int)ftglGetFontAscender(ctxcanvas->font);
+  if (descent)   *descent   = (int)ftglGetFontDescender(ctxcanvas->font);
+}
+
+static long int cdforeground(cdCtxCanvas *ctxcanvas, long int color)
+{
+  unsigned char r, g, b;
+  (void)ctxcanvas;
+
+  //TODO
+  if(glIsEnabled(GL_POLYGON_STIPPLE))
+    glDisable(GL_POLYGON_STIPPLE);
+
+  cdDecodeColor(color, &r, &g, &b);
+  glColor3ub(r, g, b);
+
+  return color;
+}
+
+static void cdclear(cdCtxCanvas* ctxcanvas)
+{
+  unsigned char r, g, b;
+  cdDecodeColor(ctxcanvas->canvas->background, &r, &g, &b);
+  glClearColor((GLclampf)((double)r/255.0), (GLclampf)((double)g/255.0), (GLclampf)((double)b/255.0), 0);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+static void cdfline(cdCtxCanvas *ctxcanvas, double x1, double y1, double x2, double y2)
+{
+  glBegin(GL_LINES);
+    glVertex2d(x1, y1);
+    glVertex2d(x2, y2);
+  glEnd();
+
+  (void)ctxcanvas;
+}
+
+static void cdline(cdCtxCanvas *ctxcanvas, int x1, int y1, int x2, int y2)
+{
+  cdfline(ctxcanvas, (double)x1, (double)y1, (double)x2, (double)y2);
+}
+
+static void cdfrect(cdCtxCanvas *ctxcanvas, double xmin, double xmax, double ymin, double ymax)
+{
+  glBegin(GL_LINE_LOOP);
+    glVertex2d(xmin, ymin);
+    glVertex2d(xmax, ymin);
+    glVertex2d(xmax, ymax);
+    glVertex2d(xmin, ymax);
+  glEnd();
+
+  (void)ctxcanvas;
+}
+
+static void cdrect(cdCtxCanvas *ctxcanvas, int xmin, int xmax, int ymin, int ymax)
+{
+  cdfrect(ctxcanvas, (double)xmin, (double)xmax, (double)ymin, (double)ymax);
+}
+
+static void cdfbox(cdCtxCanvas *ctxcanvas, double xmin, double xmax, double ymin, double ymax)
+{
+  glBegin(GL_QUADS);
+    glVertex2d(xmin, ymin);
+    glVertex2d(xmax, ymin);
+    glVertex2d(xmax, ymax);
+    glVertex2d(xmin, ymax);
+  glEnd();
+
+  (void)ctxcanvas;
+}
+
+static void cdbox(cdCtxCanvas *ctxcanvas, int xmin, int xmax, int ymin, int ymax)
+{
+  cdfbox(ctxcanvas, (double)xmin, (double)xmax, (double)ymin, (double)ymax);
+}
+
+static void cdftext(cdCtxCanvas *ctxcanvas, double x, double y, const char *s, int len)
+{
+  int dir = -1;
+  float bounds[6];
+  int w, h, desc;
+  double x_origin = x;
+  double y_origin = y;
+
+  if (!ctxcanvas->font)
+    return;
+
+  s = cdglStrConvertToUTF8(ctxcanvas, s, len);
+  ftglGetFontBBox(ctxcanvas->font, s, len, bounds);
+
+  desc = (int)ftglGetFontDescender(ctxcanvas->font);
+  w = (int)ceil(bounds[3] - bounds[0]);
+  h = (int)ceil(bounds[4] - bounds[1]);
+
+  switch (ctxcanvas->canvas->text_alignment)
+  {
+    case CD_BASE_RIGHT:
+    case CD_NORTH_EAST:
+    case CD_EAST:
+    case CD_SOUTH_EAST:
+      x = x - w;
+      break;
+    case CD_BASE_CENTER:
+    case CD_CENTER:
+    case CD_NORTH:
+    case CD_SOUTH:
+      x = x - w/2;
+      break;
+    case CD_BASE_LEFT:
+    case CD_NORTH_WEST:
+    case CD_WEST:
+    case CD_SOUTH_WEST:
+      x = x;
+      break;
+  }
+
+  if (ctxcanvas->canvas->invert_yaxis)
+    dir = 1;
+
+  switch (ctxcanvas->canvas->text_alignment)
+  {
+    case CD_BASE_LEFT:
+    case CD_BASE_CENTER:
+    case CD_BASE_RIGHT:
+      y = y;
+      break;
+    case CD_SOUTH_EAST:
+    case CD_SOUTH_WEST:
+    case CD_SOUTH:
+      y = y + dir * desc;
+      break;
+    case CD_NORTH_EAST:
+    case CD_NORTH:
+    case CD_NORTH_WEST:
+      y = y + dir * (h + desc);
+      break;
+    case CD_CENTER:
+    case CD_EAST:
+    case CD_WEST:
+      y = y + dir * (h / 2);
+      break;
+  }
+
+  if (ctxcanvas->canvas->text_orientation != 0)
+  {
+    double angle = CD_DEG2RAD * ctxcanvas->canvas->text_orientation;
+    double cos_angle = cos(angle);
+    double sin_angle = sin(angle);
+    cdfRotatePoint(ctxcanvas->canvas, x, y, x_origin, y_origin, &x, &y, sin_angle, cos_angle);
+  }
+
+  glPushMatrix();
+    glTranslated(x, y, 0.0);
+    glRotated(ctxcanvas->canvas->text_orientation, 0, 0, 1);
+
+    /* FTGL not operate as expected when a logical pixel operation (write mode) is enabled. */
+    if(glIsEnabled(GL_COLOR_LOGIC_OP))
+    {
+      glDisable(GL_COLOR_LOGIC_OP);
+      ftglRenderFont(ctxcanvas->font, s, FTGL_RENDER_ALL);
+      glEnable(GL_COLOR_LOGIC_OP);
+    }
+    else
+      ftglRenderFont(ctxcanvas->font, s, FTGL_RENDER_ALL);
+  glPopMatrix();
+}
+
+static void cdtext(cdCtxCanvas *ctxcanvas, int x, int y, const char *s, int len)
+{
+  cdftext(ctxcanvas, (double)x, (double)y, s, len);
+}
+
+static void cdgettextsize(cdCtxCanvas *ctxcanvas, const char *s, int len, int *width, int *height)
+{
+  float bounds[6];
+
+  if (!ctxcanvas->font)
+    return;
+
+  s = cdglStrConvertToUTF8(ctxcanvas, s, len);
+  ftglGetFontBBox(ctxcanvas->font, s, len, bounds);
+
+  if (width)  *width  = (int)ceil(bounds[3] - bounds[0]);
+  if (height) *height = (int)ceil(bounds[4] - bounds[1]);
+}
+
+static void cdpoly(cdCtxCanvas *ctxcanvas, int mode, cdPoint* poly, int n)
+{
+  int i;
+  
+  if (mode == CD_CLIP)
+    return;
+
+  if (mode == CD_BEZIER)
+  {
+    int i, prec = 100;
+    float (*points)[3] = malloc(n * sizeof(*points));
+
+    for(i = 0; i < n; i++)
+    {
+      points[i][0] = (float)poly[i].x;
+      points[i][1] = (float)poly[i].y;
+      points[i][2] = 0;
+    }
+
+    glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, n, &points[0][0]);
+    glEnable(GL_MAP1_VERTEX_3);
+    glMapGrid1f(prec, 0.0, 1.0);
+    glEvalMesh1(GL_LINE, 0, prec);
+    glDisable(GL_MAP1_VERTEX_3);
+
+    return;
+  }
+
+  if (mode == CD_PATH)
+  {
+    cdSimPolyPath(ctxcanvas->canvas, poly, n);
+    return;
+  }
+
+  switch (mode)
+  {
+  case CD_CLOSED_LINES :
+    glBegin(GL_LINE_LOOP);
+    break;
+  case CD_OPEN_LINES :
+    glBegin(GL_LINE_STRIP);
+    break;
+  case CD_FILL :
+    glBegin(GL_POLYGON);
+    break;
+  }
+
+  for(i = 0; i < n; i++)
+    glVertex2i(poly[i].x, poly[i].y);
+  glEnd();
+
+  (void)ctxcanvas;
+}
+
+static void cdfpoly(cdCtxCanvas *ctxcanvas, int mode, cdfPoint* poly, int n)
+{
+  int i;
+
+  if (mode == CD_CLIP)
+    return;
+
+  if (mode == CD_BEZIER)
+  {
+    int i, prec = 100;
+    double (*points)[3] = malloc(n * sizeof(*points));
+
+    for(i = 0; i < n; i++)
+    {
+      points[i][0] = poly[i].x;
+      points[i][1] = poly[i].y;
+      points[i][2] = 0;
+    }
+
+    glMap1d(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, n, &points[0][0]);
+    glEnable(GL_MAP1_VERTEX_3);
+    glMapGrid1d(prec, 0.0, 1.0);
+    glEvalMesh1(GL_LINE, 0, prec);
+    glDisable(GL_MAP1_VERTEX_3);
+
+    return;
+  }
+
+  if (mode == CD_PATH)
+  {
+    cdfSimPolyPath(ctxcanvas->canvas, poly, n);
+    return;
+  }
+
+  switch (mode)
+  {
+  case CD_CLOSED_LINES :
+    glBegin(GL_LINE_LOOP);
+    break;
+  case CD_OPEN_LINES :
+    glBegin(GL_LINE_STRIP);
+    break;
+  case CD_FILL :
+    glBegin(GL_POLYGON);
+    break;
+  }
+
+  for(i = 0; i < n; i++)
+    glVertex2d(poly[i].x, poly[i].y);
+  glEnd();
+
+  (void)ctxcanvas;
+}
+
+/******************************************************/
+
+static void cdglGetImageData(GLubyte* glImage, unsigned char *r, unsigned char *g, unsigned char *b, int w, int h)
+{
+  int y, x;
+  unsigned char *pixline_data;
+  int rowstride, channels = 3;
+
+  rowstride = w * channels;
+
+  /* planes are separated in image data */
+  for (y = 0; y < h; y++)
+  {
+    int lineoffset = y * w;
+    pixline_data = (unsigned char*)glImage + y * rowstride;
+    for(x = 0; x < w; x++)
+    {
+      int pos = x*channels;
+      r[lineoffset+x] = pixline_data[pos];
+      g[lineoffset+x] = pixline_data[pos+1];
+      b[lineoffset+x] = pixline_data[pos+2];
+    }
+  }
+}
+
+static GLubyte* cdglCreateImageRGBA(int width, int height, const unsigned char *r, const unsigned char *g, const unsigned char *b, const unsigned char *a, int image_width)
+{
+  GLubyte* pixline_data;
+  GLubyte* glImage;
+  int x, y;
+  int channels = a ? 4 : 3;
+  int rowstride = width * channels;
+  int lineoffset;
+
+  glImage = (GLubyte*)malloc(rowstride * height);
+
+  /* planes are separated in image data */
+  for (y = 0; y < height; y++)
+  {
+    lineoffset = y * image_width;
+    pixline_data = glImage + y * rowstride;
+
+    for(x=0;x<width;x++)
+    {
+      int pos = x*channels;
+      pixline_data[pos]   = r[lineoffset+x];
+      pixline_data[pos+1] = g[lineoffset+x];
+      pixline_data[pos+2] = b[lineoffset+x];
+
+      if (a)
+        pixline_data[pos+3] = a[lineoffset+x];
+    }
+  }
+
+  return glImage;
+}
+
+static GLubyte* cdglCreateImageMap(int width, int height, const long* colors, const unsigned char *map, int image_width)
+{
+  const GLubyte *line_data;
+  GLubyte *pixline_data;
+  GLubyte *glImage;
+  int x, y, channels = 3;
+  int rowstride = width * channels;
+
+  glImage = (GLubyte*)malloc(rowstride * height);
+
+  for (y = 0; y < height; y++)
+  {
+    pixline_data = glImage + y * rowstride;
+    line_data = map + y * image_width;
+
+    for (x=0; x<width; x++)
+    {
+      GLubyte index = line_data[x];
+      long c = colors[index];
+      GLubyte *r = &pixline_data[channels*x],
+              *g = r+1,
+              *b = g+1;
+
+      *r = cdRed(c);
+      *g = cdGreen(c);
+      *b = cdBlue(c);
+    }
+  }
+
+  return glImage;
+}
+
+static void cdgetimagergb(cdCtxCanvas *ctxcanvas, unsigned char *r, unsigned char *g, unsigned char *b, int x, int y, int w, int h)
+{
+  GLubyte* glImage = (GLubyte*)malloc((w*3)*h);  /* each pixel uses 3 bytes (RGB) */
+
+  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
+  glReadPixels(x, y, w, h, GL_RGB, GL_UNSIGNED_BYTE, glImage);
+  if (!glImage)
+    return;
+
+  cdglGetImageData(glImage, r, g, b, w, h);
+
+  (void)ctxcanvas;
+
+  free(glImage);
+}
+
+static void cdputimagerectrgb(cdCtxCanvas *ctxcanvas, int iw, int ih, const unsigned char *r, const unsigned char *g, const unsigned char *b, int x, int y, int w, int h, int xmin, int xmax, int ymin, int ymax)
+{
+  /* Images are bitmaps, and cannot be directly rotated or scaled */
+  GLubyte* glImage;
+  int rw = xmax-xmin+1;
+  int rh = ymax-ymin+1;
+
+  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
+
+  glImage = cdglCreateImageRGBA(rw, rh, r, g, b, NULL, iw);
+  if (!glImage)
+    return;
+
+  /* adjusts when the initial position (x,y) are less than 0 */
+  if(x < 0)
+  {
+    w -= x;
+    x = 0;
+  }
+
+  if(y < 0)
+  {
+    h -= y;
+    y = 0;
+  }
+
+  if (w != rw || w != rh)
+    glPixelZoom((GLfloat)w/rw, (GLfloat)h/rh);
+
+  glRasterPos2i(x, y);
+  glDrawPixels(rw, rh, GL_RGB, GL_UNSIGNED_BYTE, glImage);
+
+  (void)ih;
+  (void)ctxcanvas;
+
+  free(glImage);
+}
+
+static void cdputimagerectrgba(cdCtxCanvas *ctxcanvas, int iw, int ih, const unsigned char *r, const unsigned char *g, const unsigned char *b, const unsigned char *a, int x, int y, int w, int h, int xmin, int xmax, int ymin, int ymax)
+{
+  /* Images are bitmaps, and cannot be directly rotated or scaled */
+  GLubyte* glImage;
+  int rw = xmax-xmin+1;
+  int rh = ymax-ymin+1;
+
+  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
+
+  glImage = cdglCreateImageRGBA(rw, rh, r, g, b, a, iw);
+  if (!glImage)
+    return;
+
+  /* adjusts when the initial position (x,y) are less than 0 */
+  if(x < 0)
+  {
+    w -= x;
+    x = 0;
+  }
+
+  if(y < 0)
+  {
+    h -= y;
+    y = 0;
+  }
+
+  if (w != rw || h != rh)
+    glPixelZoom((GLfloat)w/rw, (GLfloat)h/rh);
+
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  glRasterPos2i(x, y);
+
+  if(glIsEnabled(GL_COLOR_LOGIC_OP))
+  {
+    glDisable(GL_COLOR_LOGIC_OP);
+    glDrawPixels(rw, rh, GL_RGBA, GL_UNSIGNED_BYTE, glImage);
+    glEnable(GL_COLOR_LOGIC_OP);
+  }
+  else
+    glDrawPixels(rw, rh, GL_RGBA, GL_UNSIGNED_BYTE, glImage);
+
+  glDisable(GL_BLEND);
+
+  (void)ih;
+  (void)ctxcanvas;
+
+  free(glImage);
+}
+
+static void cdputimagerectmap(cdCtxCanvas *ctxcanvas, int iw, int ih, const unsigned char *index, const long int *colors, int x, int y, int w, int h, int xmin, int xmax, int ymin, int ymax)
+{
+  /* Images are bitmaps, and cannot be directly rotated or scaled */
+  GLubyte* glImage;
+  int rw = xmax-xmin+1;
+  int rh = ymax-ymin+1;
+
+  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
+
+  glImage = cdglCreateImageMap(rw, rh, colors, index, iw);
+  if (!glImage)
+    return;
+
+  /* adjusts when the initial position (x,y) are less than 0 */
+  if(x < 0)
+  {
+    w -= x;
+    x = 0;
+  }
+
+  if(y < 0)
+  {
+    h -= y;
+    y = 0;
+  }
+
+  if (w != rw || h != rh)
+    glPixelZoom((GLfloat)w/rw, (GLfloat)h/rh);
+
+  glRasterPos2i(x, y);
+  glDrawPixels(rw, rh, GL_RGB, GL_UNSIGNED_BYTE, glImage);
+
+  (void)ih;
+  (void)ctxcanvas;
+
+  free(glImage);
+}
+
+static void cdpixel(cdCtxCanvas *ctxcanvas, int x, int y, long int color)
+{
+  glColor3ub(cdRed(color), cdGreen(color), cdBlue(color));
+
+  /* Draw pixel */
+  glPointSize(1);
+  glBegin(GL_POINTS);
+    glVertex2i(x, y);
+  glEnd();
+
+  /* restore the foreground color */
+  glColor3ub(cdRed(ctxcanvas->canvas->foreground), cdGreen(ctxcanvas->canvas->foreground), cdBlue(ctxcanvas->canvas->foreground));
+
+  (void)ctxcanvas;
+}
+
+static cdCtxImage *cdcreateimage (cdCtxCanvas *ctxcanvas, int w, int h)
+{
+  cdCtxImage *ctximage = (cdCtxImage *)malloc(sizeof(cdCtxImage));
+
+  ctximage->w = w;
+  ctximage->h = h;
+  ctximage->depth = ctxcanvas->canvas->bpp;
+
+  ctximage->img = (GLubyte*)malloc(w*h*4);  /* each pixel uses 4 bytes (RGBA) */
+
+  if (!ctximage->img)
+  {
+    free(ctximage);
+    return (void*)0;
+  }
+
+  return (void*)ctximage;
+}
+
+static void cdgetimage (cdCtxCanvas *ctxcanvas, cdCtxImage *ctximage, int x, int y)
+{
+  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
+  glReadPixels(x, y - ctximage->h+1, ctximage->w, ctximage->h, GL_RGBA, GL_UNSIGNED_BYTE, ctximage->img);
+
+  (void)ctxcanvas;
+}
+
+static void cdputimagerect (cdCtxCanvas *ctxcanvas, cdCtxImage *ctximage, int x, int y, int xmin, int xmax, int ymin, int ymax)
+{
+  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
+  glRasterPos2i(x, y);
+  glDrawPixels(xmax-xmin+1, ymax-ymin+1, GL_RGBA, GL_UNSIGNED_BYTE, ctximage->img);
+
+  (void)ctxcanvas;
+}
+
+static void cdkillimage (cdCtxImage *ctximage)
+{
+  free(ctximage->img);
+  free(ctximage);
+}
+
+static void cdscrollarea (cdCtxCanvas *ctxcanvas, int xmin, int xmax, int ymin, int ymax, int dx, int dy)
+{
+  glRasterPos2i(xmin+dx, ymin+dy);
+  glCopyPixels(xmin, ymin, xmax-xmin+1, ymax-ymin+1, GL_RGBA);
+
+  (void)ctxcanvas;
+}
+
+static void cdtransform(cdCtxCanvas *ctxcanvas, const double* matrix)
+{
+  if (matrix)
+  {
+    GLdouble transformMTX[4][4];
+
+    transformMTX[0][0] = matrix[0];   transformMTX[0][1] = matrix[1];   transformMTX[0][2] = 0.0;         transformMTX[0][3] = 0.0;
+    transformMTX[1][0] = matrix[2];   transformMTX[1][1] = matrix[3];   transformMTX[1][2] = 0.0;         transformMTX[1][3] = 0.0;
+    transformMTX[2][0] = 0.0;         transformMTX[2][1] = 0.0;         transformMTX[2][2] = 1.0;         transformMTX[2][3] = 0.0;
+    transformMTX[3][0] = matrix[4];   transformMTX[3][1] = matrix[5];   transformMTX[3][2] = 0.0;         transformMTX[3][3] = 1.0;
+
+    glLoadIdentity();
+    glMultMatrixd(&transformMTX[0][0]);
+  }
+
+  (void)ctxcanvas;
+}
+
+/******************************************************************/
+
+static void set_poly_attrib(cdCtxCanvas *ctxcanvas, char* data)
+{
+  int hole;
+
+  if (data == NULL)
+  {
+    ctxcanvas->holes = 0;
+    return;
+  }
+
+  sscanf(data, "%d", &hole);
+  ctxcanvas->poly_holes[ctxcanvas->holes] = hole;
+  ctxcanvas->holes++;
+}
+
+static char* get_poly_attrib(cdCtxCanvas *ctxcanvas)
+{
+  static char holes[10];
+  sprintf(holes, "%d", ctxcanvas->holes);
+  return holes;
+}
+
+static cdAttribute poly_attrib =
+{
+  "POLYHOLE",
+  set_poly_attrib,
+  get_poly_attrib
+}; 
+
+static void set_rotate_attrib(cdCtxCanvas* ctxcanvas, char* data)
+{
+  if (data)
+  {
+    sscanf(data, "%g %d %d", &ctxcanvas->rotate_angle,
+                             &ctxcanvas->rotate_center_x,
+                             &ctxcanvas->rotate_center_y);
+
+    cdCanvasTransformTranslate(ctxcanvas->canvas, ctxcanvas->rotate_center_x, ctxcanvas->rotate_center_y);
+    cdCanvasTransformRotate(ctxcanvas->canvas, ctxcanvas->rotate_angle);
+    cdCanvasTransformTranslate(ctxcanvas->canvas, -ctxcanvas->rotate_center_x, -ctxcanvas->rotate_center_y);
+  }
+  else
+  {
+    ctxcanvas->rotate_angle = 0;
+    ctxcanvas->rotate_center_x = 0;
+    ctxcanvas->rotate_center_y = 0;
+
+    cdCanvasTransform(ctxcanvas->canvas, NULL);
+  }
+}
+
+static char* get_rotate_attrib(cdCtxCanvas* ctxcanvas)
+{
+  static char data[100];
+
+  if (!ctxcanvas->rotate_angle)
+    return NULL;
+
+  sprintf(data, "%g %d %d", (double)ctxcanvas->rotate_angle,
+                            ctxcanvas->rotate_center_x,
+                            ctxcanvas->rotate_center_y);
+
+  return data;
+}
+
+static cdAttribute rotate_attrib =
+{
+  "ROTATE",
+  set_rotate_attrib,
+  get_rotate_attrib
+};
+
+static void set_size_attrib(cdCtxCanvas* ctxcanvas, char* data)
+{
+  if (data)
+  {
+    cdCanvas* canvas = ctxcanvas->canvas;
+    float res = (float)canvas->xres;
+    sscanf(data, "%dx%d %g", &canvas->w, &canvas->h, &res);
+    canvas->yres = canvas->xres = res;
+    canvas->w_mm = ((double)canvas->w) / canvas->xres;
+    canvas->h_mm = ((double)canvas->h) / canvas->yres;
+  }
+}
+
+static cdAttribute size_attrib =
+{
+  "SIZE",
+  set_size_attrib,
+  NULL
+};
+
+static char* get_version_attrib(cdCtxCanvas* ctxcanvas)
+{
+  (void)ctxcanvas;
+  return (char*)glGetString(GL_VERSION);
+}
+
+static cdAttribute version_attrib =
+{
+  "GLVERSION",
+  NULL,
+  get_version_attrib
+};
+
+static void cdcreatecanvas(cdCanvas* canvas, void *data)
+{
+  cdCtxCanvas* ctxcanvas;
+  int w = 0, h = 0;
+  float res = (float)3.78;
+  char* str_data = (char*)data;
+
+  sscanf(str_data, "%dx%d %g", &w, &h, &res);
+
+  if (w == 0 || h == 0)
+    return;
+
+  ctxcanvas = (cdCtxCanvas *)malloc(sizeof(cdCtxCanvas));
+  memset(ctxcanvas, 0, sizeof(cdCtxCanvas));
+
+  canvas->xres = res;
+  canvas->yres = res;
+
+  canvas->w_mm = ((double)canvas->w) / canvas->xres;
+  canvas->h_mm = ((double)canvas->h) / canvas->yres;
+
+  ctxcanvas->canvas = canvas;
+  canvas->ctxcanvas = ctxcanvas;
+
+  ctxcanvas->glLastConvertUTF8 = NULL;
+
+  cdRegisterAttribute(canvas, &rotate_attrib);
+  cdRegisterAttribute(canvas, &version_attrib);
+  cdRegisterAttribute(canvas, &poly_attrib);
+  cdRegisterAttribute(canvas, &size_attrib);
+}
+
+static void cdinittable(cdCanvas* canvas)
+{
+  canvas->cxFlush = cdflush;
+  canvas->cxClear = cdclear;
+  
+  canvas->cxPixel  = cdpixel;
+  canvas->cxLine   = cdline;
+  canvas->cxPoly   = cdpoly;
+  canvas->cxRect   = cdrect;
+  canvas->cxBox    = cdbox;
+  canvas->cxArc = cdSimArc;
+  canvas->cxSector = cdSimSector;
+  canvas->cxChord = cdSimChord;
+
+  canvas->cxText = cdtext;
+  canvas->cxFont = cdfont;
+  canvas->cxGetFontDim  = cdgetfontdim;
+  canvas->cxGetTextSize = cdgettextsize;
+
+  canvas->cxClip = cdclip;
+  canvas->cxClipArea = cdcliparea;
+  canvas->cxWriteMode = cdwritemode;
+  canvas->cxLineStyle = cdlinestyle;
+  canvas->cxLineWidth = cdlinewidth;
+  canvas->cxBackOpacity   = cdbackopacity;
+  canvas->cxInteriorStyle = cdinteriorstyle;
+  canvas->cxHatch = cdhatch;
+  canvas->cxForeground = cdforeground;
+  canvas->cxTransform  = cdtransform;
+
+  canvas->cxFLine = cdfline;
+  canvas->cxFPoly = cdfpoly;
+  canvas->cxFRect = cdfrect;
+  canvas->cxFBox = cdfbox;
+  canvas->cxFArc = cdfSimArc;
+  canvas->cxFSector = cdfSimSector;
+  canvas->cxFChord = cdfSimChord;
+  canvas->cxFText = cdftext;
+  canvas->cxFClipArea = cdfcliparea;
+
+  canvas->cxScrollArea = cdscrollarea;
+  canvas->cxCreateImage = cdcreateimage;
+  canvas->cxGetImage = cdgetimage;
+  canvas->cxPutImageRect = cdputimagerect;
+  canvas->cxKillImage = cdkillimage;
+
+  canvas->cxGetImageRGB = cdgetimagergb;
+  canvas->cxPutImageRectRGB = cdputimagerectrgb;
+  canvas->cxPutImageRectMap = cdputimagerectmap;
+  canvas->cxPutImageRectRGBA = cdputimagerectrgba;
+
+  canvas->cxKillCanvas = cdkillcanvas;
+}
+
+static cdContext cdGLContext =
+{
+  CD_CAP_ALL & ~(CD_CAP_PLAY | CD_CAP_PALETTE | CD_CAP_LINEJOIN | CD_CAP_LINECAP |
+                 CD_CAP_REGION | CD_CAP_STIPPLE | CD_CAP_PATTERN),
+  0,
+  cdcreatecanvas,
+  cdinittable,
+  NULL,              
+  NULL,
+};
+
+cdContext* cdContextGL(void)
+{
+  return &cdGLContext;
+}
diff --git a/src/ftgl/FTBuffer.cpp b/src/ftgl/FTBuffer.cpp
new file mode 100644
index 0000000..3815bb1
--- /dev/null
+++ b/src/ftgl/FTBuffer.cpp
@@ -0,0 +1,69 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+
+FTBuffer::FTBuffer()
+ : width(0),
+   height(0),
+   pixels(0),
+   pos(FTPoint())
+{
+}
+
+
+FTBuffer::~FTBuffer()
+{
+    if(pixels)
+    {
+        delete[] pixels;
+    }
+}
+
+
+void FTBuffer::Size(int w, int h)
+{
+    if(w == width && h == height)
+    {
+        return;
+    }
+
+    if(w * h != width * height)
+    {
+        if(pixels)
+        {
+            delete[] pixels;
+        }
+        pixels = new unsigned char[w * h];
+    }
+
+    memset(pixels, 0, w * h);
+    width = w;
+    height = h;
+}
+
diff --git a/src/ftgl/FTCharToGlyphIndexMap.h b/src/ftgl/FTCharToGlyphIndexMap.h
new file mode 100644
index 0000000..3aa10a1
--- /dev/null
+++ b/src/ftgl/FTCharToGlyphIndexMap.h
@@ -0,0 +1,155 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef    __FTCharToGlyphIndexMap__
+#define    __FTCharToGlyphIndexMap__
+
+#include <stdlib.h>
+
+#include "FTGL/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 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__
diff --git a/src/ftgl/FTCharmap.cpp b/src/ftgl/FTCharmap.cpp
new file mode 100644
index 0000000..64a2180
--- /dev/null
+++ b/src/ftgl/FTCharmap.cpp
@@ -0,0 +1,106 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTFace.h"
+#include "FTCharmap.h"
+
+
+FTCharmap::FTCharmap(FTFace* face)
+:   ftFace(*(face->Face())),
+    err(0)
+{
+    if(!ftFace->charmap)
+    {
+        if(!ftFace->num_charmaps)
+        {
+            // This face doesn't even have one charmap!
+            err = 0x96; // Invalid_CharMap_Format
+            return;
+        }
+
+        err = FT_Set_Charmap(ftFace, ftFace->charmaps[0]);
+    }
+
+    ftEncoding = ftFace->charmap->encoding;
+
+    for(unsigned int i = 0; i < FTCharmap::MAX_PRECOMPUTED; i++)
+    {
+        charIndexCache[i] = FT_Get_Char_Index(ftFace, i);
+    }
+}
+
+
+FTCharmap::~FTCharmap()
+{
+    charMap.clear();
+}
+
+
+bool FTCharmap::CharMap(FT_Encoding encoding)
+{
+    if(ftEncoding == encoding)
+    {
+        err = 0;
+        return true;
+    }
+
+    err = FT_Select_Charmap(ftFace, encoding);
+
+    if(!err)
+    {
+        ftEncoding = encoding;
+        charMap.clear();
+    }
+
+    return !err;
+}
+
+
+unsigned int FTCharmap::GlyphListIndex(const unsigned int characterCode)
+{
+    return charMap.find(characterCode);
+}
+
+
+unsigned int FTCharmap::FontIndex(const unsigned int characterCode)
+{
+    if(characterCode < FTCharmap::MAX_PRECOMPUTED)
+    {
+        return charIndexCache[characterCode];
+    }
+
+    return FT_Get_Char_Index(ftFace, characterCode);
+}
+
+
+void FTCharmap::InsertIndex(const unsigned int characterCode,
+                            const size_t containerIndex)
+{
+    charMap.insert(characterCode, static_cast<FTCharToGlyphIndexMap::GlyphIndex>(containerIndex));
+}
+
diff --git a/src/ftgl/FTCharmap.h b/src/ftgl/FTCharmap.h
new file mode 100644
index 0000000..f4ce867
--- /dev/null
+++ b/src/ftgl/FTCharmap.h
@@ -0,0 +1,165 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef     __FTCharmap__
+#define     __FTCharmap__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL/ftgl.h"
+#include "FTCharToGlyphIndexMap.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 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. If an error occurs the object is not modified.
+         * 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.
+         */
+        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 size_t 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;
+
+        /**
+         * Precomputed font indices.
+         */
+        static const unsigned int MAX_PRECOMPUTED = 128;
+        unsigned int charIndexCache[MAX_PRECOMPUTED];
+
+        /**
+         * Current error code.
+         */
+        FT_Error err;
+};
+
+
+#endif  //  __FTCharmap__
diff --git a/src/ftgl/FTContour.cpp b/src/ftgl/FTContour.cpp
new file mode 100644
index 0000000..cef1f3b
--- /dev/null
+++ b/src/ftgl/FTContour.cpp
@@ -0,0 +1,245 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Éric Beets <ericbeets@free.fr>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTContour.h"
+
+#include <math.h>
+
+static const unsigned int BEZIER_STEPS = 5;
+
+
+void FTContour::AddPoint(FTPoint point)
+{
+    if(pointList.empty() || (point != pointList[pointList.size() - 1]
+                              && point != pointList[0]))
+    {
+        pointList.push_back(point);
+    }
+}
+
+
+void FTContour::AddOutsetPoint(FTPoint point)
+{
+    outsetPointList.push_back(point);
+}
+
+
+void FTContour::AddFrontPoint(FTPoint point)
+{
+    frontPointList.push_back(point);
+}
+
+
+void FTContour::AddBackPoint(FTPoint point)
+{
+    backPointList.push_back(point);
+}
+
+
+void FTContour::evaluateQuadraticCurve(FTPoint A, FTPoint B, FTPoint C)
+{
+    for(unsigned int i = 1; i < BEZIER_STEPS; i++)
+    {
+        float t = static_cast<float>(i) / BEZIER_STEPS;
+
+        FTPoint U = (1.0f - t) * A + t * B;
+        FTPoint V = (1.0f - t) * B + t * C;
+
+        AddPoint((1.0f - t) * U + t * V);
+    }
+}
+
+
+void FTContour::evaluateCubicCurve(FTPoint A, FTPoint B, FTPoint C, FTPoint D)
+{
+    for(unsigned int i = 0; i < BEZIER_STEPS; i++)
+    {
+        float t = static_cast<float>(i) / BEZIER_STEPS;
+
+        FTPoint U = (1.0f - t) * A + t * B;
+        FTPoint V = (1.0f - t) * B + t * C;
+        FTPoint W = (1.0f - t) * C + t * D;
+
+        FTPoint M = (1.0f - t) * U + t * V;
+        FTPoint N = (1.0f - t) * V + t * W;
+
+        AddPoint((1.0f - t) * M + t * N);
+    }
+}
+
+
+// This function is a bit tricky. Given a path ABC, it returns the
+// coordinates of the outset point facing B on the left at a distance
+// of 64.0.
+//                                         M
+//                            - - - - - - X
+//                             ^         / '
+//                             | 64.0   /   '
+//  X---->-----X     ==>    X--v-------X     '
+// A          B \          A          B \   .>'
+//               \                       \<'  64.0
+//                \                       \                  .
+//                 \                       \                 .
+//                C X                     C X
+//
+FTPoint FTContour::ComputeOutsetPoint(FTPoint A, FTPoint B, FTPoint C)
+{
+    /* Build the rotation matrix from 'ba' vector */
+    FTPoint ba = (A - B).Normalise();
+    FTPoint bc = C - B;
+
+    /* Rotate bc to the left */
+    FTPoint tmp(bc.X() * -ba.X() + bc.Y() * -ba.Y(),
+                bc.X() * ba.Y() + bc.Y() * -ba.X());
+
+    /* Compute the vector bisecting 'abc' */
+    FTGL_DOUBLE norm = sqrt(tmp.X() * tmp.X() + tmp.Y() * tmp.Y());
+    FTGL_DOUBLE dist = 64.0 * sqrt((norm - tmp.X()) / (norm + tmp.X()));
+    tmp.X(tmp.Y() < 0.0 ? dist : -dist);
+    tmp.Y(64.0);
+
+    /* Rotate the new bc to the right */
+    return FTPoint(tmp.X() * -ba.X() + tmp.Y() * ba.Y(),
+                   tmp.X() * -ba.Y() + tmp.Y() * -ba.X());
+}
+
+
+void FTContour::SetParity(int parity)
+{
+    size_t size = PointCount();
+    FTPoint vOutset;
+
+    if(((parity & 1) && clockwise) || (!(parity & 1) && !clockwise))
+    {
+        // Contour orientation is wrong! We must reverse all points.
+        // FIXME: could it be worth writing FTVector::reverse() for this?
+        for(size_t i = 0; i < size / 2; i++)
+        {
+            FTPoint tmp = pointList[i];
+            pointList[i] = pointList[size - 1 - i];
+            pointList[size - 1 -i] = tmp;
+        }
+
+        clockwise = !clockwise;
+    }
+
+    for(size_t i = 0; i < size; i++)
+    {
+        size_t prev, cur, next;
+
+        prev = (i + size - 1) % size;
+        cur = i;
+        next = (i + size + 1) % size;
+
+        vOutset = ComputeOutsetPoint(Point(prev), Point(cur), Point(next));
+        AddOutsetPoint(vOutset);
+    }
+}
+
+
+FTContour::FTContour(FT_Vector* contour, char* tags, unsigned int n)
+{
+    FTPoint prev, cur(contour[(n - 1) % n]), next(contour[0]);
+    FTPoint a, b = next - cur;
+    double olddir, dir = atan2((next - cur).Y(), (next - cur).X());
+    double angle = 0.0;
+
+    // See http://freetype.sourceforge.net/freetype2/docs/glyphs/glyphs-6.html
+    // for a full description of FreeType tags.
+    for(unsigned int i = 0; i < n; i++)
+    {
+        prev = cur;
+        cur = next;
+        next = FTPoint(contour[(i + 1) % n]);
+        olddir = dir;
+        dir = atan2((next - cur).Y(), (next - cur).X());
+
+        // Compute our path's new direction.
+        double t = dir - olddir;
+        if(t < -M_PI) t += 2 * M_PI;
+        if(t > M_PI) t -= 2 * M_PI;
+        angle += t;
+
+        // Only process point tags we know.
+        if(n < 2 || FT_CURVE_TAG(tags[i]) == FT_Curve_Tag_On)
+        {
+            AddPoint(cur);
+        }
+        else if(FT_CURVE_TAG(tags[i]) == FT_Curve_Tag_Conic)
+        {
+            FTPoint prev2 = prev, next2 = next;
+
+            // Previous point is either the real previous point (an "on"
+            // point), or the midpoint between the current one and the
+            // previous "conic off" point.
+            if(FT_CURVE_TAG(tags[(i - 1 + n) % n]) == FT_Curve_Tag_Conic)
+            {
+                prev2 = (cur + prev) * 0.5;
+                AddPoint(prev2);
+            }
+
+            // Next point is either the real next point or the midpoint.
+            if(FT_CURVE_TAG(tags[(i + 1) % n]) == FT_Curve_Tag_Conic)
+            {
+                next2 = (cur + next) * 0.5;
+            }
+
+            evaluateQuadraticCurve(prev2, cur, next2);
+        }
+        else if(FT_CURVE_TAG(tags[i]) == FT_Curve_Tag_Cubic
+                 && FT_CURVE_TAG(tags[(i + 1) % n]) == FT_Curve_Tag_Cubic)
+        {
+            evaluateCubicCurve(prev, cur, next,
+                               FTPoint(contour[(i + 2) % n]));
+        }
+    }
+
+    // If final angle is positive (+2PI), it's an anti-clockwise contour,
+    // otherwise (-2PI) it's clockwise.
+    clockwise = (angle < 0.0);
+}
+
+
+void FTContour::buildFrontOutset(float outset)
+{
+    for(size_t i = 0; i < PointCount(); ++i)
+    {
+        AddFrontPoint(Point(i) + Outset(i) * outset);
+    }
+}
+
+
+void FTContour::buildBackOutset(float outset)
+{
+    for(size_t i = 0; i < PointCount(); ++i)
+    {
+        AddBackPoint(Point(i) + Outset(i) * outset);
+    }
+}
+
diff --git a/src/ftgl/FTContour.h b/src/ftgl/FTContour.h
new file mode 100644
index 0000000..4cfff6c
--- /dev/null
+++ b/src/ftgl/FTContour.h
@@ -0,0 +1,209 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Éric Beets <ericbeets@free.fr>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef     __FTContour__
+#define     __FTContour__
+
+#include "FTGL/ftgl.h"
+
+#include "FTVector.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 FTPolygonGlyph
+ * @see FTPoint
+ */
+class FTContour
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param contour
+         * @param pointTags
+         * @param numberOfPoints
+         */
+        FTContour(FT_Vector* contour, char* pointTags, unsigned int numberOfPoints);
+
+        /**
+         * Destructor
+         */
+        ~FTContour()
+        {
+            pointList.clear();
+            outsetPointList.clear();
+            frontPointList.clear();
+            backPointList.clear();
+        }
+
+        /**
+         * Return a point at index.
+         *
+         * @param index of the point in the curve.
+         * @return const point reference
+         */
+        const FTPoint& Point(size_t index) const { return pointList[index]; }
+
+        /**
+         * Return a point at index.
+         *
+         * @param index of the point in the outset curve.
+         * @return const point reference
+         */
+        const FTPoint& Outset(size_t index) const { return outsetPointList[index]; }
+
+        /**
+         * Return a point at index of the front outset contour.
+         *
+         * @param index of the point in the curve.
+         * @return const point reference
+         */
+        const FTPoint& FrontPoint(size_t index) const
+        {
+            if(frontPointList.size() == 0)
+                return Point(index);
+            return frontPointList[index];
+        }
+
+
+        /**
+         * Return a point at index of the back outset contour.
+         *
+         * @param index of the point in the curve.
+         * @return const point reference
+         */
+        const FTPoint& BackPoint(size_t index) const
+        {
+            if(backPointList.size() == 0)
+                return Point(index);
+             return backPointList[index];
+        }
+
+        /**
+         * How many points define this contour
+         *
+         * @return the number of points in this contour
+         */
+        size_t PointCount() const { return pointList.size(); }
+
+        /**
+         * Make sure the glyph has the proper parity and create the front/back
+         * outset contour.
+         *
+         * @param parity  The contour's parity within the glyph.
+         */
+        void SetParity(int parity);
+
+        // FIXME: this should probably go away.
+        void buildFrontOutset(float outset);
+        void buildBackOutset(float outset);
+
+    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);
+
+        /**
+         * Add a point to this contour. This function tests for duplicate
+         * points.
+         *
+         * @param point The point to be added to the contour.
+         */
+        inline void AddOutsetPoint(FTPoint point);
+
+        /*
+         * Add a point to this outset contour. This function tests for duplicate
+         * points.
+         *
+         * @param point The point to be added to the contour outset.
+         */
+        inline void AddFrontPoint(FTPoint point);
+        inline void AddBackPoint(FTPoint point);
+
+        /**
+         * De Casteljau (bezier) algorithm contributed by Jed Soane
+         * Evaluates a quadratic or conic (second degree) curve
+         */
+        inline void evaluateQuadraticCurve(FTPoint, FTPoint, FTPoint);
+
+        /**
+         * De Casteljau (bezier) algorithm contributed by Jed Soane
+         * Evaluates a cubic (third degree) curve
+         */
+        inline void evaluateCubicCurve(FTPoint, FTPoint, FTPoint, FTPoint);
+
+        /**
+         * Compute the vector norm
+         */
+        inline FTGL_DOUBLE NormVector(const FTPoint &v);
+
+        /**
+         * Compute a rotation matrix from a vector
+         */
+        inline void RotationMatrix(const FTPoint &a, const FTPoint &b, FTGL_DOUBLE *matRot, FTGL_DOUBLE *invRot);
+
+        /**
+         * Matrix and vector multiplication
+         */
+        inline void MultMatrixVect(FTGL_DOUBLE *mat, FTPoint &v);
+
+        /**
+         * Compute the vector bisecting from a vector 'v' and a distance 'd'
+         */
+        inline void ComputeBisec(FTPoint &v);
+
+        /**
+         * Compute the outset point coordinates
+         */
+        inline FTPoint ComputeOutsetPoint(FTPoint a, FTPoint b, FTPoint c);
+
+        /**
+         *  The list of points in this contour
+         */
+        typedef FTVector<FTPoint> PointVector;
+        PointVector pointList;
+        PointVector outsetPointList;
+        PointVector frontPointList;
+        PointVector backPointList;
+
+        /**
+         *  Is this contour clockwise or anti-clockwise?
+         */
+        bool clockwise;
+};
+
+#endif // __FTContour__
+
diff --git a/src/ftgl/FTFace.cpp b/src/ftgl/FTFace.cpp
new file mode 100644
index 0000000..542c521
--- /dev/null
+++ b/src/ftgl/FTFace.cpp
@@ -0,0 +1,232 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTFace.h"
+#include "FTLibrary.h"
+
+#include FT_TRUETYPE_TABLES_H
+
+FTFace::FTFace(const char* fontFilePath, bool precomputeKerning)
+:   numGlyphs(0),
+    fontEncodingList(0),
+    kerningCache(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;
+        return;
+    }
+
+    numGlyphs = (*ftFace)->num_glyphs;
+    hasKerningTable = (FT_HAS_KERNING((*ftFace)) != 0);
+
+    if(hasKerningTable && precomputeKerning)
+    {
+        BuildKerningCache();
+    }
+}
+
+
+FTFace::FTFace(const unsigned char *pBufferBytes, size_t bufferSizeInBytes,
+               bool precomputeKerning)
+:   numGlyphs(0),
+    fontEncodingList(0),
+    kerningCache(0),
+    err(0)
+{
+    const FT_Long DEFAULT_FACE_INDEX = 0;
+    ftFace = new FT_Face;
+
+    err = FT_New_Memory_Face(*FTLibrary::Instance().GetLibrary(),
+                             (FT_Byte const *)pBufferBytes, (FT_Long)bufferSizeInBytes,
+                             DEFAULT_FACE_INDEX, ftFace);
+    if(err)
+    {
+        delete ftFace;
+        ftFace = 0;
+        return;
+    }
+
+    numGlyphs = (*ftFace)->num_glyphs;
+    hasKerningTable = (FT_HAS_KERNING((*ftFace)) != 0);
+
+    if(hasKerningTable && precomputeKerning)
+    {
+        BuildKerningCache();
+    }
+}
+
+
+FTFace::~FTFace()
+{
+    if(kerningCache)
+    {
+        delete[] kerningCache;
+    }
+
+    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 const *)pBufferBytes;
+    open.memory_size = (FT_Long)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() const
+{
+    return (*ftFace)->num_charmaps;
+}
+
+
+FT_Encoding* FTFace::CharMapList()
+{
+    if(0 == fontEncodingList)
+    {
+        fontEncodingList = new FT_Encoding[CharMapCount()];
+        for(size_t i = 0; i < CharMapCount(); ++i)
+        {
+            fontEncodingList[i] = (*ftFace)->charmaps[i]->encoding;
+        }
+    }
+
+    return fontEncodingList;
+}
+
+
+FTPoint FTFace::KernAdvance(unsigned int index1, unsigned int index2)
+{
+    float x, y;
+
+    if(!hasKerningTable || !index1 || !index2)
+    {
+        return FTPoint(0.0f, 0.0f);
+    }
+
+    if(kerningCache && index1 < FTFace::MAX_PRECOMPUTED
+        && index2 < FTFace::MAX_PRECOMPUTED)
+    {
+        x = kerningCache[2 * (index2 * FTFace::MAX_PRECOMPUTED + index1)];
+        y = kerningCache[2 * (index2 * FTFace::MAX_PRECOMPUTED + index1) + 1];
+        return FTPoint(x, y);
+    }
+
+    FT_Vector kernAdvance;
+    kernAdvance.x = kernAdvance.y = 0;
+
+    err = FT_Get_Kerning(*ftFace, index1, index2, ft_kerning_unfitted,
+                         &kernAdvance);
+    if(err)
+    {
+        return FTPoint(0.0f, 0.0f);
+    }
+
+    x = static_cast<float>(kernAdvance.x) / 64.0f;
+    y = static_cast<float>(kernAdvance.y) / 64.0f;
+
+    return FTPoint(x, y);
+}
+
+
+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;
+}
+
+
+void FTFace::BuildKerningCache()
+{
+    FT_Vector kernAdvance;
+    kernAdvance.x = 0;
+    kernAdvance.y = 0;
+    kerningCache = new float[FTFace::MAX_PRECOMPUTED
+                              * FTFace::MAX_PRECOMPUTED * 2];
+    for(unsigned int j = 0; j < FTFace::MAX_PRECOMPUTED; j++)
+    {
+        for(unsigned int i = 0; i < FTFace::MAX_PRECOMPUTED; i++)
+        {
+            err = FT_Get_Kerning(*ftFace, i, j, ft_kerning_unfitted,
+                                 &kernAdvance);
+            if(err)
+            {
+                delete[] kerningCache;
+                kerningCache = NULL;
+                return;
+            }
+
+            kerningCache[2 * (j * FTFace::MAX_PRECOMPUTED + i)] =
+                                static_cast<float>(kernAdvance.x) / 64.0f;
+            kerningCache[2 * (j * FTFace::MAX_PRECOMPUTED + i) + 1] =
+                                static_cast<float>(kernAdvance.y) / 64.0f;
+        }
+    }
+}
+
diff --git a/src/ftgl/FTFace.h b/src/ftgl/FTFace.h
new file mode 100644
index 0000000..0e903b5
--- /dev/null
+++ b/src/ftgl/FTFace.h
@@ -0,0 +1,181 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef     __FTFace__
+#define     __FTFace__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL/ftgl.h"
+
+#include "FTSize.h"
+
+/**
+ * FTFace class provides an abstraction layer for the Freetype Face.
+ *
+ * @see "Freetype 2 Documentation"
+ *
+ */
+class FTFace
+{
+    public:
+        /**
+         * Opens and reads a face file. Error is set.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTFace(const char* fontFilePath, bool precomputeKerning = true);
+
+        /**
+         * 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,
+               bool precomputeKerning = true);
+
+        /**
+         * 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() const;
+
+        /**
+         * 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;
+
+        /**
+         * If this face has kerning tables, we can cache them.
+         */
+        void BuildKerningCache();
+        static const unsigned int MAX_PRECOMPUTED = 128;
+        float *kerningCache;
+
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+};
+
+
+#endif  //  __FTFace__
diff --git a/src/ftgl/FTFont/FTBitmapFont.cpp b/src/ftgl/FTFont/FTBitmapFont.cpp
new file mode 100644
index 0000000..ebf3f1e
--- /dev/null
+++ b/src/ftgl/FTFont/FTBitmapFont.cpp
@@ -0,0 +1,106 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTBitmapFontImpl.h"
+
+
+//
+//  FTBitmapFont
+//
+
+
+FTBitmapFont::FTBitmapFont(char const *fontFilePath) :
+    FTFont(new FTBitmapFontImpl(this, fontFilePath))
+{}
+
+
+FTBitmapFont::FTBitmapFont(unsigned char const *pBufferBytes,
+                           size_t bufferSizeInBytes) :
+    FTFont(new FTBitmapFontImpl(this, pBufferBytes, bufferSizeInBytes))
+{}
+
+
+FTBitmapFont::~FTBitmapFont()
+{}
+
+
+FTGlyph* FTBitmapFont::MakeGlyph(FT_GlyphSlot ftGlyph)
+{
+    return new FTBitmapGlyph(ftGlyph);
+}
+
+
+//
+//  FTBitmapFontImpl
+//
+
+
+template <typename T>
+inline FTPoint FTBitmapFontImpl::RenderI(const T* string, const int len,
+                                         FTPoint position, FTPoint spacing,
+                                         int renderMode)
+{
+    // Protect GL_BLEND
+    glPushAttrib(GL_COLOR_BUFFER_BIT);
+
+    // Protect glPixelStorei() calls (also in FTBitmapGlyphImpl::RenderImpl)
+    glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
+
+    glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+    glDisable(GL_BLEND);
+
+    FTPoint tmp = FTFontImpl::Render(string, len,
+                                     position, spacing, renderMode);
+
+    glPopClientAttrib();
+    glPopAttrib();
+
+    return tmp;
+}
+
+
+FTPoint FTBitmapFontImpl::Render(const char * string, const int len,
+                                 FTPoint position, FTPoint spacing,
+                                 int renderMode)
+{
+    return RenderI(string, len, position, spacing, renderMode);
+}
+
+
+FTPoint FTBitmapFontImpl::Render(const wchar_t * string, const int len,
+                                 FTPoint position, FTPoint spacing,
+                                 int renderMode)
+{
+    return RenderI(string, len, position, spacing, renderMode);
+}
+
diff --git a/src/ftgl/FTFont/FTBitmapFontImpl.h b/src/ftgl/FTFont/FTBitmapFontImpl.h
new file mode 100644
index 0000000..7f733d6
--- /dev/null
+++ b/src/ftgl/FTFont/FTBitmapFontImpl.h
@@ -0,0 +1,62 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTBitmapFontImpl__
+#define __FTBitmapFontImpl__
+
+#include "FTFontImpl.h"
+
+class FTGlyph;
+
+class FTBitmapFontImpl : public FTFontImpl
+{
+    friend class FTBitmapFont;
+
+    protected:
+        FTBitmapFontImpl(FTFont *ftFont, const char* fontFilePath) :
+            FTFontImpl(ftFont, fontFilePath) {};
+
+        FTBitmapFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+                         size_t bufferSizeInBytes) :
+            FTFontImpl(ftFont, pBufferBytes, bufferSizeInBytes) {};
+
+        virtual FTPoint Render(const char *s, const int len,
+                               FTPoint position, FTPoint spacing,
+                               int renderMode);
+
+        virtual FTPoint Render(const wchar_t *s, const int len,
+                               FTPoint position, FTPoint spacing,
+                               int renderMode);
+
+    private:
+        /* Internal generic Render() implementation */
+        template <typename T>
+        inline FTPoint RenderI(const T *s, const int len,
+                               FTPoint position, FTPoint spacing, int mode);
+};
+
+#endif  //  __FTBitmapFontImpl__
+
diff --git a/src/ftgl/FTFont/FTBufferFont.cpp b/src/ftgl/FTFont/FTBufferFont.cpp
new file mode 100644
index 0000000..e48e2ab
--- /dev/null
+++ b/src/ftgl/FTFont/FTBufferFont.cpp
@@ -0,0 +1,349 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <wchar.h>
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTBufferFontImpl.h"
+
+
+//
+//  FTBufferFont
+//
+
+
+FTBufferFont::FTBufferFont(char const *fontFilePath) :
+    FTFont(new FTBufferFontImpl(this, fontFilePath))
+{}
+
+
+FTBufferFont::FTBufferFont(unsigned char const *pBufferBytes,
+                           size_t bufferSizeInBytes) :
+    FTFont(new FTBufferFontImpl(this, pBufferBytes, bufferSizeInBytes))
+{}
+
+
+FTBufferFont::~FTBufferFont()
+{}
+
+
+FTGlyph* FTBufferFont::MakeGlyph(FT_GlyphSlot ftGlyph)
+{
+    FTBufferFontImpl *myimpl = dynamic_cast<FTBufferFontImpl *>(impl);
+    if(!myimpl)
+    {
+        return NULL;
+    }
+
+    return myimpl->MakeGlyphImpl(ftGlyph);
+}
+
+
+//
+//  FTBufferFontImpl
+//
+
+
+FTBufferFontImpl::FTBufferFontImpl(FTFont *ftFont, const char* fontFilePath) :
+    FTFontImpl(ftFont, fontFilePath),
+    buffer(new FTBuffer())
+{
+    load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
+
+    glGenTextures(BUFFER_CACHE_SIZE, idCache);
+
+    for(int i = 0; i < BUFFER_CACHE_SIZE; i++)
+    {
+        stringCache[i] = NULL;
+        glBindTexture(GL_TEXTURE_2D, idCache[i]);
+        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);
+    }
+
+    lastString = 0;
+}
+
+
+FTBufferFontImpl::FTBufferFontImpl(FTFont *ftFont,
+                                   const unsigned char *pBufferBytes,
+                                   size_t bufferSizeInBytes) :
+    FTFontImpl(ftFont, pBufferBytes, bufferSizeInBytes),
+    buffer(new FTBuffer())
+{
+    load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
+
+    glGenTextures(BUFFER_CACHE_SIZE, idCache);
+
+    for(int i = 0; i < BUFFER_CACHE_SIZE; i++)
+    {
+        stringCache[i] = NULL;
+        glBindTexture(GL_TEXTURE_2D, idCache[i]);
+        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);
+    }
+
+    lastString = 0;
+}
+
+
+FTBufferFontImpl::~FTBufferFontImpl()
+{
+    glDeleteTextures(BUFFER_CACHE_SIZE, idCache);
+
+    for(int i = 0; i < BUFFER_CACHE_SIZE; i++)
+    {
+        if(stringCache[i])
+        {
+            free(stringCache[i]);
+        }
+    }
+
+    delete buffer;
+}
+
+
+FTGlyph* FTBufferFontImpl::MakeGlyphImpl(FT_GlyphSlot ftGlyph)
+{
+    return new FTBufferGlyph(ftGlyph, buffer);
+}
+
+
+bool FTBufferFontImpl::FaceSize(const unsigned int size,
+                                const unsigned int res)
+{
+    for(int i = 0; i < BUFFER_CACHE_SIZE; i++)
+    {
+        if(stringCache[i])
+        {
+            free(stringCache[i]);
+            stringCache[i] = NULL;
+        }
+    }
+
+    return FTFontImpl::FaceSize(size, res);
+}
+
+
+static 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;
+}
+
+
+inline int StringCompare(void const *a, char const *b, int len)
+{
+    return len < 0 ? strcmp((char const *)a, b)
+                   : strncmp((char const *)a, b, len);
+}
+
+
+inline int StringCompare(void const *a, wchar_t const *b, int len)
+{
+    return len < 0 ? wcscmp((wchar_t const *)a, b)
+                   : wcsncmp((wchar_t const *)a, b, len);
+}
+
+
+inline char *StringCopy(char const *s, int len)
+{
+    if(len < 0)
+    {
+        return strdup(s);
+    }
+    else
+    {
+#ifdef HAVE_STRNDUP
+        return strndup(s, len);
+#else
+        char *s2 = (char*)malloc(len + 1);
+        memcpy(s2, s, len);
+        s2[len] = 0;
+        return s2;
+#endif
+    }
+}
+
+
+inline wchar_t *StringCopy(wchar_t const *s, int len)
+{
+    if(len < 0)
+    {
+#if defined HAVE_WCSDUP
+        return wcsdup(s);
+#else
+        len = (int)wcslen(s);
+#endif
+    }
+
+    wchar_t *s2 = (wchar_t *)malloc((len + 1) * sizeof(wchar_t));
+    memcpy(s2, s, len * sizeof(wchar_t));
+    s2[len] = 0;
+    return s2;
+}
+
+
+template <typename T>
+inline FTPoint FTBufferFontImpl::RenderI(const T* string, const int len,
+                                         FTPoint position, FTPoint spacing,
+                                         int renderMode)
+{
+    const float padding = 3.0f;
+    int width, height, texWidth, texHeight;
+    int cacheIndex = -1;
+    bool inCache = false;
+
+    // Protect blending functions, GL_BLEND and GL_TEXTURE_2D
+    glPushAttrib(GL_COLOR_BUFFER_BIT | GL_ENABLE_BIT);
+
+    // Protect glPixelStorei() calls
+    glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
+
+    glEnable(GL_BLEND);
+    glEnable(GL_TEXTURE_2D);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // GL_ONE
+
+    // Search whether the string is already in a texture we uploaded
+    for(int n = 0; n < BUFFER_CACHE_SIZE; n++)
+    {
+        int i = (lastString + n + BUFFER_CACHE_SIZE) % BUFFER_CACHE_SIZE;
+
+        if(stringCache[i] && !StringCompare(stringCache[i], string, len))
+        {
+            cacheIndex = i;
+            inCache = true;
+            break;
+        }
+    }
+
+    // If the string was not found, we need to put it in the cache and compute
+    // its new bounding box.
+    if(!inCache)
+    {
+        // FIXME: this cache is not very efficient. We should first expire
+        // strings that are not used very often.
+        cacheIndex = lastString;
+        lastString = (lastString + 1) % BUFFER_CACHE_SIZE;
+
+        if(stringCache[cacheIndex])
+        {
+            free(stringCache[cacheIndex]);
+        }
+        // FIXME: only the first N bytes are copied; we want the first N chars.
+        stringCache[cacheIndex] = StringCopy(string, len);
+        bboxCache[cacheIndex] = BBox(string, len, FTPoint(), spacing);
+    }
+
+    FTBBox bbox = bboxCache[cacheIndex];
+
+    width = static_cast<int>(bbox.Upper().X() - bbox.Lower().X()
+                              + padding + padding + 0.5);
+    height = static_cast<int>(bbox.Upper().Y() - bbox.Lower().Y()
+                               + padding + padding + 0.5);
+
+    texWidth = NextPowerOf2(width);
+    texHeight = NextPowerOf2(height);
+
+    glBindTexture(GL_TEXTURE_2D, idCache[cacheIndex]);
+
+    // If the string was not found, we need to render the text in a new
+    // texture buffer, then upload it to the OpenGL layer.
+    if(!inCache)
+    {
+        buffer->Size(texWidth, texHeight);
+        buffer->Pos(FTPoint(padding, padding) - bbox.Lower());
+
+        advanceCache[cacheIndex] =
+              FTFontImpl::Render(string, len, FTPoint(), spacing, renderMode);
+
+        glBindTexture(GL_TEXTURE_2D, idCache[cacheIndex]);
+
+        glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
+        glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+        /* TODO: use glTexSubImage2D later? */
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, texWidth, texHeight, 0,
+                     GL_ALPHA, GL_UNSIGNED_BYTE, (GLvoid *)buffer->Pixels());
+
+        buffer->Size(0, 0);
+    }
+
+    FTPoint low = position + bbox.Lower();
+    FTPoint up = position + bbox.Upper();
+
+    glBegin(GL_QUADS);
+        glNormal3f(0.0f, 0.0f, 1.0f);
+        glTexCoord2f(padding / texWidth,
+                     (texHeight - height + padding) / texHeight);
+        glVertex2f(low.Xf(), up.Yf());
+        glTexCoord2f(padding / texWidth,
+                     (texHeight - padding) / texHeight);
+        glVertex2f(low.Xf(), low.Yf());
+        glTexCoord2f((width - padding) / texWidth,
+                     (texHeight - padding) / texHeight);
+        glVertex2f(up.Xf(), low.Yf());
+        glTexCoord2f((width - padding) / texWidth,
+                     (texHeight - height + padding) / texHeight);
+        glVertex2f(up.Xf(), up.Yf());
+    glEnd();
+
+    glPopClientAttrib();
+    glPopAttrib();
+
+    return position + advanceCache[cacheIndex];
+}
+
+
+FTPoint FTBufferFontImpl::Render(const char * string, const int len,
+                                 FTPoint position, FTPoint spacing,
+                                 int renderMode)
+{
+    return RenderI(string, len, position, spacing, renderMode);
+}
+
+
+FTPoint FTBufferFontImpl::Render(const wchar_t * string, const int len,
+                                 FTPoint position, FTPoint spacing,
+                                 int renderMode)
+{
+    return RenderI(string, len, position, spacing, renderMode);
+}
+
diff --git a/src/ftgl/FTFont/FTBufferFontImpl.h b/src/ftgl/FTFont/FTBufferFontImpl.h
new file mode 100644
index 0000000..15557f6
--- /dev/null
+++ b/src/ftgl/FTFont/FTBufferFontImpl.h
@@ -0,0 +1,81 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTBufferFontImpl__
+#define __FTBufferFontImpl__
+
+#include "FTFontImpl.h"
+
+class FTGlyph;
+class FTBuffer;
+
+class FTBufferFontImpl : public FTFontImpl
+{
+    friend class FTBufferFont;
+
+    protected:
+        FTBufferFontImpl(FTFont *ftFont, const char* fontFilePath);
+
+        FTBufferFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+                         size_t bufferSizeInBytes);
+
+        virtual ~FTBufferFontImpl();
+
+        virtual FTPoint Render(const char *s, const int len,
+                               FTPoint position, FTPoint spacing,
+                               int renderMode);
+
+        virtual FTPoint Render(const wchar_t *s, const int len,
+                               FTPoint position, FTPoint spacing,
+                               int renderMode);
+
+        virtual bool FaceSize(const unsigned int size,
+                              const unsigned int res);
+
+    private:
+        /**
+         * Create an FTBufferGlyph object for the base class.
+         */
+        FTGlyph* MakeGlyphImpl(FT_GlyphSlot ftGlyph);
+
+        /* Internal generic Render() implementation */
+        template <typename T>
+        inline FTPoint RenderI(const T *s, const int len,
+                               FTPoint position, FTPoint spacing, int mode);
+
+        /* Pixel buffer */
+        FTBuffer *buffer;
+
+        static const int BUFFER_CACHE_SIZE = 16;
+        /* Texture IDs */
+        GLuint idCache[BUFFER_CACHE_SIZE];
+        void *stringCache[BUFFER_CACHE_SIZE];
+        FTBBox bboxCache[BUFFER_CACHE_SIZE];
+        FTPoint advanceCache[BUFFER_CACHE_SIZE];
+        int lastString;
+};
+
+#endif  //  __FTBufferFontImpl__
+
diff --git a/src/ftgl/FTFont/FTExtrudeFont.cpp b/src/ftgl/FTFont/FTExtrudeFont.cpp
new file mode 100644
index 0000000..9e8eb72
--- /dev/null
+++ b/src/ftgl/FTFont/FTExtrudeFont.cpp
@@ -0,0 +1,89 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTExtrudeFontImpl.h"
+
+
+//
+//  FTExtrudeFont
+//
+
+
+FTExtrudeFont::FTExtrudeFont(char const *fontFilePath) :
+    FTFont(new FTExtrudeFontImpl(this, fontFilePath))
+{}
+
+
+FTExtrudeFont::FTExtrudeFont(const unsigned char *pBufferBytes,
+                             size_t bufferSizeInBytes) :
+    FTFont(new FTExtrudeFontImpl(this, pBufferBytes, bufferSizeInBytes))
+{}
+
+
+FTExtrudeFont::~FTExtrudeFont()
+{}
+
+
+FTGlyph* FTExtrudeFont::MakeGlyph(FT_GlyphSlot ftGlyph)
+{
+    FTExtrudeFontImpl *myimpl = dynamic_cast<FTExtrudeFontImpl *>(impl);
+    if(!myimpl)
+    {
+        return NULL;
+    }
+
+    return new FTExtrudeGlyph(ftGlyph, myimpl->depth, myimpl->front,
+                              myimpl->back, myimpl->useDisplayLists);
+}
+
+
+//
+//  FTExtrudeFontImpl
+//
+
+
+FTExtrudeFontImpl::FTExtrudeFontImpl(FTFont *ftFont, const char* fontFilePath)
+: FTFontImpl(ftFont, fontFilePath),
+  depth(0.0f), front(0.0f), back(0.0f)
+{
+    load_flags = FT_LOAD_NO_HINTING;
+}
+
+
+FTExtrudeFontImpl::FTExtrudeFontImpl(FTFont *ftFont,
+                                     const unsigned char *pBufferBytes,
+                                     size_t bufferSizeInBytes)
+: FTFontImpl(ftFont, pBufferBytes, bufferSizeInBytes),
+  depth(0.0f), front(0.0f), back(0.0f)
+{
+    load_flags = FT_LOAD_NO_HINTING;
+}
+
diff --git a/src/ftgl/FTFont/FTExtrudeFontImpl.h b/src/ftgl/FTFont/FTExtrudeFontImpl.h
new file mode 100644
index 0000000..c2ddf27
--- /dev/null
+++ b/src/ftgl/FTFont/FTExtrudeFontImpl.h
@@ -0,0 +1,81 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTExtrudeFontImpl__
+#define __FTExtrudeFontImpl__
+
+#include "FTFontImpl.h"
+
+class FTGlyph;
+
+class FTExtrudeFontImpl : public FTFontImpl
+{
+    friend class FTExtrudeFont;
+
+    protected:
+        FTExtrudeFontImpl(FTFont *ftFont, const char* fontFilePath);
+
+        FTExtrudeFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+                          size_t bufferSizeInBytes);
+
+        /**
+         * Set the extrusion distance for the font.
+         *
+         * @param d  The extrusion distance.
+         */
+        virtual void Depth(float d) { depth = d; }
+
+        /**
+         * Set the outset distance for the font. Only implemented by
+         * FTOutlineFont, FTPolygonFont and FTExtrudeFont
+         *
+         * @param o  The outset distance.
+         */
+        virtual void Outset(float o) { front = back = o; }
+
+        /**
+         * Set the outset distance for the font. Only implemented by
+         * FTExtrudeFont
+         *
+         * @param f  The front outset distance.
+         * @param b  The back outset distance.
+         */
+        virtual void Outset(float f, float b) { front = f; back = b; }
+
+    private:
+        /**
+         * The extrusion distance for the font.
+         */
+        float depth;
+
+        /**
+         * The outset distance (front and back) for the font.
+         */
+        float front, back;
+};
+
+#endif // __FTExtrudeFontImpl__
+
diff --git a/src/ftgl/FTFont/FTFont.cpp b/src/ftgl/FTFont/FTFont.cpp
new file mode 100644
index 0000000..a7206fb
--- /dev/null
+++ b/src/ftgl/FTFont/FTFont.cpp
@@ -0,0 +1,552 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTInternals.h"
+#include "FTUnicode.h"
+
+#include "FTFontImpl.h"
+
+#include "FTBitmapFontImpl.h"
+#include "FTExtrudeFontImpl.h"
+#include "FTOutlineFontImpl.h"
+#include "FTPixmapFontImpl.h"
+#include "FTPolygonFontImpl.h"
+#include "FTTextureFontImpl.h"
+
+#include "FTGlyphContainer.h"
+#include "FTFace.h"
+
+
+//
+//  FTFont
+//
+
+
+FTFont::FTFont(char const *fontFilePath)
+{
+    impl = new FTFontImpl(this, fontFilePath);
+}
+
+
+FTFont::FTFont(const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+{
+    impl = new FTFontImpl(this, pBufferBytes, bufferSizeInBytes);
+}
+
+
+FTFont::FTFont(FTFontImpl *pImpl)
+{
+    impl = pImpl;
+}
+
+
+FTFont::~FTFont()
+{
+    delete impl;
+}
+
+
+bool FTFont::Attach(const char* fontFilePath)
+{
+    return impl->Attach(fontFilePath);
+}
+
+
+bool FTFont::Attach(const unsigned char *pBufferBytes, size_t bufferSizeInBytes)
+{
+    return impl->Attach(pBufferBytes, bufferSizeInBytes);
+}
+
+
+bool FTFont::FaceSize(const unsigned int size, const unsigned int res)
+{
+    return impl->FaceSize(size, res);
+}
+
+
+unsigned int FTFont::FaceSize() const
+{
+    return impl->FaceSize();
+}
+
+
+void FTFont::Depth(float depth)
+{
+    return impl->Depth(depth);
+}
+
+
+void FTFont::Outset(float outset)
+{
+    return impl->Outset(outset);
+}
+
+
+void FTFont::Outset(float front, float back)
+{
+    return impl->Outset(front, back);
+}
+
+
+void FTFont::GlyphLoadFlags(FT_Int flags)
+{
+    return impl->GlyphLoadFlags(flags);
+}
+
+
+bool FTFont::CharMap(FT_Encoding encoding)
+{
+    return impl->CharMap(encoding);
+}
+
+
+unsigned int FTFont::CharMapCount() const
+{
+    return impl->CharMapCount();
+}
+
+
+FT_Encoding* FTFont::CharMapList()
+{
+    return impl->CharMapList();
+}
+
+
+void FTFont::UseDisplayList(bool useList)
+{
+    return impl->UseDisplayList(useList);
+}
+
+
+float FTFont::Ascender() const
+{
+    return impl->Ascender();
+}
+
+
+float FTFont::Descender() const
+{
+    return impl->Descender();
+}
+
+
+float FTFont::LineHeight() const
+{
+    return impl->LineHeight();
+}
+
+
+FTPoint FTFont::Render(const char * string, const int len,
+                       FTPoint position, FTPoint spacing, int renderMode)
+{
+    return impl->Render(string, len, position, spacing, renderMode);
+}
+
+
+FTPoint FTFont::Render(const wchar_t * string, const int len,
+                       FTPoint position, FTPoint spacing, int renderMode)
+{
+    return impl->Render(string, len, position, spacing, renderMode);
+}
+
+
+float FTFont::Advance(const char * string, const int len, FTPoint spacing)
+{
+    return impl->Advance(string, len, spacing);
+}
+
+
+float FTFont::Advance(const wchar_t * string, const int len, FTPoint spacing)
+{
+    return impl->Advance(string, len, spacing);
+}
+
+
+FTBBox FTFont::BBox(const char *string, const int len,
+                    FTPoint position, FTPoint spacing)
+{
+    return impl->BBox(string, len, position, spacing);
+}
+
+
+FTBBox FTFont::BBox(const wchar_t *string, const int len,
+                    FTPoint position, FTPoint spacing)
+{
+    return impl->BBox(string, len, position, spacing);
+}
+
+
+FT_Error FTFont::Error() const
+{
+    return impl->err;
+}
+
+
+//
+//  FTFontImpl
+//
+
+
+FTFontImpl::FTFontImpl(FTFont *ftFont, char const *fontFilePath) :
+    face(fontFilePath),
+    useDisplayLists(true),
+    load_flags(FT_LOAD_DEFAULT),
+    intf(ftFont),
+    glyphList(0)
+{
+    err = face.Error();
+    if(err == 0)
+    {
+        glyphList = new FTGlyphContainer(&face);
+    }
+}
+
+
+FTFontImpl::FTFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+                       size_t bufferSizeInBytes) :
+    face(pBufferBytes, bufferSizeInBytes),
+    useDisplayLists(true),
+    load_flags(FT_LOAD_DEFAULT),
+    intf(ftFont),
+    glyphList(0)
+{
+    err = face.Error();
+    if(err == 0)
+    {
+        glyphList = new FTGlyphContainer(&face);
+    }
+}
+
+
+FTFontImpl::~FTFontImpl()
+{
+    if(glyphList)
+    {
+        delete glyphList;
+    }
+}
+
+
+bool FTFontImpl::Attach(const char* fontFilePath)
+{
+    if(!face.Attach(fontFilePath))
+    {
+        err = face.Error();
+        return false;
+    }
+
+    err = 0;
+    return true;
+}
+
+
+bool FTFontImpl::Attach(const unsigned char *pBufferBytes,
+                        size_t bufferSizeInBytes)
+{
+    if(!face.Attach(pBufferBytes, bufferSizeInBytes))
+    {
+        err = face.Error();
+        return false;
+    }
+
+    err = 0;
+    return true;
+}
+
+
+bool FTFontImpl::FaceSize(const unsigned int size, const unsigned int res)
+{
+    if(glyphList != NULL)
+    {
+        delete glyphList;
+        glyphList = NULL;
+    }
+
+    charSize = face.Size(size, res);
+    err = face.Error();
+
+    if(err != 0)
+    {
+        return false;
+    }
+
+    glyphList = new FTGlyphContainer(&face);
+    return true;
+}
+
+
+unsigned int FTFontImpl::FaceSize() const
+{
+    return charSize.CharSize();
+}
+
+
+void FTFontImpl::Depth(float depth)
+{
+    ;
+}
+
+
+void FTFontImpl::Outset(float outset)
+{
+    ;
+}
+
+
+void FTFontImpl::Outset(float front, float back)
+{
+    ;
+}
+
+
+void FTFontImpl::GlyphLoadFlags(FT_Int flags)
+{
+    load_flags = flags;
+}
+
+
+bool FTFontImpl::CharMap(FT_Encoding encoding)
+{
+    bool result = glyphList->CharMap(encoding);
+    err = glyphList->Error();
+    return result;
+}
+
+
+unsigned int FTFontImpl::CharMapCount() const
+{
+    return face.CharMapCount();
+}
+
+
+FT_Encoding* FTFontImpl::CharMapList()
+{
+    return face.CharMapList();
+}
+
+
+void FTFontImpl::UseDisplayList(bool useList)
+{
+    useDisplayLists = useList;
+}
+
+
+float FTFontImpl::Ascender() const
+{
+    return charSize.Ascender();
+}
+
+
+float FTFontImpl::Descender() const
+{
+    return charSize.Descender();
+}
+
+
+float FTFontImpl::LineHeight() const
+{
+    return charSize.Height();
+}
+
+
+template <typename T>
+inline FTBBox FTFontImpl::BBoxI(const T* string, const int len,
+                                FTPoint position, FTPoint spacing)
+{
+    FTBBox totalBBox;
+
+    /* Only compute the bounds if string is non-empty. */
+    if(string && ('\0' != string[0]))
+    {
+        // for multibyte - we can't rely on sizeof(T) == character
+        FTUnicodeStringItr<T> ustr(string);
+        unsigned int thisChar = *ustr++;
+        unsigned int nextChar = *ustr;
+
+        if(CheckGlyph(thisChar))
+        {
+            totalBBox = glyphList->BBox(thisChar);
+            totalBBox += position;
+
+            position += FTPoint(glyphList->Advance(thisChar, nextChar), 0.0);
+        }
+
+        /* Expand totalBox by each glyph in string */
+        for(int i = 1; (len < 0 && *ustr) || (len >= 0 && i < len); i++)
+        {
+            thisChar = *ustr++;
+            nextChar = *ustr;
+
+            if(CheckGlyph(thisChar))
+            {
+                position += spacing;
+
+                FTBBox tempBBox = glyphList->BBox(thisChar);
+                tempBBox += position;
+                totalBBox |= tempBBox;
+
+                position += FTPoint(glyphList->Advance(thisChar, nextChar),
+                                    0.0);
+            }
+        }
+    }
+
+    return totalBBox;
+}
+
+
+FTBBox FTFontImpl::BBox(const char *string, const int len,
+                        FTPoint position, FTPoint spacing)
+{
+    /* The chars need to be unsigned because they are cast to int later */
+    return BBoxI((const unsigned char *)string, len, position, spacing);
+}
+
+
+FTBBox FTFontImpl::BBox(const wchar_t *string, const int len,
+                        FTPoint position, FTPoint spacing)
+{
+    return BBoxI(string, len, position, spacing);
+}
+
+
+template <typename T>
+inline float FTFontImpl::AdvanceI(const T* string, const int len,
+                                  FTPoint spacing)
+{
+    float advance = 0.0f;
+    FTUnicodeStringItr<T> ustr(string);
+
+    for(int i = 0; (len < 0 && *ustr) || (len >= 0 && i < len); i++)
+    {
+        unsigned int thisChar = *ustr++;
+        unsigned int nextChar = *ustr;
+
+        if(CheckGlyph(thisChar))
+        {
+            advance += glyphList->Advance(thisChar, nextChar);
+        }
+
+        if(nextChar)
+        {
+            advance += spacing.Xf();
+        }
+    }
+
+    return advance;
+}
+
+
+float FTFontImpl::Advance(const char* string, const int len, FTPoint spacing)
+{
+    /* The chars need to be unsigned because they are cast to int later */
+    return AdvanceI((const unsigned char *)string, len, spacing);
+}
+
+
+float FTFontImpl::Advance(const wchar_t* string, const int len, FTPoint spacing)
+{
+    return AdvanceI(string, len, spacing);
+}
+
+
+template <typename T>
+inline FTPoint FTFontImpl::RenderI(const T* string, const int len,
+                                   FTPoint position, FTPoint spacing,
+                                   int renderMode)
+{
+    // for multibyte - we can't rely on sizeof(T) == character
+    FTUnicodeStringItr<T> ustr(string);
+
+    for(int i = 0; (len < 0 && *ustr) || (len >= 0 && i < len); i++)
+    {
+        unsigned int thisChar = *ustr++;
+        unsigned int nextChar = *ustr;
+
+        if(CheckGlyph(thisChar))
+        {
+            position += glyphList->Render(thisChar, nextChar,
+                                          position, renderMode);
+        }
+
+        if(nextChar)
+        {
+            position += spacing;
+        }
+    }
+
+    return position;
+}
+
+
+FTPoint FTFontImpl::Render(const char * string, const int len,
+                           FTPoint position, FTPoint spacing, int renderMode)
+{
+    return RenderI((const unsigned char *)string,
+                   len, position, spacing, renderMode);
+}
+
+
+FTPoint FTFontImpl::Render(const wchar_t * string, const int len,
+                           FTPoint position, FTPoint spacing, int renderMode)
+{
+    return RenderI(string, len, position, spacing, renderMode);
+}
+
+
+bool FTFontImpl::CheckGlyph(const unsigned int characterCode)
+{
+    if(glyphList->Glyph(characterCode))
+    {
+        return true;
+    }
+
+    unsigned int glyphIndex = glyphList->FontIndex(characterCode);
+    FT_GlyphSlot ftSlot = face.Glyph(glyphIndex, load_flags);
+    if(!ftSlot)
+    {
+        err = face.Error();
+        return false;
+    }
+
+    FTGlyph* tempGlyph = intf->MakeGlyph(ftSlot);
+    if(!tempGlyph)
+    {
+        if(0 == err)
+        {
+            err = 0x13;
+        }
+
+        return false;
+    }
+
+    glyphList->Add(tempGlyph, characterCode);
+
+    return true;
+}
+
diff --git a/src/ftgl/FTFont/FTFontGlue.cpp b/src/ftgl/FTFont/FTFontGlue.cpp
new file mode 100644
index 0000000..b23e787
--- /dev/null
+++ b/src/ftgl/FTFont/FTFontGlue.cpp
@@ -0,0 +1,227 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Éric Beets <ericbeets@free.fr>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTInternals.h"
+
+static const FTPoint static_ftpoint;
+static const FTBBox static_ftbbox;
+
+FTGL_BEGIN_C_DECLS
+
+#define C_TOR(cname, cargs, cxxname, cxxarg, cxxtype) \
+    FTGLfont* cname cargs \
+    { \
+        cxxname *f = new cxxname cxxarg; \
+        if(f->Error()) \
+        { \
+            delete f; \
+            return NULL; \
+        } \
+        FTGLfont *ftgl = (FTGLfont *)malloc(sizeof(FTGLfont)); \
+        ftgl->ptr = f; \
+        ftgl->type = cxxtype; \
+        return ftgl; \
+    }
+
+// FTBitmapFont::FTBitmapFont();
+C_TOR(ftglCreateBitmapFont, (const char *fontname),
+      FTBitmapFont, (fontname), FONT_BITMAP);
+
+// FTBufferFont::FTBufferFont();
+C_TOR(ftglCreateBufferFont, (const char *fontname),
+      FTBufferFont, (fontname), FONT_BUFFER);
+
+// FTExtrudeFont::FTExtrudeFont();
+C_TOR(ftglCreateExtrudeFont, (const char *fontname),
+      FTExtrudeFont, (fontname), FONT_EXTRUDE);
+
+// FTOutlineFont::FTOutlineFont();
+C_TOR(ftglCreateOutlineFont, (const char *fontname),
+      FTOutlineFont, (fontname), FONT_OUTLINE);
+
+// FTPixmapFont::FTPixmapFont();
+C_TOR(ftglCreatePixmapFont, (const char *fontname),
+      FTPixmapFont, (fontname), FONT_PIXMAP);
+
+// FTPolygonFont::FTPolygonFont();
+C_TOR(ftglCreatePolygonFont, (const char *fontname),
+      FTPolygonFont, (fontname), FONT_POLYGON);
+
+// FTTextureFont::FTTextureFont();
+C_TOR(ftglCreateTextureFont, (const char *fontname),
+      FTTextureFont, (fontname), FONT_TEXTURE);
+
+// FTCustomFont::FTCustomFont();
+class FTCustomFont : public FTFont
+{
+public:
+    FTCustomFont(char const *fontFilePath, void *p,
+                 FTGLglyph * (*makeglyph) (FT_GlyphSlot, void *))
+     : FTFont(fontFilePath),
+       data(p),
+       makeglyphCallback(makeglyph)
+    {}
+
+    ~FTCustomFont()
+    {}
+
+    FTGlyph* MakeGlyph(FT_GlyphSlot slot)
+    {
+        FTGLglyph *g = makeglyphCallback(slot, data);
+        FTGlyph *glyph = g->ptr;
+        // XXX: we no longer need g, and no one will free it for us. Not
+        // very elegant, and we need to make sure no one else will try to
+        // use it.
+        free(g);
+        return glyph;
+    }
+
+private:
+    void *data;
+    FTGLglyph *(*makeglyphCallback) (FT_GlyphSlot, void *);
+};
+
+C_TOR(ftglCreateCustomFont, (char const *fontFilePath, void *data,
+                   FTGLglyph * (*makeglyphCallback) (FT_GlyphSlot, void *)),
+      FTCustomFont, (fontFilePath, data, makeglyphCallback), FONT_CUSTOM);
+
+#define C_FUN(cret, cname, cargs, cxxerr, cxxname, cxxarg) \
+    cret cname cargs \
+    { \
+        if(!f || !f->ptr) \
+        { \
+            fprintf(stderr, "FTGL warning: NULL pointer in %s\n", #cname); \
+            cxxerr; \
+        } \
+        return f->ptr->cxxname cxxarg; \
+    }
+
+// FTFont::~FTFont();
+void ftglDestroyFont(FTGLfont *f)
+{
+    if(!f || !f->ptr)
+    {
+        fprintf(stderr, "FTGL warning: NULL pointer in %s\n", __FUNCTION__);
+        return;
+    }
+    delete f->ptr;
+    free(f);
+}
+
+// bool FTFont::Attach(const char* fontFilePath);
+C_FUN(int, ftglAttachFile, (FTGLfont *f, const char* path),
+      return 0, Attach, (path));
+
+// bool FTFont::Attach(const unsigned char *pBufferBytes,
+//                     size_t bufferSizeInBytes);
+C_FUN(int, ftglAttachData, (FTGLfont *f, const unsigned char *p, size_t s),
+      return 0, Attach, (p, s));
+
+// void FTFont::GlyphLoadFlags(FT_Int flags);
+C_FUN(void, ftglSetFontGlyphLoadFlags, (FTGLfont *f, FT_Int flags),
+      return, GlyphLoadFlags, (flags));
+
+// bool FTFont::CharMap(FT_Encoding encoding);
+C_FUN(int, ftglSetFontCharMap, (FTGLfont *f, FT_Encoding enc),
+      return 0, CharMap, (enc));
+
+// unsigned int FTFont::CharMapCount();
+C_FUN(unsigned int, ftglGetFontCharMapCount, (FTGLfont *f),
+      return 0, CharMapCount, ());
+
+// FT_Encoding* FTFont::CharMapList();
+C_FUN(FT_Encoding *, ftglGetFontCharMapList, (FTGLfont* f),
+      return NULL, CharMapList, ());
+
+// virtual bool FTFont::FaceSize(const unsigned int size,
+//                               const unsigned int res = 72);
+C_FUN(int, ftglSetFontFaceSize, (FTGLfont *f, unsigned int s, unsigned int r),
+      return 0, FaceSize, (s, r > 0 ? r : 72));
+
+// unsigned int FTFont::FaceSize() const;
+// XXX: need to call FaceSize() as FTFont::FaceSize() because of FTGLTexture
+C_FUN(unsigned int, ftglGetFontFaceSize, (FTGLfont *f),
+      return 0, FTFont::FaceSize, ());
+
+// virtual void FTFont::Depth(float depth);
+C_FUN(void, ftglSetFontDepth, (FTGLfont *f, float d), return, Depth, (d));
+
+// virtual void FTFont::Outset(float front, float back);
+C_FUN(void, ftglSetFontOutset, (FTGLfont *f, float front, float back),
+      return, FTFont::Outset, (front, back));
+
+// void FTFont::UseDisplayList(bool useList);
+C_FUN(void, ftglSetFontDisplayList, (FTGLfont *f, int l),
+      return, UseDisplayList, (l != 0));
+
+// float FTFont::Ascender() const;
+C_FUN(float, ftglGetFontAscender, (FTGLfont *f), return 0.f, Ascender, ());
+
+// float FTFont::Descender() const;
+C_FUN(float, ftglGetFontDescender, (FTGLfont *f), return 0.f, Descender, ());
+
+// float FTFont::LineHeight() const;
+C_FUN(float, ftglGetFontLineHeight, (FTGLfont *f), return 0.f, LineHeight, ());
+
+// void FTFont::BBox(const char* string, float& llx, float& lly, float& llz,
+//                   float& urx, float& ury, float& urz);
+extern "C++" {
+C_FUN(static FTBBox, _ftglGetFontBBox, (FTGLfont *f, char const *s, int len),
+      return static_ftbbox, BBox, (s, len));
+}
+
+void ftglGetFontBBox(FTGLfont *f, const char* s, int len, float c[6])
+{
+    FTBBox ret = _ftglGetFontBBox(f, s, len);
+    FTPoint lower = ret.Lower(), upper = ret.Upper();
+    c[0] = lower.Xf(); c[1] = lower.Yf(); c[2] = lower.Zf();
+    c[3] = upper.Xf(); c[4] = upper.Yf(); c[5] = upper.Zf();
+}
+
+// float FTFont::Advance(const char* string);
+C_FUN(float, ftglGetFontAdvance, (FTGLfont *f, char const *s),
+      return 0.0, Advance, (s));
+
+// virtual void Render(const char* string, int renderMode);
+extern "C++" {
+C_FUN(static FTPoint, _ftglRenderFont, (FTGLfont *f, char const *s, int len,
+                                        FTPoint pos, FTPoint spacing, int mode),
+      return static_ftpoint, Render, (s, len, pos, spacing, mode));
+}
+
+void ftglRenderFont(FTGLfont *f, const char *s, int mode)
+{
+    _ftglRenderFont(f, s, -1, FTPoint(), FTPoint(), mode);
+}
+
+// FT_Error FTFont::Error() const;
+C_FUN(FT_Error, ftglGetFontError, (FTGLfont *f), return -1, Error, ());
+
+FTGL_END_C_DECLS
+
diff --git a/src/ftgl/FTFont/FTFontImpl.h b/src/ftgl/FTFont/FTFontImpl.h
new file mode 100644
index 0000000..36c3bf8
--- /dev/null
+++ b/src/ftgl/FTFont/FTFontImpl.h
@@ -0,0 +1,162 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTFontImpl__
+#define __FTFontImpl__
+
+#include "FTGL/ftgl.h"
+
+#include "FTFace.h"
+
+class FTGlyphContainer;
+class FTGlyph;
+
+class FTFontImpl
+{
+        friend class FTFont;
+
+    protected:
+        FTFontImpl(FTFont *ftFont, char const *fontFilePath);
+
+        FTFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+                   size_t bufferSizeInBytes);
+
+        virtual ~FTFontImpl();
+
+        virtual bool Attach(const char* fontFilePath);
+
+        virtual bool Attach(const unsigned char *pBufferBytes,
+                            size_t bufferSizeInBytes);
+
+        virtual void GlyphLoadFlags(FT_Int flags);
+
+        virtual bool CharMap(FT_Encoding encoding);
+
+        virtual unsigned int CharMapCount() const;
+
+        virtual FT_Encoding* CharMapList();
+
+        virtual void UseDisplayList(bool useList);
+
+        virtual float Ascender() const;
+
+        virtual float Descender() const;
+
+        virtual float LineHeight() const;
+
+        virtual bool FaceSize(const unsigned int size,
+                              const unsigned int res);
+
+        virtual unsigned int FaceSize() const;
+
+        virtual void Depth(float depth);
+
+        virtual void Outset(float outset);
+
+        virtual void Outset(float front, float back);
+
+        virtual FTBBox BBox(const char *s, const int len, FTPoint, FTPoint);
+
+        virtual FTBBox BBox(const wchar_t *s, const int len, FTPoint, FTPoint);
+
+        virtual float Advance(const char *s, const int len, FTPoint);
+
+        virtual float Advance(const wchar_t *s, const int len, FTPoint);
+
+        virtual FTPoint Render(const char *s, const int len,
+                               FTPoint, FTPoint, int);
+
+        virtual FTPoint Render(const wchar_t *s, const int len,
+                               FTPoint, FTPoint, int);
+
+        /**
+         * 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;
+
+        /**
+         * The default glyph loading flags.
+         */
+        FT_Int load_flags;
+
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+
+    private:
+        /**
+         * A link back to the interface of which we are the implementation.
+         */
+        FTFont *intf;
+
+        /**
+         * 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.
+         */
+        bool CheckGlyph(const unsigned int chr);
+
+        /**
+         * An object that holds a list of glyphs
+         */
+        FTGlyphContainer* glyphList;
+
+        /**
+         * Current pen or cursor position;
+         */
+        FTPoint pen;
+
+        /* Internal generic BBox() implementation */
+        template <typename T>
+        inline FTBBox BBoxI(const T *s, const int len,
+                            FTPoint position, FTPoint spacing);
+
+        /* Internal generic Advance() implementation */
+        template <typename T>
+        inline float AdvanceI(const T *s, const int len, FTPoint spacing);
+
+        /* Internal generic Render() implementation */
+        template <typename T>
+        inline FTPoint RenderI(const T *s, const int len,
+                               FTPoint position, FTPoint spacing, int mode);
+};
+
+#endif  //  __FTFontImpl__
+
diff --git a/src/ftgl/FTFont/FTOutlineFont.cpp b/src/ftgl/FTFont/FTOutlineFont.cpp
new file mode 100644
index 0000000..9ebc9a0
--- /dev/null
+++ b/src/ftgl/FTFont/FTOutlineFont.cpp
@@ -0,0 +1,129 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTOutlineFontImpl.h"
+
+
+//
+//  FTOutlineFont
+//
+
+
+FTOutlineFont::FTOutlineFont(char const *fontFilePath) :
+    FTFont(new FTOutlineFontImpl(this, fontFilePath))
+{}
+
+
+FTOutlineFont::FTOutlineFont(const unsigned char *pBufferBytes,
+                             size_t bufferSizeInBytes) :
+    FTFont(new FTOutlineFontImpl(this, pBufferBytes, bufferSizeInBytes))
+{}
+
+
+FTOutlineFont::~FTOutlineFont()
+{}
+
+
+FTGlyph* FTOutlineFont::MakeGlyph(FT_GlyphSlot ftGlyph)
+{
+    FTOutlineFontImpl *myimpl = dynamic_cast<FTOutlineFontImpl *>(impl);
+    if(!myimpl)
+    {
+        return NULL;
+    }
+
+    return new FTOutlineGlyph(ftGlyph, myimpl->outset,
+                              myimpl->useDisplayLists);
+}
+
+
+//
+//  FTOutlineFontImpl
+//
+
+
+FTOutlineFontImpl::FTOutlineFontImpl(FTFont *ftFont, const char* fontFilePath)
+: FTFontImpl(ftFont, fontFilePath),
+  outset(0.0f)
+{
+    load_flags = FT_LOAD_NO_HINTING;
+}
+
+
+FTOutlineFontImpl::FTOutlineFontImpl(FTFont *ftFont,
+                                     const unsigned char *pBufferBytes,
+                                     size_t bufferSizeInBytes)
+: FTFontImpl(ftFont, pBufferBytes, bufferSizeInBytes),
+  outset(0.0f)
+{
+    load_flags = FT_LOAD_NO_HINTING;
+}
+
+
+template <typename T>
+inline FTPoint FTOutlineFontImpl::RenderI(const T* string, const int len,
+                                          FTPoint position, FTPoint spacing,
+                                          int renderMode)
+{
+    // Protect GL_TEXTURE_2D, glHint(), GL_LINE_SMOOTH and blending functions
+    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
+
+    FTPoint tmp = FTFontImpl::Render(string, len,
+                                     position, spacing, renderMode);
+
+    glPopAttrib();
+
+    return tmp;
+}
+
+
+FTPoint FTOutlineFontImpl::Render(const char * string, const int len,
+                                  FTPoint position, FTPoint spacing,
+                                  int renderMode)
+{
+    return RenderI(string, len, position, spacing, renderMode);
+}
+
+
+FTPoint FTOutlineFontImpl::Render(const wchar_t * string, const int len,
+                                  FTPoint position, FTPoint spacing,
+                                  int renderMode)
+{
+    return RenderI(string, len, position, spacing, renderMode);
+}
+
diff --git a/src/ftgl/FTFont/FTOutlineFontImpl.h b/src/ftgl/FTFont/FTOutlineFontImpl.h
new file mode 100644
index 0000000..38b4d26
--- /dev/null
+++ b/src/ftgl/FTFont/FTOutlineFontImpl.h
@@ -0,0 +1,73 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTOutlineFontImpl__
+#define __FTOutlineFontImpl__
+
+#include "FTFontImpl.h"
+
+class FTGlyph;
+
+class FTOutlineFontImpl : public FTFontImpl
+{
+    friend class FTOutlineFont;
+
+    protected:
+        FTOutlineFontImpl(FTFont *ftFont, const char* fontFilePath);
+
+        FTOutlineFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+                          size_t bufferSizeInBytes);
+
+        /**
+         * Set the outset distance for the font. Only implemented by
+         * FTOutlineFont, FTPolygonFont and FTExtrudeFont
+         *
+         * @param outset  The outset distance.
+         */
+        virtual void Outset(float o) { outset = o; }
+
+        virtual FTPoint Render(const char *s, const int len,
+                               FTPoint position, FTPoint spacing,
+                               int renderMode);
+
+        virtual FTPoint Render(const wchar_t *s, const int len,
+                               FTPoint position, FTPoint spacing,
+                               int renderMode);
+
+    private:
+        /**
+         * The outset distance for the font.
+         */
+        float outset;
+
+        /* Internal generic Render() implementation */
+        template <typename T>
+        inline FTPoint RenderI(const T *s, const int len,
+                               FTPoint position, FTPoint spacing, int mode);
+};
+
+#endif // __FTOutlineFontImpl__
+
diff --git a/src/ftgl/FTFont/FTPixmapFont.cpp b/src/ftgl/FTFont/FTPixmapFont.cpp
new file mode 100644
index 0000000..5638ac8
--- /dev/null
+++ b/src/ftgl/FTFont/FTPixmapFont.cpp
@@ -0,0 +1,131 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTPixmapFontImpl.h"
+
+
+//
+//  FTPixmapFont
+//
+
+
+FTPixmapFont::FTPixmapFont(char const *fontFilePath) :
+    FTFont(new FTPixmapFontImpl(this, fontFilePath))
+{}
+
+
+FTPixmapFont::FTPixmapFont(const unsigned char *pBufferBytes,
+                           size_t bufferSizeInBytes) :
+    FTFont(new FTPixmapFontImpl(this, pBufferBytes, bufferSizeInBytes))
+{}
+
+
+FTPixmapFont::~FTPixmapFont()
+{}
+
+
+FTGlyph* FTPixmapFont::MakeGlyph(FT_GlyphSlot ftGlyph)
+{
+    return new FTPixmapGlyph(ftGlyph);
+}
+
+
+//
+//  FTPixmapFontImpl
+//
+
+
+FTPixmapFontImpl::FTPixmapFontImpl(FTFont *ftFont, const char* fontFilePath)
+: FTFontImpl(ftFont, fontFilePath)
+{
+    load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
+}
+
+
+FTPixmapFontImpl::FTPixmapFontImpl(FTFont *ftFont,
+                                   const unsigned char *pBufferBytes,
+                                   size_t bufferSizeInBytes)
+: FTFontImpl(ftFont, pBufferBytes, bufferSizeInBytes)
+{
+    load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
+}
+
+
+template <typename T>
+inline FTPoint FTPixmapFontImpl::RenderI(const T* string, const int len,
+                                         FTPoint position, FTPoint spacing,
+                                         int renderMode)
+{
+    // Protect GL_TEXTURE_2D and GL_BLEND, glPixelTransferf(), and blending
+    // functions.
+    glPushAttrib(GL_ENABLE_BIT | GL_PIXEL_MODE_BIT | GL_COLOR_BUFFER_BIT);
+
+    // Protect glPixelStorei() calls (made by FTPixmapGlyphImpl::RenderImpl).
+    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]);
+
+    FTPoint tmp = FTFontImpl::Render(string, len,
+                                     position, spacing, renderMode);
+
+    glPopClientAttrib();
+    glPopAttrib();
+
+    return tmp;
+}
+
+
+FTPoint FTPixmapFontImpl::Render(const char * string, const int len,
+                                 FTPoint position, FTPoint spacing,
+                                 int renderMode)
+{
+    return RenderI(string, len, position, spacing, renderMode);
+}
+
+
+FTPoint FTPixmapFontImpl::Render(const wchar_t * string, const int len,
+                                 FTPoint position, FTPoint spacing,
+                                 int renderMode)
+{
+    return RenderI(string, len, position, spacing, renderMode);
+}
+
diff --git a/src/ftgl/FTFont/FTPixmapFontImpl.h b/src/ftgl/FTFont/FTPixmapFontImpl.h
new file mode 100644
index 0000000..321f4a6
--- /dev/null
+++ b/src/ftgl/FTFont/FTPixmapFontImpl.h
@@ -0,0 +1,60 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTPixmapFontImpl__
+#define __FTPixmapFontImpl__
+
+#include "FTFontImpl.h"
+
+class FTGlyph;
+
+class FTPixmapFontImpl : public FTFontImpl
+{
+    friend class FTPixmapFont;
+
+    protected:
+        FTPixmapFontImpl(FTFont *ftFont, const char* fontFilePath);
+
+        FTPixmapFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+                         size_t bufferSizeInBytes);
+
+        virtual FTPoint Render(const char *s, const int len,
+                               FTPoint position, FTPoint spacing,
+                               int renderMode);
+
+        virtual FTPoint Render(const wchar_t *s, const int len,
+                               FTPoint position, FTPoint spacing,
+                               int renderMode);
+
+    private:
+        /* Internal generic Render() implementation */
+        template <typename T>
+        inline FTPoint RenderI(const T *s, const int len,
+                               FTPoint position, FTPoint spacing, int mode);
+};
+
+#endif  //  __FTPixmapFontImpl__
+
diff --git a/src/ftgl/FTFont/FTPolygonFont.cpp b/src/ftgl/FTFont/FTPolygonFont.cpp
new file mode 100644
index 0000000..83c3ad1
--- /dev/null
+++ b/src/ftgl/FTFont/FTPolygonFont.cpp
@@ -0,0 +1,89 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTPolygonFontImpl.h"
+
+
+//
+//  FTPolygonFont
+//
+
+
+FTPolygonFont::FTPolygonFont(char const *fontFilePath) :
+    FTFont(new FTPolygonFontImpl(this, fontFilePath))
+{}
+
+
+FTPolygonFont::FTPolygonFont(const unsigned char *pBufferBytes,
+                             size_t bufferSizeInBytes) :
+    FTFont(new FTPolygonFontImpl(this, pBufferBytes, bufferSizeInBytes))
+{}
+
+
+FTPolygonFont::~FTPolygonFont()
+{}
+
+
+FTGlyph* FTPolygonFont::MakeGlyph(FT_GlyphSlot ftGlyph)
+{
+    FTPolygonFontImpl *myimpl = dynamic_cast<FTPolygonFontImpl *>(impl);
+    if(!myimpl)
+    {
+        return NULL;
+    }
+
+    return new FTPolygonGlyph(ftGlyph, myimpl->outset,
+                              myimpl->useDisplayLists);
+}
+
+
+//
+//  FTPolygonFontImpl
+//
+
+
+FTPolygonFontImpl::FTPolygonFontImpl(FTFont *ftFont, const char* fontFilePath)
+: FTFontImpl(ftFont, fontFilePath),
+  outset(0.0f)
+{
+    load_flags = FT_LOAD_NO_HINTING;
+}
+
+
+FTPolygonFontImpl::FTPolygonFontImpl(FTFont *ftFont,
+                                     const unsigned char *pBufferBytes,
+                                     size_t bufferSizeInBytes)
+: FTFontImpl(ftFont, pBufferBytes, bufferSizeInBytes),
+  outset(0.0f)
+{
+    load_flags = FT_LOAD_NO_HINTING;
+}
+
diff --git a/src/ftgl/FTFont/FTPolygonFontImpl.h b/src/ftgl/FTFont/FTPolygonFontImpl.h
new file mode 100644
index 0000000..47b35a6
--- /dev/null
+++ b/src/ftgl/FTFont/FTPolygonFontImpl.h
@@ -0,0 +1,60 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTPolygonFontImpl__
+#define __FTPolygonFontImpl__
+
+#include "FTFontImpl.h"
+
+class FTGlyph;
+
+class FTPolygonFontImpl : public FTFontImpl
+{
+    friend class FTPolygonFont;
+
+    protected:
+        FTPolygonFontImpl(FTFont *ftFont, const char* fontFilePath);
+
+        FTPolygonFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+                          size_t bufferSizeInBytes);
+
+        /**
+         * Set the outset distance for the font. Only implemented by
+         * FTOutlineFont, FTPolygonFont and FTExtrudeFont
+         *
+         * @param depth  The outset distance.
+         */
+        virtual void Outset(float o) { outset = o; }
+
+    private:
+        /**
+         * The outset distance (front and back) for the font.
+         */
+        float outset;
+};
+
+#endif  //  __FTPolygonFontImpl__
+
diff --git a/src/ftgl/FTFont/FTTextureFont.cpp b/src/ftgl/FTFont/FTTextureFont.cpp
new file mode 100644
index 0000000..4e385ea
--- /dev/null
+++ b/src/ftgl/FTFont/FTTextureFont.cpp
@@ -0,0 +1,267 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <cassert>
+#include <string> // For memset
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+
+#include "../FTGlyph/FTTextureGlyphImpl.h"
+#include "./FTTextureFontImpl.h"
+
+
+//
+//  FTTextureFont
+//
+
+
+FTTextureFont::FTTextureFont(char const *fontFilePath) :
+    FTFont(new FTTextureFontImpl(this, fontFilePath))
+{}
+
+
+FTTextureFont::FTTextureFont(const unsigned char *pBufferBytes,
+                             size_t bufferSizeInBytes) :
+    FTFont(new FTTextureFontImpl(this, pBufferBytes, bufferSizeInBytes))
+{}
+
+
+FTTextureFont::~FTTextureFont()
+{}
+
+
+FTGlyph* FTTextureFont::MakeGlyph(FT_GlyphSlot ftGlyph)
+{
+    FTTextureFontImpl *myimpl = dynamic_cast<FTTextureFontImpl *>(impl);
+    if(!myimpl)
+    {
+        return NULL;
+    }
+
+    return myimpl->MakeGlyphImpl(ftGlyph);
+}
+
+
+//
+//  FTTextureFontImpl
+//
+
+
+static 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;
+}
+
+
+FTTextureFontImpl::FTTextureFontImpl(FTFont *ftFont, const char* fontFilePath)
+:   FTFontImpl(ftFont, fontFilePath),
+    maximumGLTextureSize(0),
+    textureWidth(0),
+    textureHeight(0),
+    glyphHeight(0),
+    glyphWidth(0),
+    padding(3),
+    xOffset(0),
+    yOffset(0)
+{
+    load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
+    remGlyphs = numGlyphs = face.GlyphCount();
+}
+
+
+FTTextureFontImpl::FTTextureFontImpl(FTFont *ftFont,
+                                     const unsigned char *pBufferBytes,
+                                     size_t bufferSizeInBytes)
+:   FTFontImpl(ftFont, pBufferBytes, bufferSizeInBytes),
+    maximumGLTextureSize(0),
+    textureWidth(0),
+    textureHeight(0),
+    glyphHeight(0),
+    glyphWidth(0),
+    padding(3),
+    xOffset(0),
+    yOffset(0)
+{
+    load_flags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
+    remGlyphs = numGlyphs = face.GlyphCount();
+}
+
+
+FTTextureFontImpl::~FTTextureFontImpl()
+{
+    if(textureIDList.size())
+    {
+        glDeleteTextures((GLsizei)textureIDList.size(),
+                         (const GLuint*)&textureIDList[0]);
+    }
+}
+
+
+FTGlyph* FTTextureFontImpl::MakeGlyphImpl(FT_GlyphSlot ftGlyph)
+{
+    glyphHeight = static_cast<int>(charSize.Height() + 0.5);
+    glyphWidth = static_cast<int>(charSize.Width() + 0.5);
+
+    if(glyphHeight < 1) glyphHeight = 1;
+    if(glyphWidth < 1) glyphWidth = 1;
+
+    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().Upper().X() - tempGlyph->BBox().Lower().X() + padding + 0.5);
+
+    --remGlyphs;
+
+    return tempGlyph;
+}
+
+
+void FTTextureFontImpl::CalculateTextureSize()
+{
+    if(!maximumGLTextureSize)
+    {
+        maximumGLTextureSize = 1024;
+        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 + 0.5);
+
+    textureHeight = NextPowerOf2(((numGlyphs / h) + 1) * glyphHeight);
+    textureHeight = textureHeight > maximumGLTextureSize ? maximumGLTextureSize : textureHeight;
+}
+
+
+GLuint FTTextureFontImpl::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 FTTextureFontImpl::FaceSize(const unsigned int size, const unsigned int res)
+{
+    if(!textureIDList.empty())
+    {
+        glDeleteTextures((GLsizei)textureIDList.size(), (const GLuint*)&textureIDList[0]);
+        textureIDList.clear();
+        remGlyphs = numGlyphs = face.GlyphCount();
+    }
+
+    return FTFontImpl::FaceSize(size, res);
+}
+
+
+template <typename T>
+inline FTPoint FTTextureFontImpl::RenderI(const T* string, const int len,
+                                          FTPoint position, FTPoint spacing,
+                                          int renderMode)
+{
+    // Protect GL_TEXTURE_2D, GL_BLEND and blending functions
+    glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT);
+
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // GL_ONE
+
+    glEnable(GL_TEXTURE_2D);
+
+    FTTextureGlyphImpl::ResetActiveTexture();
+
+    FTPoint tmp = FTFontImpl::Render(string, len,
+                                     position, spacing, renderMode);
+
+    glPopAttrib();
+
+    return tmp;
+}
+
+
+FTPoint FTTextureFontImpl::Render(const char * string, const int len,
+                                  FTPoint position, FTPoint spacing,
+                                  int renderMode)
+{
+    return RenderI(string, len, position, spacing, renderMode);
+}
+
+
+FTPoint FTTextureFontImpl::Render(const wchar_t * string, const int len,
+                                  FTPoint position, FTPoint spacing,
+                                  int renderMode)
+{
+    return RenderI(string, len, position, spacing, renderMode);
+}
+
diff --git a/src/ftgl/FTFont/FTTextureFontImpl.h b/src/ftgl/FTFont/FTTextureFontImpl.h
new file mode 100644
index 0000000..c9cf22b
--- /dev/null
+++ b/src/ftgl/FTFont/FTTextureFontImpl.h
@@ -0,0 +1,152 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTTextureFontImpl__
+#define __FTTextureFontImpl__
+
+#include "FTFontImpl.h"
+
+#include "FTVector.h"
+
+class FTTextureGlyph;
+
+class FTTextureFontImpl : public FTFontImpl
+{
+    friend class FTTextureFont;
+
+    protected:
+        FTTextureFontImpl(FTFont *ftFont, const char* fontFilePath);
+
+        FTTextureFontImpl(FTFont *ftFont, const unsigned char *pBufferBytes,
+                          size_t bufferSizeInBytes);
+
+        virtual ~FTTextureFontImpl();
+
+        /**
+         * 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);
+
+        virtual FTPoint Render(const char *s, const int len,
+                               FTPoint position, FTPoint spacing,
+                               int renderMode);
+
+        virtual FTPoint Render(const wchar_t *s, const int len,
+                               FTPoint position, FTPoint spacing,
+                               int renderMode);
+
+    private:
+        /**
+         * Create an FTTextureGlyph object for the base class.
+         */
+        FTGlyph* MakeGlyphImpl(FT_GlyphSlot ftGlyph);
+
+        /**
+         * 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;
+
+        /* Internal generic Render() implementation */
+        template <typename T>
+        inline FTPoint RenderI(const T *s, const int len,
+                               FTPoint position, FTPoint spacing, int mode);
+};
+
+#endif // __FTTextureFontImpl__
+
diff --git a/src/ftgl/FTGL/FTBBox.h b/src/ftgl/FTGL/FTBBox.h
new file mode 100644
index 0000000..858ff7a
--- /dev/null
+++ b/src/ftgl/FTGL/FTBBox.h
@@ -0,0 +1,180 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTBBox__
+#define __FTBBox__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTBBox is a convenience class for handling bounding boxes.
+ */
+class FTGL_EXPORT FTBBox
+{
+    public:
+        /**
+         * Default constructor. Bounding box is set to zero.
+         */
+        FTBBox()
+        :   lower(0.0f, 0.0f, 0.0f),
+            upper(0.0f, 0.0f, 0.0f)
+        {}
+
+        /**
+         * Constructor.
+         */
+        FTBBox(float lx, float ly, float lz, float ux, float uy, float uz)
+        :   lower(lx, ly, lz),
+            upper(ux, uy, uz)
+        {}
+
+        /**
+         * Constructor.
+         */
+        FTBBox(FTPoint l, FTPoint u)
+        :   lower(l),
+            upper(u)
+        {}
+
+        /**
+         * 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)
+        :   lower(0.0f, 0.0f, 0.0f),
+            upper(0.0f, 0.0f, 0.0f)
+        {
+            FT_BBox bbox;
+            FT_Outline_Get_CBox(&(glyph->outline), &bbox);
+
+            lower.X(static_cast<float>(bbox.xMin) / 64.0f);
+            lower.Y(static_cast<float>(bbox.yMin) / 64.0f);
+            lower.Z(0.0f);
+            upper.X(static_cast<float>(bbox.xMax) / 64.0f);
+            upper.Y(static_cast<float>(bbox.yMax) / 64.0f);
+            upper.Z(0.0f);
+        }
+
+        /**
+         * Destructor
+         */
+        ~FTBBox()
+        {}
+
+        /**
+         * Mark the bounds invalid by setting all lower dimensions greater
+         * than the upper dimensions.
+         */
+        void Invalidate()
+        {
+            lower = FTPoint(1.0f, 1.0f, 1.0f);
+            upper = FTPoint(-1.0f, -1.0f, -1.0f);
+        }
+
+        /**
+         * Determines if this bounding box is valid.
+         *
+         * @return True if all lower values are <= the corresponding
+         *         upper values.
+         */
+        bool IsValid()
+        {
+            return lower.X() <= upper.X()
+                && lower.Y() <= upper.Y()
+                && lower.Z() <= upper.Z();
+        }
+
+        /**
+         * Move the Bounding Box by a vector.
+         *
+         * @param vector  The vector to move the bbox in 3D space.
+         */
+        FTBBox& operator += (const FTPoint vector)
+        {
+            lower += vector;
+            upper += vector;
+
+            return *this;
+        }
+
+        /**
+         * Combine two bounding boxes. The result is the smallest bounding
+         * box containing the two original boxes.
+         *
+         * @param bbox  The bounding box to merge with the second one.
+         */
+        FTBBox& operator |= (const FTBBox& bbox)
+        {
+            if(bbox.lower.X() < lower.X()) lower.X(bbox.lower.X());
+            if(bbox.lower.Y() < lower.Y()) lower.Y(bbox.lower.Y());
+            if(bbox.lower.Z() < lower.Z()) lower.Z(bbox.lower.Z());
+            if(bbox.upper.X() > upper.X()) upper.X(bbox.upper.X());
+            if(bbox.upper.Y() > upper.Y()) upper.Y(bbox.upper.Y());
+            if(bbox.upper.Z() > upper.Z()) upper.Z(bbox.upper.Z());
+
+            return *this;
+        }
+
+        void SetDepth(float depth)
+        {
+            if(depth > 0)
+                upper.Z(lower.Z() + depth);
+            else
+                lower.Z(upper.Z() + depth);
+        }
+
+
+        inline FTPoint const Upper() const
+        {
+            return upper;
+        }
+
+
+        inline FTPoint const Lower() const
+        {
+            return lower;
+        }
+
+    private:
+        /**
+         * The bounds of the box
+         */
+        FTPoint lower, upper;
+};
+
+#endif //__cplusplus
+
+#endif  //  __FTBBox__
+
diff --git a/src/ftgl/FTGL/FTBitmapGlyph.h b/src/ftgl/FTGL/FTBitmapGlyph.h
new file mode 100644
index 0000000..f8ef87f
--- /dev/null
+++ b/src/ftgl/FTGL/FTBitmapGlyph.h
@@ -0,0 +1,82 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTBitmapGlyph__
+#define __FTBitmapGlyph__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTBitmapGlyph is a specialisation of FTGlyph for creating bitmaps.
+ */
+class FTGL_EXPORT FTBitmapGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param glyph The Freetype glyph to be processed
+         */
+        FTBitmapGlyph(FT_GlyphSlot glyph);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTBitmapGlyph();
+
+        /**
+         * Render this glyph at the current pen position.
+         *
+         * @param pen  The current pen position.
+         * @param renderMode  Render mode to display
+         * @return  The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render(const FTPoint& pen, int renderMode);
+};
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * Create a specialisation of FTGLglyph for creating bitmaps.
+ *
+ * @param glyph The Freetype glyph to be processed
+ * @return  An FTGLglyph* object.
+ */
+FTGL_EXPORT FTGLglyph *ftglCreateBitmapGlyph(FT_GlyphSlot glyph);
+
+FTGL_END_C_DECLS
+
+#endif  //  __FTBitmapGlyph__
+
diff --git a/src/ftgl/FTGL/FTBuffer.h b/src/ftgl/FTGL/FTBuffer.h
new file mode 100644
index 0000000..11f33b5
--- /dev/null
+++ b/src/ftgl/FTGL/FTBuffer.h
@@ -0,0 +1,127 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning Please use <FTGL/ftgl.h> instead of <FTBuffer.h>.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTBuffer__
+#define __FTBuffer__
+
+#ifdef __cplusplus
+
+/**
+ * FTBuffer is a helper class for pixel buffers.
+ *
+ * It provides the interface between FTBufferFont and FTBufferGlyph to
+ * optimise rendering operations.
+ *
+ * @see FTBufferGlyph
+ * @see FTBufferFont
+ */
+class FTGL_EXPORT FTBuffer
+{
+    public:
+        /**
+         * Default constructor.
+         */
+        FTBuffer();
+
+        /**
+         * Destructor
+         */
+        ~FTBuffer();
+
+        /**
+         * Get the pen's position in the buffer.
+         *
+         * @return  The pen's position as an FTPoint object.
+         */
+        inline FTPoint Pos() const
+        {
+            return pos;
+        }
+
+        /**
+         * Set the pen's position in the buffer.
+         *
+         * @param arg  An FTPoint object with the desired pen's position.
+         */
+        inline void Pos(FTPoint arg)
+        {
+            pos = arg;
+        }
+
+        /**
+         * Set the buffer's size.
+         *
+         * @param w  The buffer's desired width, in pixels.
+         * @param h  The buffer's desired height, in pixels.
+         */
+        void Size(int w, int h);
+
+        /**
+         * Get the buffer's width.
+         *
+         * @return  The buffer's width, in pixels.
+         */
+        inline int Width() const { return width; }
+
+        /**
+         * Get the buffer's height.
+         *
+         * @return  The buffer's height, in pixels.
+         */
+        inline int Height() const { return height; }
+
+        /**
+         * Get the buffer's direct pixel buffer.
+         *
+         * @return  A read-write pointer to the buffer's pixels.
+         */
+        inline unsigned char *Pixels() const { return pixels; }
+
+    private:
+        /**
+         * Buffer's width and height.
+         */
+        int width, height;
+
+        /**
+         * Buffer's pixel buffer.
+         */
+        unsigned char *pixels;
+
+        /**
+         * Buffer's internal pen position.
+         */
+        FTPoint pos;
+};
+
+#endif //__cplusplus
+
+#endif // __FTBuffer__
+
diff --git a/src/ftgl/FTGL/FTBufferFont.h b/src/ftgl/FTGL/FTBufferFont.h
new file mode 100644
index 0000000..15d358d
--- /dev/null
+++ b/src/ftgl/FTGL/FTBufferFont.h
@@ -0,0 +1,99 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning Please use <FTGL/ftgl.h> instead of <FTBufferFont.h>.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTBufferFont__
+#define __FTBufferFont__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTBufferFont is a specialisation of the FTFont class for handling
+ * memory buffer fonts.
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTBufferFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTBufferFont(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
+         */
+        FTBufferFont(const unsigned char *pBufferBytes,
+                     size_t bufferSizeInBytes);
+
+        /**
+         * Destructor
+         */
+        ~FTBufferFont();
+
+    protected:
+        /**
+         * Construct a glyph of the correct type.
+         *
+         * Clients must override the function and return their specialised
+         * FTGlyph.
+         *
+         * @param slot  A FreeType glyph slot.
+         * @return  An FT****Glyph or <code>null</code> on failure.
+         */
+        virtual FTGlyph* MakeGlyph(FT_GlyphSlot slot);
+};
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * Create a specialised FTGLfont object for handling memory buffer fonts.
+ *
+ * @param file  The font file name.
+ * @return  An FTGLfont* object.
+ *
+ * @see  FTGLfont
+ */
+FTGL_EXPORT FTGLfont *ftglCreateBufferFont(const char *file);
+
+FTGL_END_C_DECLS
+
+#endif  //  __FTBufferFont__
+
diff --git a/src/ftgl/FTGL/FTBufferGlyph.h b/src/ftgl/FTGL/FTBufferGlyph.h
new file mode 100644
index 0000000..cb7b3ed
--- /dev/null
+++ b/src/ftgl/FTGL/FTBufferGlyph.h
@@ -0,0 +1,69 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning Please use <FTGL/ftgl.h> instead of <FTBufferGlyph.h>.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTBufferGlyph__
+#define __FTBufferGlyph__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTBufferGlyph is a specialisation of FTGlyph for memory buffer rendering.
+ */
+class FTGL_EXPORT FTBufferGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param glyph The Freetype glyph to be processed
+         * @param buffer  An FTBuffer object in which to render the glyph.
+         */
+        FTBufferGlyph(FT_GlyphSlot glyph, FTBuffer *buffer);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTBufferGlyph();
+
+        /**
+         * Render this glyph at the current pen position.
+         *
+         * @param pen  The current pen position.
+         * @param renderMode  Render mode to display
+         * @return  The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render(const FTPoint& pen, int renderMode);
+};
+
+#endif //__cplusplus
+
+#endif  //  __FTBufferGlyph__
+
diff --git a/src/ftgl/FTGL/FTExtrdGlyph.h b/src/ftgl/FTGL/FTExtrdGlyph.h
new file mode 100644
index 0000000..c1eaa54
--- /dev/null
+++ b/src/ftgl/FTGL/FTExtrdGlyph.h
@@ -0,0 +1,104 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTExtrudeGlyph__
+#define __FTExtrudeGlyph__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTExtrudeGlyph is a specialisation of FTGlyph for creating tessellated
+ * extruded polygon glyphs.
+ */
+class FTGL_EXPORT FTExtrudeGlyph : 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 frontOutset outset contour size
+         * @param backOutset outset contour size
+         * @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.
+         */
+        FTExtrudeGlyph(FT_GlyphSlot glyph, float depth, float frontOutset,
+                       float backOutset, bool useDisplayList);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTExtrudeGlyph();
+
+        /**
+         * Render this glyph at the current pen position.
+         *
+         * @param pen  The current pen position.
+         * @param renderMode  Render mode to display
+         * @return  The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render(const FTPoint& pen, int renderMode);
+};
+
+#define FTExtrdGlyph FTExtrudeGlyph
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * Create a specialisation of FTGLglyph for creating tessellated
+ * extruded polygon glyphs.
+ *
+ * @param glyph The Freetype glyph to be processed
+ * @param depth The distance along the z axis to extrude the glyph
+ * @param frontOutset outset contour size
+ * @param backOutset outset contour size
+ * @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.
+ * @return  An FTGLglyph* object.
+ */
+FTGL_EXPORT FTGLglyph *ftglCreateExtrudeGlyph(FT_GlyphSlot glyph, float depth,
+                                float frontOutset, float backOutset,
+                                int useDisplayList);
+
+FTGL_END_C_DECLS
+
+#endif  //  __FTExtrudeGlyph__
+
diff --git a/src/ftgl/FTGL/FTFont.h b/src/ftgl/FTGL/FTFont.h
new file mode 100644
index 0000000..0799fff
--- /dev/null
+++ b/src/ftgl/FTGL/FTFont.h
@@ -0,0 +1,584 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTFont__
+#define __FTFont__
+
+#ifdef __cplusplus
+
+class FTFontImpl;
+
+/**
+ * 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
+ */
+class FTGL_EXPORT FTFont
+{
+    protected:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTFont(char const *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);
+
+    private:
+        /* Allow our internal subclasses to access the private constructor */
+        friend class FTBitmapFont;
+        friend class FTBufferFont;
+        friend class FTExtrudeFont;
+        friend class FTOutlineFont;
+        friend class FTPixmapFont;
+        friend class FTPolygonFont;
+        friend class FTTextureFont;
+
+        /**
+         * Internal FTGL FTFont constructor. For private use only.
+         *
+         * @param pImpl  Internal implementation object. Will be destroyed
+         *               upon FTFont deletion.
+         */
+        FTFont(FTFontImpl *pImpl);
+
+    public:
+        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.
+         */
+        virtual 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.
+         */
+        virtual bool Attach(const unsigned char *pBufferBytes,
+                            size_t bufferSizeInBytes);
+
+        /**
+         * Set the glyph loading flags. By default, fonts use the most
+         * sensible flags when loading a font's glyph using FT_Load_Glyph().
+         * This function allows to override the default flags.
+         *
+         * @param flags  The glyph loading flags.
+         */
+        virtual void GlyphLoadFlags(FT_Int flags);
+
+        /**
+         * 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.
+         */
+        virtual bool CharMap(FT_Encoding encoding);
+
+        /**
+         * Get the number of character maps in this face.
+         *
+         * @return character map count.
+         */
+        virtual unsigned int CharMapCount() const;
+
+        /**
+         * Get a list of character maps in this face.
+         *
+         * @return pointer to the first encoding.
+         */
+        virtual 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 (1/72 inch).
+         *
+         * @return face size
+         */
+        virtual unsigned int FaceSize() const;
+
+        /**
+         * Set the extrusion distance for the font. Only implemented by
+         * FTExtrudeFont
+         *
+         * @param depth  The extrusion distance.
+         */
+        virtual void Depth(float depth);
+
+        /**
+         * Set the outset distance for the font. Only implemented by
+         * FTOutlineFont, FTPolygonFont and FTExtrudeFont
+         *
+         * @param outset  The outset distance.
+         */
+        virtual void Outset(float outset);
+
+        /**
+         * Set the front and back outset distances for the font. Only
+         * implemented by FTExtrudeFont
+         *
+         * @param front  The front outset distance.
+         * @param back   The back outset distance.
+         */
+        virtual void Outset(float front, float back);
+
+        /**
+         * 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.
+         */
+        virtual void UseDisplayList(bool useList);
+
+        /**
+         * Get the global ascender height for the face.
+         *
+         * @return  Ascender height
+         */
+        virtual float Ascender() const;
+
+        /**
+         * Gets the global descender height for the face.
+         *
+         * @return  Descender height
+         */
+        virtual float Descender() const;
+
+        /**
+         * Gets the line spacing for the font.
+         *
+         * @return  Line height
+         */
+        virtual float LineHeight() const;
+
+        /**
+         * Get the bounding box for a string.
+         *
+         * @param string  A char buffer.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be checked until a null character is encountered
+         *             (optional).
+         * @param position  The pen position of the first character (optional).
+         * @param spacing  A displacement vector to add after each character
+         *                 has been checked (optional).
+         * @return  The corresponding bounding box.
+         */
+        virtual FTBBox BBox(const char *string, const int len = -1,
+                            FTPoint position = FTPoint(),
+                            FTPoint spacing = FTPoint());
+
+        /**
+         * Get the bounding box for a string (deprecated).
+         *
+         * @param string  A char buffer.
+         * @param llx  Lower left near x coordinate.
+         * @param lly  Lower left near y coordinate.
+         * @param llz  Lower left near z coordinate.
+         * @param urx  Upper right far x coordinate.
+         * @param ury  Upper right far y coordinate.
+         * @param urz  Upper right far z coordinate.
+         */
+        void BBox(const char* string, float& llx, float& lly, float& llz,
+                  float& urx, float& ury, float& urz)
+        {
+            FTBBox b = BBox(string);
+            llx = b.Lower().Xf(); lly = b.Lower().Yf(); llz = b.Lower().Zf();
+            urx = b.Upper().Xf(); ury = b.Upper().Yf(); urz = b.Upper().Zf();
+        }
+
+        /**
+         * Get the bounding box for a string.
+         *
+         * @param string  A wchar_t buffer.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be checked until a null character is encountered
+         *             (optional).
+         * @param position  The pen position of the first character (optional).
+         * @param spacing  A displacement vector to add after each character
+         *                 has been checked (optional).
+         * @return  The corresponding bounding box.
+         */
+        virtual FTBBox BBox(const wchar_t *string, const int len = -1,
+                            FTPoint position = FTPoint(),
+                            FTPoint spacing = FTPoint());
+
+        /**
+         * Get the bounding box for a string (deprecated).
+         *
+         * @param string  A wchar_t buffer.
+         * @param llx  Lower left near x coordinate.
+         * @param lly  Lower left near y coordinate.
+         * @param llz  Lower left near z coordinate.
+         * @param urx  Upper right far x coordinate.
+         * @param ury  Upper right far y coordinate.
+         * @param urz  Upper right far z coordinate.
+         */
+        void BBox(const wchar_t* string, float& llx, float& lly, float& llz,
+                  float& urx, float& ury, float& urz)
+        {
+            FTBBox b = BBox(string);
+            llx = b.Lower().Xf(); lly = b.Lower().Yf(); llz = b.Lower().Zf();
+            urx = b.Upper().Xf(); ury = b.Upper().Yf(); urz = b.Upper().Zf();
+        }
+
+        /**
+         * Get the advance for a string.
+         *
+         * @param string  'C' style string to be checked.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be checked until a null character is encountered
+         *             (optional).
+         * @param spacing  A displacement vector to add after each character
+         *                 has been checked (optional).
+         * @return  The string's advance width.
+         */
+        virtual float Advance(const char* string, const int len = -1,
+                              FTPoint spacing = FTPoint());
+
+        /**
+         * Get the advance for a string.
+         *
+         * @param string  A wchar_t string
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be checked until a null character is encountered
+         *             (optional).
+         * @param spacing  A displacement vector to add after each character
+         *                 has been checked (optional).
+         * @return  The string's advance width.
+         */
+        virtual float Advance(const wchar_t* string, const int len = -1,
+                              FTPoint spacing = FTPoint());
+
+        /**
+         * Render a string of characters.
+         *
+         * @param string  'C' style string to be output.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be displayed until a null character is encountered
+         *             (optional).
+         * @param position  The pen position of the first character (optional).
+         * @param spacing  A displacement vector to add after each character
+         *                 has been displayed (optional).
+         * @param renderMode  Render mode to use for display (optional).
+         * @return  The new pen position after the last character was output.
+         */
+        virtual FTPoint Render(const char* string, const int len = -1,
+                               FTPoint position = FTPoint(),
+                               FTPoint spacing = FTPoint(),
+                               int renderMode = FTGL::RENDER_ALL);
+
+        /**
+         * Render a string of characters
+         *
+         * @param string    wchar_t string to be output.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be displayed until a null character is encountered
+         *             (optional).
+         * @param position  The pen position of the first character (optional).
+         * @param spacing  A displacement vector to add after each character
+         *                 has been displayed (optional).
+         * @param renderMode  Render mode to use for display (optional).
+         * @return  The new pen position after the last character was output.
+         */
+        virtual FTPoint Render(const wchar_t *string, const int len = -1,
+                               FTPoint position = FTPoint(),
+                               FTPoint spacing = FTPoint(),
+                               int renderMode = FTGL::RENDER_ALL);
+
+        /**
+         * Queries the Font for errors.
+         *
+         * @return  The current error code.
+         */
+        virtual FT_Error Error() const;
+
+    protected:
+        /* Allow impl to access MakeGlyph */
+        friend class FTFontImpl;
+
+        /**
+         * Construct a glyph of the correct type.
+         *
+         * Clients must override the function and return their specialised
+         * FTGlyph.
+         *
+         * @param slot  A FreeType glyph slot.
+         * @return  An FT****Glyph or <code>null</code> on failure.
+         */
+        virtual FTGlyph* MakeGlyph(FT_GlyphSlot slot) = 0;
+
+    private:
+        /**
+         * Internal FTGL FTFont implementation object. For private use only.
+         */
+        FTFontImpl *impl;
+};
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * FTGLfont is the public interface for the FTGL library.
+ *
+ * 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.
+ */
+struct _FTGLFont;
+typedef struct _FTGLfont FTGLfont;
+
+/**
+ * Create a custom FTGL font object.
+ *
+ * @param fontFilePath  The font file name.
+ * @param data  A pointer to private data that will be passed to callbacks.
+ * @param makeglyphCallback  A glyph-making callback function.
+ * @return  An FTGLfont* object.
+ */
+FTGL_EXPORT FTGLfont *ftglCreateCustomFont(char const *fontFilePath,
+                                           void *data,
+                   FTGLglyph * (*makeglyphCallback) (FT_GlyphSlot, void *));
+
+/**
+ * Destroy an FTGL font object.
+ *
+ * @param font  An FTGLfont* object.
+ */
+FTGL_EXPORT void ftglDestroyFont(FTGLfont* font);
+
+/**
+ * Attach auxilliary file to font e.g. font metrics.
+ *
+ * Note: not all font formats implement this function.
+ *
+ * @param font  An FTGLfont* object.
+ * @param path  Auxilliary font file path.
+ * @return  1 if file has been attached successfully.
+ */
+FTGL_EXPORT int ftglAttachFile(FTGLfont* font, const char* path);
+
+/**
+ * Attach auxilliary data to font, e.g. font metrics, from memory.
+ *
+ * Note: not all font formats implement this function.
+ *
+ * @param font  An FTGLfont* object.
+ * @param data  The in-memory buffer.
+ * @param size  The length of the buffer in bytes.
+ * @return  1 if file has been attached successfully.
+ */
+FTGL_EXPORT int ftglAttachData(FTGLfont* font, const unsigned char * data,
+                               size_t size);
+
+/**
+ * Set the character map for the face.
+ *
+ * @param font  An FTGLfont* object.
+ * @param encoding  Freetype enumerate for char map code.
+ * @return  1 if charmap was valid and set correctly.
+ */
+FTGL_EXPORT int ftglSetFontCharMap(FTGLfont* font, FT_Encoding encoding);
+
+/**
+ * Get the number of character maps in this face.
+ *
+ * @param font  An FTGLfont* object.
+ * @return character map count.
+ */
+FTGL_EXPORT unsigned int ftglGetFontCharMapCount(FTGLfont* font);
+
+/**
+ * Get a list of character maps in this face.
+ *
+ * @param font  An FTGLfont* object.
+ * @return pointer to the first encoding.
+ */
+FTGL_EXPORT FT_Encoding* ftglGetFontCharMapList(FTGLfont* font);
+
+/**
+ * Set the char size for the current face.
+ *
+ * @param font  An FTGLfont* object.
+ * @param size  The face size in points (1/72 inch).
+ * @param res  The resolution of the target device, or 0 to use the default
+ *             value of 72.
+ * @return  1 if size was set correctly.
+ */
+FTGL_EXPORT int ftglSetFontFaceSize(FTGLfont* font, unsigned int size,
+                                    unsigned int res);
+
+/**
+ * Get the current face size in points (1/72 inch).
+ *
+ * @param font  An FTGLfont* object.
+ * @return face size
+ */
+FTGL_EXPORT unsigned int ftglGetFontFaceSize(FTGLfont* font);
+
+/**
+ * Set the extrusion distance for the font. Only implemented by
+ * FTExtrudeFont.
+ *
+ * @param font  An FTGLfont* object.
+ * @param depth  The extrusion distance.
+ */
+FTGL_EXPORT void ftglSetFontDepth(FTGLfont* font, float depth);
+
+/**
+ * Set the outset distance for the font. Only FTOutlineFont, FTPolygonFont
+ * and FTExtrudeFont implement front outset. Only FTExtrudeFont implements
+ * back outset.
+ *
+ * @param font  An FTGLfont* object.
+ * @param front  The front outset distance.
+ * @param back  The back outset distance.
+ */
+FTGL_EXPORT void ftglSetFontOutset(FTGLfont* font, float front, float back);
+
+/**
+ * Enable or disable the use of Display Lists inside FTGL.
+ *
+ * @param font  An FTGLfont* object.
+ * @param useList  1 turns ON display lists.
+ *                 0 turns OFF display lists.
+ */
+FTGL_EXPORT void ftglSetFontDisplayList(FTGLfont* font, int useList);
+
+/**
+ * Get the global ascender height for the face.
+ *
+ * @param font  An FTGLfont* object.
+ * @return  Ascender height
+ */
+FTGL_EXPORT float ftglGetFontAscender(FTGLfont* font);
+
+/**
+ * Gets the global descender height for the face.
+ *
+ * @param font  An FTGLfont* object.
+ * @return  Descender height
+ */
+FTGL_EXPORT float ftglGetFontDescender(FTGLfont* font);
+
+/**
+ * Gets the line spacing for the font.
+ *
+ * @param font  An FTGLfont* object.
+ * @return  Line height
+ */
+FTGL_EXPORT float ftglGetFontLineHeight(FTGLfont* font);
+
+/**
+ * Get the bounding box for a string.
+ *
+ * @param font  An FTGLfont* object.
+ * @param string  A char buffer
+ * @param len  The length of the string. If < 0 then all characters will be
+ *             checked until a null character is encountered (optional).
+ * @param bounds  An array of 6 float values where the bounding box's lower
+ *                left near and upper right far 3D coordinates will be stored.
+ */
+FTGL_EXPORT void ftglGetFontBBox(FTGLfont* font, const char *string,
+                                 int len, float bounds[6]);
+
+/**
+ * Get the advance width for a string.
+ *
+ * @param font  An FTGLfont* object.
+ * @param string  A char string.
+ * @return  Advance width
+ */
+FTGL_EXPORT float ftglGetFontAdvance(FTGLfont* font, const char *string);
+
+/**
+ * Render a string of characters.
+ *
+ * @param font  An FTGLfont* object.
+ * @param string  Char string to be output.
+ * @param mode  Render mode to display.
+ */
+FTGL_EXPORT void ftglRenderFont(FTGLfont* font, const char *string, int mode);
+
+/**
+ * Query a font for errors.
+ *
+ * @param font  An FTGLfont* object.
+ * @return  The current error code.
+ */
+FTGL_EXPORT FT_Error ftglGetFontError(FTGLfont* font);
+
+FTGL_END_C_DECLS
+
+#endif  //  __FTFont__
+
diff --git a/src/ftgl/FTGL/FTGLBitmapFont.h b/src/ftgl/FTGL/FTGLBitmapFont.h
new file mode 100644
index 0000000..d2fb1ba
--- /dev/null
+++ b/src/ftgl/FTGL/FTGLBitmapFont.h
@@ -0,0 +1,103 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTBitmapFont__
+#define __FTBitmapFont__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTBitmapFont is a specialisation of the FTFont class for handling
+ * Bitmap fonts
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTBitmapFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTBitmapFont(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
+         */
+        FTBitmapFont(const unsigned char *pBufferBytes,
+                     size_t bufferSizeInBytes);
+
+        /**
+         * Destructor
+         */
+        ~FTBitmapFont();
+
+    protected:
+        /**
+         * Construct a glyph of the correct type.
+         *
+         * Clients must override the function and return their specialised
+         * FTGlyph.
+         *
+         * @param slot  A FreeType glyph slot.
+         * @return  An FT****Glyph or <code>null</code> on failure.
+         */
+        virtual FTGlyph* MakeGlyph(FT_GlyphSlot slot);
+};
+
+#define FTGLBitmapFont FTBitmapFont
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * Create a specialised FTGLfont object for handling bitmap fonts.
+ *
+ * @param file  The font file name.
+ * @return  An FTGLfont* object.
+ *
+ * @see  FTGLfont
+ */
+FTGL_EXPORT FTGLfont *ftglCreateBitmapFont(const char *file);
+
+FTGL_END_C_DECLS
+
+#endif  //  __FTBitmapFont__
+
diff --git a/src/ftgl/FTGL/FTGLExtrdFont.h b/src/ftgl/FTGL/FTGLExtrdFont.h
new file mode 100644
index 0000000..47d6714
--- /dev/null
+++ b/src/ftgl/FTGL/FTGLExtrdFont.h
@@ -0,0 +1,105 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTExtrudeFont__
+#define __FTExtrudeFont__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTExtrudeFont is a specialisation of the FTFont class for handling
+ * extruded Polygon fonts
+ *
+ * @see FTFont
+ * @see FTPolygonFont
+ */
+class FTGL_EXPORT FTExtrudeFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTExtrudeFont(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
+         */
+        FTExtrudeFont(const unsigned char *pBufferBytes,
+                      size_t bufferSizeInBytes);
+
+        /**
+         * Destructor
+         */
+        ~FTExtrudeFont();
+
+    protected:
+        /**
+         * Construct a glyph of the correct type.
+         *
+         * Clients must override the function and return their specialised
+         * FTGlyph.
+         *
+         * @param slot  A FreeType glyph slot.
+         * @return  An FT****Glyph or <code>null</code> on failure.
+         */
+        virtual FTGlyph* MakeGlyph(FT_GlyphSlot slot);
+};
+
+#define FTGLExtrdFont FTExtrudeFont
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * Create a specialised FTGLfont object for handling extruded poygon fonts.
+ *
+ * @param file  The font file name.
+ * @return  An FTGLfont* object.
+ *
+ * @see  FTGLfont
+ * @see  ftglCreatePolygonFont
+ */
+FTGL_EXPORT FTGLfont *ftglCreateExtrudeFont(const char *file);
+
+FTGL_END_C_DECLS
+
+#endif // __FTExtrudeFont__
+
diff --git a/src/ftgl/FTGL/FTGLOutlineFont.h b/src/ftgl/FTGL/FTGLOutlineFont.h
new file mode 100644
index 0000000..bbf62da
--- /dev/null
+++ b/src/ftgl/FTGL/FTGLOutlineFont.h
@@ -0,0 +1,103 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTOutlineFont__
+#define __FTOutlineFont__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTOutlineFont is a specialisation of the FTFont class for handling
+ * Vector Outline fonts
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTOutlineFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTOutlineFont(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
+         */
+        FTOutlineFont(const unsigned char *pBufferBytes,
+                      size_t bufferSizeInBytes);
+
+        /**
+         * Destructor
+         */
+        ~FTOutlineFont();
+
+    protected:
+        /**
+         * Construct a glyph of the correct type.
+         *
+         * Clients must override the function and return their specialised
+         * FTGlyph.
+         *
+         * @param slot  A FreeType glyph slot.
+         * @return  An FT****Glyph or <code>null</code> on failure.
+         */
+        virtual FTGlyph* MakeGlyph(FT_GlyphSlot slot);
+};
+
+#define FTGLOutlineFont FTOutlineFont
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * Create a specialised FTGLfont object for handling vector outline fonts.
+ *
+ * @param file  The font file name.
+ * @return  An FTGLfont* object.
+ *
+ * @see  FTGLfont
+ */
+FTGL_EXPORT FTGLfont *ftglCreateOutlineFont(const char *file);
+
+FTGL_END_C_DECLS
+
+#endif // __FTOutlineFont__
+
diff --git a/src/ftgl/FTGL/FTGLPixmapFont.h b/src/ftgl/FTGL/FTGLPixmapFont.h
new file mode 100644
index 0000000..c90b9c5
--- /dev/null
+++ b/src/ftgl/FTGL/FTGLPixmapFont.h
@@ -0,0 +1,103 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTPixmapFont__
+#define __FTPixmapFont__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTPixmapFont is a specialisation of the FTFont class for handling
+ * Pixmap (Grey Scale) fonts
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTPixmapFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTPixmapFont(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
+         */
+        FTPixmapFont(const unsigned char *pBufferBytes,
+                     size_t bufferSizeInBytes);
+
+        /**
+         * Destructor
+         */
+        ~FTPixmapFont();
+
+    protected:
+        /**
+         * Construct a glyph of the correct type.
+         *
+         * Clients must override the function and return their specialised
+         * FTGlyph.
+         *
+         * @param slot  A FreeType glyph slot.
+         * @return  An FT****Glyph or <code>null</code> on failure.
+         */
+        virtual FTGlyph* MakeGlyph(FT_GlyphSlot slot);
+};
+
+#define FTGLPixmapFont FTPixmapFont
+
+#endif // __cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * Create a specialised FTGLfont object for handling pixmap (grey scale) fonts.
+ *
+ * @param file  The font file name.
+ * @return  An FTGLfont* object.
+ *
+ * @see  FTGLfont
+ */
+FTGL_EXPORT FTGLfont *ftglCreatePixmapFont(const char *file);
+
+FTGL_END_C_DECLS
+
+#endif  //  __FTPixmapFont__
+
diff --git a/src/ftgl/FTGL/FTGLPolygonFont.h b/src/ftgl/FTGL/FTGLPolygonFont.h
new file mode 100644
index 0000000..1dab097
--- /dev/null
+++ b/src/ftgl/FTGL/FTGLPolygonFont.h
@@ -0,0 +1,104 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTPolygonFont__
+#define __FTPolygonFont__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTPolygonFont is a specialisation of the FTFont class for handling
+ * tesselated Polygon Mesh fonts
+ *
+ * @see     FTFont
+ */
+class FTGL_EXPORT FTPolygonFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTPolygonFont(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
+         */
+        FTPolygonFont(const unsigned char *pBufferBytes,
+                      size_t bufferSizeInBytes);
+
+        /**
+         * Destructor
+         */
+        ~FTPolygonFont();
+
+    protected:
+        /**
+         * Construct a glyph of the correct type.
+         *
+         * Clients must override the function and return their specialised
+         * FTGlyph.
+         *
+         * @param slot  A FreeType glyph slot.
+         * @return  An FT****Glyph or <code>null</code> on failure.
+         */
+        virtual FTGlyph* MakeGlyph(FT_GlyphSlot slot);
+};
+
+#define FTGLPolygonFont FTPolygonFont
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * Create a specialised FTGLfont object for handling tesselated polygon
+ * mesh fonts.
+ *
+ * @param file  The font file name.
+ * @return  An FTGLfont* object.
+ *
+ * @see  FTGLfont
+ */
+FTGL_EXPORT FTGLfont *ftglCreatePolygonFont(const char *file);
+
+FTGL_END_C_DECLS
+
+#endif  //  __FTPolygonFont__
+
diff --git a/src/ftgl/FTGL/FTGLTextureFont.h b/src/ftgl/FTGL/FTGLTextureFont.h
new file mode 100644
index 0000000..03991e9
--- /dev/null
+++ b/src/ftgl/FTGL/FTGLTextureFont.h
@@ -0,0 +1,103 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTTextureFont__
+#define __FTTextureFont__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTTextureFont is a specialisation of the FTFont class for handling
+ * Texture mapped fonts
+ *
+ * @see     FTFont
+ */
+class  FTGL_EXPORT FTTextureFont : public FTFont
+{
+    public:
+        /**
+         * Open and read a font file. Sets Error flag.
+         *
+         * @param fontFilePath  font file path.
+         */
+        FTTextureFont(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
+         */
+        FTTextureFont(const unsigned char *pBufferBytes,
+                      size_t bufferSizeInBytes);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTTextureFont();
+
+    protected:
+        /**
+         * Construct a glyph of the correct type.
+         *
+         * Clients must override the function and return their specialised
+         * FTGlyph.
+         *
+         * @param slot  A FreeType glyph slot.
+         * @return  An FT****Glyph or <code>null</code> on failure.
+         */
+        virtual FTGlyph* MakeGlyph(FT_GlyphSlot slot);
+};
+
+#define FTGLTextureFont FTTextureFont
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * Create a specialised FTGLfont object for handling texture-mapped fonts.
+ *
+ * @param file  The font file name.
+ * @return  An FTGLfont* object.
+ *
+ * @see  FTGLfont
+ */
+FTGL_EXPORT FTGLfont *ftglCreateTextureFont(const char *file);
+
+FTGL_END_C_DECLS
+
+#endif // __FTTextureFont__
+
diff --git a/src/ftgl/FTGL/FTGlyph.h b/src/ftgl/FTGL/FTGlyph.h
new file mode 100644
index 0000000..a5023b2
--- /dev/null
+++ b/src/ftgl/FTGL/FTGlyph.h
@@ -0,0 +1,201 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTGlyph__
+#define __FTGlyph__
+
+#ifdef __cplusplus
+
+class FTGlyphImpl;
+
+/**
+ * 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 FTBBox
+ * @see FTPoint
+ */
+class FTGL_EXPORT FTGlyph
+{
+    protected:
+        /**
+         * Create a glyph.
+         *
+         * @param glyph  The Freetype glyph to be processed
+         */
+        FTGlyph(FT_GlyphSlot glyph);
+
+    private:
+        /**
+         * Internal FTGL FTGlyph constructor. For private use only.
+         *
+         * @param pImpl  Internal implementation object. Will be destroyed
+         *               upon FTGlyph deletion.
+         */
+        FTGlyph(FTGlyphImpl *pImpl);
+
+        /* Allow our internal subclasses to access the private constructor */
+        friend class FTBitmapGlyph;
+        friend class FTBufferGlyph;
+        friend class FTExtrudeGlyph;
+        friend class FTOutlineGlyph;
+        friend class FTPixmapGlyph;
+        friend class FTPolygonGlyph;
+        friend class FTTextureGlyph;
+
+    public:
+        /**
+          * Destructor
+          */
+        virtual ~FTGlyph();
+
+        /**
+         * Renders this glyph at the current pen position.
+         *
+         * @param pen  The current pen position.
+         * @param renderMode  Render mode to display
+         * @return  The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render(const FTPoint& pen, int renderMode) = 0;
+
+        /**
+         * Return the advance width for this glyph.
+         *
+         * @return  advance width.
+         */
+        virtual float Advance() const;
+
+        /**
+         * Return the bounding box for this glyph.
+         *
+         * @return  bounding box.
+         */
+        virtual const FTBBox& BBox() const;
+
+        /**
+         * Queries for errors.
+         *
+         * @return  The current error code.
+         */
+        virtual FT_Error Error() const;
+
+    private:
+        /**
+         * Internal FTGL FTGlyph implementation object. For private use only.
+         */
+        FTGlyphImpl *impl;
+};
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * FTGLglyph 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 ftglRenderGlyph() function.
+ */
+struct _FTGLGlyph;
+typedef struct _FTGLglyph FTGLglyph;
+
+/**
+ * Create a custom FTGL glyph object.
+ * FIXME: maybe get rid of "base" and have advanceCallback etc. functions
+ *
+ * @param base  The base FTGLglyph* to subclass.
+ * @param data  A pointer to private data that will be passed to callbacks.
+ * @param renderCallback  A rendering callback function.
+ * @param destroyCallback  A callback function to be called upon destruction.
+ * @return  An FTGLglyph* object.
+ */
+FTGL_EXPORT FTGLglyph *ftglCreateCustomGlyph(FTGLglyph *base, void *data,
+    void (*renderCallback) (FTGLglyph *, void *, FTGL_DOUBLE, FTGL_DOUBLE,
+                             int, FTGL_DOUBLE *, FTGL_DOUBLE *),
+    void (*destroyCallback) (FTGLglyph *, void *));
+
+/**
+ * Destroy an FTGL glyph object.
+ *
+ * @param glyph  An FTGLglyph* object.
+ */
+FTGL_EXPORT void ftglDestroyGlyph(FTGLglyph *glyph);
+
+/**
+ * Render a glyph at the current pen position and compute the corresponding
+ * advance.
+ *
+ * @param glyph  An FTGLglyph* object.
+ * @param penx  The current pen's X position.
+ * @param peny  The current pen's Y position.
+ * @param renderMode  Render mode to display
+ * @param advancex  A pointer to an FTGL_DOUBLE where to write the advance's X
+ *                  component.
+ * @param advancey  A pointer to an FTGL_DOUBLE where to write the advance's Y
+ *                  component.
+ */
+FTGL_EXPORT void ftglRenderGlyph(FTGLglyph *glyph, FTGL_DOUBLE penx,
+                                 FTGL_DOUBLE peny, int renderMode,
+                                 FTGL_DOUBLE *advancex, FTGL_DOUBLE *advancey);
+/**
+ * Return the advance for a glyph.
+ *
+ * @param glyph  An FTGLglyph* object.
+ * @return  The advance's X component.
+ */
+FTGL_EXPORT float ftglGetGlyphAdvance(FTGLglyph *glyph);
+
+/**
+ * Return the bounding box for a glyph.
+ *
+ * @param glyph  An FTGLglyph* object.
+ * @param bounds  An array of 6 float values where the bounding box's lower
+ *                left near and upper right far 3D coordinates will be stored.
+ */
+FTGL_EXPORT void ftglGetGlyphBBox(FTGLglyph *glyph, float bounds[6]);
+
+/**
+ * Query a glyph for errors.
+ *
+ * @param glyph  An FTGLglyph* object.
+ * @return  The current error code.
+ */
+FTGL_EXPORT FT_Error ftglGetGlyphError(FTGLglyph* glyph);
+
+FTGL_END_C_DECLS
+
+#endif  //  __FTGlyph__
+
diff --git a/src/ftgl/FTGL/FTLayout.h b/src/ftgl/FTGL/FTLayout.h
new file mode 100644
index 0000000..329b98a
--- /dev/null
+++ b/src/ftgl/FTGL/FTLayout.h
@@ -0,0 +1,192 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTLayout__
+#define __FTLayout__
+
+#ifdef __cplusplus
+
+
+class FTLayoutImpl;
+
+/**
+ * FTLayout is the interface for layout managers that render text.
+ *
+ * Specific layout manager classes are derived from this class. This class
+ * is abstract and deriving classes must implement the protected
+ * <code>Render</code> methods to render formatted text and
+ * <code>BBox</code> methods to determine the bounding box of output text.
+ *
+ * @see     FTFont
+ * @see     FTBBox
+ */
+class FTGL_EXPORT FTLayout
+{
+    protected:
+        FTLayout();
+
+    private:
+        /**
+         * Internal FTGL FTLayout constructor. For private use only.
+         *
+         * @param pImpl  Internal implementation object. Will be destroyed
+         *               upon FTLayout deletion.
+         */
+        FTLayout(FTLayoutImpl *pImpl);
+
+        /* Allow our internal subclasses to access the private constructor */
+        friend class FTSimpleLayout;
+
+    public:
+        /**
+         * Destructor
+         */
+        virtual ~FTLayout();
+
+        /**
+         * Get the bounding box for a formatted string.
+         *
+         * @param string  A char string.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be checked until a null character is encountered
+         *             (optional).
+         * @param position  The pen position of the first character (optional).
+         * @return  The corresponding bounding box.
+         */
+        virtual FTBBox BBox(const char* string, const int len = -1,
+                            FTPoint position = FTPoint()) = 0;
+
+        /**
+         * Get the bounding box for a formatted string.
+         *
+         * @param string  A wchar_t string.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be checked until a null character is encountered
+         *             (optional).
+         * @param position  The pen position of the first character (optional).
+         * @return  The corresponding bounding box.
+         */
+        virtual FTBBox BBox(const wchar_t* string, const int len = -1,
+                            FTPoint position = FTPoint()) = 0;
+
+        /**
+         * Render a string of characters.
+         *
+         * @param string    'C' style string to be output.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be displayed until a null character is encountered
+         *             (optional).
+         * @param position  The pen position of the first character (optional).
+         * @param renderMode  Render mode to display (optional)
+         */
+        virtual void Render(const char *string, const int len = -1,
+                            FTPoint position = FTPoint(),
+                            int renderMode = FTGL::RENDER_ALL) = 0;
+
+        /**
+         * Render a string of characters.
+         *
+         * @param string    wchar_t string to be output.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be displayed until a null character is encountered
+         *             (optional).
+         * @param position  The pen position of the first character (optional).
+         * @param renderMode  Render mode to display (optional)
+         */
+        virtual void Render(const wchar_t *string, const int len = -1,
+                            FTPoint position = FTPoint(),
+                            int renderMode = FTGL::RENDER_ALL) = 0;
+
+        /**
+         * Queries the Layout for errors.
+         *
+         * @return  The current error code.
+         */
+        virtual FT_Error Error() const;
+
+    private:
+        /**
+         * Internal FTGL FTLayout implementation object. For private use only.
+         */
+        FTLayoutImpl *impl;
+};
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * FTGLlayout is the interface for layout managers that render text.
+ */
+struct _FTGLlayout;
+typedef struct _FTGLlayout FTGLlayout;
+
+/**
+ * Destroy an FTGL layout object.
+ *
+ * @param layout  An FTGLlayout* object.
+ */
+FTGL_EXPORT void ftglDestroyLayout(FTGLlayout* layout);
+
+/**
+ * Get the bounding box for a string.
+ *
+ * @param layout  An FTGLlayout* object.
+ * @param string  A char buffer
+ * @param bounds  An array of 6 float values where the bounding box's lower
+ *                left near and upper right far 3D coordinates will be stored.
+ */
+FTGL_EXPORT void ftglGetLayoutBBox(FTGLlayout *layout, const char* string,
+                                   float bounds[6]);
+
+/**
+ * Render a string of characters.
+ *
+ * @param layout  An FTGLlayout* object.
+ * @param string  Char string to be output.
+ * @param mode  Render mode to display.
+ */
+FTGL_EXPORT void ftglRenderLayout(FTGLlayout *layout, const char *string,
+                                  int mode);
+
+/**
+ * Query a layout for errors.
+ *
+ * @param layout  An FTGLlayout* object.
+ * @return  The current error code.
+ */
+FTGL_EXPORT FT_Error ftglGetLayoutError(FTGLlayout* layout);
+
+FTGL_END_C_DECLS
+
+#endif  /* __FTLayout__ */
+
diff --git a/src/ftgl/FTGL/FTOutlineGlyph.h b/src/ftgl/FTGL/FTOutlineGlyph.h
new file mode 100644
index 0000000..2919139
--- /dev/null
+++ b/src/ftgl/FTGL/FTOutlineGlyph.h
@@ -0,0 +1,94 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTOutlineGlyph__
+#define __FTOutlineGlyph__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTOutlineGlyph is a specialisation of FTGlyph for creating outlines.
+ */
+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 outset outset distance
+         * @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, float outset, bool useDisplayList);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTOutlineGlyph();
+
+        /**
+         * Render this glyph at the current pen position.
+         *
+         * @param pen  The current pen position.
+         * @param renderMode  Render mode to display
+         * @return  The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render(const FTPoint& pen, int renderMode);
+};
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * Create a specialisation of FTGLglyph for creating outlines.
+ *
+ * @param glyph The Freetype glyph to be processed
+ * @param outset outset contour size
+ * @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.
+ * @return  An FTGLglyph* object.
+ */
+FTGL_EXPORT FTGLglyph *ftglCreateOutlineGlyph(FT_GlyphSlot glyph, float outset,
+                                  int useDisplayList);
+
+FTGL_END_C_DECLS
+
+#endif  // __FTOutlineGlyph__
+
diff --git a/src/ftgl/FTGL/FTPixmapGlyph.h b/src/ftgl/FTGL/FTPixmapGlyph.h
new file mode 100644
index 0000000..d9a317f
--- /dev/null
+++ b/src/ftgl/FTGL/FTPixmapGlyph.h
@@ -0,0 +1,82 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTPixmapGlyph__
+#define __FTPixmapGlyph__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTPixmapGlyph is a specialisation of FTGlyph for creating pixmaps.
+ */
+class  FTGL_EXPORT FTPixmapGlyph : public FTGlyph
+{
+    public:
+        /**
+         * Constructor
+         *
+         * @param glyph The Freetype glyph to be processed
+         */
+        FTPixmapGlyph(FT_GlyphSlot glyph);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTPixmapGlyph();
+
+        /**
+         * Render this glyph at the current pen position.
+         *
+         * @param pen  The current pen position.
+         * @param renderMode  Render mode to display
+         * @return  The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render(const FTPoint& pen, int renderMode);
+};
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * Create a specialisation of FTGLglyph for creating pixmaps.
+ *
+ * @param glyph The Freetype glyph to be processed
+ * @return  An FTGLglyph* object.
+ */
+FTGL_EXPORT FTGLglyph *ftglCreatePixmapGlyph(FT_GlyphSlot glyph);
+
+FTGL_END_C_DECLS
+
+#endif  //  __FTPixmapGlyph__
+
diff --git a/src/ftgl/FTGL/FTPoint.h b/src/ftgl/FTGL/FTPoint.h
new file mode 100644
index 0000000..fef4af6
--- /dev/null
+++ b/src/ftgl/FTGL/FTPoint.h
@@ -0,0 +1,274 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTPoint__
+#define __FTPoint__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTPoint class is a basic 3-dimensional point or vector.
+ */
+class FTGL_EXPORT FTPoint
+{
+    public:
+        /**
+         * Default constructor. Point is set to zero.
+         */
+        inline FTPoint()
+        {
+            values[0] = 0;
+            values[1] = 0;
+            values[2] = 0;
+        }
+
+        /**
+         * Constructor. Z coordinate is set to zero if unspecified.
+         *
+         * @param x First component
+         * @param y Second component
+         * @param z Third component
+         */
+        inline FTPoint(const FTGL_DOUBLE x, const FTGL_DOUBLE y,
+                       const FTGL_DOUBLE z = 0)
+        {
+            values[0] = x;
+            values[1] = y;
+            values[2] = z;
+        }
+
+        /**
+         * Constructor. This converts an FT_Vector to an FTPoint
+         *
+         * @param ft_vector A freetype vector
+         */
+        inline FTPoint(const FT_Vector& ft_vector)
+        {
+            values[0] = ft_vector.x;
+            values[1] = ft_vector.y;
+            values[2] = 0;
+        }
+
+        /**
+         * Normalise a point's coordinates. If the coordinates are zero,
+         * the point is left untouched.
+         *
+         * @return A vector of norm one.
+         */
+        FTPoint Normalise();
+
+
+        /**
+         * Operator += In Place Addition.
+         *
+         * @param point
+         * @return this plus point.
+         */
+        inline 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.
+         */
+        inline FTPoint operator + (const FTPoint& point) const
+        {
+            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 -= In Place Substraction.
+         *
+         * @param point
+         * @return this minus point.
+         */
+        inline 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 minus point.
+         */
+        inline FTPoint operator - (const FTPoint& point) const
+        {
+            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 *  Scalar multiplication
+         *
+         * @param multiplier
+         * @return <code>this</code> multiplied by <code>multiplier</code>.
+         */
+        inline FTPoint operator * (double multiplier) const
+        {
+            FTPoint temp;
+            temp.values[0] = values[0] * multiplier;
+            temp.values[1] = values[1] * multiplier;
+            temp.values[2] = values[2] * multiplier;
+
+            return temp;
+        }
+
+
+        /**
+         * Operator *  Scalar multiplication
+         *
+         * @param point
+         * @param multiplier
+         * @return <code>multiplier</code> multiplied by <code>point</code>.
+         */
+        inline friend FTPoint operator * (double multiplier, FTPoint& point)
+        {
+            return point * multiplier;
+        }
+
+
+        /**
+         * Operator *  Scalar product
+         *
+         * @param a  First vector.
+         * @param b  Second vector.
+         * @return  <code>a.b</code> scalar product.
+         */
+        inline friend double operator * (FTPoint &a, FTPoint& b)
+        {
+            return a.values[0] * b.values[0]
+                 + a.values[1] * b.values[1]
+                 + a.values[2] * b.values[2];
+        }
+
+
+        /**
+         * Operator ^  Vector product
+         *
+         * @param point Second point
+         * @return this vector point.
+         */
+        inline FTPoint operator ^ (const FTPoint& point)
+        {
+            FTPoint temp;
+            temp.values[0] = values[1] * point.values[2]
+                              - values[2] * point.values[1];
+            temp.values[1] = values[2] * point.values[0]
+                              - values[0] * point.values[2];
+            temp.values[2] = values[0] * point.values[1]
+                              - values[1] * point.values[0];
+            return temp;
+        }
+
+
+        /**
+         * Operator == Tests for equality
+         *
+         * @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*
+         */
+        inline operator const FTGL_DOUBLE*() const
+        {
+            return values;
+        }
+
+
+        /**
+         * Setters
+         */
+        inline void X(FTGL_DOUBLE x) { values[0] = x; };
+        inline void Y(FTGL_DOUBLE y) { values[1] = y; };
+        inline void Z(FTGL_DOUBLE z) { values[2] = z; };
+
+
+        /**
+         * Getters
+         */
+        inline FTGL_DOUBLE X() const { return values[0]; };
+        inline FTGL_DOUBLE Y() const { return values[1]; };
+        inline FTGL_DOUBLE Z() const { return values[2]; };
+        inline FTGL_FLOAT Xf() const { return static_cast<FTGL_FLOAT>(values[0]); };
+        inline FTGL_FLOAT Yf() const { return static_cast<FTGL_FLOAT>(values[1]); };
+        inline FTGL_FLOAT Zf() const { return static_cast<FTGL_FLOAT>(values[2]); };
+
+    private:
+        /**
+         * The point data
+         */
+        FTGL_DOUBLE values[3];
+};
+
+#endif //__cplusplus
+
+#endif  //  __FTPoint__
+
diff --git a/src/ftgl/FTGL/FTPolyGlyph.h b/src/ftgl/FTGL/FTPolyGlyph.h
new file mode 100644
index 0000000..ce3b000
--- /dev/null
+++ b/src/ftgl/FTGL/FTPolyGlyph.h
@@ -0,0 +1,98 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTPolygonGlyph__
+#define __FTPolygonGlyph__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTPolygonGlyph is a specialisation of FTGlyph for creating tessellated
+ * polygon glyphs.
+ */
+class FTGL_EXPORT FTPolygonGlyph : 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 outset  The outset distance
+         * @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.
+         */
+        FTPolygonGlyph(FT_GlyphSlot glyph, float outset, bool useDisplayList);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTPolygonGlyph();
+
+        /**
+         * Render this glyph at the current pen position.
+         *
+         * @param pen  The current pen position.
+         * @param renderMode  Render mode to display
+         * @return  The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render(const FTPoint& pen, int renderMode);
+};
+
+#define FTPolyGlyph FTPolygonGlyph
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * Create a specialisation of FTGLglyph for creating tessellated
+ * polygon glyphs.
+ *
+ * @param glyph The Freetype glyph to be processed
+ * @param outset outset contour size
+ * @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.
+ * @return  An FTGLglyph* object.
+ */
+FTGL_EXPORT FTGLglyph *ftglCreatePolygonGlyph(FT_GlyphSlot glyph, float outset,
+                                              int useDisplayList);
+
+FTGL_END_C_DECLS
+
+#endif  //  __FTPolygonGlyph__
+
diff --git a/src/ftgl/FTGL/FTSimpleLayout.h b/src/ftgl/FTGL/FTSimpleLayout.h
new file mode 100644
index 0000000..c778b18
--- /dev/null
+++ b/src/ftgl/FTGL/FTSimpleLayout.h
@@ -0,0 +1,191 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTSimpleLayout__
+#define __FTSimpleLayout__
+
+#ifdef __cplusplus
+
+
+class FTFont;
+
+/**
+ * FTSimpleLayout is a specialisation of FTLayout for simple text boxes.
+ *
+ * This class has basic support for text wrapping, left, right and centered
+ * alignment, and text justification.
+ *
+ * @see     FTLayout
+ */
+class FTGL_EXPORT FTSimpleLayout : public FTLayout
+{
+    public:
+        /**
+         * Initializes line spacing to 1.0, alignment to
+         * ALIGN_LEFT and wrap to 100.0
+         */
+        FTSimpleLayout();
+
+        /**
+         * Destructor
+         */
+        ~FTSimpleLayout();
+
+        /**
+         * Get the bounding box for a formatted string.
+         *
+         * @param string  A char string.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be checked until a null character is encountered
+         *             (optional).
+         * @param position  The pen position of the first character (optional).
+         * @return  The corresponding bounding box.
+         */
+        virtual FTBBox BBox(const char* string, const int len = -1,
+                            FTPoint position = FTPoint());
+
+        /**
+         * Get the bounding box for a formatted string.
+         *
+         * @param string  A wchar_t string.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be checked until a null character is encountered
+         *             (optional).
+         * @param position  The pen position of the first character (optional).
+         * @return  The corresponding bounding box.
+         */
+        virtual FTBBox BBox(const wchar_t* string, const int len = -1,
+                            FTPoint position = FTPoint());
+
+        /**
+         * Render a string of characters.
+         *
+         * @param string    'C' style string to be output.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be displayed until a null character is encountered
+         *             (optional).
+         * @param position  The pen position of the first character (optional).
+         * @param renderMode  Render mode to display (optional)
+         */
+        virtual void Render(const char *string, const int len = -1,
+                            FTPoint position = FTPoint(),
+                            int renderMode = FTGL::RENDER_ALL);
+
+        /**
+         * Render a string of characters.
+         *
+         * @param string    wchar_t string to be output.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be displayed until a null character is encountered
+         *             (optional).
+         * @param position  The pen position of the first character (optional).
+         * @param renderMode  Render mode to display (optional)
+         */
+        virtual void Render(const wchar_t *string, const int len = -1,
+                            FTPoint position = FTPoint(),
+                            int renderMode = FTGL::RENDER_ALL);
+
+        /**
+         * Set the font to use for rendering the text.
+         *
+         * @param fontInit A pointer to the new font.  The font is
+         *                 referenced by this but will not be
+         *                 disposed of when this is deleted.
+         */
+        void SetFont(FTFont *fontInit);
+
+        /**
+         * @return The current font.
+         */
+        FTFont *GetFont();
+
+        /**
+         * The maximum line length for formatting text.
+         *
+         * @param LineLength The new line length.
+         */
+        void SetLineLength(const float LineLength);
+
+        /**
+         * @return The current line length.
+         */
+        float GetLineLength() const;
+
+        /**
+         * The text alignment mode used to distribute
+         * space within a line or rendered text.
+         *
+         * @param Alignment The new alignment mode.
+         */
+        void SetAlignment(const FTGL::TextAlignment Alignment);
+
+        /**
+         * @return The text alignment mode.
+         */
+        FTGL::TextAlignment GetAlignment() const;
+
+        /**
+         * Sets the line height.
+         *
+         * @param LineSpacing The height of each line of text expressed as
+         *                    a percentage of the current fonts line height.
+         */
+        void SetLineSpacing(const float LineSpacing);
+
+        /**
+         * @return The line spacing.
+         */
+        float GetLineSpacing() const;
+};
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+FTGL_EXPORT FTGLlayout *ftglCreateSimpleLayout(void);
+
+FTGL_EXPORT void ftglSetLayoutFont(FTGLlayout *, FTGLfont*);
+FTGL_EXPORT FTGLfont *ftglGetLayoutFont(FTGLlayout *);
+
+FTGL_EXPORT void ftglSetLayoutLineLength(FTGLlayout *, const float);
+FTGL_EXPORT float ftglGetLayoutLineLength(FTGLlayout *);
+
+FTGL_EXPORT void ftglSetLayoutAlignment(FTGLlayout *, const int);
+FTGL_EXPORT int ftglGetLayoutAlignement(FTGLlayout *);
+
+FTGL_EXPORT void ftglSetLayoutLineSpacing(FTGLlayout *, const float);
+FTGL_EXPORT float ftglGetLayoutLineSpacing(FTGLlayout *);
+
+FTGL_END_C_DECLS
+
+#endif  /* __FTSimpleLayout__ */
+
diff --git a/src/ftgl/FTGL/FTTextureGlyph.h b/src/ftgl/FTGL/FTTextureGlyph.h
new file mode 100644
index 0000000..ec545f3
--- /dev/null
+++ b/src/ftgl/FTGL/FTTextureGlyph.h
@@ -0,0 +1,99 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#   warning This header is deprecated. Please use <FTGL/ftgl.h> from now.
+#   include <FTGL/ftgl.h>
+#endif
+
+#ifndef __FTTextureGlyph__
+#define __FTTextureGlyph__
+
+#ifdef __cplusplus
+
+
+/**
+ * FTTextureGlyph is a specialisation of FTGlyph for creating texture
+ * glyphs.
+ */
+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,
+                       int width, int height);
+
+        /**
+         * Destructor
+         */
+        virtual ~FTTextureGlyph();
+
+        /**
+         * Render this glyph at the current pen position.
+         *
+         * @param pen  The current pen position.
+         * @param renderMode  Render mode to display
+         * @return  The advance distance for this glyph.
+         */
+        virtual const FTPoint& Render(const FTPoint& pen, int renderMode);
+};
+
+#endif //__cplusplus
+
+FTGL_BEGIN_C_DECLS
+
+/**
+ * Create a specialisation of FTGLglyph for creating pixmaps.
+ *
+ * @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.
+ * @return  An FTGLglyph* object.
+ */
+FTGL_EXPORT FTGLglyph *ftglCreateTextureGlyph(FT_GlyphSlot glyph, int id,
+                                              int xOffset, int yOffset,
+                                              int width, int height);
+
+FTGL_END_C_DECLS
+
+#endif  //  __FTTextureGlyph__
+
diff --git a/src/ftgl/FTGL/ftgl.h b/src/ftgl/FTGL/ftgl.h
new file mode 100644
index 0000000..f5d043c
--- /dev/null
+++ b/src/ftgl/FTGL/ftgl.h
@@ -0,0 +1,135 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ * Copyright (c) 2008 Sean Morrison <learner@brlcad.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __ftgl__
+#define __ftgl__
+
+/* We need the Freetype headers */
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+#include FT_OUTLINE_H
+
+/* Floating point types used by the library */
+typedef double   FTGL_DOUBLE;
+typedef float    FTGL_FLOAT;
+
+/* Macros used to declare C-linkage types and symbols */
+#ifdef __cplusplus
+#   define FTGL_BEGIN_C_DECLS extern "C" { namespace FTGL {
+#   define FTGL_END_C_DECLS } }
+#else
+#   define FTGL_BEGIN_C_DECLS
+#   define FTGL_END_C_DECLS
+#endif
+
+#ifdef __cplusplus
+namespace FTGL
+{
+    typedef enum
+    {
+        RENDER_FRONT = 0x0001,
+        RENDER_BACK  = 0x0002,
+        RENDER_SIDE  = 0x0004,
+        RENDER_ALL   = 0xffff
+    } RenderMode;
+
+    typedef enum
+    {
+        ALIGN_LEFT    = 0,
+        ALIGN_CENTER  = 1,
+        ALIGN_RIGHT   = 2,
+        ALIGN_JUSTIFY = 3
+    } TextAlignment;
+}
+#else
+#   define FTGL_RENDER_FRONT 0x0001
+#   define FTGL_RENDER_BACK  0x0002
+#   define FTGL_RENDER_SIDE  0x0004
+#   define FTGL_RENDER_ALL   0xffff
+
+#   define FTGL_ALIGN_LEFT    0
+#   define FTGL_ALIGN_CENTER  1
+#   define FTGL_ALIGN_RIGHT   2
+#   define FTGL_ALIGN_JUSTIFY 3
+#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
+
+#include <FTGL/FTPoint.h>
+#include <FTGL/FTBBox.h>
+#include <FTGL/FTBuffer.h>
+
+#include <FTGL/FTGlyph.h>
+#include <FTGL/FTBitmapGlyph.h>
+#include <FTGL/FTBufferGlyph.h>
+#include <FTGL/FTExtrdGlyph.h>
+#include <FTGL/FTOutlineGlyph.h>
+#include <FTGL/FTPixmapGlyph.h>
+#include <FTGL/FTPolyGlyph.h>
+#include <FTGL/FTTextureGlyph.h>
+
+#include <FTGL/FTFont.h>
+#include <FTGL/FTGLBitmapFont.h>
+#include <FTGL/FTBufferFont.h>
+#include <FTGL/FTGLExtrdFont.h>
+#include <FTGL/FTGLOutlineFont.h>
+#include <FTGL/FTGLPixmapFont.h>
+#include <FTGL/FTGLPolygonFont.h>
+#include <FTGL/FTGLTextureFont.h>
+
+#include <FTGL/FTLayout.h>
+#include <FTGL/FTSimpleLayout.h>
+
+#endif  //  __ftgl__
diff --git a/src/ftgl/FTGlyph/FTBitmapGlyph.cpp b/src/ftgl/FTGlyph/FTBitmapGlyph.cpp
new file mode 100644
index 0000000..989c890
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTBitmapGlyph.cpp
@@ -0,0 +1,128 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <string>
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTBitmapGlyphImpl.h"
+
+
+//
+//  FTGLBitmapGlyph
+//
+
+
+FTBitmapGlyph::FTBitmapGlyph(FT_GlyphSlot glyph) :
+    FTGlyph(new FTBitmapGlyphImpl(glyph))
+{}
+
+
+FTBitmapGlyph::~FTBitmapGlyph()
+{}
+
+
+const FTPoint& FTBitmapGlyph::Render(const FTPoint& pen, int renderMode)
+{
+    FTBitmapGlyphImpl *myimpl = dynamic_cast<FTBitmapGlyphImpl *>(impl);
+    return myimpl->RenderImpl(pen, renderMode);
+}
+
+
+//
+//  FTGLBitmapGlyphImpl
+//
+
+
+FTBitmapGlyphImpl::FTBitmapGlyphImpl(FT_GlyphSlot glyph)
+:   FTGlyphImpl(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);
+}
+
+
+FTBitmapGlyphImpl::~FTBitmapGlyphImpl()
+{
+    delete [] data;
+}
+
+
+const FTPoint& FTBitmapGlyphImpl::RenderImpl(const FTPoint& pen, int renderMode)
+{
+    if(data)
+    {
+        float dx, dy;
+
+        dx = pen.Xf() + pos.Xf();
+        dy = pen.Yf() - pos.Yf();
+
+        glBitmap(0, 0, 0.0f, 0.0f, dx, dy, (const GLubyte*)0);
+        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, -dx, -dy, (const GLubyte*)0);
+    }
+
+    return advance;
+}
+
diff --git a/src/ftgl/FTGlyph/FTBitmapGlyphImpl.h b/src/ftgl/FTGlyph/FTBitmapGlyphImpl.h
new file mode 100644
index 0000000..c61a679
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTBitmapGlyphImpl.h
@@ -0,0 +1,71 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTBitmapGlyphImpl__
+#define __FTBitmapGlyphImpl__
+
+#include "FTGlyphImpl.h"
+
+class FTBitmapGlyphImpl : public FTGlyphImpl
+{
+    friend class FTBitmapGlyph;
+
+    protected:
+        FTBitmapGlyphImpl(FT_GlyphSlot glyph);
+
+        virtual ~FTBitmapGlyphImpl();
+
+        virtual const FTPoint& RenderImpl(const FTPoint& pen, int renderMode);
+
+    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  //  __FTBitmapGlyphImpl__
+
diff --git a/src/ftgl/FTGlyph/FTBufferGlyph.cpp b/src/ftgl/FTGlyph/FTBufferGlyph.cpp
new file mode 100644
index 0000000..7a78b0e
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTBufferGlyph.cpp
@@ -0,0 +1,121 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <string>
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTBufferGlyphImpl.h"
+
+
+//
+//  FTGLBufferGlyph
+//
+
+
+FTBufferGlyph::FTBufferGlyph(FT_GlyphSlot glyph, FTBuffer *buffer) :
+    FTGlyph(new FTBufferGlyphImpl(glyph, buffer))
+{}
+
+
+FTBufferGlyph::~FTBufferGlyph()
+{}
+
+
+const FTPoint& FTBufferGlyph::Render(const FTPoint& pen, int renderMode)
+{
+    FTBufferGlyphImpl *myimpl = dynamic_cast<FTBufferGlyphImpl *>(impl);
+    return myimpl->RenderImpl(pen, renderMode);
+}
+
+
+//
+//  FTGLBufferGlyphImpl
+//
+
+
+FTBufferGlyphImpl::FTBufferGlyphImpl(FT_GlyphSlot glyph, FTBuffer *p)
+:   FTGlyphImpl(glyph),
+    has_bitmap(false),
+    buffer(p)
+{
+    err = FT_Render_Glyph(glyph, FT_RENDER_MODE_NORMAL);
+    if(err || glyph->format != ft_glyph_format_bitmap)
+    {
+        return;
+    }
+
+    bitmap = glyph->bitmap;
+    pixels = new unsigned char[bitmap.pitch * bitmap.rows];
+    memcpy(pixels, bitmap.buffer, bitmap.pitch * bitmap.rows);
+
+    if(bitmap.width && bitmap.rows)
+    {
+        has_bitmap = true;
+        corner = FTPoint(glyph->bitmap_left, glyph->bitmap_top);
+    }
+}
+
+
+FTBufferGlyphImpl::~FTBufferGlyphImpl()
+{
+    delete[] pixels;
+}
+
+
+const FTPoint& FTBufferGlyphImpl::RenderImpl(const FTPoint& pen, int renderMode)
+{
+    if(has_bitmap)
+    {
+        FTPoint pos(buffer->Pos() + pen + corner);
+        int dx = (int)(pos.Xf() + 0.5f);
+        int dy = buffer->Height() - (int)(pos.Yf() + 0.5f);
+        unsigned char * dest = buffer->Pixels() + dx + dy * buffer->Width();
+
+        for(int y = 0; y < bitmap.rows; y++)
+        {
+            // FIXME: change the loop bounds instead of doing this test
+            if(y + dy < 0 || y + dy >= buffer->Height()) continue;
+
+            for(int x = 0; x < bitmap.width; x++)
+            {
+                if(x + dx < 0 || x + dx >= buffer->Width()) continue;
+
+                unsigned char p = pixels[y * bitmap.pitch + x];
+
+                if(p)
+                {
+                    dest[y * buffer->Width() + x] = p;
+                }
+            }
+        }
+    }
+
+    return advance;
+}
+
diff --git a/src/ftgl/FTGlyph/FTBufferGlyphImpl.h b/src/ftgl/FTGlyph/FTBufferGlyphImpl.h
new file mode 100644
index 0000000..5a15049
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTBufferGlyphImpl.h
@@ -0,0 +1,52 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTBufferGlyphImpl__
+#define __FTBufferGlyphImpl__
+
+#include "FTGlyphImpl.h"
+
+class FTBufferGlyphImpl : public FTGlyphImpl
+{
+    friend class FTBufferGlyph;
+
+    protected:
+        FTBufferGlyphImpl(FT_GlyphSlot glyph, FTBuffer *p);
+
+        virtual ~FTBufferGlyphImpl();
+
+        virtual const FTPoint& RenderImpl(const FTPoint& pen, int renderMode);
+
+    private:
+        bool has_bitmap;
+        FT_Bitmap bitmap;
+        unsigned char *pixels;
+        FTPoint corner;
+
+        FTBuffer *buffer;
+};
+
+#endif  //  __FTBufferGlyphImpl__
+
diff --git a/src/ftgl/FTGlyph/FTExtrudeGlyph.cpp b/src/ftgl/FTGlyph/FTExtrudeGlyph.cpp
new file mode 100644
index 0000000..df0496e
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTExtrudeGlyph.cpp
@@ -0,0 +1,265 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <iostream>
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTExtrudeGlyphImpl.h"
+#include "FTVectoriser.h"
+
+
+//
+//  FTGLExtrudeGlyph
+//
+
+
+FTExtrudeGlyph::FTExtrudeGlyph(FT_GlyphSlot glyph, float depth,
+                               float frontOutset, float backOutset,
+                               bool useDisplayList) :
+    FTGlyph(new FTExtrudeGlyphImpl(glyph, depth, frontOutset, backOutset,
+                                   useDisplayList))
+{}
+
+
+FTExtrudeGlyph::~FTExtrudeGlyph()
+{}
+
+
+const FTPoint& FTExtrudeGlyph::Render(const FTPoint& pen, int renderMode)
+{
+    FTExtrudeGlyphImpl *myimpl = dynamic_cast<FTExtrudeGlyphImpl *>(impl);
+    return myimpl->RenderImpl(pen, renderMode);
+}
+
+
+//
+//  FTGLExtrudeGlyphImpl
+//
+
+
+FTExtrudeGlyphImpl::FTExtrudeGlyphImpl(FT_GlyphSlot glyph, float _depth,
+                                       float _frontOutset, float _backOutset,
+                                       bool useDisplayList)
+:   FTGlyphImpl(glyph),
+    vectoriser(0),
+    glList(0)
+{
+    bBox.SetDepth(-_depth);
+
+    if(ft_glyph_format_outline != glyph->format)
+    {
+        err = 0x14; // Invalid_Outline
+        return;
+    }
+
+    vectoriser = new FTVectoriser(glyph);
+
+    if((vectoriser->ContourCount() < 1) || (vectoriser->PointCount() < 3))
+    {
+        delete vectoriser;
+        vectoriser = NULL;
+        return;
+    }
+
+    hscale = glyph->face->size->metrics.x_ppem * 64;
+    vscale = glyph->face->size->metrics.y_ppem * 64;
+    depth = _depth;
+    frontOutset = _frontOutset;
+    backOutset = _backOutset;
+
+    if(useDisplayList)
+    {
+        glList = glGenLists(3);
+
+        /* Front face */
+        glNewList(glList + 0, GL_COMPILE);
+        RenderFront();
+        glEndList();
+
+        /* Back face */
+        glNewList(glList + 1, GL_COMPILE);
+        RenderBack();
+        glEndList();
+
+        /* Side face */
+        glNewList(glList + 2, GL_COMPILE);
+        RenderSide();
+        glEndList();
+
+        delete vectoriser;
+        vectoriser = NULL;
+    }
+}
+
+
+FTExtrudeGlyphImpl::~FTExtrudeGlyphImpl()
+{
+    if(glList)
+    {
+        glDeleteLists(glList, 3);
+    }
+    else if(vectoriser)
+    {
+        delete vectoriser;
+    }
+}
+
+
+const FTPoint& FTExtrudeGlyphImpl::RenderImpl(const FTPoint& pen,
+                                              int renderMode)
+{
+    glTranslatef(pen.Xf(), pen.Yf(), pen.Zf());
+    if(glList)
+    {
+        if(renderMode & FTGL::RENDER_FRONT)
+            glCallList(glList + 0);
+        if(renderMode & FTGL::RENDER_BACK)
+            glCallList(glList + 1);
+        if(renderMode & FTGL::RENDER_SIDE)
+            glCallList(glList + 2);
+    }
+    else if(vectoriser)
+    {
+        if(renderMode & FTGL::RENDER_FRONT)
+            RenderFront();
+        if(renderMode & FTGL::RENDER_BACK)
+            RenderBack();
+        if(renderMode & FTGL::RENDER_SIDE)
+            RenderSide();
+    }
+    glTranslatef(-pen.Xf(), -pen.Yf(), -pen.Zf());
+
+    return advance;
+}
+
+
+void FTExtrudeGlyphImpl::RenderFront()
+{
+    vectoriser->MakeMesh(1.0, 1, frontOutset);
+    glNormal3d(0.0, 0.0, 1.0);
+
+    const FTMesh *mesh = vectoriser->GetMesh();
+    for(unsigned int j = 0; j < mesh->TesselationCount(); ++j)
+    {
+        const FTTesselation* subMesh = mesh->Tesselation(j);
+        unsigned int polygonType = subMesh->PolygonType();
+
+        glBegin(polygonType);
+            for(unsigned int i = 0; i < subMesh->PointCount(); ++i)
+            {
+                FTPoint pt = subMesh->Point(i);
+
+                glTexCoord2f(pt.Xf() / hscale,
+                             pt.Yf() / vscale);
+
+                glVertex3f(pt.Xf() / 64.0f,
+                           pt.Yf() / 64.0f,
+                           0.0f);
+            }
+        glEnd();
+    }
+}
+
+
+void FTExtrudeGlyphImpl::RenderBack()
+{
+    vectoriser->MakeMesh(-1.0, 2, backOutset);
+    glNormal3d(0.0, 0.0, -1.0);
+
+    const FTMesh *mesh = vectoriser->GetMesh();
+    for(unsigned int j = 0; j < mesh->TesselationCount(); ++j)
+    {
+        const FTTesselation* subMesh = mesh->Tesselation(j);
+        unsigned int polygonType = subMesh->PolygonType();
+
+        glBegin(polygonType);
+            for(unsigned int i = 0; i < subMesh->PointCount(); ++i)
+            {
+                FTPoint pt = subMesh->Point(i);
+
+                glTexCoord2f(subMesh->Point(i).Xf() / hscale,
+                             subMesh->Point(i).Yf() / vscale);
+
+                glVertex3f(subMesh->Point(i).Xf() / 64.0f,
+                           subMesh->Point(i).Yf() / 64.0f,
+                           -depth);
+            }
+        glEnd();
+    }
+}
+
+
+void FTExtrudeGlyphImpl::RenderSide()
+{
+    int contourFlag = vectoriser->ContourFlag();
+
+    for(size_t c = 0; c < vectoriser->ContourCount(); ++c)
+    {
+        const FTContour* contour = vectoriser->Contour(c);
+        size_t n = contour->PointCount();
+
+        if(n < 2)
+        {
+            continue;
+        }
+
+        glBegin(GL_QUAD_STRIP);
+            for(size_t j = 0; j <= n; ++j)
+            {
+                size_t cur = (j == n) ? 0 : j;
+                size_t next = (cur == n - 1) ? 0 : cur + 1;
+
+                FTPoint frontPt = contour->FrontPoint(cur);
+                FTPoint nextPt = contour->FrontPoint(next);
+                FTPoint backPt = contour->BackPoint(cur);
+
+                FTPoint normal = FTPoint(0.f, 0.f, 1.f) ^ (frontPt - nextPt);
+                if(normal != FTPoint(0.0f, 0.0f, 0.0f))
+                {
+                    glNormal3dv(static_cast<const FTGL_DOUBLE*>(normal.Normalise()));
+                }
+
+                glTexCoord2f(frontPt.Xf() / hscale, frontPt.Yf() / vscale);
+
+                if(contourFlag & ft_outline_reverse_fill)
+                {
+                    glVertex3f(backPt.Xf() / 64.0f, backPt.Yf() / 64.0f, 0.0f);
+                    glVertex3f(frontPt.Xf() / 64.0f, frontPt.Yf() / 64.0f, -depth);
+                }
+                else
+                {
+                    glVertex3f(backPt.Xf() / 64.0f, backPt.Yf() / 64.0f, -depth);
+                    glVertex3f(frontPt.Xf() / 64.0f, frontPt.Yf() / 64.0f, 0.0f);
+                }
+            }
+        glEnd();
+    }
+}
+
diff --git a/src/ftgl/FTGlyph/FTExtrudeGlyphImpl.h b/src/ftgl/FTGlyph/FTExtrudeGlyphImpl.h
new file mode 100644
index 0000000..7c547c7
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTExtrudeGlyphImpl.h
@@ -0,0 +1,69 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTExtrudeGlyphImpl__
+#define __FTExtrudeGlyphImpl__
+
+#include "FTGlyphImpl.h"
+
+class FTVectoriser;
+
+class FTExtrudeGlyphImpl : public FTGlyphImpl
+{
+    friend class FTExtrudeGlyph;
+
+    protected:
+        FTExtrudeGlyphImpl(FT_GlyphSlot glyph, float depth, float frontOutset,
+                           float backOutset, bool useDisplayList);
+
+        virtual ~FTExtrudeGlyphImpl();
+
+        virtual const FTPoint& RenderImpl(const FTPoint& pen, int renderMode);
+
+    private:
+        /**
+         * Private rendering methods.
+         */
+        void RenderFront();
+        void RenderBack();
+        void RenderSide();
+
+        /**
+         * Private rendering variables.
+         */
+        unsigned int hscale, vscale;
+        float depth;
+        float frontOutset, backOutset;
+        FTVectoriser *vectoriser;
+
+        /**
+         * OpenGL display list
+         */
+        GLuint glList;
+};
+
+#endif  //  __FTExtrudeGlyphImpl__
+
diff --git a/src/ftgl/FTGlyph/FTGlyph.cpp b/src/ftgl/FTGlyph/FTGlyph.cpp
new file mode 100644
index 0000000..4d3dff6
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTGlyph.cpp
@@ -0,0 +1,112 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTGlyphImpl.h"
+
+
+//
+//  FTGlyph
+//
+
+
+FTGlyph::FTGlyph(FT_GlyphSlot glyph)
+{
+    impl = new FTGlyphImpl(glyph);
+}
+
+
+FTGlyph::FTGlyph(FTGlyphImpl *pImpl)
+{
+    impl = pImpl;
+}
+
+
+FTGlyph::~FTGlyph()
+{
+    delete impl;
+}
+
+
+float FTGlyph::Advance() const
+{
+    return impl->Advance();
+}
+
+
+const FTBBox& FTGlyph::BBox() const
+{
+    return impl->BBox();
+}
+
+
+FT_Error FTGlyph::Error() const
+{
+    return impl->Error();
+}
+
+
+//
+//  FTGlyphImpl
+//
+
+
+FTGlyphImpl::FTGlyphImpl(FT_GlyphSlot glyph, bool useList) : err(0)
+{
+    if(glyph)
+    {
+        bBox = FTBBox(glyph);
+        advance = FTPoint(glyph->advance.x / 64.0f,
+                          glyph->advance.y / 64.0f);
+    }
+}
+
+
+FTGlyphImpl::~FTGlyphImpl()
+{}
+
+
+float FTGlyphImpl::Advance() const
+{
+    return advance.Xf();
+}
+
+
+const FTBBox& FTGlyphImpl::BBox() const
+{
+    return bBox;
+}
+
+
+FT_Error FTGlyphImpl::Error() const
+{
+    return err;
+}
+
diff --git a/src/ftgl/FTGlyph/FTGlyphGlue.cpp b/src/ftgl/FTGlyph/FTGlyphGlue.cpp
new file mode 100644
index 0000000..0fbbc01
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTGlyphGlue.cpp
@@ -0,0 +1,198 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+
+static const FTPoint static_ftpoint;
+static const FTBBox static_ftbbox;
+
+FTGL_BEGIN_C_DECLS
+
+#define C_TOR(cname, cargs, cxxname, cxxarg, cxxtype) \
+    FTGLglyph* cname cargs \
+    { \
+        cxxname *g = new cxxname cxxarg; \
+        if(g->Error()) \
+        { \
+            delete g; \
+            return NULL; \
+        } \
+        FTGLglyph *ftgl = (FTGLglyph *)malloc(sizeof(FTGLglyph)); \
+        ftgl->ptr = g; \
+        ftgl->type = cxxtype; \
+        return ftgl; \
+    }
+
+// FTBitmapGlyph::FTBitmapGlyph();
+C_TOR(ftglCreateBitmapGlyph, (FT_GlyphSlot glyph),
+      FTBitmapGlyph, (glyph), GLYPH_BITMAP);
+
+// FTBufferGlyph::FTBufferGlyph();
+// FIXME: not implemented
+
+// FTExtrudeGlyph::FTExtrudeGlyph();
+C_TOR(ftglCreateExtrudeGlyph, (FT_GlyphSlot glyph, float depth,
+                   float frontOutset, float backOutset, int useDisplayList),
+      FTExtrudeGlyph, (glyph, depth, frontOutset, backOutset, (useDisplayList != 0)),
+      GLYPH_EXTRUDE);
+
+// FTOutlineGlyph::FTOutlineGlyph();
+C_TOR(ftglCreateOutlineGlyph, (FT_GlyphSlot glyph, float outset,
+                               int useDisplayList),
+      FTOutlineGlyph, (glyph, outset, (useDisplayList != 0)), GLYPH_OUTLINE);
+
+// FTPixmapGlyph::FTPixmapGlyph();
+C_TOR(ftglCreatePixmapGlyph, (FT_GlyphSlot glyph),
+      FTPixmapGlyph, (glyph), GLYPH_PIXMAP);
+
+// FTPolygonGlyph::FTPolygonGlyph();
+C_TOR(ftglCreatePolygonGlyph, (FT_GlyphSlot glyph, float outset,
+                               int useDisplayList),
+      FTPolygonGlyph, (glyph, outset, (useDisplayList != 0)), GLYPH_POLYGON);
+
+// FTTextureGlyph::FTTextureGlyph();
+C_TOR(ftglCreateTextureGlyph, (FT_GlyphSlot glyph, int id, int xOffset,
+                               int yOffset, int width, int height),
+      FTTextureGlyph, (glyph, id, xOffset, yOffset, width, height),
+      GLYPH_TEXTURE);
+
+// FTCustomGlyph::FTCustomGlyph();
+class FTCustomGlyph : public FTGlyph
+{
+public:
+    FTCustomGlyph(FTGLglyph *base, void *p,
+                  void (*render) (FTGLglyph *, void *, FTGL_DOUBLE, FTGL_DOUBLE,
+                                  int, FTGL_DOUBLE *, FTGL_DOUBLE *),
+                  void (*destroy) (FTGLglyph *, void *))
+     : FTGlyph((FT_GlyphSlot)0),
+       baseGlyph(base),
+       data(p),
+       renderCallback(render),
+       destroyCallback(destroy)
+    {}
+
+    ~FTCustomGlyph()
+    {
+        destroyCallback(baseGlyph, data);
+    }
+
+    float Advance() const { return baseGlyph->ptr->Advance(); }
+
+    const FTPoint& Render(const FTPoint& pen, int renderMode)
+    {
+        FTGL_DOUBLE advancex, advancey;
+        renderCallback(baseGlyph, data, pen.X(), pen.Y(), renderMode,
+                       &advancex, &advancey);
+        advance = FTPoint(advancex, advancey);
+        return advance;
+    }
+
+    const FTBBox& BBox() const { return baseGlyph->ptr->BBox(); }
+
+    FT_Error Error() const { return baseGlyph->ptr->Error(); }
+
+private:
+    FTPoint advance;
+    FTGLglyph *baseGlyph;
+    void *data;
+    void (*renderCallback) (FTGLglyph *, void *, FTGL_DOUBLE, FTGL_DOUBLE,
+                            int, FTGL_DOUBLE *, FTGL_DOUBLE *);
+    void (*destroyCallback) (FTGLglyph *, void *);
+};
+
+C_TOR(ftglCreateCustomGlyph, (FTGLglyph *base, void *data,
+         void (*renderCallback) (FTGLglyph *, void *, FTGL_DOUBLE, FTGL_DOUBLE,
+                                 int, FTGL_DOUBLE *, FTGL_DOUBLE *),
+         void (*destroyCallback) (FTGLglyph *, void *)),
+      FTCustomGlyph, (base, data, renderCallback, destroyCallback),
+      GLYPH_CUSTOM);
+
+#define C_FUN(cret, cname, cargs, cxxerr, cxxname, cxxarg) \
+    cret cname cargs \
+    { \
+        if(!g || !g->ptr) \
+        { \
+            fprintf(stderr, "FTGL warning: NULL pointer in %s\n", #cname); \
+            cxxerr; \
+        } \
+        return g->ptr->cxxname cxxarg; \
+    }
+
+// FTGlyph::~FTGlyph();
+void ftglDestroyGlyph(FTGLglyph *g)
+{
+    if(!g || !g->ptr)
+    {
+        fprintf(stderr, "FTGL warning: NULL pointer in %s\n", __FUNCTION__);
+        return;
+    }
+    delete g->ptr;
+    free(g);
+}
+
+// const FTPoint& FTGlyph::Render(const FTPoint& pen, int renderMode);
+extern "C++" {
+C_FUN(static const FTPoint&, _ftglRenderGlyph, (FTGLglyph *g,
+                                   const FTPoint& pen, int renderMode),
+      return static_ftpoint, Render, (pen, renderMode));
+}
+
+void ftglRenderGlyph(FTGLglyph *g, FTGL_DOUBLE penx, FTGL_DOUBLE peny,
+                     int renderMode, FTGL_DOUBLE *advancex,
+                     FTGL_DOUBLE *advancey)
+{
+    FTPoint pen(penx, peny);
+    FTPoint ret = _ftglRenderGlyph(g, pen, renderMode);
+    *advancex = ret.X();
+    *advancey = ret.Y();
+}
+
+// float FTGlyph::Advance() const;
+C_FUN(float, ftglGetGlyphAdvance, (FTGLglyph *g), return 0.0, Advance, ());
+
+// const FTBBox& FTGlyph::BBox() const;
+extern "C++" {
+C_FUN(static const FTBBox&, _ftglGetGlyphBBox, (FTGLglyph *g),
+      return static_ftbbox, BBox, ());
+}
+
+void ftglGetGlyphBBox(FTGLglyph *g, float bounds[6])
+{
+    FTBBox ret = _ftglGetGlyphBBox(g);
+    FTPoint lower = ret.Lower(), upper = ret.Upper();
+    bounds[0] = lower.Xf(); bounds[1] = lower.Yf(); bounds[2] = lower.Zf();
+    bounds[3] = upper.Xf(); bounds[4] = upper.Yf(); bounds[5] = upper.Zf();
+}
+
+// FT_Error FTGlyph::Error() const;
+C_FUN(FT_Error, ftglGetGlyphError, (FTGLglyph *g), return -1, Error, ());
+
+FTGL_END_C_DECLS
+
diff --git a/src/ftgl/FTGlyph/FTGlyphImpl.h b/src/ftgl/FTGlyph/FTGlyphImpl.h
new file mode 100644
index 0000000..37ea96f
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTGlyphImpl.h
@@ -0,0 +1,64 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTGlyphImpl__
+#define __FTGlyphImpl__
+
+#include "FTGL/ftgl.h"
+
+class FTGlyphImpl
+{
+    friend class FTGlyph;
+
+    protected:
+        FTGlyphImpl(FT_GlyphSlot glyph, bool useDisplayList = true);
+
+        virtual ~FTGlyphImpl();
+
+        float Advance() const;
+
+        const FTBBox& BBox() const;
+
+        FT_Error Error() const;
+
+        /**
+         * The advance distance for this glyph
+         */
+        FTPoint advance;
+
+        /**
+         * The bounding box of this glyph.
+         */
+        FTBBox bBox;
+
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+};
+
+#endif  //  __FTGlyphImpl__
+
diff --git a/src/ftgl/FTGlyph/FTOutlineGlyph.cpp b/src/ftgl/FTGlyph/FTOutlineGlyph.cpp
new file mode 100644
index 0000000..48e11f7
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTOutlineGlyph.cpp
@@ -0,0 +1,149 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Éric Beets <ericbeets@free.fr>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTOutlineGlyphImpl.h"
+#include "FTVectoriser.h"
+
+
+//
+//  FTGLOutlineGlyph
+//
+
+
+FTOutlineGlyph::FTOutlineGlyph(FT_GlyphSlot glyph, float outset,
+                               bool useDisplayList) :
+    FTGlyph(new FTOutlineGlyphImpl(glyph, outset, useDisplayList))
+{}
+
+
+FTOutlineGlyph::~FTOutlineGlyph()
+{}
+
+
+const FTPoint& FTOutlineGlyph::Render(const FTPoint& pen, int renderMode)
+{
+    FTOutlineGlyphImpl *myimpl = dynamic_cast<FTOutlineGlyphImpl *>(impl);
+    return myimpl->RenderImpl(pen, renderMode);
+}
+
+
+//
+//  FTGLOutlineGlyphImpl
+//
+
+
+FTOutlineGlyphImpl::FTOutlineGlyphImpl(FT_GlyphSlot glyph, float _outset,
+                                       bool useDisplayList)
+:   FTGlyphImpl(glyph),
+    glList(0)
+{
+    if(ft_glyph_format_outline != glyph->format)
+    {
+        err = 0x14; // Invalid_Outline
+        return;
+    }
+
+    vectoriser = new FTVectoriser(glyph);
+
+    if((vectoriser->ContourCount() < 1) || (vectoriser->PointCount() < 3))
+    {
+        delete vectoriser;
+        vectoriser = NULL;
+        return;
+    }
+
+    outset = _outset;
+
+    if(useDisplayList)
+    {
+        glList = glGenLists(1);
+        glNewList(glList, GL_COMPILE);
+
+        DoRender();
+
+        glEndList();
+
+        delete vectoriser;
+        vectoriser = NULL;
+    }
+}
+
+
+FTOutlineGlyphImpl::~FTOutlineGlyphImpl()
+{
+    if(glList)
+    {
+        glDeleteLists(glList, 1);
+    }
+    else if(vectoriser)
+    {
+        delete vectoriser;
+    }
+}
+
+
+const FTPoint& FTOutlineGlyphImpl::RenderImpl(const FTPoint& pen,
+                                              int renderMode)
+{
+    glTranslatef(pen.Xf(), pen.Yf(), pen.Zf());
+    if(glList)
+    {
+        glCallList(glList);
+    }
+    else if(vectoriser)
+    {
+        DoRender();
+    }
+    glTranslatef(-pen.Xf(), -pen.Yf(), -pen.Zf());
+
+    return advance;
+}
+
+
+void FTOutlineGlyphImpl::DoRender()
+{
+    for(unsigned int c = 0; c < vectoriser->ContourCount(); ++c)
+    {
+        const FTContour* contour = vectoriser->Contour(c);
+
+        glBegin(GL_LINE_LOOP);
+            for(unsigned int i = 0; i < contour->PointCount(); ++i)
+            {
+                FTPoint point = FTPoint(contour->Point(i).X() + contour->Outset(i).X() * outset,
+                                        contour->Point(i).Y() + contour->Outset(i).Y() * outset,
+                                        0);
+                glVertex2f(point.Xf() / 64.0f, point.Yf() / 64.0f);
+            }
+        glEnd();
+    }
+}
+
diff --git a/src/ftgl/FTGlyph/FTOutlineGlyphImpl.h b/src/ftgl/FTGlyph/FTOutlineGlyphImpl.h
new file mode 100644
index 0000000..ead4b12
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTOutlineGlyphImpl.h
@@ -0,0 +1,69 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTOutlineGlyphImpl__
+#define __FTOutlineGlyphImpl__
+
+#include "FTGlyphImpl.h"
+
+class FTVectoriser;
+
+class FTOutlineGlyphImpl : public FTGlyphImpl
+{
+    friend class FTOutlineGlyph;
+
+    protected:
+        FTOutlineGlyphImpl(FT_GlyphSlot glyph, float outset,
+                           bool useDisplayList);
+
+        virtual ~FTOutlineGlyphImpl();
+
+        virtual const FTPoint& RenderImpl(const FTPoint& pen, int renderMode);
+
+    private:
+        /**
+         * Private rendering method.
+         */
+        void DoRender();
+
+        /**
+         * Private rendering variables.
+         */
+        FTVectoriser *vectoriser;
+
+        /**
+         * Private rendering variables.
+         */
+        float outset;
+
+        /**
+         * OpenGL display list
+         */
+        GLuint glList;
+};
+
+#endif  // __FTOutlineGlyphImpl__
+
diff --git a/src/ftgl/FTGlyph/FTPixmapGlyph.cpp b/src/ftgl/FTGlyph/FTPixmapGlyph.cpp
new file mode 100644
index 0000000..5301e43
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTPixmapGlyph.cpp
@@ -0,0 +1,139 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <math.h>
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTPixmapGlyphImpl.h"
+
+
+//
+//  FTGLPixmapGlyph
+//
+
+
+FTPixmapGlyph::FTPixmapGlyph(FT_GlyphSlot glyph) :
+    FTGlyph(new FTPixmapGlyphImpl(glyph))
+{}
+
+
+FTPixmapGlyph::~FTPixmapGlyph()
+{}
+
+
+const FTPoint& FTPixmapGlyph::Render(const FTPoint& pen, int renderMode)
+{
+    FTPixmapGlyphImpl *myimpl = dynamic_cast<FTPixmapGlyphImpl *>(impl);
+    return myimpl->RenderImpl(pen, renderMode);
+}
+
+
+//
+//  FTGLPixmapGlyphImpl
+//
+
+
+FTPixmapGlyphImpl::FTPixmapGlyphImpl(FT_GlyphSlot glyph)
+:   FTGlyphImpl(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);
+}
+
+
+FTPixmapGlyphImpl::~FTPixmapGlyphImpl()
+{
+    delete [] data;
+}
+
+
+const FTPoint& FTPixmapGlyphImpl::RenderImpl(const FTPoint& pen,
+                                             int renderMode)
+{
+    if(data)
+    {
+        float dx, dy;
+
+        dx = floor(pen.Xf() + pos.Xf());
+        dy = floor(pen.Yf() - pos.Yf());
+
+        glBitmap(0, 0, 0.0f, 0.0f, dx, dy, (const GLubyte*)0);
+        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, -dx, -dy, (const GLubyte*)0);
+    }
+
+    return advance;
+}
+
diff --git a/src/ftgl/FTGlyph/FTPixmapGlyphImpl.h b/src/ftgl/FTGlyph/FTPixmapGlyphImpl.h
new file mode 100644
index 0000000..8331469
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTPixmapGlyphImpl.h
@@ -0,0 +1,67 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTPixmapGlyphImpl__
+#define __FTPixmapGlyphImpl__
+
+#include "FTGlyphImpl.h"
+
+class FTPixmapGlyphImpl : public FTGlyphImpl
+{
+    friend class FTPixmapGlyph;
+
+    protected:
+        FTPixmapGlyphImpl(FT_GlyphSlot glyph);
+
+        virtual ~FTPixmapGlyphImpl();
+
+        virtual const FTPoint& RenderImpl(const FTPoint& pen, int renderMode);
+
+    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  //  __FTPixmapGlyphImpl__
+
diff --git a/src/ftgl/FTGlyph/FTPolygonGlyph.cpp b/src/ftgl/FTGlyph/FTPolygonGlyph.cpp
new file mode 100644
index 0000000..6db3581
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTPolygonGlyph.cpp
@@ -0,0 +1,156 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Éric Beets <ericbeets@free.fr>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTPolygonGlyphImpl.h"
+#include "FTVectoriser.h"
+
+
+//
+//  FTGLPolyGlyph
+//
+
+
+FTPolygonGlyph::FTPolygonGlyph(FT_GlyphSlot glyph, float outset,
+                               bool useDisplayList) :
+    FTGlyph(new FTPolygonGlyphImpl(glyph, outset, useDisplayList))
+{}
+
+
+FTPolygonGlyph::~FTPolygonGlyph()
+{}
+
+
+const FTPoint& FTPolygonGlyph::Render(const FTPoint& pen, int renderMode)
+{
+    FTPolygonGlyphImpl *myimpl = dynamic_cast<FTPolygonGlyphImpl *>(impl);
+    return myimpl->RenderImpl(pen, renderMode);
+}
+
+
+//
+//  FTGLPolyGlyphImpl
+//
+
+
+FTPolygonGlyphImpl::FTPolygonGlyphImpl(FT_GlyphSlot glyph, float _outset,
+                                       bool useDisplayList)
+:   FTGlyphImpl(glyph),
+    glList(0)
+{
+    if(ft_glyph_format_outline != glyph->format)
+    {
+        err = 0x14; // Invalid_Outline
+        return;
+    }
+
+    vectoriser = new FTVectoriser(glyph);
+
+    if((vectoriser->ContourCount() < 1) || (vectoriser->PointCount() < 3))
+    {
+        delete vectoriser;
+        vectoriser = NULL;
+        return;
+    }
+
+
+    hscale = glyph->face->size->metrics.x_ppem * 64;
+    vscale = glyph->face->size->metrics.y_ppem * 64;
+    outset = _outset;
+
+    if(useDisplayList)
+    {
+        glList = glGenLists(1);
+        glNewList(glList, GL_COMPILE);
+
+        DoRender();
+
+        glEndList();
+
+        delete vectoriser;
+        vectoriser = NULL;
+    }
+}
+
+
+FTPolygonGlyphImpl::~FTPolygonGlyphImpl()
+{
+    if(glList)
+    {
+        glDeleteLists(glList, 1);
+    }
+    else if(vectoriser)
+    {
+        delete vectoriser;
+    }
+}
+
+
+const FTPoint& FTPolygonGlyphImpl::RenderImpl(const FTPoint& pen,
+                                              int renderMode)
+{
+    glTranslatef(pen.Xf(), pen.Yf(), pen.Zf());
+    if(glList)
+    {
+        glCallList(glList);
+    }
+    else if(vectoriser)
+    {
+        DoRender();
+    }
+    glTranslatef(-pen.Xf(), -pen.Yf(), -pen.Zf());
+
+    return advance;
+}
+
+
+void FTPolygonGlyphImpl::DoRender()
+{
+    vectoriser->MakeMesh(1.0, 1, outset);
+
+    const FTMesh *mesh = vectoriser->GetMesh();
+
+    for(unsigned int t = 0; t < mesh->TesselationCount(); ++t)
+    {
+        const FTTesselation* subMesh = mesh->Tesselation(t);
+        unsigned int polygonType = subMesh->PolygonType();
+
+        glBegin(polygonType);
+            for(unsigned int i = 0; i < subMesh->PointCount(); ++i)
+            {
+                FTPoint point = subMesh->Point(i);
+                glTexCoord2f(point.Xf() / hscale, point.Yf() / vscale);
+                glVertex3f(point.Xf() / 64.0f, point.Yf() / 64.0f, 0.0f);
+            }
+        glEnd();
+    }
+}
+
diff --git a/src/ftgl/FTGlyph/FTPolygonGlyphImpl.h b/src/ftgl/FTGlyph/FTPolygonGlyphImpl.h
new file mode 100644
index 0000000..e353391
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTPolygonGlyphImpl.h
@@ -0,0 +1,66 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTPolygonGlyphImpl__
+#define __FTPolygonGlyphImpl__
+
+#include "FTGlyphImpl.h"
+
+class FTVectoriser;
+
+class FTPolygonGlyphImpl : public FTGlyphImpl
+{
+    friend class FTPolygonGlyph;
+
+    public:
+        FTPolygonGlyphImpl(FT_GlyphSlot glyph, float outset,
+                           bool useDisplayList);
+
+        virtual ~FTPolygonGlyphImpl();
+
+        virtual const FTPoint& RenderImpl(const FTPoint& pen, int renderMode);
+
+    private:
+        /**
+         * Private rendering method.
+         */
+        void DoRender();
+
+        /**
+         * Private rendering variables.
+         */
+        unsigned int hscale, vscale;
+        FTVectoriser *vectoriser;
+        float outset;
+
+        /**
+         * OpenGL display list
+         */
+        GLuint glList;
+};
+
+#endif  //  __FTPolygonGlyphImpl__
+
diff --git a/src/ftgl/FTGlyph/FTTextureGlyph.cpp b/src/ftgl/FTGlyph/FTTextureGlyph.cpp
new file mode 100644
index 0000000..a9cf2e8
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTTextureGlyph.cpp
@@ -0,0 +1,153 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <math.h>
+
+#include "FTGL/ftgl.h"
+
+#include "FTInternals.h"
+#include "FTTextureGlyphImpl.h"
+
+
+//
+//  FTGLTextureGlyph
+//
+
+
+FTTextureGlyph::FTTextureGlyph(FT_GlyphSlot glyph, int id, int xOffset,
+                               int yOffset, int width, int height) :
+    FTGlyph(new FTTextureGlyphImpl(glyph, id, xOffset, yOffset, width, height))
+{}
+
+
+FTTextureGlyph::~FTTextureGlyph()
+{}
+
+
+const FTPoint& FTTextureGlyph::Render(const FTPoint& pen, int renderMode)
+{
+    FTTextureGlyphImpl *myimpl = dynamic_cast<FTTextureGlyphImpl *>(impl);
+    return myimpl->RenderImpl(pen, renderMode);
+}
+
+
+//
+//  FTGLTextureGlyphImpl
+//
+
+
+GLint FTTextureGlyphImpl::activeTextureID = 0;
+
+FTTextureGlyphImpl::FTTextureGlyphImpl(FT_GlyphSlot glyph, int id, int xOffset,
+                                       int yOffset, int width, int height)
+:   FTGlyphImpl(glyph),
+    destWidth(0),
+    destHeight(0),
+    glTextureID(id)
+{
+    /* FIXME: need to propagate the render mode all the way down to
+     * here in order to get FT_RENDER_MODE_MONO aliased fonts.
+     */
+
+    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));
+
+    corner = FTPoint(glyph->bitmap_left, glyph->bitmap_top);
+}
+
+
+FTTextureGlyphImpl::~FTTextureGlyphImpl()
+{}
+
+
+const FTPoint& FTTextureGlyphImpl::RenderImpl(const FTPoint& pen,
+                                              int renderMode)
+{
+    float dx, dy;
+
+    if(activeTextureID != glTextureID)
+    {
+        glBindTexture(GL_TEXTURE_2D, (GLuint)glTextureID);
+        activeTextureID = glTextureID;
+    }
+
+    dx = floor(pen.Xf() + corner.Xf());
+    dy = floor(pen.Yf() + corner.Yf());
+
+    glBegin(GL_QUADS);
+        glTexCoord2f(uv[0].Xf(), uv[0].Yf());
+        glVertex2f(dx, dy);
+
+        glTexCoord2f(uv[0].Xf(), uv[1].Yf());
+        glVertex2f(dx, dy - destHeight);
+
+        glTexCoord2f(uv[1].Xf(), uv[1].Yf());
+        glVertex2f(dx + destWidth, dy - destHeight);
+
+        glTexCoord2f(uv[1].Xf(), uv[0].Yf());
+        glVertex2f(dx + destWidth, dy);
+    glEnd();
+
+    return advance;
+}
+
diff --git a/src/ftgl/FTGlyph/FTTextureGlyphImpl.h b/src/ftgl/FTGlyph/FTTextureGlyphImpl.h
new file mode 100644
index 0000000..793af04
--- /dev/null
+++ b/src/ftgl/FTGlyph/FTTextureGlyphImpl.h
@@ -0,0 +1,88 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTTextureGlyphImpl__
+#define __FTTextureGlyphImpl__
+
+#include "FTGlyphImpl.h"
+
+class FTTextureGlyphImpl : public FTGlyphImpl
+{
+    friend class FTTextureGlyph;
+    friend class FTTextureFontImpl;
+
+    protected:
+        FTTextureGlyphImpl(FT_GlyphSlot glyph, int id, int xOffset,
+                           int yOffset, int width, int height);
+
+        virtual ~FTTextureGlyphImpl();
+
+        virtual const FTPoint& RenderImpl(const FTPoint& pen, int renderMode);
+
+    private:
+        /**
+         * 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; }
+
+        /**
+         * 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 corner;
+
+        /**
+         * 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  //  __FTTextureGlyphImpl__
+
diff --git a/src/ftgl/FTGlyphContainer.cpp b/src/ftgl/FTGlyphContainer.cpp
new file mode 100644
index 0000000..54c1de4
--- /dev/null
+++ b/src/ftgl/FTGlyphContainer.cpp
@@ -0,0 +1,119 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "FTGlyphContainer.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 it;
+    for(it = glyphs.begin(); it != glyphs.end(); ++it)
+    {
+        delete *it;
+    }
+
+    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 charCode) const
+{
+    return charMap->FontIndex(charCode);
+}
+
+
+void FTGlyphContainer::Add(FTGlyph* tempGlyph, const unsigned int charCode)
+{
+    charMap->InsertIndex(charCode, glyphs.size());
+    glyphs.push_back(tempGlyph);
+}
+
+
+const FTGlyph* const FTGlyphContainer::Glyph(const unsigned int charCode) const
+{
+    unsigned int index = charMap->GlyphListIndex(charCode);
+    return glyphs[index];
+}
+
+
+FTBBox FTGlyphContainer::BBox(const unsigned int charCode) const
+{
+    return Glyph(charCode)->BBox();
+}
+
+
+float FTGlyphContainer::Advance(const unsigned int charCode,
+                                const unsigned int nextCharCode)
+{
+    unsigned int left = charMap->FontIndex(charCode);
+    unsigned int right = charMap->FontIndex(nextCharCode);
+
+    return face->KernAdvance(left, right).Xf() + Glyph(charCode)->Advance();
+}
+
+
+FTPoint FTGlyphContainer::Render(const unsigned int charCode,
+                                 const unsigned int nextCharCode,
+                                 FTPoint penPosition, int renderMode)
+{
+    unsigned int left = charMap->FontIndex(charCode);
+    unsigned int right = charMap->FontIndex(nextCharCode);
+
+    FTPoint kernAdvance = face->KernAdvance(left, right);
+
+    if(!face->Error())
+    {
+        unsigned int index = charMap->GlyphListIndex(charCode);
+        kernAdvance += glyphs[index]->Render(penPosition, renderMode);
+    }
+
+    return kernAdvance;
+}
+
diff --git a/src/ftgl/FTGlyphContainer.h b/src/ftgl/FTGlyphContainer.h
new file mode 100644
index 0000000..d4bbb74
--- /dev/null
+++ b/src/ftgl/FTGlyphContainer.h
@@ -0,0 +1,155 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef     __FTGlyphContainer__
+#define     __FTGlyphContainer__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_GLYPH_H
+
+#include "FTGL/ftgl.h"
+
+#include "FTVector.h"
+
+class FTFace;
+class FTGlyph;
+class FTCharmap;
+
+/**
+ * FTGlyphContainer holds the post processed FTGlyph objects.
+ *
+ * @see FTGlyph
+ */
+class 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
+         * @param renderMode         Render mode to display
+         * @return                   The distance to advance the pen position after Rendering
+         */
+        FTPoint Render(const unsigned int characterCode,
+                       const unsigned int nextCharacterCode,
+                       FTPoint penPosition, int renderMode);
+
+        /**
+         * 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__
diff --git a/src/ftgl/FTInternals.h b/src/ftgl/FTInternals.h
new file mode 100644
index 0000000..61e1f94
--- /dev/null
+++ b/src/ftgl/FTInternals.h
@@ -0,0 +1,145 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Éric Beets <ericbeets@free.fr>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTINTERNALS_H__
+#define __FTINTERNALS_H__
+
+#include "FTGL/ftgl.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+
+
+// 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 SDL_main
+            #include "SDL_opengl.h"
+        #elif __APPLE_CC__
+            #include <OpenGL/gl.h>
+            #include <OpenGL/glu.h>
+        #else
+            #include <GL/gl.h>
+            #if defined (__sun__) && !defined (__sparc__)
+                #include <mesa/glu.h>
+            #else
+                #include <GL/glu.h>
+            #endif
+        #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
+
+FTGL_BEGIN_C_DECLS
+
+typedef enum
+{
+    GLYPH_CUSTOM,
+    GLYPH_BITMAP,
+    GLYPH_BUFFER,
+    GLYPH_PIXMAP,
+    GLYPH_OUTLINE,
+    GLYPH_POLYGON,
+    GLYPH_EXTRUDE,
+    GLYPH_TEXTURE,
+} GlyphType;
+
+struct _FTGLglyph
+{
+    FTGlyph *ptr;
+    FTGL::GlyphType type;
+};
+
+typedef enum
+{
+    FONT_CUSTOM,
+    FONT_BITMAP,
+    FONT_BUFFER,
+    FONT_PIXMAP,
+    FONT_OUTLINE,
+    FONT_POLYGON,
+    FONT_EXTRUDE,
+    FONT_TEXTURE,
+} FontType;
+
+struct _FTGLfont
+{
+    FTFont *ptr;
+    FTGL::FontType type;
+};
+
+typedef enum
+{
+    LAYOUT_SIMPLE,
+} LayoutType;
+
+struct _FTGLlayout
+{
+    FTLayout *ptr;
+    FTGLfont *font;
+    FTGL::LayoutType type;
+};
+
+FTGL_END_C_DECLS
+
+#endif  //__FTINTERNALS_H__
+
diff --git a/src/ftgl/FTLayout/FTLayout.cpp b/src/ftgl/FTLayout/FTLayout.cpp
new file mode 100644
index 0000000..d4298bd
--- /dev/null
+++ b/src/ftgl/FTLayout/FTLayout.cpp
@@ -0,0 +1,80 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTGL/ftgl.h"
+
+#include "../FTFont/FTFontImpl.h"
+#include "./FTLayoutImpl.h"
+
+
+//
+//  FTLayout
+//
+
+
+FTLayout::FTLayout()
+{
+    impl = new FTLayoutImpl();
+}
+
+
+FTLayout::FTLayout(FTLayoutImpl *pImpl)
+{
+    impl = pImpl;
+}
+
+
+FTLayout::~FTLayout()
+{
+    delete impl;
+}
+
+
+FT_Error FTLayout::Error() const
+{
+    return impl->err;
+}
+
+
+//
+//  FTLayoutImpl
+//
+
+
+FTLayoutImpl::FTLayoutImpl() :
+    err(0)
+{
+    ;
+}
+
+
+FTLayoutImpl::~FTLayoutImpl()
+{
+    ;
+}
+
diff --git a/src/ftgl/FTLayout/FTLayoutGlue.cpp b/src/ftgl/FTLayout/FTLayoutGlue.cpp
new file mode 100644
index 0000000..60f428d
--- /dev/null
+++ b/src/ftgl/FTLayout/FTLayoutGlue.cpp
@@ -0,0 +1,171 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Éric Beets <ericbeets@free.fr>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTInternals.h"
+
+static const FTBBox static_ftbbox;
+
+FTGL_BEGIN_C_DECLS
+
+#define C_TOR(cname, cargs, cxxname, cxxarg, cxxtype) \
+    FTGLlayout* cname cargs \
+    { \
+        cxxname *l = new cxxname cxxarg; \
+        if(l->Error()) \
+        { \
+            delete l; \
+            return NULL; \
+        } \
+        FTGLlayout *ftgl = (FTGLlayout *)malloc(sizeof(FTGLlayout)); \
+        ftgl->ptr = l; \
+        ftgl->type = cxxtype; \
+        return ftgl; \
+    }
+
+// FTSimpleLayout::FTSimpleLayout();
+C_TOR(ftglCreateSimpleLayout, (), FTSimpleLayout, (), LAYOUT_SIMPLE);
+
+#define C_FUN(cret, cname, cargs, cxxerr, cxxname, cxxarg) \
+    cret cname cargs \
+    { \
+        if(!l || !l->ptr) \
+        { \
+            fprintf(stderr, "FTGL warning: NULL pointer in %s\n", #cname); \
+            cxxerr; \
+        } \
+        return l->ptr->cxxname cxxarg; \
+    }
+
+// FTLayout::~FTLayout();
+void ftglDestroyLayout(FTGLlayout *l)
+{
+    if(!l || !l->ptr)
+    {
+        fprintf(stderr, "FTGL warning: NULL pointer in %s\n", __FUNCTION__);
+        return;
+    }
+    delete l->ptr;
+    free(l);
+}
+
+// virtual FTBBox FTLayout::BBox(const char* string)
+extern "C++" {
+C_FUN(static FTBBox, _ftgGetlLayoutBBox, (FTGLlayout *l, const char *s),
+      return static_ftbbox, BBox, (s));
+}
+
+void ftgGetlLayoutBBox(FTGLlayout *l, const char * s, float c[6])
+{
+    FTBBox ret = _ftgGetlLayoutBBox(l, s);
+    FTPoint lower = ret.Lower(), upper = ret.Upper();
+    c[0] = lower.Xf(); c[1] = lower.Yf(); c[2] = lower.Zf();
+    c[3] = upper.Xf(); c[4] = upper.Yf(); c[5] = upper.Zf();
+}
+
+// virtual void FTLayout::Render(const char* string, int renderMode);
+C_FUN(void, ftglRenderLayout, (FTGLlayout *l, const char *s, int r),
+      return, Render, (s, r));
+
+// FT_Error FTLayout::Error() const;
+C_FUN(FT_Error, ftglGetLayoutError, (FTGLlayout *l), return -1, Error, ());
+
+// void FTSimpleLayout::SetFont(FTFont *fontInit)
+void ftglSetLayoutFont(FTGLlayout *l, FTGLfont *font)
+{
+    if(!l || !l->ptr)
+    {
+        fprintf(stderr, "FTGL warning: NULL pointer in %s\n", __FUNCTION__);
+        return;
+    }
+    if(l->type != FTGL::LAYOUT_SIMPLE)
+    {
+        fprintf(stderr, "FTGL warning: %s not implemented for %d\n",
+                        __FUNCTION__, l->type);
+    }
+    l->font = font;
+    return dynamic_cast<FTSimpleLayout*>(l->ptr)->SetFont(font->ptr);
+}
+
+// FTFont *FTSimpleLayout::GetFont()
+FTGLfont *ftglGetLayoutFont(FTGLlayout *l)
+{
+    if(!l || !l->ptr)
+    {
+        fprintf(stderr, "FTGL warning: NULL pointer in %s\n", __FUNCTION__);
+        return NULL;
+    }
+    if(l->type != FTGL::LAYOUT_SIMPLE)
+    {
+        fprintf(stderr, "FTGL warning: %s not implemented for %d\n",
+                        __FUNCTION__, l->type);
+    }
+    return l->font;
+}
+
+#undef C_FUN
+
+#define C_FUN(cret, cname, cargs, cxxerr, cxxname, cxxarg) \
+    cret cname cargs \
+    { \
+        if(!l || !l->ptr) \
+        { \
+            fprintf(stderr, "FTGL warning: NULL pointer in %s\n", #cname); \
+            cxxerr; \
+        } \
+        if(l->type != FTGL::LAYOUT_SIMPLE) \
+        { \
+            fprintf(stderr, "FTGL warning: %s not implemented for %d\n", \
+                            __FUNCTION__, l->type); \
+            cxxerr; \
+        } \
+        return dynamic_cast<FTSimpleLayout*>(l->ptr)->cxxname cxxarg; \
+    }
+
+// void FTSimpleLayout::SetLineLength(const float LineLength);
+C_FUN(void, ftglSetLayoutLineLength, (FTGLlayout *l, const float length),
+      return, SetLineLength, (length));
+
+// float FTSimpleLayout::GetLineLength() const
+C_FUN(float, ftglGetLayoutLineLength, (FTGLlayout *l),
+      return 0.0f, GetLineLength, ());
+
+// void FTSimpleLayout::SetAlignment(const TextAlignment Alignment)
+C_FUN(void, ftglSetLayoutAlignment, (FTGLlayout *l, const int a),
+      return, SetAlignment, ((FTGL::TextAlignment)a));
+
+// TextAlignment FTSimpleLayout::GetAlignment() const
+C_FUN(int, ftglGetLayoutAlignement, (FTGLlayout *l),
+      return FTGL::ALIGN_LEFT, GetAlignment, ());
+
+// void FTSimpleLayout::SetLineSpacing(const float LineSpacing)
+C_FUN(void, ftglSetLayoutLineSpacing, (FTGLlayout *l, const float f),
+      return, SetLineSpacing, (f));
+
+FTGL_END_C_DECLS
+
diff --git a/src/ftgl/FTLayout/FTLayoutImpl.h b/src/ftgl/FTLayout/FTLayoutImpl.h
new file mode 100644
index 0000000..85df50d
--- /dev/null
+++ b/src/ftgl/FTLayout/FTLayoutImpl.h
@@ -0,0 +1,56 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTLayoutImpl__
+#define __FTLayoutImpl__
+
+#include "FTSize.h"
+#include "FTGlyphContainer.h"
+
+
+class FTLayoutImpl
+{
+        friend class FTLayout;
+
+    protected:
+        FTLayoutImpl();
+
+        virtual ~FTLayoutImpl();
+
+    protected:
+        /**
+         * Current pen or cursor position;
+         */
+        FTPoint pen;
+
+        /**
+         * Current error code. Zero means no error.
+         */
+        FT_Error err;
+};
+
+#endif  //  __FTLayoutImpl__
+
diff --git a/src/ftgl/FTLayout/FTSimpleLayout.cpp b/src/ftgl/FTLayout/FTSimpleLayout.cpp
new file mode 100644
index 0000000..b5a7beb
--- /dev/null
+++ b/src/ftgl/FTLayout/FTSimpleLayout.cpp
@@ -0,0 +1,460 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <ctype.h>
+#include <wctype.h>
+
+#include "FTInternals.h"
+#include "FTUnicode.h"
+
+#include "FTGlyphContainer.h"
+#include "FTSimpleLayoutImpl.h"
+
+
+//
+//  FTSimpleLayout
+//
+
+
+FTSimpleLayout::FTSimpleLayout() :
+    FTLayout(new FTSimpleLayoutImpl())
+{}
+
+
+FTSimpleLayout::~FTSimpleLayout()
+{}
+
+
+FTBBox FTSimpleLayout::BBox(const char *string, const int len, FTPoint pos)
+{
+    return dynamic_cast<FTSimpleLayoutImpl*>(impl)->BBox(string, len, pos);
+}
+
+
+FTBBox FTSimpleLayout::BBox(const wchar_t *string, const int len, FTPoint pos)
+{
+    return dynamic_cast<FTSimpleLayoutImpl*>(impl)->BBox(string, len, pos);
+}
+
+
+void FTSimpleLayout::Render(const char *string, const int len, FTPoint pos,
+                            int renderMode)
+{
+    return dynamic_cast<FTSimpleLayoutImpl*>(impl)->Render(string, len, pos,
+                                                           renderMode);
+}
+
+
+void FTSimpleLayout::Render(const wchar_t* string, const int len, FTPoint pos,
+                            int renderMode)
+{
+    return dynamic_cast<FTSimpleLayoutImpl*>(impl)->Render(string, len, pos,
+                                                           renderMode);
+}
+
+
+void FTSimpleLayout::SetFont(FTFont *fontInit)
+{
+    dynamic_cast<FTSimpleLayoutImpl*>(impl)->currentFont = fontInit;
+}
+
+
+FTFont *FTSimpleLayout::GetFont()
+{
+    return dynamic_cast<FTSimpleLayoutImpl*>(impl)->currentFont;
+}
+
+
+void FTSimpleLayout::SetLineLength(const float LineLength)
+{
+    dynamic_cast<FTSimpleLayoutImpl*>(impl)->lineLength = LineLength;
+}
+
+
+float FTSimpleLayout::GetLineLength() const
+{
+    return dynamic_cast<FTSimpleLayoutImpl*>(impl)->lineLength;
+}
+
+
+void FTSimpleLayout::SetAlignment(const FTGL::TextAlignment Alignment)
+{
+    dynamic_cast<FTSimpleLayoutImpl*>(impl)->alignment = Alignment;
+}
+
+
+FTGL::TextAlignment FTSimpleLayout::GetAlignment() const
+{
+    return dynamic_cast<FTSimpleLayoutImpl*>(impl)->alignment;
+}
+
+
+void FTSimpleLayout::SetLineSpacing(const float LineSpacing)
+{
+    dynamic_cast<FTSimpleLayoutImpl*>(impl)->lineSpacing = LineSpacing;
+}
+
+
+float FTSimpleLayout::GetLineSpacing() const
+{
+    return dynamic_cast<FTSimpleLayoutImpl*>(impl)->lineSpacing;
+}
+
+
+//
+//  FTSimpleLayoutImpl
+//
+
+
+FTSimpleLayoutImpl::FTSimpleLayoutImpl()
+{
+    currentFont = NULL;
+    lineLength = 100.0f;
+    alignment = FTGL::ALIGN_LEFT;
+    lineSpacing = 1.0f;
+}
+
+
+template <typename T>
+inline FTBBox FTSimpleLayoutImpl::BBoxI(const T* string, const int len,
+                                        FTPoint position)
+{
+    FTBBox tmp;
+
+    WrapText(string, len, position, 0, &tmp);
+
+    return tmp;
+}
+
+
+FTBBox FTSimpleLayoutImpl::BBox(const char *string, const int len,
+                                FTPoint position)
+{
+    return BBoxI(string, len, position);
+}
+
+
+FTBBox FTSimpleLayoutImpl::BBox(const wchar_t *string, const int len,
+                                FTPoint position)
+{
+    return BBoxI(string, len, position);
+}
+
+
+template <typename T>
+inline void FTSimpleLayoutImpl::RenderI(const T *string, const int len,
+                                        FTPoint position, int renderMode)
+{
+    pen = FTPoint(0.0f, 0.0f);
+    WrapText(string, len, position, renderMode, NULL);
+}
+
+
+void FTSimpleLayoutImpl::Render(const char *string, const int len,
+                                FTPoint position, int renderMode)
+{
+    RenderI(string, len, position, renderMode);
+}
+
+
+void FTSimpleLayoutImpl::Render(const wchar_t* string, const int len,
+                                FTPoint position, int renderMode)
+{
+    RenderI(string, len, position, renderMode);
+}
+
+
+template <typename T>
+inline void FTSimpleLayoutImpl::WrapTextI(const T *buf, const int len,
+                                          FTPoint position, int renderMode,
+                                          FTBBox *bounds)
+{
+    FTUnicodeStringItr<T> breakItr(buf);          // points to the last break character
+    FTUnicodeStringItr<T> lineStart(buf);         // points to the line start
+    float nextStart = 0.0;     // total width of the current line
+    float breakWidth = 0.0;    // width of the line up to the last word break
+    float currentWidth = 0.0;  // width of all characters on the current line
+    float prevWidth;           // width of all characters but the current glyph
+    float wordLength = 0.0;    // length of the block since the last break char
+    int charCount = 0;         // number of characters so far on the line
+    int breakCharCount = 0;    // number of characters before the breakItr
+    float glyphWidth, advance;
+    FTBBox glyphBounds;
+
+    // Reset the pen position
+    pen.Y(0);
+
+    // If we have bounds mark them invalid
+    if(bounds)
+    {
+        bounds->Invalidate();
+    }
+
+    // Scan the input for all characters that need output
+    FTUnicodeStringItr<T> prevItr(buf);
+    for (FTUnicodeStringItr<T> itr(buf); *itr; prevItr = itr++, charCount++)
+    {
+        // Find the width of the current glyph
+        glyphBounds = currentFont->BBox(itr.getBufferFromHere(), 1);
+        glyphWidth = glyphBounds.Upper().Xf() - glyphBounds.Lower().Xf();
+
+        advance = currentFont->Advance(itr.getBufferFromHere(), 1);
+        prevWidth = currentWidth;
+        // Compute the width of all glyphs up to the end of buf[i]
+        currentWidth = nextStart + glyphWidth;
+        // Compute the position of the next glyph
+        nextStart += advance;
+
+        // See if the current character is a space, a break or a regular character
+        if((currentWidth > lineLength) || (*itr == '\n'))
+        {
+            // A non whitespace character has exceeded the line length.  Or a
+            // newline character has forced a line break.  Output the last
+            // line and start a new line after the break character.
+            // If we have not yet found a break, break on the last character
+            if(breakItr == lineStart || (*itr == '\n'))
+            {
+                // Break on the previous character
+                breakItr = prevItr;
+                breakCharCount = charCount - 1;
+                breakWidth = prevWidth;
+                // None of the previous words will be carried to the next line
+                wordLength = 0;
+                // If the current character is a newline discard its advance
+                if(*itr == '\n') advance = 0;
+            }
+
+            float remainingWidth = lineLength - breakWidth;
+
+            // Render the current substring
+            FTUnicodeStringItr<T> breakChar = breakItr;
+            // move past the break character and don't count it on the next line either
+            ++breakChar; --charCount;
+            // If the break character is a newline do not render it
+            if(*breakChar == '\n')
+            {
+                ++breakChar; --charCount;
+            }
+
+            OutputWrapped(lineStart.getBufferFromHere(), breakCharCount,
+                          //breakItr.getBufferFromHere() - lineStart.getBufferFromHere(),
+                          position, renderMode, remainingWidth, bounds);
+
+            // Store the start of the next line
+            lineStart = breakChar;
+            // TODO: Is Height() the right value here?
+            pen -= FTPoint(0, currentFont->LineHeight() * lineSpacing);
+            // The current width is the width since the last break
+            nextStart = wordLength + advance;
+            wordLength += advance;
+            currentWidth = wordLength + advance;
+            // Reset the safe break for the next line
+            breakItr = lineStart;
+            charCount -= breakCharCount;
+        }
+        else if(iswspace(*itr))
+        {
+            // This is the last word break position
+            wordLength = 0;
+            breakItr = itr;
+            breakCharCount = charCount;
+
+            // Check to see if this is the first whitespace character in a run
+            if(buf == itr.getBufferFromHere() || !iswspace(*prevItr))
+            {
+                // Record the width of the start of the block
+                breakWidth = currentWidth;
+            }
+        }
+        else
+        {
+            wordLength += advance;
+        }
+    }
+
+    float remainingWidth = lineLength - currentWidth;
+    // Render any remaining text on the last line
+    // Disable justification for the last row
+    if(alignment == FTGL::ALIGN_JUSTIFY)
+    {
+        alignment = FTGL::ALIGN_LEFT;
+        OutputWrapped(lineStart.getBufferFromHere(), -1, position, renderMode,
+                      remainingWidth, bounds);
+        alignment = FTGL::ALIGN_JUSTIFY;
+    }
+    else
+    {
+        OutputWrapped(lineStart.getBufferFromHere(), -1, position, renderMode,
+                      remainingWidth, bounds);
+    }
+}
+
+
+void FTSimpleLayoutImpl::WrapText(const char *buf, const int len,
+                                  FTPoint position, int renderMode,
+                                  FTBBox *bounds)
+{
+    WrapTextI(buf, len, position, renderMode, bounds);
+}
+
+
+void FTSimpleLayoutImpl::WrapText(const wchar_t* buf, const int len,
+                                  FTPoint position, int renderMode,
+                                  FTBBox *bounds)
+{
+    WrapTextI(buf, len, position, renderMode, bounds);
+}
+
+
+template <typename T>
+inline void FTSimpleLayoutImpl::OutputWrappedI(const T *buf, const int len,
+                                               FTPoint position, int renderMode,
+                                               const float remaining,
+                                               FTBBox *bounds)
+{
+    float distributeWidth = 0.0;
+    // Align the text according as specified by Alignment
+    switch (alignment)
+    {
+        case FTGL::ALIGN_LEFT:
+            pen.X(0);
+            break;
+        case FTGL::ALIGN_CENTER:
+            pen.X(remaining / 2);
+            break;
+        case FTGL::ALIGN_RIGHT:
+            pen.X(remaining);
+            break;
+        case FTGL::ALIGN_JUSTIFY:
+            pen.X(0);
+            distributeWidth = remaining;
+            break;
+    }
+
+    // If we have bounds expand them by the line's bounds, otherwise render
+    // the line.
+    if(bounds)
+    {
+        FTBBox temp = currentFont->BBox(buf, len);
+
+        // Add the extra space to the upper x dimension
+        temp = FTBBox(temp.Lower() + pen,
+                      temp.Upper() + pen + FTPoint(distributeWidth, 0));
+
+        // See if this is the first area to be added to the bounds
+        if(bounds->IsValid())
+        {
+            *bounds |= temp;
+        }
+        else
+        {
+            *bounds = temp;
+        }
+    }
+    else
+    {
+        RenderSpace(buf, len, position, renderMode, distributeWidth);
+    }
+}
+
+
+void FTSimpleLayoutImpl::OutputWrapped(const char *buf, const int len,
+                                       FTPoint position, int renderMode,
+                                       const float remaining, FTBBox *bounds)
+{
+    OutputWrappedI(buf, len, position, renderMode, remaining, bounds);
+}
+
+
+void FTSimpleLayoutImpl::OutputWrapped(const wchar_t *buf, const int len,
+                                       FTPoint position, int renderMode,
+                                       const float remaining, FTBBox *bounds)
+{
+    OutputWrappedI(buf, len, position, renderMode, remaining, bounds);
+}
+
+
+template <typename T>
+inline void FTSimpleLayoutImpl::RenderSpaceI(const T *string, const int len,
+                                             FTPoint position, int renderMode,
+                                             const float extraSpace)
+{
+    float space = 0.0;
+
+    // If there is space to distribute, count the number of spaces
+    if(extraSpace > 0.0)
+    {
+        int numSpaces = 0;
+
+        // Count the number of space blocks in the input
+        FTUnicodeStringItr<T> prevItr(string), itr(string);
+        for(int i = 0; ((len < 0) && *itr) || ((len >= 0) && (i <= len));
+            ++i, prevItr = itr++)
+        {
+            // If this is the end of a space block, increment the counter
+            if((i > 0) && !iswspace(*itr) && iswspace(*prevItr))
+            {
+                numSpaces++;
+            }
+        }
+
+        space = extraSpace/numSpaces;
+    }
+
+    // Output all characters of the string
+    FTUnicodeStringItr<T> prevItr(string), itr(string);
+    for(int i = 0; ((len < 0) && *itr) || ((len >= 0) && (i <= len));
+        ++i, prevItr = itr++)
+    {
+        // If this is the end of a space block, distribute the extra space
+        // inside it
+        if((i > 0) && !iswspace(*itr) && iswspace(*prevItr))
+        {
+            pen += FTPoint(space, 0);
+        }
+
+        pen = currentFont->Render(itr.getBufferFromHere(), 1, pen, FTPoint(), renderMode);
+    }
+}
+
+
+void FTSimpleLayoutImpl::RenderSpace(const char *string, const int len,
+                                     FTPoint position, int renderMode,
+                                     const float extraSpace)
+{
+    RenderSpaceI(string, len, position, renderMode, extraSpace);
+}
+
+
+void FTSimpleLayoutImpl::RenderSpace(const wchar_t *string, const int len,
+                                     FTPoint position, int renderMode,
+                                     const float extraSpace)
+{
+    RenderSpaceI(string, len, position, renderMode, extraSpace);
+}
+
diff --git a/src/ftgl/FTLayout/FTSimpleLayoutImpl.h b/src/ftgl/FTLayout/FTSimpleLayoutImpl.h
new file mode 100644
index 0000000..96a074d
--- /dev/null
+++ b/src/ftgl/FTLayout/FTSimpleLayoutImpl.h
@@ -0,0 +1,225 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __FTSimpleLayoutImpl__
+#define __FTSimpleLayoutImpl__
+
+#include "FTLayoutImpl.h"
+
+
+class FTFont;
+
+class FTSimpleLayoutImpl : public FTLayoutImpl
+{
+    friend class FTSimpleLayout;
+
+    protected:
+        FTSimpleLayoutImpl();
+
+        virtual ~FTSimpleLayoutImpl() {};
+
+        virtual FTBBox BBox(const char* string, const int len,
+                            FTPoint position);
+
+        virtual FTBBox BBox(const wchar_t* string, const int len,
+                            FTPoint position);
+
+        virtual void Render(const char *string, const int len,
+                            FTPoint position, int renderMode);
+
+        virtual void Render(const wchar_t *string, const int len,
+                            FTPoint position, int renderMode);
+
+        /**
+         * Render a string of characters and distribute extra space amongst
+         * the whitespace regions of the string.
+         *
+         * @param string   A buffer of wchar_t characters to output.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be displayed until a null character is encountered.
+         * @param position TODO
+         * @param renderMode Render mode to display
+         * @param extraSpace The amount of extra space to distribute amongst
+         *                   the characters.
+         */
+        virtual void RenderSpace(const char *string, const int len,
+                                 FTPoint position, int renderMode,
+                                 const float extraSpace);
+
+        /**
+         * Render a string of characters and distribute extra space amongst
+         * the whitespace regions of the string.
+         *
+         * @param string   A buffer of wchar_t characters to output.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be displayed until a null character is encountered.
+         * @param position TODO
+         * @param renderMode Render mode to display
+         * @param extraSpace The amount of extra space to distribute amongst
+         *                   the characters.
+         */
+        virtual void RenderSpace(const wchar_t *string, const int len,
+                                 FTPoint position, int renderMode,
+                                 const float extraSpace);
+
+    private:
+        /**
+         * Either render a string of characters and wrap lines
+         * longer than a threshold or compute the bounds
+         * of a string of characters when wrapped.  The functionality
+         * of this method is exposed by the BBoxWrapped and
+         * RenderWrapped methods.
+         *
+         * @param buf  A char string to output.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be displayed until a null character is encountered.
+         * @param position TODO
+         * @param renderMode  Render mode to display
+         * @param bounds      A pointer to a bounds object.  If non null
+         *                    the bounds of the text when laid out
+         *                    will be stored in bounds.  If null the
+         *                    text will be rendered.
+         */
+        virtual void WrapText(const char *buf, const int len,
+                              FTPoint position, int renderMode,
+                              FTBBox *bounds);
+
+        /**
+         * Either render a string of characters and wrap lines
+         * longer than a threshold or compute the bounds
+         * of a string of characters when wrapped.  The functionality
+         * of this method is exposed by the BBoxWrapped and
+         * RenderWrapped methods.
+         *
+         * @param buf  A wchar_t style string to output.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be displayed until a null character is encountered.
+         * @param position TODO
+         * @param renderMode  Render mode to display
+         * @param bounds      A pointer to a bounds object.  If non null
+         *                    the bounds of the text when laid out
+         *                    will be stored in bounds.  If null the
+         *                    text will be rendered.
+         */
+        virtual void WrapText(const wchar_t *buf, const int len,
+                              FTPoint position, int renderMode,
+                              FTBBox *bounds);
+
+        /**
+         * A helper method used by WrapText to either output the text or
+         * compute it's bounds.
+         *
+         * @param buf      A pointer to an array of character data.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be displayed until a null character is encountered.
+         * @param position TODO
+         * @param renderMode  Render mode to display
+         * @param RemainingWidth The amount of extra space left on the line.
+         * @param bounds     A pointer to a bounds object.  If non null the
+         *                   bounds will be initialized or expanded by the
+         *                   bounds of the line.  If null the text will be
+         *                   rendered.  If the bounds are invalid (lower > upper)
+         *                   they will be initialized.  Otherwise they
+         *                   will be expanded.
+         */
+        void OutputWrapped(const char *buf, const int len,
+                           FTPoint position, int renderMode,
+                           const float RemainingWidth, FTBBox *bounds);
+
+        /**
+         * A helper method used by WrapText to either output the text or
+         * compute it's bounds.
+         *
+         * @param buf      A pointer to an array of character data.
+         * @param len  The length of the string. If < 0 then all characters
+         *             will be displayed until a null character is encountered.
+         * @param position TODO
+         * @param renderMode  Render mode to display
+         * @param RemainingWidth The amount of extra space left on the line.
+         * @param bounds     A pointer to a bounds object.  If non null the
+         *                   bounds will be initialized or expanded by the
+         *                   bounds of the line.  If null the text will be
+         *                   rendered.  If the bounds are invalid (lower > upper)
+         *                   they will be initialized.  Otherwise they
+         *                   will be expanded.
+         */
+        void OutputWrapped(const wchar_t *buf, const int len,
+                           FTPoint position, int renderMode,
+                           const float RemainingWidth, FTBBox *bounds);
+
+        /**
+         * The font to use for rendering the text.  The font is
+         * referenced by this but will not be disposed of when this
+         * is deleted.
+         */
+        FTFont *currentFont;
+
+        /**
+         * The maximum line length for formatting text.
+         */
+        float lineLength;
+
+        /**
+         * The text alignment mode used to distribute
+         * space within a line or rendered text.
+         */
+        FTGL::TextAlignment alignment;
+
+        /**
+         * The height of each line of text expressed as
+         * a percentage of the font's line height.
+         */
+        float lineSpacing;
+
+        /* Internal generic BBox() implementation */
+        template <typename T>
+        inline FTBBox BBoxI(const T* string, const int len, FTPoint position);
+
+        /* Internal generic Render() implementation */
+        template <typename T>
+        inline void RenderI(const T* string, const int len,
+                            FTPoint position, int renderMode);
+
+        /* Internal generic RenderSpace() implementation */
+        template <typename T>
+        inline void RenderSpaceI(const T* string, const int len,
+                                 FTPoint position, int renderMode,
+                                 const float extraSpace);
+
+        /* Internal generic WrapText() implementation */
+        template <typename T>
+        void WrapTextI(const T* buf, const int len, FTPoint position,
+                       int renderMode, FTBBox *bounds);
+
+        /* Internal generic OutputWrapped() implementation */
+        template <typename T>
+        void OutputWrappedI(const T* buf, const int len, FTPoint position,
+                            int renderMode, const float RemainingWidth,
+                            FTBBox *bounds);
+};
+
+#endif  //  __FTSimpleLayoutImpl__
+
diff --git a/src/ftgl/FTLibrary.cpp b/src/ftgl/FTLibrary.cpp
new file mode 100644
index 0000000..66074c3
--- /dev/null
+++ b/src/ftgl/FTLibrary.cpp
@@ -0,0 +1,91 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#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;
+}
diff --git a/src/ftgl/FTLibrary.h b/src/ftgl/FTLibrary.h
new file mode 100644
index 0000000..951fecc
--- /dev/null
+++ b/src/ftgl/FTLibrary.h
@@ -0,0 +1,122 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef     __FTLibrary__
+#define     __FTLibrary__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+//#include FT_CACHE_H
+
+#include "FTGL/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 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__
diff --git a/src/ftgl/FTList.h b/src/ftgl/FTList.h
new file mode 100644
index 0000000..1440667
--- /dev/null
+++ b/src/ftgl/FTList.h
@@ -0,0 +1,137 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef    __FTList__
+#define    __FTList__
+
+#include "FTGL/ftgl.h"
+
+/**
+* Provides a non-STL alternative to the STL list
+ */
+template <typename FT_LIST_ITEM_TYPE>
+class 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__
+
diff --git a/src/ftgl/FTPoint.cpp b/src/ftgl/FTPoint.cpp
new file mode 100644
index 0000000..cc02e5a
--- /dev/null
+++ b/src/ftgl/FTPoint.cpp
@@ -0,0 +1,58 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <math.h>
+
+#include "FTGL/ftgl.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 FTPoint::Normalise()
+{
+    double norm = sqrt(values[0] * values[0]
+                       + values[1] * values[1]
+                       + values[2] * values[2]);
+    if(norm == 0.0)
+    {
+        return *this;
+    }
+
+    FTPoint temp(values[0] / norm, values[1] / norm, values[2] / norm);
+    return temp;
+}
+
diff --git a/src/ftgl/FTSize.cpp b/src/ftgl/FTSize.cpp
new file mode 100644
index 0000000..49f1596
--- /dev/null
+++ b/src/ftgl/FTSize.cpp
@@ -0,0 +1,123 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#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;
+        }
+    }
+
+    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;
+}
+
diff --git a/src/ftgl/FTSize.h b/src/ftgl/FTSize.h
new file mode 100644
index 0000000..4ba2666
--- /dev/null
+++ b/src/ftgl/FTSize.h
@@ -0,0 +1,164 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef     __FTSize__
+#define     __FTSize__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#include "FTGL/ftgl.h"
+
+
+
+/**
+ * FTSize class provides an abstraction layer for the Freetype Size.
+ *
+ * @see "Freetype 2 Documentation"
+ *
+ */
+class 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. If an error does occur the size object isn't modified.
+         *
+         * @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__
+
diff --git a/src/ftgl/FTUnicode.h b/src/ftgl/FTUnicode.h
new file mode 100644
index 0000000..6c74100
--- /dev/null
+++ b/src/ftgl/FTUnicode.h
@@ -0,0 +1,237 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2008 Daniel Remenak <dtremenak@users.sourceforge.net>
+ *
+ * Portions derived from ConvertUTF.c Copyright (C) 2001-2004 Unicode, Inc
+ *   Unicode, Inc. hereby grants the right to freely use the information
+ *   supplied in this file in the creation of products supporting the
+ *   Unicode Standard, and to make copies of this file in any form
+ *   for internal or external distribution as long as this notice
+ *   remains attached.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef    __FTUnicode__
+#define    __FTUnicode__
+
+/**
+ * Provides a way to easily walk multibyte unicode strings in the various
+ * Unicode encodings (UTF-8, UTF-16, UTF-32, UCS-2, and UCS-4).  Encodings
+ * with elements larger than one byte must already be in the correct endian
+ * order for the current architecture.
+ */
+template <typename T>
+class FTUnicodeStringItr
+{
+public:
+    /**
+     * Constructor.  Also reads the first character and stores it.
+     *
+     * @param string  The buffer to iterate.  No copy is made.
+     */
+    FTUnicodeStringItr(const T* string) : curPos(string), nextPos(string)
+    {
+        (*this)++;
+    };
+
+    /**
+     * Pre-increment operator.  Reads the next unicode character and sets
+     * the state appropriately.
+     * Note - not protected against overruns.
+     */
+    FTUnicodeStringItr& operator++()
+    {
+        curPos = nextPos;
+        // unicode handling
+        switch (sizeof(T))
+        {
+            case 1: // UTF-8
+                // get this character
+                readUTF8(); break;
+            case 2: // UTF-16
+                readUTF16(); break;
+            case 4: // UTF-32
+                // fall through
+            default: // error condition really, but give it a shot anyway
+                curChar = *nextPos++;
+        }
+        return *this;
+    }
+
+    /**
+     * Post-increment operator.  Reads the next character and sets
+     * the state appropriately.
+     * Note - not protected against overruns.
+     */
+    FTUnicodeStringItr operator++(int)
+    {
+        FTUnicodeStringItr temp = *this;
+        ++*this;
+        return temp;
+    }
+
+    /**
+     * Equality operator.  Two FTUnicodeStringItrs are considered equal
+     * if they have the same current buffer and buffer position.
+     */
+    bool operator==(const FTUnicodeStringItr& right) const
+    {
+        if (curPos == right.getBufferFromHere())
+            return true;
+        return false;
+    }
+
+    /**
+     * Dereference operator.
+     *
+     * @return  The unicode codepoint of the character currently pointed
+     * to by the FTUnicodeStringItr.
+     */
+    unsigned int operator*() const
+    {
+        return curChar;
+    }
+
+    /**
+     * Buffer-fetching getter.  You can use this to retreive the buffer
+     * starting at the currently-iterated character for functions which
+     * require a Unicode string as input.
+     */
+    const T* getBufferFromHere() const { return curPos; }
+
+private:
+    /**
+     * Helper function for reading a single UTF8 character from the string.
+     * Updates internal state appropriately.
+     */
+    void readUTF8();
+
+    /**
+     * Helper function for reading a single UTF16 character from the string.
+     * Updates internal state appropriately.
+     */
+    void readUTF16();
+
+    /**
+     * The buffer position of the first element in the current character.
+     */
+    const T* curPos;
+
+    /**
+     * The character stored at the current buffer position (prefetched on
+     * increment, so there's no penalty for dereferencing more than once).
+     */
+    unsigned int curChar;
+
+    /**
+     * The buffer position of the first element in the next character.
+     */
+    const T* nextPos;
+
+    // unicode magic numbers
+    static const char utf8bytes[256];
+    static const unsigned long offsetsFromUTF8[6];
+    static const unsigned long highSurrogateStart;
+    static const unsigned long highSurrogateEnd;
+    static const unsigned long lowSurrogateStart;
+    static const unsigned long lowSurrogateEnd;
+    static const unsigned long highSurrogateShift;
+    static const unsigned long lowSurrogateBase;
+};
+
+/* The first character in a UTF8 sequence indicates how many bytes
+ * to read (among other things) */
+template <typename T>
+const char FTUnicodeStringItr<T>::utf8bytes[256] = {
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+  3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3, 4,4,4,4,4,4,4,4,5,5,5,5,6,6,6,6
+};
+
+/* Magic values subtracted from a buffer value during UTF8 conversion.
+ * This table contains as many values as there might be trailing bytes
+ * in a UTF-8 sequence. */
+template <typename T>
+const unsigned long FTUnicodeStringItr<T>::offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL,
+  0x03C82080UL, 0xFA082080UL, 0x82082080UL };
+
+// get a UTF8 character; leave the tracking pointer at the start of the
+// next character
+// not protected against invalid UTF8
+template <typename T>
+inline void FTUnicodeStringItr<T>::readUTF8()
+{
+    unsigned int ch = 0;
+    unsigned int extraBytesToRead = utf8bytes[(unsigned char)(*nextPos)];
+    // falls through
+    switch (extraBytesToRead)
+    {
+          case 6: ch += *nextPos++; ch <<= 6; /* remember, illegal UTF-8 */
+          case 5: ch += *nextPos++; ch <<= 6; /* remember, illegal UTF-8 */
+          case 4: ch += *nextPos++; ch <<= 6;
+          case 3: ch += *nextPos++; ch <<= 6;
+          case 2: ch += *nextPos++; ch <<= 6;
+          case 1: ch += *nextPos++;
+    }
+    ch -= offsetsFromUTF8[extraBytesToRead-1];
+    curChar = ch;
+}
+
+// Magic numbers for UTF-16 conversions
+template <typename T>
+const unsigned long FTUnicodeStringItr<T>::highSurrogateStart = 0xD800;
+template <typename T>
+const unsigned long FTUnicodeStringItr<T>::highSurrogateEnd = 0xDBFF;
+template <typename T>
+const unsigned long FTUnicodeStringItr<T>::lowSurrogateStart = 0xDC00;
+template <typename T>
+const unsigned long FTUnicodeStringItr<T>::lowSurrogateEnd = 0xDFFF;
+template <typename T>
+const unsigned long FTUnicodeStringItr<T>::highSurrogateShift = 10;
+template <typename T>
+const unsigned long FTUnicodeStringItr<T>::lowSurrogateBase = 0x0010000UL;
+
+template <typename T>
+inline void FTUnicodeStringItr<T>::readUTF16()
+{
+    unsigned int ch = *nextPos++;
+    // if we have the first half of the surrogate pair
+    if (ch >= highSurrogateStart && ch <= highSurrogateEnd)
+    {
+        unsigned int ch2 = *curPos;
+        // complete the surrogate pair
+        if (ch2 >= lowSurrogateStart && ch2 <= lowSurrogateEnd)
+        {
+            ch = ((ch - highSurrogateStart) << highSurrogateShift)
+                + (ch2 - lowSurrogateStart) + lowSurrogateBase;
+            ++nextPos;
+        }
+    }
+    curChar = ch;
+}
+
+#endif
diff --git a/src/ftgl/FTVector.h b/src/ftgl/FTVector.h
new file mode 100644
index 0000000..ceac72a
--- /dev/null
+++ b/src/ftgl/FTVector.h
@@ -0,0 +1,215 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef    __FTVector__
+#define    __FTVector__
+
+#include "FTGL/ftgl.h"
+
+/**
+ * Provides a non-STL alternative to the STL vector
+ */
+template <typename FT_VECTOR_ITEM_TYPE>
+class 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 ibegin, iend;
+
+            if(n >= Size)
+            {
+                ibegin = this->end();
+                iend = this->begin() + n;
+            }
+            else
+            {
+                ibegin = this->begin() + n;
+                iend = this->end();
+            }
+
+            while(ibegin != iend)
+            {
+                *ibegin++ = 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 ibegin = this->begin();
+            iterator iend = this->end();
+            value_type *ptr = new_items;
+
+            while(ibegin != iend)
+            {
+                *ptr++ = *ibegin++;
+            }
+
+            if(Capacity)
+            {
+                delete [] Items;
+            }
+
+            Items = new_items;
+            Capacity = new_capacity;
+        }
+
+        size_type Capacity;
+        size_type Size;
+        value_type* Items;
+};
+
+#endif  //  __FTVector__
diff --git a/src/ftgl/FTVectoriser.cpp b/src/ftgl/FTVectoriser.cpp
new file mode 100644
index 0000000..ea5c571
--- /dev/null
+++ b/src/ftgl/FTVectoriser.cpp
@@ -0,0 +1,328 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Éric Beets <ericbeets@free.fr>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include "FTInternals.h"
+#include "FTVectoriser.h"
+
+#ifndef CALLBACK
+#define CALLBACK
+#endif
+
+#if defined __APPLE_CC__ && __APPLE_CC__ < 5465
+    typedef GLvoid (*GLUTesselatorFunction) (...);
+#elif defined WIN32 && !defined __CYGWIN__
+    typedef GLvoid (CALLBACK *GLUTesselatorFunction) ();
+#else
+    typedef GLvoid (*GLUTesselatorFunction) ();
+#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(size_t 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(int i = 0; i < ftContourCount; ++i)
+    {
+        FT_Vector* pointList = &outline.points[startIndex];
+        char* tagList = &outline.tags[startIndex];
+
+        endIndex = outline.contours[i];
+        contourLength =  (endIndex - startIndex) + 1;
+
+        FTContour* contour = new FTContour(pointList, tagList, contourLength);
+
+        contourList[i] = contour;
+
+        startIndex = endIndex + 1;
+    }
+
+    // Compute each contour's parity. FIXME: see if FT_Outline_Get_Orientation
+    // can do it for us.
+    for(int i = 0; i < ftContourCount; i++)
+    {
+        FTContour *c1 = contourList[i];
+
+        // 1. Find the leftmost point.
+        FTPoint leftmost(65536.0, 0.0);
+
+        for(size_t n = 0; n < c1->PointCount(); n++)
+        {
+            FTPoint p = c1->Point(n);
+            if(p.X() < leftmost.X())
+            {
+                leftmost = p;
+            }
+        }
+
+        // 2. Count how many other contours we cross when going further to
+        // the left.
+        int parity = 0;
+
+        for(int j = 0; j < ftContourCount; j++)
+        {
+            if(j == i)
+            {
+                continue;
+            }
+
+            FTContour *c2 = contourList[j];
+
+            for(size_t n = 0; n < c2->PointCount(); n++)
+            {
+                FTPoint p1 = c2->Point(n);
+                FTPoint p2 = c2->Point((n + 1) % c2->PointCount());
+
+                /* FIXME: combinations of >= > <= and < do not seem stable */
+                if((p1.Y() < leftmost.Y() && p2.Y() < leftmost.Y())
+                    || (p1.Y() >= leftmost.Y() && p2.Y() >= leftmost.Y())
+                    || (p1.X() > leftmost.X() && p2.X() > leftmost.X()))
+                {
+                    continue;
+                }
+                else if(p1.X() < leftmost.X() && p2.X() < leftmost.X())
+                {
+                    parity++;
+                }
+                else
+                {
+                    FTPoint a = p1 - leftmost;
+                    FTPoint b = p2 - leftmost;
+                    if(b.X() * a.Y() > b.Y() * a.X())
+                    {
+                        parity++;
+                    }
+                }
+            }
+        }
+
+        // 3. Make sure the glyph has the proper parity.
+        c1->SetParity(parity);
+    }
+}
+
+
+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(size_t index) const
+{
+    return (index < ContourCount()) ? contourList[index] : NULL;
+}
+
+
+void FTVectoriser::MakeMesh(FTGL_DOUBLE zNormal, int outsetType, float outsetSize)
+{
+    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)
+        {
+            /* Build the */
+            switch(outsetType)
+            {
+                case 1 : contourList[c]->buildFrontOutset(outsetSize); break;
+                case 2 : contourList[c]->buildBackOutset(outsetSize); break;
+            }
+            const FTContour* contour = contourList[c];
+
+
+            gluTessBeginContour(tobj);
+                for(size_t p = 0; p < contour->PointCount(); ++p)
+                {
+                    const FTGL_DOUBLE* d;
+                    switch(outsetType)
+                    {
+                        case 1: d = contour->FrontPoint(p); break;
+                        case 2: d = contour->BackPoint(p); break;
+                        case 0: default: d = contour->Point(p); break;
+                    }
+                    // XXX: gluTessVertex doesn't modify the data but does not
+                    // specify "const" in its prototype, so we cannot cast to
+                    // a const type.
+                    gluTessVertex(tobj, (GLdouble *)d, (GLvoid *)d);
+                }
+
+            gluTessEndContour(tobj);
+        }
+    gluTessEndPolygon(tobj);
+
+    gluDeleteTess(tobj);
+}
+
diff --git a/src/ftgl/FTVectoriser.h b/src/ftgl/FTVectoriser.h
new file mode 100644
index 0000000..942aea1
--- /dev/null
+++ b/src/ftgl/FTVectoriser.h
@@ -0,0 +1,313 @@
+/*
+ * FTGL - OpenGL font library
+ *
+ * Copyright (c) 2001-2004 Henry Maddocks <ftgl@opengl.geek.nz>
+ * Copyright (c) 2008 Sam Hocevar <sam@zoy.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef     __FTVectoriser__
+#define     __FTVectoriser__
+
+#include "FTGL/ftgl.h"
+
+#include "FTContour.h"
+#include "FTList.h"
+#include "FTVector.h"
+
+
+#ifndef CALLBACK
+#define CALLBACK
+#endif
+
+
+/**
+ * FTTesselation captures points that are output by OpenGL's gluTesselator.
+ */
+class 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 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
+         */
+        size_t TesselationCount() const { return tesselationList.size(); }
+
+        /**
+         * Get a tesselation by index
+         */
+        const FTTesselation* const Tesselation(size_t 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 FTExtrudeGlyph
+ * @see FTOutlineGlyph
+ * @see FTPolygonGlyph
+ * @see FTContour
+ * @see FTPoint
+ *
+ */
+class 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
+         * FIXME: change the following for a constant
+         * @param outsetType Specify the outset type contour
+         *  0 : Original
+         *  1 : Front
+         *  2 : Back
+         * @param outsetSize Specify the outset size contour
+         */
+        void MakeMesh(FTGL_DOUBLE zNormal = FTGL_FRONT_FACING, int outsetType = 0, float outsetSize = 0.0f);
+
+        /**
+         * 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(size_t 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
+         *
+         * @param front front outset distance
+         * @param back back outset distance
+         */
+        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__
diff --git a/src/ftgl/config.h b/src/ftgl/config.h
new file mode 100644
index 0000000..109a1ae
--- /dev/null
+++ b/src/ftgl/config.h
@@ -0,0 +1,10 @@
+// GLUT
+//#define HAVE_GL_GLUT_H
+
+// M_PI and friends on VC
+#define _USE_MATH_DEFINES
+
+// quell spurious "'this': used in base member initializer list" warnings
+#ifdef _MSC_VER
+#pragma warning(disable: 4355)
+#endif
diff --git a/src/gdk/cdgdk.c b/src/gdk/cdgdk.c
index a6db25f..dfffef1 100644
--- a/src/gdk/cdgdk.c
+++ b/src/gdk/cdgdk.c
@@ -1057,10 +1057,7 @@ static void cdgetimagergb(cdCtxCanvas *ctxcanvas, unsigned char *r, unsigned cha
                                                    x, y-h+1, 
                                                    0, 0, w, h);
   if (!pixbuf)
-  {
-    fprintf(stderr, "CanvasDraw: error getting image\n");
     return;
-  }
 
   cdgdkGetPixbufData(pixbuf, r, g, b);
 }
@@ -1087,10 +1084,8 @@ static void cdputimagerectrgba_matrix(cdCtxCanvas* ctxcanvas, int iw, int ih, co
   if (a) nc = 4;
   dst_r = malloc(nc*size);
   if (!dst_r)
-  {
-    fprintf(stderr, "CanvasDraw: no enough memory\n");
     return;
-  }
+
   dst_g = dst_r + size;
   dst_b = dst_g + size;
   if (a) dst_a = dst_b + size;
@@ -1177,10 +1172,8 @@ static void cdputimagerectmap_matrix(cdCtxCanvas* ctxcanvas, int iw, int ih, con
   size = ew*eh;
   dst_index = malloc(size);
   if (!dst_index)
-  {
-    fprintf(stderr, "CanvasDraw: no enough memory\n");
     return;
-  }
+
   memset(dst_index, 0, size);
 
   /* for all pixels in the destiny area */