Removed FTGL, added C++ integrated port of freetype-gl

Projects/CodeBlocks/SleepyHead.cbp

@@ -126,6 +126,20 @@
 		</Unit>
 		<Unit filename="../../src/graphs/graph.cpp" />
 		<Unit filename="../../src/graphs/graph.h" />
+		<Unit filename="../../src/libs/freetype-gl/font-manager.cpp" />
+		<Unit filename="../../src/libs/freetype-gl/font-manager.h" />
+		<Unit filename="../../src/libs/freetype-gl/text-markup.cpp" />
+		<Unit filename="../../src/libs/freetype-gl/text-markup.h" />
+		<Unit filename="../../src/libs/freetype-gl/texture-atlas.cpp" />
+		<Unit filename="../../src/libs/freetype-gl/texture-atlas.h" />
+		<Unit filename="../../src/libs/freetype-gl/texture-font.cpp" />
+		<Unit filename="../../src/libs/freetype-gl/texture-font.h" />
+		<Unit filename="../../src/libs/freetype-gl/texture-glyph.cpp" />
+		<Unit filename="../../src/libs/freetype-gl/texture-glyph.h" />
+		<Unit filename="../../src/libs/freetype-gl/vector.cpp" />
+		<Unit filename="../../src/libs/freetype-gl/vector.h" />
+		<Unit filename="../../src/libs/freetype-gl/vertex-buffer.cpp" />
+		<Unit filename="../../src/libs/freetype-gl/vertex-buffer.h" />
 		<Unit filename="../../src/libs/sleeplib/binary_file.cpp" />
 		<Unit filename="../../src/libs/sleeplib/binary_file.h" />
 		<Unit filename="../../src/libs/sleeplib/loader_plugins/cms50_loader.cpp" />

Projects/CodeBlocks/SleepyHead.layout

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
 <CodeBlocks_layout_file>
-	<ActiveTarget name="Debug" />
+	<ActiveTarget name="Debug-wx29" />
-	<File name="../../src/GUIFrame.cpp" open="1" top="0" tabpos="11">
+	<File name="../../src/GUIFrame.cpp" open="0" top="0" tabpos="11">
 		<Cursor position="1318" topLine="9" />
 	</File>
 	<File name="../../src/GUIFrame.h" open="0" top="0" tabpos="9">
@@ -11,19 +11,55 @@
 		<Cursor position="1042" topLine="16" />
 	</File>
 	<File name="../../src/SleepyHeadMain.cpp" open="1" top="0" tabpos="2">
-		<Cursor position="10959" topLine="335" />
+		<Cursor position="29214" topLine="757" />
 	</File>
 	<File name="../../src/SleepyHeadMain.h" open="1" top="0" tabpos="3">
 		<Cursor position="2630" topLine="75" />
 	</File>
-	<File name="../../src/graphs/freesans.c" open="1" top="0" tabpos="10">
+	<File name="../../src/graphs/freesans.c" open="0" top="0" tabpos="10">
 		<Cursor position="0" topLine="0" />
 	</File>
 	<File name="../../src/graphs/graph.cpp" open="1" top="1" tabpos="7">
-		<Cursor position="55196" topLine="2003" />
+		<Cursor position="0" topLine="0" />
 	</File>
 	<File name="../../src/graphs/graph.h" open="1" top="0" tabpos="8">
-		<Cursor position="14685" topLine="387" />
+		<Cursor position="12163" topLine="323" />
+	</File>
+	<File name="../../src/libs/freetype-gl/font-manager.cpp" open="1" top="0" tabpos="9">
+		<Cursor position="0" topLine="30" />
+	</File>
+	<File name="../../src/libs/freetype-gl/font-manager.h" open="1" top="0" tabpos="14">
+		<Cursor position="1954" topLine="13" />
+	</File>
+	<File name="../../src/libs/freetype-gl/texture-atlas.cpp" open="1" top="0" tabpos="10">
+		<Cursor position="3243" topLine="80" />
+	</File>
+	<File name="../../src/libs/freetype-gl/texture-atlas.h" open="1" top="0" tabpos="13">
+		<Cursor position="1629" topLine="29" />
+	</File>
+	<File name="../../src/libs/freetype-gl/texture-font.cpp" open="1" top="0" tabpos="11">
+		<Cursor position="3837" topLine="106" />
+	</File>
+	<File name="../../src/libs/freetype-gl/texture-font.h" open="1" top="0" tabpos="12">
+		<Cursor position="0" topLine="17" />
+	</File>
+	<File name="../../src/libs/freetype-gl/texture-glyph.cpp" open="1" top="0" tabpos="15">
+		<Cursor position="0" topLine="69" />
+	</File>
+	<File name="../../src/libs/freetype-gl/texture-glyph.h" open="1" top="0" tabpos="16">
+		<Cursor position="0" topLine="24" />
+	</File>
+	<File name="../../src/libs/freetype-gl/vector.cpp" open="0" top="0" tabpos="13">
+		<Cursor position="1187" topLine="18" />
+	</File>
+	<File name="../../src/libs/freetype-gl/vector.h" open="0" top="0" tabpos="14">
+		<Cursor position="0" topLine="0" />
+	</File>
+	<File name="../../src/libs/freetype-gl/vertex-buffer.cpp" open="1" top="0" tabpos="17">
+		<Cursor position="2573" topLine="131" />
+	</File>
+	<File name="../../src/libs/freetype-gl/vertex-buffer.h" open="1" top="0" tabpos="18">
+		<Cursor position="3491" topLine="54" />
 	</File>
 	<File name="../../src/libs/sleeplib/binary_file.cpp" open="0" top="0" tabpos="11">
 		<Cursor position="7148" topLine="269" />
@@ -38,7 +74,7 @@
 		<Cursor position="1662" topLine="27" />
 	</File>
 	<File name="../../src/libs/sleeplib/machine.cpp" open="1" top="0" tabpos="5">
-		<Cursor position="9760" topLine="283" />
+		<Cursor position="11760" topLine="264" />
 	</File>
 	<File name="../../src/libs/sleeplib/machine.h" open="1" top="0" tabpos="4">
 		<Cursor position="5047" topLine="119" />
@@ -46,8 +82,8 @@
 	<File name="../../src/libs/sleeplib/machine_loader.h" open="0" top="0" tabpos="14">
 		<Cursor position="222" topLine="0" />
 	</File>
-	<File name="../../src/libs/sleeplib/profiles.cpp" open="1" top="0" tabpos="9">
+	<File name="../../src/libs/sleeplib/profiles.cpp" open="0" top="0" tabpos="9">
-		<Cursor position="601" topLine="1" />
+		<Cursor position="2827" topLine="38" />
 	</File>
 	<File name="../../src/libs/sleeplib/profiles.h" open="0" top="0" tabpos="13">
 		<Cursor position="757" topLine="15" />

src/SleepyHeadMain.cpp

@@ -790,6 +790,7 @@ Daily::Daily(wxWindow *win,Profile *p)
     gwSizer->Add(PRD,1,wxEXPAND);
     gwSizer->Add(LEAK,1,wxEXPAND);
     gwSizer->Add(SNORE,1,wxEXPAND);
+    //gwSizer->Add(TAP,1,wxEXPAND);
     gwSizer->Add(PULSE,1,wxEXPAND);
     gwSizer->Add(SPO2,1,wxEXPAND);
 
@@ -1028,7 +1029,7 @@ void Daily::RefreshData()
        // html=html+wxT("<tr><td colspan=4>&nbsp;</td></tr>\n");
         //html=html+wxT("<tr><td colspan=4>&nbsp;</td></tr>\n");
         html=html+wxT("<tr><td colspan=4 align=center><i>")+_("Event Breakdown")+wxT("</i></td></tr>\n");
-        html=html+wxT("<tr><td colspan=4 align=center><img src=\"memory:ahi.png\" ></td></tr>\n");
+        html=html+wxT("<tr><td colspan=4 align=left><img src=\"memory:ahi.png\"></td></tr>\n");
         //html=html+wxT("<tr><td colspan=4>&nbsp;</td></tr>\n");
 
         //html=html+wxT("<tr><td colspan=4 align=center><i>")+_("Other Information")+wxT("</i></td></tr>\n");

src/graphs/graph.h

@@ -9,7 +9,7 @@ License: LGPL
 
 #include <wx/dcgraph.h>
 #include <wx/glcanvas.h>
-#include <FTGL/ftgl.h>
+//#include <FTGL/ftgl.h>
 
 #include <sleeplib/machine.h>
 #include <list>
@@ -215,7 +215,9 @@ class gGraphWindow:public wxGLCanvas //Window // rename to gGraphWindow
             return min_y+(yy*hh);
         };
 
-        virtual void Update();
+        void Render(float scrx,float scry);
+
+        //virtual void Update();
         //virtual void Update();
         void AddLayer(gLayer *l);
 
@@ -228,7 +230,7 @@ class gGraphWindow:public wxGLCanvas //Window // rename to gGraphWindow
         void SetBlockMove(bool b) { m_block_move=b; };
 
         wxGLContext *gl_context;
-        FTFont *texfont;
+        //FTFont *texfont;
 
     protected:
         list<gGraphWindow *>link_zoom;
@@ -267,7 +269,7 @@ class gLayer
         gLayer(gPointData *g=NULL,wxString title=wxT(""));
         virtual ~gLayer();
         //virtual void Update() { data=gd; };
-        virtual void Plot(wxDC & dc, gGraphWindow & w);
+        virtual void Plot(gGraphWindow & w,float scrx,float scry);
         vector<wxColor> color;
 
         virtual void SetData(gPointData * gd) { data=gd; };
@@ -336,16 +338,16 @@ class gLayer
 class gGraphTitle:public gLayer
 {
     public:
-        gGraphTitle(const wxString & _title,wxOrientation o=wxVERTICAL,const wxFont * font=wxNORMAL_FONT,const wxColor * color=wxBLACK);
+        gGraphTitle(const wxString & _title,wxOrientation o=wxVERTICAL,const wxColor * color=wxBLACK);
         virtual ~gGraphTitle();
-        virtual void Plot(wxDC & dc, gGraphWindow & w);
+        virtual void Plot(gGraphWindow & w,float scrx,float scry);
         wxOrientation Orientation() { return m_orientation; };
         static const int Margin=20;
 
     protected:
         wxString m_title;
         wxOrientation m_orientation;
-        wxFont *m_font;
+        //wxFont *m_font;
         wxColor *m_color;
         wxCoord m_textheight,m_textwidth;
 };
@@ -356,7 +358,7 @@ class gCandleStick:public gLayer
         gCandleStick(gPointData *d=NULL,wxOrientation o=wxHORIZONTAL);
         virtual ~gCandleStick();
 
-        virtual void Plot(wxDC & dc, gGraphWindow & w);
+        virtual void Plot(gGraphWindow & w,float scrx,float scry);
         void AddName(wxString name) { m_names.push_back(name); };
 
     protected:
@@ -370,7 +372,7 @@ class gXAxis:public gLayer
     public:
         gXAxis(const wxColor * col=wxBLACK);
         virtual ~gXAxis();
-        virtual void Plot(wxDC & dc, gGraphWindow & w);
+        virtual void Plot(gGraphWindow & w,float scrx,float scry);
         static const int Margin=40; // How much room does this take up. (Bottom margin)
     protected:
 //        virtual const wxString & Format(double v) { static wxString t; wxDateTime d; d.Set(v); t=d.Format(wxT("%H:%M")); return t; };
@@ -380,7 +382,7 @@ class gYAxis:public gLayer
     public:
         gYAxis(const wxColor * col=wxBLACK);
         virtual ~gYAxis();
-        virtual void Plot(wxDC & dc, gGraphWindow & w);
+        virtual void Plot(gGraphWindow & w,float scrx,float scry);
         void SetShowMinorLines(bool b) { m_show_minor_lines=b; };
         void SetShowMajorLines(bool b) { m_show_major_lines=b; };
         bool ShowMinorLines() { return m_show_minor_lines; };
@@ -397,7 +399,7 @@ class gFooBar:public gLayer
     public:
         gFooBar(const wxColor * color1=wxGREEN,const wxColor * color2=wxDARK_GREY);
         virtual ~gFooBar();
-        virtual void Plot(wxDC & dc, gGraphWindow & w);
+        virtual void Plot(gGraphWindow & w,float scrx,float scry);
         static const int Margin=15;
     protected:
 };
@@ -409,7 +411,7 @@ class gLineChart:public gLayer
         gLineChart(gPointData *d=NULL,const wxColor * col=wxBLACK,int dlsize=4096,bool accelerate=false,bool _hide_axes=false,bool _square_plot=false);
         virtual ~gLineChart();
 
-        virtual void Plot(wxDC & dc, gGraphWindow & w);
+        virtual void Plot(gGraphWindow & w,float scrx,float scry);
 
         void SetSquarePlot(bool b) { m_square_plot=b; };
         bool GetSquarePlot() { return m_square_plot; };
@@ -435,7 +437,7 @@ class gLineOverlayBar:public gLayer
         gLineOverlayBar(gPointData *d=NULL,const wxColor * col=wxBLACK,wxString _label=wxT(""),LO_Type _lot=LOT_Bar);
         virtual ~gLineOverlayBar();
 
-        virtual void Plot(wxDC & dc, gGraphWindow & w);
+        virtual void Plot(gGraphWindow & w,float scrx,float scry);
 
     protected:
         wxString label;
@@ -448,7 +450,7 @@ class gFlagsLine:public gLayer
         gFlagsLine(gPointData *d=NULL,const wxColor * col=wxBLACK,wxString _label=wxT(""),int _line_num=0,int _total_lines=0);
         virtual ~gFlagsLine();
 
-        virtual void Plot(wxDC & dc, gGraphWindow & w);
+        virtual void Plot(gGraphWindow & w,float scrx,float scry);
 
     protected:
         wxString label;
@@ -462,7 +464,7 @@ class gBarChart:public gLayer
         gBarChart(gPointData *d=NULL,const wxColor *col=NULL,wxOrientation o=wxHORIZONTAL);
         virtual ~gBarChart();
 
-        virtual void Plot(wxDC & dc, gGraphWindow & w);
+        virtual void Plot(gGraphWindow & w,float scrx,float scry);
 
     protected:
         wxOrientation m_direction;

src/libs/freetype-gl/README

@@ -0,0 +1,39 @@
+Freetype GL - A C OpenGL Freetype engine
+========================================
+
+This code intends to show how to display fonts efficiently using regular C,
+Freetype and OpenGL. The idea is to use a single texture and a single vertex
+buffer. The code is fairly simple and organized as follow:
+
+texture-atlas: This structure is responsible for the packing of small regions
+               into a bigger texture. It is based on the skyline bottom left
+               algorithm which appear to be well suited for storing glyphs.
+
+               More information at:
+               http://clb.demon.fi/files/RectangleBinPack.pdf
+
+vector:        This structure loosely mimics the std::vector class from c++. It
+               is used by texture-atlas (for storing nodes), texture-font (for
+               storing glyphs) and font-manager (for storing fonts).
+
+               More information at:
+               http://www.cppreference.com/wiki/container/vector/start
+
+
+texture-font:  The texture-font structure is in charge of creating bitmap
+               glyphs and to upload them to the texture atlas.
+
+
+texture-glyph: Simple structure that described a texture glyph (position within
+               texture, advance, kerning, ...)
+
+text-markup:   Simple structure that describes text properties (font family,
+               font size, colors, underline, etc.)
+
+font-manager:  Structure in charge of caching fonts.
+
+vertex-buffer: Generic vertex buffer structure inspired by pyglet (python).
+
+               More information at:
+               http://www.pyglet.org
+

src/libs/freetype-gl/font-manager.cpp

@@ -0,0 +1,166 @@
+/* =========================================================================
+ * Freetype GL - A C OpenGL Freetype engine
+ * Platform:    Any
+ * API version: 1.0
+ * WWW:         http://code.google.com/p/freetype-gl/
+ * C++ Conversion by Mark Watkins
+ * -------------------------------------------------------------------------
+ * Copyright (c) 2011 Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ * ========================================================================= */
+
+
+#include <wx/log.h>
+#include <fontconfig/fontconfig.h>
+#include <assert.h>
+#include <stdio.h>
+#include <wchar.h>
+#include "font-manager.h"
+
+
+wchar_t *
+wcsdup( const wchar_t *string )
+{
+    wchar_t * result;
+    assert( string );
+    result = (wchar_t *) malloc( (wcslen(string) + 1) * sizeof(wchar_t) );
+    wcscpy( result, string );
+    return result;
+}
+
+FontManager *manager_instance=NULL;
+
+FontManager::FontManager()
+{
+    m_atlas = new TextureAtlas(512, 512);
+    m_fonts.clear();
+    m_cache = wcsdup( L" " );
+/*
+        self->cache = wcsdup( L" !\"#$%&'()*+,-./0123456789:;<=>?"
+                              L"@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
+                              L"`abcdefghijklmnopqrstuvwxyz{|}~" );
+*/
+}
+
+FontManager::~FontManager()
+{
+    for (vector<TextureFont *>::iterator f=m_fonts.begin();f!=m_fonts.end();f++) {
+        delete *f;
+    }
+    delete m_atlas;
+
+    if (m_cache) {
+        free(m_cache);
+    }
+}
+
+TextureFont * FontManager::GetFromFilename(const wxString & filename, const float size)
+{
+    size_t i;
+    TextureFont *font;
+
+    for (i=0; i<m_fonts.size();++i ) {
+        font = m_fonts[i];
+        if (((font->m_filename == filename)) && (font->m_size == size)) {
+            return font;
+        }
+    }
+    font = new TextureFont(m_atlas,filename, size);
+
+    if (font) {
+        font->CacheGlyphs(m_cache);
+        m_fonts.push_back(font);
+        return font;
+    }
+    return NULL;
+}
+
+
+TextureFont * FontManager::GetFromDescription(const wxString & family, const float size, const int bold, const int italic)
+{
+    TextureFont *font;
+    wxString filename=MatchDescription(family, size, bold, italic);
+
+    if (filename.IsEmpty()) {
+        return NULL;
+    }
+    font = GetFromFilename(filename, size);
+    return font;
+}
+
+TextureFont * FontManager::GetFromMarkup(const TextMarkup *markup)
+{
+    assert( markup );
+
+    return GetFromDescription(markup->family, markup->size, markup->bold, markup->italic );
+}
+
+
+const wxString & FontManager::MatchDescription(const wxString & family, const float size, const int bold, const int italic)
+{
+    static wxString filename=wxEmptyString;
+    int weight = FC_WEIGHT_REGULAR;
+    int slant = FC_SLANT_ROMAN;
+    if (bold) {
+        weight = FC_WEIGHT_BOLD;
+    }
+    if (italic) {
+        slant = FC_SLANT_ITALIC;
+    }
+    FcInit();
+    FcPattern *pattern = FcPatternCreate();
+    FcPatternAddDouble(pattern, FC_SIZE, size);
+    FcPatternAddInteger(pattern, FC_WEIGHT, weight);
+    FcPatternAddInteger(pattern, FC_SLANT, slant);
+
+    char *t=strdup(family.mb_str());
+    FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)t);
+    free(t);
+    FcConfigSubstitute(0, pattern, FcMatchPattern);
+    FcDefaultSubstitute(pattern);
+    FcResult result;
+    FcPattern *match = FcFontMatch(0, pattern, &result);
+    FcPatternDestroy(pattern);
+
+    if (!match ) {
+        wxLogError(wxT("fontconfig error: Could not match family '")+family+wxT("'"));
+        return filename;
+    } else {
+        FcValue value;
+        FcResult result = FcPatternGet(match, FC_FILE, 0, &value);
+        if (result) {
+            wxLogError(wxT("fontconfig error: Could not match family '")+family+wxT("'"));
+        } else {
+            filename = wxString((char *)(value.u.s),wxConvUTF8);
+        }
+    }
+    FcPatternDestroy(match);
+    return filename;
+}
+
+const wchar_t * FontManager::GetCache()
+{
+    return m_cache;
+}
+
+void FontManager::SetCache(const wchar_t * cache)
+{
+    assert( cache );
+
+    if (m_cache) {
+        free(m_cache);
+    }
+    m_cache=wcsdup(cache);
+}

src/libs/freetype-gl/font-manager.h

@@ -0,0 +1,50 @@
+/* =========================================================================
+ * Freetype GL - A C OpenGL Freetype engine
+ * Platform:    Any
+ * API version: 1.0
+ * WWW:         http://code.google.com/p/freetype-gl/
+ * C++ Conversion by Mark Watkins
+ * -------------------------------------------------------------------------
+ * Copyright (c) 2011 Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ * ========================================================================= */
+#ifndef __FONT_MANAGER_H__
+#define __FONT_MANAGER_H__
+
+#include <vector>
+#include "text-markup.h"
+#include "texture-font.h"
+#include "texture-atlas.h"
+
+
+class FontManager {
+public:
+    FontManager();
+    ~FontManager();
+    TextureFont * GetFromFilename(const wxString & filename, const float size);
+    TextureFont * GetFromDescription(const wxString & family, const float size, const int bold, const int italic);
+    TextureFont * GetFromMarkup(const TextMarkup * markup);
+    const wxString & MatchDescription(const wxString & family, const float size, const int bold, const int italic);
+
+    const wchar_t * GetCache();
+    void SetCache(const wchar_t *cache);
+
+    TextureAtlas * m_atlas;
+    vector<TextureFont *> m_fonts;
+    wchar_t *      m_cache;
+};
+
+#endif /* __FONT_MANAGER_H__ */
+

src/libs/freetype-gl/text-markup.cpp

@@ -0,0 +1,56 @@
+/* =========================================================================
+ * Freetype GL - A C OpenGL Freetype engine
+ * Platform:    Any
+ * API version: 1.0
+ * WWW:         http://code.google.com/p/freetype-gl/
+ * C++ Conversion by Mark Watkins
+ * -------------------------------------------------------------------------
+ * Copyright (c) 2011 Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ * ========================================================================= */
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include "font-manager.h"
+#include "text-markup.h"
+
+TextMarkup::TextMarkup()
+{
+    wxColor black(0,0,0,255);
+    wxColor white(255,255,255,255);
+
+
+    family = wxString("monotype");
+    italic = 0;
+    bold   = 0;
+    size   = 16;
+    rise   = 0;
+    spacing= 0;
+
+    foreground_color    = black;
+    background_color    = white;
+    underline           = 0;
+    underline_color     = black;
+    overline            = 0;
+    overline_color      = black;
+    strikethrough       = 0;
+    strikethrough_color = black;
+}
+
+TextMarkup::~TextMarkup()
+{
+}
+
+

src/libs/freetype-gl/text-markup.h

@@ -0,0 +1,85 @@
+/* =========================================================================
+ * Freetype GL - A C OpenGL Freetype engine
+ * Platform:    Any
+ * API version: 1.0
+ * WWW:         http://code.google.com/p/freetype-gl/
+ * C++ Conversion by Mark Watkins
+ * -------------------------------------------------------------------------
+ * Copyright (c) 2011 Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ * ========================================================================= */
+#ifndef __TEXT_MARKUP_H__
+#define __TEXT_MARKUP_H__
+
+#include <wx/colour.h>
+
+
+class TextMarkup {
+public:
+    TextMarkup();
+    ~TextMarkup();
+    const wxString & GetFamily() { return family; };
+    void SetFamily(wxString fam) { family=fam; };
+    int GetItalic() { return italic; };
+    void SetItalic(int i) { italic=i; };
+    int GetBold() { return bold; };
+    void SetBold(int i) { bold=i; };
+    float GetSize() { return size; };
+    void SetSize(float f) { size=f; };
+    float GetRise() { return rise; };
+    void SetRise(float f) { rise=f; };
+    float GetSpacing() { return spacing; };
+    void SetSpacing(float f) { spacing=f; };
+    wxColor GetForegroundColor() { return foreground_color; };
+    void SetForegroundColor(wxColor c) { foreground_color=c; };
+    wxColor GetBackgroundColor() { return background_color; };
+    void SetBackgroundColor(wxColor c) { background_color=c; };
+    int GetOutline() { return outline; };
+    void SetOutline(int i) { outline=i; };
+    wxColor GetOutlineColor() { return outline_color; };
+    void SetOutlineColor(wxColor c) { outline_color=c; };
+    int GetUnderline() { return underline; };
+    void SetUnderline(int i) { underline=i; };
+    wxColor GetUnderlineColor() { return underline_color; };
+    void SetUnderlineColor(wxColor c) { underline_color=c; };
+    int GetOverline() { return overline; };
+    void SetOverline(int i) { overline=i; };
+    wxColor GetOverlineColor() { return overline_color; };
+    void SetOverlineColor(wxColor c) { overline_color=c; };
+    int GetStrikethrough() { return strikethrough; };
+    void SetStrikethrough(int i) { strikethrough=i; };
+    wxColor GetStrikethroughColor() { return strikethrough_color; };
+    void SetStrikethroughColor(wxColor c) { strikethrough_color=c; };
+
+
+    wxString     family;
+    float         size;
+    int           bold;
+    int           italic;
+    float         rise;
+    float         spacing;
+    wxColor       foreground_color;
+    wxColor       background_color;
+    int           outline;
+    wxColor       outline_color;
+    int           underline;
+    wxColor       underline_color;
+    int           overline;
+    wxColor       overline_color;
+    int           strikethrough;
+    wxColor       strikethrough_color;
+};
+
+#endif /* __TEXT_MARKUP_H__ */

src/libs/freetype-gl/texture-atlas.cpp

@@ -0,0 +1,217 @@
+/* =========================================================================
+ * Freetype GL - A C OpenGL Freetype engine
+ * Platform:    Any
+ * API version: 1.0
+ * WWW:         http://code.google.com/p/freetype-gl/
+ * C++ Conversion by Mark Watkins
+ * -------------------------------------------------------------------------
+ * Copyright (c) 2011 Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ * ========================================================================= */
+#if defined(__APPLE__)
+    #include <Glut/glut.h>
+#else
+    #include <GL/glut.h>
+#endif
+//#include <stdlib.h>
+#include <limits.h>
+#include "texture-atlas.h"
+
+#define max(a,b) (a)>(b)?(a):(b)
+#define min(a,b) (a)<(b)?(a):(b)
+
+
+/* ========================================================================= */
+/*                                                                           */
+/* ========================================================================= */
+TextureAtlas::TextureAtlas(int width, int height)
+:m_used(0),m_width(width),m_height(height),m_texid(0)
+{
+    Node *node=new Node(0,0,m_width);
+    m_nodes.push_back(node);
+    m_data = (unsigned char *) calloc(m_width * m_height, sizeof(unsigned char));
+    // Think I have to use calloc here..
+    //data=new unsigned char [width*height];
+}
+
+/* ========================================================================= */
+/*                                                                           */
+/* ========================================================================= */
+TextureAtlas::~TextureAtlas()
+{
+    if (m_texid) {
+        glDeleteTextures(1, &m_texid);
+    }
+
+    // delete [] data;
+    free(m_data);
+    for (vector<Node *>::iterator n=m_nodes.begin();n!=m_nodes.end();n++) {
+        delete *n;
+    }
+}
+
+
+/* ========================================================================= */
+/*                                                                           */
+/* ========================================================================= */
+void TextureAtlas::Upload()
+{
+    if (!m_texid) {
+        glGenTextures( 1, &m_texid );
+    }
+    glBindTexture(GL_TEXTURE_2D, m_texid );
+    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, m_width, m_height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, m_data );
+}
+
+
+
+/* ========================================================================= */
+/*                                                                           */
+/* ========================================================================= */
+void TextureAtlas::SetRegion(int x, int y, int width, int height, unsigned char *data, int stride)
+{
+    assert( x < m_width);
+    assert( (x + width) <= m_width);
+    assert( y < m_height);
+    assert( (y + height) <= m_height);
+    size_t i;
+    size_t charsize = sizeof(char);
+
+    for (i=0; i<height; ++i) {
+        memcpy( m_data + ((y+i) * m_width+x) * charsize,
+                data+(i*stride) * charsize, width  * charsize );
+    }
+}
+
+
+
+/* ========================================================================= */
+/*                                                                           */
+/* ========================================================================= */
+int TextureAtlas::Fit(int index, int width, int height)
+{
+    Node *node = m_nodes[index];
+    int x = node->x, y, width_left = width;
+	size_t i = index;
+
+	if ((x + width) > m_width) {
+		return -1;
+    }
+	y = node->y;
+
+	while (width_left > 0) {
+        node = m_nodes[i];
+		y = max( y, node->y );
+		if ((y + height) > m_height) {
+			return -1;
+        }
+		width_left -= node->width;
+		++i;
+	}
+	return y;
+}
+
+
+
+/* ========================================================================= */
+/*                                                                           */
+/* ========================================================================= */
+void TextureAtlas::Merge()
+{
+    Node *node, *next;
+    int i;
+
+	for (i=0; i<m_nodes.size()-1; ++i)
+    {
+        node = m_nodes[i];
+        next = m_nodes[i+1];
+
+		if (node->y == next->y) {
+			node->width += next->width;
+			int j=i+1;
+			m_nodes.erase(m_nodes.begin()+(i+1));
+			--i;
+		}
+    }
+}
+
+
+
+/* ========================================================================= */
+/*                                                                           */
+/* ========================================================================= */
+wxRect TextureAtlas::GetRegion(int width, int height)
+{
+	int y, best_height, best_width, best_index;
+    Node *node, *prev;
+    wxRect region(0,0,width,height);
+
+    size_t i;
+
+    best_height = INT_MAX;
+    best_index  = -1;
+    best_width = INT_MAX;
+
+	for (i=0; i<m_nodes.size(); ++i ) {
+        y = Fit(i, width, height);
+		if (y >= 0) {
+            node = m_nodes[i];
+			if ((y + height < best_height) || (y + height == best_height && node->width < best_width)) {
+				best_height = y + height;
+				best_index = i;
+				best_width = node->width;
+				region.x = node->x;
+				region.y = y;
+			}
+        }
+    }
+
+	if (best_index == -1) {
+        region.x = -1;
+        region.y = -1;
+        region.width = 0;
+        region.height = 0;
+        return region;
+    }
+
+    node = new Node(region.x,region.y+height,width);
+    m_nodes.insert(m_nodes.begin()+best_index,node);
+
+    for(i = best_index+1; i < m_nodes.size(); ++i) {
+        node = m_nodes[i];
+        prev = m_nodes[i-1];
+
+        if (node->x < (prev->x + prev->width)) {
+            int shrink = prev->x + prev->width - node->x;
+            node->x += shrink;
+            node->width -= shrink;
+            if (node->width <= 0) {
+                m_nodes.erase(m_nodes.begin()+i);
+                --i;
+            } else {
+                break;
+            }
+        } else {
+            break;
+        }
+    }
+    Merge();
+    m_used += width * height;
+    return region;
+}

src/libs/freetype-gl/texture-atlas.h

@@ -0,0 +1,66 @@
+/* =========================================================================
+ * Freetype GL - A C OpenGL Freetype engine
+ * Platform:    Any
+ * API version: 1.0
+ * WWW:         http://code.google.com/p/freetype-gl/
+ * C++ Conversion by Mark Watkins
+ * -------------------------------------------------------------------------
+ * Copyright (c) 2011 Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ * =========================================================================
+
+   This source is based on the article by Jukka Jylänki :
+   "A Thousand Ways to Pack the Bin - A Practical Approach to
+    Two-Dimensional Rectangle Bin Packing", February 27, 2010.
+
+   More precisely, this is an implementation of the Skyline Bottom-Left
+   algorithm based on C++ sources provided by Jukka Jylänki at:
+   http://clb.demon.fi/files/RectangleBinPack/
+
+   ========================================================================= */
+#ifndef __TEXTURE_ATLAS_H__
+#define __TEXTURE_ATLAS_H__
+
+#include <wx/gdicmn.h>
+#include <vector>
+
+using namespace std;
+
+struct Node {
+    Node(int _x,int _y,int _width) { x=_x; y=_y; width=_width; };
+    int x, y, width;
+};
+
+class TextureAtlas {
+public:
+    TextureAtlas(int width, int height);
+    ~TextureAtlas();
+    void Upload();
+    wxRect GetRegion(int width, int height);
+    void SetRegion(int x, int y, int width, int height, unsigned char *data, int stride);
+
+    int m_width, m_height, m_used;
+
+    int Fit(int index, int width, int height);
+    void Merge();
+
+    vector<Node *> m_nodes;
+    unsigned int m_texid;
+    unsigned char *m_data;
+};
+
+
+
+#endif /* __TEXTURE_ATLAS_H__ */

src/libs/freetype-gl/texture-font.cpp

@@ -0,0 +1,264 @@
+/* =========================================================================
+ * Freetype GL - An ansi C OpenGL Freetype engine
+ * Platform:    Any
+ * API version: 1.0
+ * WWW:         http://www.loria.fr/~rougier/freetype-gl
+ * C++ Conversion by Mark Watkins
+ * -------------------------------------------------------------------------
+ * Copyright (c) 2011 Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ * ========================================================================= */
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include <wx/log.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <math.h>
+#include "texture-font.h"
+
+#undef __FTERRORS_H__
+#define FT_ERRORDEF( e, v, s )  { e, s },
+#define FT_ERROR_START_LIST     {
+#define FT_ERROR_END_LIST       { 0, 0 } };
+const struct {
+    int          code;
+    const char*  message;
+} FT_Errors[] =
+#include FT_ERRORS_H
+
+TextureFont::TextureFont(TextureAtlas * atlas,const wxString & filename, const float size)
+:m_atlas(atlas),m_filename(filename),m_size(size),m_gamma(1.5)
+{
+}
+
+TextureFont::~TextureFont()
+{
+    for (vector<TextureGlyph *>::iterator g=m_glyphs.begin();g!=m_glyphs.end();g++) {
+        delete *g;
+    }
+}
+
+void TextureFont::GenerateKerning()
+{
+    size_t i, j, k, count;
+    FT_Library   library;
+    FT_Face      face;
+    FT_UInt      glyph_index, prev_index;
+    TextureGlyph *glyph, *prev_glyph;
+    FT_Vector    kerning;
+
+    if (!LoadFace(&library, m_filename, m_size, &face)) {
+        return;
+    }
+
+    for( i=0; i<m_glyphs.size(); ++i ) {
+        glyph = m_glyphs[i];
+        if (glyph->m_kerning) {
+            free(glyph->m_kerning);
+            glyph->m_kerning = 0;
+            glyph->m_kerning_count = 0;
+        }
+
+        // Count how many kerning pairs we need
+        count = 0;
+        glyph_index = FT_Get_Char_Index(face, glyph->m_charcode);
+        for (j=0; j<m_glyphs.size(); ++j) {
+            prev_glyph = m_glyphs[i];
+            prev_index = FT_Get_Char_Index(face, prev_glyph->m_charcode);
+            FT_Get_Kerning(face, prev_index, glyph_index, FT_KERNING_UNSCALED, &kerning);
+            if (kerning.x != 0.0) {
+                count++;
+            }
+        }
+
+        // No kerning necessary
+        if (!count) {
+            continue;
+        }
+        // Store kerning pairs
+        glyph->m_kerning = (KerningPair *) malloc(count * sizeof(KerningPair));
+        glyph->m_kerning_count = count;
+        k = 0;
+        for (j=0; j<m_glyphs.size(); ++j) {
+            prev_glyph = m_glyphs[i];
+            prev_index = FT_Get_Char_Index(face, prev_glyph->m_charcode);
+            FT_Get_Kerning(face, prev_index, glyph_index, FT_KERNING_UNSCALED, &kerning);
+            if (kerning.x != 0.0) {
+                glyph->m_kerning[k].charcode = prev_glyph->m_charcode;
+                glyph->m_kerning[k].kerning = kerning.x / 64.0f;
+                ++k;
+            }
+        }
+    }
+
+    FT_Done_FreeType( library );
+}
+
+
+
+// -------------------------------------------------------------------------
+int TextureFont::CacheGlyphs(wchar_t * charcodes)
+{
+    size_t i, x, y, width, height;
+    FT_Library    library;
+    FT_Error      error;
+    FT_Face       face;
+    FT_GlyphSlot  slot;
+    FT_UInt       glyph_index;
+    TextureGlyph *glyph;
+    wxRect  region;
+    unsigned char c;
+    size_t        missed = 0;
+    width  = m_atlas->m_width;
+    height = m_atlas->m_height;
+
+    if (!LoadFace( &library, m_filename, m_size, &face)){
+        return wcslen(charcodes);
+    }
+
+    // Load each glyph
+    for (i=0; i<wcslen(charcodes); ++i) {
+        glyph_index = FT_Get_Char_Index(face, charcodes[i]);
+        error = FT_Load_Glyph( face, glyph_index, FT_LOAD_RENDER | FT_LOAD_TARGET_LIGHT );
+        if (error) {
+            wxLogError(wxString::Format(wxT("FT_Error (line%d, code 0x%02x) : "),__LINE__,FT_Errors[error].code)+wxString(FT_Errors[error].message,wxConvUTF8));
+            FT_Done_FreeType(library);
+            return wcslen(charcodes)-i;
+        }
+        slot = face->glyph;
+
+        // Gamma correction (sort of)
+        for( x=0; x<slot->bitmap.width; ++x ) {
+            for( y=0; y<slot->bitmap.rows; ++y ){
+                c = *(unsigned char *)(slot->bitmap.buffer + y*slot->bitmap.pitch + x );
+                c = (unsigned char) ( pow(c/255.0, m_gamma) * 255);
+                *(unsigned char *)(slot->bitmap.buffer + y*slot->bitmap.pitch + x ) = c;
+            }
+        }
+        region = m_atlas->GetRegion(slot->bitmap.width, slot->bitmap.rows);
+        if (region.x < 0) {
+            missed++;
+            continue;
+        }
+        m_atlas->SetRegion(region.x, region.y, slot->bitmap.width, slot->bitmap.rows, slot->bitmap.buffer, slot->bitmap.pitch );
+
+        glyph = new TextureGlyph();
+        glyph->m_charcode = charcodes[i];
+        glyph->m_kerning  = 0;
+        glyph->m_width    = slot->bitmap.width;
+        glyph->m_height   = slot->bitmap.rows;
+        glyph->m_offset_x = slot->bitmap_left;
+        glyph->m_offset_y = slot->bitmap_top;
+        glyph->m_u0       = region.x/(float)width;
+        glyph->m_v0       = region.y/(float)height;
+        glyph->m_u1       = (region.x + glyph->m_width)/(float)width;
+        glyph->m_v1       = (region.y + glyph->m_height)/(float)height;
+
+        // Discard hinting to get advance
+        FT_Load_Glyph(face, glyph_index, FT_LOAD_RENDER | FT_LOAD_NO_HINTING);
+        slot = face->glyph;
+        glyph->m_advance_x    = slot->advance.x/64.0;
+        glyph->m_advance_y    = slot->advance.y/64.0;
+
+        m_glyphs.push_back(glyph);
+    }
+    FT_Done_FreeType( library );
+    m_atlas->Upload();
+    GenerateKerning();
+    return missed;
+}
+
+// -------------------------------------------------------------------------
+TextureGlyph * TextureFont::GetGlyph(wchar_t charcode)
+{
+    size_t i;
+    static wchar_t *buffer = 0;
+    TextureGlyph *glyph;
+
+    assert(m_atlas);
+
+    // Check if charcode has been already loaded
+    for (i=0; i<m_glyphs.size(); ++i) {
+        glyph = m_glyphs[i];
+        if (glyph->m_charcode == charcode) {
+            return glyph;
+        }
+    }
+
+    // If not, load it
+    if (!buffer) {
+        buffer = (wchar_t *)calloc( 2, sizeof(wchar_t));
+    }
+    buffer[0] = charcode;
+
+    if (CacheGlyphs(buffer )==0) {
+        return *(m_glyphs.rbegin());
+    }
+    return NULL;
+}
+
+
+
+// -------------------------------------------------------------------------
+int TextureFont::LoadFace(FT_Library * library, const wxString & filename, const float size, FT_Face * face)
+{
+    size_t hres = 1;
+    FT_Error error;
+    FT_Matrix matrix = { (int)((1.0/hres) * 0x10000L),
+                         (int)((0.0)      * 0x10000L),
+                         (int)((0.0)      * 0x10000L),
+                         (int)((1.0)      * 0x10000L) };
+
+    // Initialize library
+    error = FT_Init_FreeType( library );
+    if (error)
+    {
+        wxLogError(wxString::Format(wxT("FT_Error (code 0x%02x) : "),FT_Errors[error].code)+wxString(FT_Errors[error].message,wxConvUTF8));
+        return 0;
+    }
+
+    // Load face
+    error = FT_New_Face( *library, filename.mb_str(), 0, face );
+    if (error) {
+        wxLogError(wxString::Format(wxT("FT_Error (line%d, code 0x%02x) : "),__LINE__,FT_Errors[error].code)+wxString(FT_Errors[error].message,wxConvUTF8));
+        FT_Done_FreeType(*library);
+        return 0;
+    }
+
+    // Select charmap
+    error = FT_Select_Charmap( *face, FT_ENCODING_UNICODE );
+    if (error) {
+        wxLogError(wxString::Format(wxT("FT_Error (line%d, code 0x%02x) : "),__LINE__,FT_Errors[error].code)+wxString(FT_Errors[error].message,wxConvUTF8));
+        FT_Done_FreeType( *library );
+        return 0;
+    }
+
+    // Set char size
+    error=FT_Set_Char_Size( *face, size*64, 0, 72*hres, 72 );
+    // error = FT_Set_Char_Size( *face, size*64, 0, 72, 72 );
+    if (error) {
+        wxLogError(wxString::Format(wxT("FT_Error (line%d, code 0x%02x) : "),__LINE__,FT_Errors[error].code)+wxString(FT_Errors[error].message,wxConvUTF8));
+        FT_Done_FreeType( *library );
+        return 0;
+    }
+
+    // Set transform matrix
+    FT_Set_Transform(*face, &matrix, NULL);
+
+    return 1;
+}
+

src/libs/freetype-gl/texture-font.h

@@ -0,0 +1,54 @@
+// ============================================================================
+// Freetype GL - An ansi C OpenGL Freetype engine
+// Platform:    Any
+// API version: 1.0
+// WWW:         http://www.loria.fr/~rougier/freetype-gl
+// C++ Conversion by Mark Watkins
+// ----------------------------------------------------------------------------
+// Copyright (c) 2011 Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the
+// Free Software Foundation, either version 3 of the License, or (at your
+// option) any later version.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
+// Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+// ============================================================================
+#ifndef __TEXTURE_FONT_H__
+#define __TEXTURE_FONT_H__
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include "vector.h"
+#include "texture-atlas.h"
+#include "texture-glyph.h"
+
+
+class TextureFont {
+public:
+    TextureFont(TextureAtlas *,const wxString & filename, const float size);
+    virtual ~TextureFont();
+
+    TextureGlyph * GetGlyph(wchar_t charcode);
+    int CacheGlyphs(wchar_t * charcodes);
+    int LoadFace(FT_Library *library, const wxString & filename, const float size, FT_Face * face);
+
+    void GenerateKerning();
+
+    vector <TextureGlyph *> m_glyphs;
+    TextureAtlas * m_atlas;
+    wxString       m_filename;
+    int            m_bold;
+    int            m_italic;
+    float          m_size;
+    float          m_gamma;
+};
+
+
+#endif /* __TEXTURE_FONT_H__ */
+

src/libs/freetype-gl/texture-glyph.cpp

@@ -0,0 +1,123 @@
+/* =========================================================================
+ * Freetype GL - A C OpenGL Freetype engine
+ * Platform:    Any
+ * API version: 1.0
+ * WWW:         http://code.google.com/p/freetype-gl/
+ * C++ Conversion by Mark Watkins
+ * -------------------------------------------------------------------------
+ * Copyright (c) 2011 Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ * ========================================================================= */
+#if defined(__APPLE__)
+    #include <Glut/glut.h>
+#else
+    #include <GL/glut.h>
+#endif
+#include <assert.h>
+#include <stdlib.h>
+#include "texture-glyph.h"
+
+
+
+TextureGlyph::TextureGlyph()
+:m_width(0),m_height(0),m_offset_x(0),m_offset_y(0),m_advance_x(0),m_advance_y(0)
+{
+    m_u0=m_v0=m_u1=m_v1 = 0.0;
+}
+
+TextureGlyph::~TextureGlyph()
+{
+}
+
+void TextureGlyph::Render(TextMarkup *markup, Pen *pen)
+{
+    int x  = pen->x + m_offset_x;
+    int y  = pen->y + m_offset_y + markup->rise;
+    int w  = m_width;
+    int h  = m_height;
+
+    float u0 = m_u0;
+    float v0 = m_v0;
+    float u1 = m_u1;
+    float v1 = m_v1;
+
+    glBegin( GL_TRIANGLES );
+    {
+        glTexCoord2f(u0, v0); glVertex2i(x, y);
+        glTexCoord2f(u0, v1); glVertex2i(x, y-h);
+        glTexCoord2f(u1, v1); glVertex2i(x+w, y-h);
+
+        glTexCoord2f(u0, v0); glVertex2i(x, y);
+        glTexCoord2f(u1, v1); glVertex2i(x+w, y-h);
+        glTexCoord2f(u1, v0); glVertex2i(x+w, y);
+    }
+    glEnd();
+
+    pen->x += m_advance_x + markup->spacing;
+    pen->y += m_advance_y;
+}
+
+
+void TextureGlyph::AddToVertexBuffer(VertexBuffer *buffer, const TextMarkup *markup, Pen *pen)
+{
+    size_t i;
+    int x0  = pen->x + m_offset_x;
+    int y0  = pen->y + m_offset_y + markup->rise;
+    int x1  = x0 + m_width;
+    int y1  = y0 - m_height;
+    float u0 = m_u0;
+    float v0 = m_v0;
+    float u1 = m_u1;
+    float v1 = m_v1;
+
+    GLuint index = buffer->vertices->size;
+    GLuint indices[] = {index, index+1, index+2,
+                        index, index+2, index+3};
+
+    TextureGlyphVertex vertices[] = { { x0,y0,0,  u0,v0,  0,0,0,1 },
+                                      { x0,y1,0,  u0,v1,  0,0,0,1 },
+                                      { x1,y1,0,  u1,v1,  0,0,0,1 },
+                                      { x1,y0,0,  u1,v0,  0,0,0,1 } };
+    if (markup) {
+        for (i=0; i<4; ++i) {
+            vertices[i].r = markup->foreground_color.Red()/256.0;
+            vertices[i].g = markup->foreground_color.Green()/256.0;
+            vertices[i].b = markup->foreground_color.Blue()/256.0;
+            vertices[i].a = markup->foreground_color.Alpha()/256.0;
+        }
+    }
+    buffer->PushBackIndices(indices, 6);
+    buffer->PushBackVertices(vertices, 4);
+
+    pen->x += m_advance_x + markup->spacing;
+    pen->y += m_advance_y;
+}
+
+float TextureGlyph::GetKerning(wchar_t charcode)
+{
+    size_t i;
+
+    if (!m_kerning ) {
+        return 0;
+    }
+
+    for (i=0; i<m_kerning_count; ++i)
+    {
+        if (m_kerning[i].charcode == charcode) {
+            return m_kerning[i].kerning;
+        }
+    }
+    return 0;
+}

src/libs/freetype-gl/texture-glyph.h

@@ -0,0 +1,64 @@
+/* =========================================================================
+ * Freetype GL - A C OpenGL Freetype engine
+ * Platform:    Any
+ * API version: 1.0
+ * WWW:         http://code.google.com/p/freetype-gl/
+ * C++ Conversion by Mark Watkins
+ * -------------------------------------------------------------------------
+ * Copyright (c) 2011 Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ * ========================================================================= */
+#ifndef __TEXTURE_GLYPH_H__
+#define __TEXTURE_GLYPH_H__
+
+#include <wchar.h>
+#include "text-markup.h"
+#include "vertex-buffer.h"
+
+typedef struct {
+    wchar_t   charcode;
+    float     kerning;
+} KerningPair;
+
+typedef struct {
+    float x,y;
+} Pen;
+
+typedef struct {
+    int x, y, z;
+    float u, v;
+    float r, g, b, a;
+} TextureGlyphVertex;
+
+
+class TextureGlyph {
+public:
+    TextureGlyph();
+    ~TextureGlyph();
+    void Render(TextMarkup * markup, Pen * pen );
+    void AddToVertexBuffer( VertexBuffer * buffer, const TextMarkup * markup, Pen * pen );
+    float GetKerning(wchar_t charcode);
+
+    wchar_t       m_charcode;
+    int           m_width, m_height;
+    int           m_offset_x, m_offset_y;
+    int           m_advance_x, m_advance_y;
+    float         m_u0, m_v0, m_u1, m_v1;
+    KerningPair * m_kerning;
+    size_t        m_kerning_count;
+};
+
+
+#endif /* __TEXTURE_GLYPH_H__ */

src/libs/freetype-gl/vector.cpp

@@ -0,0 +1,326 @@
+/* =========================================================================
+ * Freetype GL - A C OpenGL Freetype engine
+ * Platform:    Any
+ * API version: 1.0
+ * WWW:         http://code.google.com/p/freetype-gl/
+ * -------------------------------------------------------------------------
+ * Copyright (c) 2011 Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ * ========================================================================= */
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "freetype-gl/vector.h"
+
+Vector *
+vector_new( size_t item_size )
+{
+    assert( item_size );
+
+    Vector *self = (Vector *) malloc( sizeof(Vector) );
+    if( !self )
+    {
+        return NULL;
+    }
+    self->item_size = item_size;
+    self->size      = 0;
+    self->capacity  = 1;
+    self->items     = malloc( self->item_size * self->capacity );
+    return self;
+}
+
+
+
+void
+vector_delete( Vector *self )
+{
+    assert( self );
+    free( self->items );
+    free( self );
+}
+
+
+
+const void *
+vector_get( const Vector *self,
+            size_t index )
+{
+    assert( self );
+    assert( self->size );
+    assert( index  < self->size );
+    return self->items + index * self->item_size;
+}
+
+
+
+const void *
+vector_front( const Vector *self )
+{
+    assert( self );
+    assert( self->size );
+    return vector_get( self, 0 );
+}
+
+
+
+const void *
+vector_back( const Vector *self )
+{
+    assert( self );
+    assert( self->size );
+    return vector_get( self, self->size-1 );
+}
+
+
+
+int
+vector_contains( const Vector *self,
+                 const void *item,
+                 int (*cmp)(const void *, const void *) )
+{
+    size_t i;
+    assert( self );
+    for( i=0; i<self->size; ++i )
+    {
+        if( (*cmp)(item, vector_get(self,i) ) == 0 )
+        {
+            return 1;
+        }
+    }
+   return 0;
+}
+
+
+
+int
+vector_empty( const Vector *self )
+{
+    assert( self );
+    return self->size == 0;
+}
+
+
+
+size_t
+vector_size( const Vector *self )
+{
+    assert( self );
+    return self->size;
+}
+
+
+
+void
+vector_reserve( Vector *self,
+                const size_t size )
+{
+    assert( self );
+    if( self->capacity < size);
+    {
+        self->items = realloc( self->items, size * self->item_size );
+        self->capacity = size;
+    }
+}
+
+
+
+size_t
+vector_capacity( const Vector *self )
+{
+    assert( self );
+    return self->capacity;
+}
+
+
+
+void
+vector_shrink( Vector *self )
+{
+    assert( self );
+    if( self->capacity > self->size )
+    {
+        self->items = realloc( self->items, self->size * self->item_size );
+    }
+    self->capacity = self->size;
+}
+
+
+
+void
+vector_clear( Vector *self )
+{
+    assert( self );
+    self->size = 0;
+}
+
+
+void
+vector_set( Vector *self,
+            const size_t index,
+            const void *item )
+{
+    assert( self );
+    assert( self->size );
+    assert( index  < self->size );
+    memcpy( self->items + index * self->item_size,
+            item, self->item_size );
+}
+
+
+
+void
+vector_insert( Vector *self,
+               const size_t index,
+               const void *item )
+{
+    assert( self );
+    assert( index <= self->size);
+
+    if( self->capacity <= self->size )
+    {
+        vector_reserve(self, 2 * self->capacity );
+    }
+    if( index < self->size )
+    {
+        memmove( self->items + (index + 1) * self->item_size,
+                 self->items + (index + 0) * self->item_size,
+                 (self->size - index)  * self->item_size);
+    }
+    self->size++;
+    vector_set( self, index, item );
+}
+
+
+
+void
+vector_erase_range( Vector *self,
+                    const size_t first,
+                    const size_t last )
+{
+    assert( self );
+    assert( first < self->size );
+    assert( last  < self->size+1 );
+    assert( first < last );
+    memmove( self->items + first * self->item_size,
+             self->items + last  * self->item_size,
+             (self->size - last)   * self->item_size);
+    self->size -= (last-first);
+}
+
+
+
+void
+vector_erase( Vector *self,
+              const size_t index )
+{
+    assert( self );
+    assert( index < self->size );
+
+    vector_erase_range( self, index, index+1 );
+}
+
+
+
+void
+vector_push_back( Vector *self,
+                  const void *item )
+{
+    vector_insert( self, self->size, item );
+}
+
+
+
+void
+vector_pop_back( Vector *self )
+{
+    assert( self );
+    assert( self->size );
+    self->size--;
+}
+
+
+
+void
+vector_resize( Vector *self,
+               const size_t size )
+{
+    assert( self );
+    if( size > self->capacity)
+    {
+        vector_reserve( self, size );
+        self->size = self->capacity;
+    }
+    else
+    {
+        self->size = size;
+    }
+}
+
+
+
+void
+vector_push_back_data( Vector *self,
+                       const void * data,
+                       const size_t count )
+{
+    assert( self );
+    assert( data );
+    assert( count );
+
+    if( self->capacity < (self->size+count) )
+    {
+        vector_reserve(self, self->size+count);
+    }
+    memmove( self->items + self->size * self->item_size, data,
+             count*self->item_size );
+    self->size += count;
+}
+
+
+
+void
+vector_insert_data( Vector *self,
+                    const size_t index,
+                    const void * data,
+                    const size_t count )
+{
+    assert( self );
+    assert( index < self->size );
+    assert( data );
+    assert( count );
+
+    if( self->capacity < (self->size+count) )
+    {
+        vector_reserve(self, self->size+count);
+    }
+    memmove( self->items + (index + count ) * self->item_size,
+             self->items + (index ) * self->item_size,
+             count*self->item_size );
+    memmove( self->items + index * self->item_size, data,
+             count*self->item_size );
+    self->size += count;
+}
+
+
+
+void
+vector_sort( Vector *self,
+             int (*cmp)(const void *, const void *) )
+{
+    assert( self );
+    assert( self->size );
+    qsort(self->items, self->size, self->item_size, cmp);
+}

src/libs/freetype-gl/vector.h

@@ -0,0 +1,273 @@
+/* =========================================================================
+ * Freetype GL - A C OpenGL Freetype engine
+ * Platform:    Any
+ * API version: 1.0
+ * WWW:         http://code.google.com/p/freetype-gl/
+ * -------------------------------------------------------------------------
+ * Copyright (c) 2011 Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+ * 
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ * =========================================================================
+
+   ========================================================================= */
+#ifndef __VECTOR_H__
+#define __VECTOR_H__
+
+
+
+/**
+ *  Generic vector structure.
+ */
+typedef struct
+ {
+     /** Pointer to dynamically allocated items. */
+     void * items;
+
+     /** Number of items that can be held in currently allocated storage. */
+     size_t capacity;
+
+     /** Number of items. */
+     size_t size;
+
+     /** Size (in bytes) of a single item. */
+     size_t item_size;
+} Vector;
+
+/**
+ *  Creates a vector.
+ *
+ *  @param  item_size    item size in bytes
+ *  @return              a new empty vector
+ */
+  Vector *
+  vector_new( size_t item_size );
+
+/**
+ *  Deletes a vector.
+ *
+ *  @param  self a vector structure
+ */
+  void
+  vector_delete( Vector *self );
+
+/**
+ *  Returns a pointer to the item located at specified index.
+ *
+ *  @param  self  a vector structure
+ *  @param  index the index of the item to be returned
+ *  @return       pointer on the specified item
+ */
+  const void *
+  vector_get( const Vector *self,
+              size_t index );
+
+/**
+ *  Returns a pointer to the first item.
+ *
+ *  @param  self  a vector structure
+ *  @return       pointer on the first item
+ */
+  const void *
+  vector_front( const Vector *self );
+
+/**
+ *  Returns a pointer to the last item
+ *
+ *  @param  self  a vector structure
+ *  @return pointer on the last item
+ */
+  const void *
+  vector_back( const Vector *self );
+
+/**
+ *  Check if an item is contained within the vector.
+ *
+ *  @param  self  a vector structure
+ *  @param  item  item to be searched in the vector
+ *  @param  cmp   a pointer a comparison function
+ *  @return       1 if item is contained within the vector, 0 otherwise
+ */
+  int
+  vector_contains( const Vector *self,
+                   const void *item,
+                   int (*cmp)(const void *, const void *) );
+
+/**
+ *  Checks whether the vector is empty.
+ *
+ *  @param  self  a vector structure
+ *  @return       1 if the vector is empty, 0 otherwise
+ */
+  int
+  vector_empty( const Vector *self );
+
+/**
+ *  Returns the number of items
+ *
+ *  @param  self  a vector structure
+ *  @return       number of items
+ */
+  size_t
+  vector_size( const Vector *self );
+
+/**
+ *  Reserve storage such that it can hold at last size items.
+ *
+ *  @param  self  a vector structure
+ *  @param  size  the new storage capacity
+ */
+  void
+  vector_reserve( Vector *self,
+                  const size_t size );
+
+/**
+ *  Returns current storage capacity
+ *
+ *  @param  self  a vector structure
+ *  @return       storage capacity
+ */
+  size_t
+  vector_capacity( const Vector *self );
+
+/**
+ *  Decrease capacity to fit actual size.
+ *
+ *  @param  self  a vector structure
+ */
+  void
+  vector_shrink( Vector *self );
+
+/**
+ *  Removes all items.
+ *
+ *  @param  self  a vector structure
+ */
+  void
+  vector_clear( Vector *self );
+
+/**
+ *  Replace an item.
+ *
+ *  @param  self  a vector structure
+ *  @param  index the index of the item to be replaced
+ *  @param  item  the new item
+ */
+  void
+  vector_set( Vector *self,
+              const size_t index,
+              const void *item );
+
+/**
+ *  Erase an item.
+ *
+ *  @param  self  a vector structure
+ *  @param  index the index of the item to be erased
+ */
+  void
+  vector_erase( Vector *self,
+                const size_t index );
+
+/**
+ *  Erase a range of items.
+ *
+ *  @param  self  a vector structure
+ *  @param  first the index of the first item to be erased
+ *  @param  last  the index of the last item to be erased
+ */
+  void
+  vector_erase_range( Vector *self,
+                      const size_t first,
+                      const size_t last );
+
+/**
+ *  Appends given item to the end of the vector.
+ *
+ *  @param  self a vector structure
+ *  @param  item the item to be inserted
+ */
+  void
+  vector_push_back( Vector *self,
+                    const void *item );
+
+/**
+ *  Removes the last item of the vector.
+ *
+ *  @param  self a vector structure
+ */
+  void
+  vector_pop_back( Vector *self );
+
+/**
+ *  Resizes the vector to contain size items
+ *
+ *  If the current size is less than size, additional items are appended and
+ *  initialized with value. If the current size is greater than size, the
+ *  vector is reduced to its first size elements.
+ *
+ *  @param  self a vector structure
+ *  @param  size the new size
+ */
+  void
+  vector_resize( Vector *self,
+                 const size_t size );
+
+/**
+ *  Insert a single item at specified index.
+ *
+ *  @param  self  a vector structure
+ *  @param  index location before which to insert item
+ *  @param  item  the item to be inserted
+ */
+  void
+  vector_insert( Vector *self,
+                 const size_t index,
+                 const void *item );
+
+/**
+ *  Insert raw data at specified index.
+ *
+ *  @param  self  a vector structure
+ *  @param  index location before which to insert item
+ *  @param  data  a pointer to the items to be inserted
+ *  @param  count the number of items to be inserted
+ */
+  void
+  vector_insert_data( Vector *self,
+                      const size_t index,
+                      const void * data,
+                      const size_t count );
+
+/**
+ *  Append raw data to the end of the vector.
+ *
+ *  @param  self  a vector structure
+ *  @param  data  a pointer to the items to be inserted
+ *  @param  count the number of items to be inserted
+ */
+  void
+  vector_push_back_data( Vector *self,
+                         const void * data, 
+                         const size_t count );
+
+/**
+ *  Sort vector items according to cmp function.
+ *
+ *  @param  self  a vector structure
+ *  @param  cmp   a pointer a comparison function
+ */
+  void
+  vector_sort( Vector *self,
+               int (*cmp)(const void *, const void *) );
+
+#endif /* __VECTOR_H__ */

src/libs/freetype-gl/vertex-buffer.cpp

@@ -0,0 +1,417 @@
+/* =========================================================================
+ * Freetype GL - A C OpenGL Freetype engine
+ * Platform:    Any
+ * API version: 1.0
+ * WWW:         http://code.google.com/p/freetype-gl/
+ * C++ Conversion by Mark Watkins
+ * -------------------------------------------------------------------------
+ * Copyright (c) 2011 Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ * ========================================================================= */
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "vertex-buffer.h"
+#include <GL/gl.h>
+#include <GL/glext.h>
+
+
+VertexBuffer::VertexBuffer(char *_format )
+{
+    __init(_format);
+}
+void VertexBuffer::__init(char *_format)
+{
+    size_t i, index = 0;
+    int stride = 0;
+    GLvoid *pointer = 0;
+
+    format = strdup(_format);
+    char *p = format-1;
+
+    for (i=0; i<MAX_VERTEX_ATTRIBUTE; ++i) {
+        attributes[i] = 0;
+    }
+
+    while (p && (index < MAX_VERTEX_ATTRIBUTE)) {
+        p++;
+        VertexAttribute *attribute = VertexAttribute::Parse(p);
+        p = (char *)(strchr(p, ':'));
+        attribute->m_pointer = pointer;
+        stride += attribute->m_size*GL_TYPE_SIZE(attribute->m_type);
+        pointer+= attribute->m_size*GL_TYPE_SIZE(attribute->m_type);
+        attributes[index] = attribute;
+        index++;
+    }
+
+    for (i=0; i<index; ++i) {
+        attributes[i]->m_stride=stride;
+    }
+
+    vertices = vector_new( stride );
+    vertices_id  = 0;
+
+    indices = vector_new(sizeof(GLuint));
+    indices_id  = 0;
+    dirty = true;
+}
+
+VertexBuffer::VertexBuffer(char * format, size_t vcount, void *_vertices, size_t icount, GLuint *_indices)
+{
+    vector_resize(vertices, vcount );
+    assert(vertices->size == vcount);
+    memcpy(vertices->items, _vertices, vcount * vertices->item_size );
+
+    vector_resize(indices, icount );
+    assert(indices->size == icount);
+    memcpy(indices->items, _indices, icount * indices->item_size );
+
+    dirty = true;
+}
+
+VertexBuffer::~VertexBuffer()
+{
+    vector_delete(vertices);
+    vertices = 0;
+    if (vertices_id ) {
+        glDeleteBuffers( 1, &vertices_id );
+    }
+    vertices_id = 0;
+
+    vector_delete(indices);
+    indices = 0;
+    if (indices_id) {
+        glDeleteBuffers( 1, &vertices_id );
+    }
+    indices_id = 0;
+    if (format) {
+        free(format);
+    }
+    format = 0;
+    dirty = false;
+}
+
+
+void VertexBuffer::Upload()
+{
+    if (!vertices_id) {
+        glGenBuffers(1, &vertices_id);
+    }
+    if (!indices_id) {
+        glGenBuffers(1, &indices_id );
+    }
+    glBindBuffer(GL_ARRAY_BUFFER, vertices_id);
+    glBufferData(GL_ARRAY_BUFFER,
+                 vertices->size * vertices->item_size,
+                 vertices->items, GL_DYNAMIC_DRAW);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices_id);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER,
+                 indices->size * indices->item_size,
+                indices->items, GL_DYNAMIC_DRAW);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+}
+
+
+void VertexBuffer::Clear()
+{
+    vector_clear(indices);
+    vector_clear(vertices);
+    dirty = true;
+}
+
+void VertexBuffer::Render(GLenum mode, char *what)
+{
+    int i,j;
+
+    if (!vertices->size) {
+        return;
+    }
+
+    if (dirty) {
+        Upload();
+        dirty=false;
+    }
+
+    glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
+    glBindBuffer(GL_ARRAY_BUFFER, vertices_id);
+    for (i=0; i<strlen(what); ++i) {
+        char ctarget = what[i];
+        GLuint target = GL_VERTEX_ATTRIBUTE_TARGET(ctarget);
+        for (j=0; j<MAX_VERTEX_ATTRIBUTE; ++j) {
+            VertexAttribute *attribute = attributes[j];
+            if (attribute == 0) {
+                break;
+            } else if (attribute->m_target == target) {
+                (*(attribute->enable))(attribute);
+                break;
+            }
+        }
+    }
+    if (indices->size) {
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices_id);
+        glDrawElements(mode, indices->size, GL_UNSIGNED_INT, 0);
+    } else {
+        glDrawArrays(mode, 0, vertices->size);
+    }
+
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    glPopClientAttrib();
+}
+
+void VertexBuffer::PushBackIndex(GLuint index)
+{
+    dirty = true;
+    vector_push_back(indices, &index);
+}
+
+void VertexBuffer::PushBackVertex (void *vertex)
+{
+    dirty = true;
+    vector_push_back(vertices, vertex);
+}
+
+void VertexBuffer::PushBackIndices(GLuint *_indices, size_t count)
+{
+    dirty = true;
+    vector_push_back_data(indices, _indices, count );
+}
+
+void VertexBuffer::PushBackVertices(void *_vertices,size_t count)
+{
+    dirty = true;
+    vector_push_back_data(vertices, _vertices, count);
+}
+
+void VertexBuffer::InsertIndices(size_t index, GLuint *_indices, size_t count)
+{
+    dirty = true;
+    vector_insert_data( indices, index, _indices, count);
+}
+
+void VertexBuffer::InsertVertices(size_t index, void *_vertices, size_t count)
+{
+    size_t i;
+
+    assert(vertices);
+    assert(index < vertices->size+1 );
+
+    dirty = true;
+    for (i=0; i<indices->size-index; ++i) {
+        if( *(GLuint *)(vector_get(indices, i )) > index ) {
+            *(GLuint *)(vector_get(indices, i )) += index;
+        }
+    }
+    vector_insert_data(vertices, index, _vertices, count);
+}
+
+// These are callbacks.
+void VertexAttributePositionEnable(VertexAttribute *attr)
+{
+    glEnableClientState(attr->m_target);
+    glVertexPointer(attr->m_size, attr->m_type, attr->m_stride, attr->m_pointer);
+}
+
+void VertexAttributeNormalEnable(VertexAttribute *attr)
+{
+    glEnableClientState(attr->m_target);
+    glNormalPointer(attr->m_type, attr->m_stride, attr->m_pointer);
+}
+
+void VertexAttributeColorEnable(VertexAttribute *attr)
+{
+    glEnableClientState(attr->m_target);
+    glColorPointer(attr->m_size, attr->m_type, attr->m_stride, attr->m_pointer);
+}
+
+
+void VertexAttributeTexCoordEnable(VertexAttribute *attr)
+{
+    glEnableClientState(attr->m_target);
+    glTexCoordPointer(attr->m_size, attr->m_type, attr->m_stride, attr->m_pointer);
+}
+
+void VertexAttributeFogCoordEnable(VertexAttribute *attr)
+{
+    glEnableClientState(attr->m_target );
+    glFogCoordPointer(attr->m_type, attr->m_stride, attr->m_pointer);
+}
+
+void VertexAttributeEdgeFlagEnable(VertexAttribute *attr)
+{
+    glEnableClientState(attr->m_target);
+    glEdgeFlagPointer(attr->m_stride, attr->m_pointer);
+}
+
+void VertexAttributeSecondaryColorEnable(VertexAttribute *attr)
+{
+    glEnableClientState(attr->m_target);
+    glSecondaryColorPointer(attr->m_size, attr->m_type, attr->m_stride, attr->m_pointer);
+}
+
+VertexAttribute *VertexAttribute::Parse(char *format)
+{
+    char *p = strpbrk ( format, "vcntfse" );
+    if (p != 0) {
+        int size;
+        char ctarget, ctype;
+        sscanf( p, "%c%d%c", &ctarget, &size, &ctype );
+        GLenum type = GL_TYPE( ctype );
+        GLenum target = GL_VERTEX_ATTRIBUTE_TARGET( ctarget );
+        return new VertexAttribute(target, size, type, 0, 0);
+    } else {
+    }
+    return NULL;
+}
+
+
+
+VertexAttribute::VertexAttribute(GLenum target,GLint size,GLenum type,GLsizei stride,GLvoid *pointer)
+{
+    switch(target ) {
+    case GL_VERTEX_ARRAY:
+        assert( size > 1 );
+        enable = (void(*)(void *)) VertexAttributePositionEnable;
+        break;
+
+    case GL_NORMAL_ARRAY:
+        assert (size == 3);
+        assert( (type == GL_BYTE) || (type == GL_SHORT) ||
+                (type == GL_INT)  || (type == GL_FLOAT) ||
+                (type == GL_DOUBLE) );
+        enable = (void(*)(void *)) VertexAttributeNormalEnable;
+        break;
+
+    case GL_COLOR_ARRAY:
+        assert( (size == 3) || (size == 4) );
+        assert( (type == GL_BYTE)  || (type == GL_UNSIGNED_BYTE)  ||
+                (type == GL_SHORT) || (type == GL_UNSIGNED_SHORT) ||
+                (type == GL_INT)   || (type == GL_UNSIGNED_INT)   ||
+                (type == GL_FLOAT) || (type == GL_DOUBLE) );
+        enable = (void(*)(void *)) VertexAttributeColorEnable;
+        break;
+
+    case GL_TEXTURE_COORD_ARRAY:
+        assert( (type == GL_SHORT) || (type == GL_INT) ||
+                (type == GL_FLOAT) || (type == GL_DOUBLE) );
+        enable = (void(*)(void *)) VertexAttributeTexCoordEnable;
+        break;
+
+    case GL_FOG_COORD_ARRAY:
+        assert( size == 2 );
+        assert( (type == GL_FLOAT) || (type == GL_DOUBLE) );
+        enable = (void(*)(void *)) VertexAttributeFogCoordEnable;
+        break;
+
+    case GL_EDGE_FLAG_ARRAY:
+        assert( size == 1 );
+        assert( type == GL_BOOL );
+        enable = (void(*)(void *)) VertexAttributeEdgeFlagEnable;
+        break;
+
+    case GL_SECONDARY_COLOR_ARRAY:
+        assert( size == 3 );
+        assert( (type == GL_BYTE)  || (type == GL_UNSIGNED_BYTE)  ||
+                (type == GL_SHORT) || (type == GL_UNSIGNED_SHORT) ||
+                (type == GL_INT)   ||  (type == GL_UNSIGNED_INT)  ||
+                (type == GL_FLOAT) || (type == GL_DOUBLE) );
+        enable = (void(*)(void *)) VertexAttributeSecondaryColorEnable;
+        break;
+
+    default:
+        enable = 0;
+        break;
+    }
+
+    m_target  = target;
+    m_size    = size;
+    m_type    = type;
+    m_stride  = stride;
+    m_pointer = pointer;
+}
+
+
+GLenum GL_TYPE(char ctype)
+{
+    switch( ctype )
+    {
+    case 'b': return GL_BYTE;
+    case 'B': return GL_UNSIGNED_BYTE;
+    case 's': return GL_SHORT;
+    case 'S': return GL_UNSIGNED_SHORT;
+    case 'i': return GL_INT;
+    case 'I': return GL_UNSIGNED_INT;
+    case 'f': return GL_FLOAT;
+    case 'd': return GL_DOUBLE;
+    default:  return 0;
+    }
+}
+
+
+
+GLenum GL_VERTEX_ATTRIBUTE_TARGET(char ctarget)
+{
+    switch(ctarget)
+    {
+    case 'v': return GL_VERTEX_ARRAY;
+    case 'n': return GL_NORMAL_ARRAY;
+    case 'c': return GL_COLOR_ARRAY;
+    case 't': return GL_TEXTURE_COORD_ARRAY;
+    case 'f': return GL_FOG_COORD_ARRAY;
+    case 's': return GL_SECONDARY_COLOR_ARRAY;
+    case 'e': return GL_EDGE_FLAG_ARRAY;
+    default:  return 0;
+    }
+}
+
+
+
+GLuint GL_TYPE_SIZE(GLenum gtype)
+{
+    switch(gtype)
+    {
+    case GL_BOOL:           return sizeof(GLboolean);
+    case GL_BYTE:           return sizeof(GLbyte);
+    case GL_UNSIGNED_BYTE:  return sizeof(GLubyte);
+    case GL_SHORT:          return sizeof(GLshort);
+    case GL_UNSIGNED_SHORT: return sizeof(GLushort);
+    case GL_INT:            return sizeof(GLint);
+    case GL_UNSIGNED_INT:   return sizeof(GLuint);
+    case GL_FLOAT:          return sizeof(GLfloat);
+    case GL_DOUBLE:         return sizeof(GLdouble);
+    default:                return 0;
+    }
+}
+
+
+
+char * GL_TYPE_STRING(GLenum gtype)
+{
+    switch(gtype)
+    {
+    case GL_BOOL:           return "GL_BOOL";
+    case GL_BYTE:           return "GL_BYTE";
+    case GL_UNSIGNED_BYTE:  return "GL_UNSIGNED_BYTE";
+    case GL_SHORT:          return "GL_SHORT";
+    case GL_UNSIGNED_SHORT: return "GL_UNSIGNED_SHORT";
+    case GL_INT:            return "GL_INT";
+    case GL_UNSIGNED_INT:   return "GL_UNSIGNED_INT";
+    case GL_FLOAT:          return "GL_FLOAT";
+    case GL_DOUBLE:         return "GL_DOUBLE";
+    default:                return "GL_VOID";
+    }
+}

src/libs/freetype-gl/vertex-buffer.h

@@ -0,0 +1,99 @@
+/* =========================================================================
+ * Freetype GL - A C OpenGL Freetype engine
+ * Platform:    Any
+ * API version: 1.0
+ * WWW:         http://code.google.com/p/freetype-gl/
+ * C++ Conversion by Mark Watkins
+ * -------------------------------------------------------------------------
+ * Copyright (c) 2011 Nicolas P. Rougier <Nicolas.Rougier@inria.fr>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ * =========================================================================
+
+   ========================================================================= */
+#ifndef __VERTEX_BUFFER_H__
+#define __VERTEX_BUFFER_H__
+
+#define GL_GLEXT_PROTOTYPES 1
+
+#if defined(__APPLE__)
+    #include <Glut/glut.h>
+#else
+    #include <GL/glut.h>
+#endif
+
+#include "freetype-gl/vector.h"  // grrr.. nasty c programmers.. go learn a real OOPL.
+
+#define MAX_VERTEX_ATTRIBUTE 8
+
+class VertexAttribute;
+
+//Generic vertex buffer.
+class VertexBuffer
+{
+public:
+    VertexBuffer(char * format);
+    VertexBuffer(char * format, size_t vcount, void *vertices, size_t icount, GLuint * indices);
+    ~VertexBuffer();
+
+    void Draw(const char * format, const GLenum mode, const void * vertices, const size_t count );
+    void DrawIndexed(const char * format, const GLenum mode, const void * vertices, const size_t vcount, const GLuint * indices, const size_t icount);
+    void Render(GLenum mode, char * what);
+    void Upload();
+    void Clear();
+    void PushBackIndex(GLuint index );
+    void PushBackVertex(void *vertex);
+    void PushBackIndices (GLuint *indices, size_t count);
+    void PushBackVertices(void *vertices, size_t count );
+    void InsertIndices (size_t index, GLuint *indices, size_t count);
+    void InsertVertices(size_t index, void *_vertices, size_t count);
+
+    void AddVertices(size_t index, void *vertices, size_t count);
+
+    char * format;      // Format of the vertex buffer.
+    Vector * vertices;  // Vector of vertices.
+    GLuint vertices_id; // GL idendity of the vertices buffer.
+    Vector * indices;   // Vector of indices.
+    GLuint indices_id;  // GL idendity of the indices buffer.
+    bool dirty;         // Whether the vertex buffer needs to be uploaded to GPU memory.
+
+    VertexAttribute *attributes[MAX_VERTEX_ATTRIBUTE]; // Array of attributes.
+
+protected:
+    void __init(char *format);
+};
+
+// Generic vertex attribute.
+class VertexAttribute
+{
+public:
+    VertexAttribute( GLenum target, GLint size, GLenum type, GLsizei stride, GLvoid *pointer );
+    static VertexAttribute *Parse(char *format);
+
+    GLenum m_target;      // a client-side capability.
+    GLint m_size;         // Number of component.
+    GLenum m_type;        // Data type.
+    GLsizei m_stride;     // Byte offset between consecutive attributes.
+    GLvoid * m_pointer;   // Pointer to the first component of the first attribute element in the array.
+    void (* enable)(void *); // Pointer to the function that enable this attribute.
+};
+
+
+GLenum GL_TYPE(char ctype);
+GLenum GL_VERTEX_ATTRIBUTE_TARGET(char ctarget);
+GLuint GL_TYPE_SIZE(GLenum gtype);
+char * GL_TYPE_STRING(GLenum gtype);
+
+
+#endif /* __VERTEX_BUFFER_H__ */

src/version.h

@@ -4,7 +4,7 @@
 namespace AutoVersion{
 	
 	//Date Version Types
-	static const char DATE[] = "12";
+	static const char DATE[] = "14";
 	static const char MONTH[] = "06";
 	static const char YEAR[] = "2011";
 	static const char UBUNTU_VERSION_STYLE[] = "11.06";
@@ -16,14 +16,14 @@ namespace AutoVersion{
 	//Standard Version Type
 	static const long MAJOR = 0;
 	static const long MINOR = 7;
-	static const long BUILD = 5214;
+	static const long BUILD = 5544;
-	static const long REVISION = 11765;
+	static const long REVISION = 13556;
 	
 	//Miscellaneous Version Types
-	static const long BUILDS_COUNT = 4917;
+	static const long BUILDS_COUNT = 5634;
-	#define RC_FILEVERSION 0,7,5214,11765
+	#define RC_FILEVERSION 0,7,5544,13556
-	#define RC_FILEVERSION_STRING "0, 7, 5214, 11765\0"
+	#define RC_FILEVERSION_STRING "0, 7, 5544, 13556\0"
-	static const char FULLVERSION_STRING[] = "0.7.5214.11765";
+	static const char FULLVERSION_STRING[] = "0.7.5544.13556";
 	
 	//These values are to keep track of your versioning state, don't modify them.
 	static const long BUILD_HISTORY = 0;