chris/OSCAR-code
1
0
Fork 0
mirror of https://gitlab.com/pholy/OSCAR-code.git synced 2025-04-05 18:50:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Mark Watkins 2011-06-14 05:37:25 +10:00
parent ba7dc8c5fb
commit d1c0a99683
22 changed files with 3115 additions and 672 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
Projects/CodeBlocks/SleepyHead.cbp
View File

@ -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" />

743
Projects/CodeBlocks/SleepyHead.depend
View File

File diff suppressed because it is too large Load Diff

54
Projects/CodeBlocks/SleepyHead.layout
View File

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_layout_file>
<ActiveTarget name="Debug" />
<File name="../../src/GUIFrame.cpp" open="1" top="0" tabpos="11">
<ActiveTarget name="Debug-wx29" />
<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">
<Cursor position="601" topLine="1" />
<File name="../../src/libs/sleeplib/profiles.cpp" open="0" top="0" tabpos="9">
<Cursor position="2827" topLine="38" />
</File>
<File name="../../src/libs/sleeplib/profiles.h" open="0" top="0" tabpos="13">
<Cursor position="757" topLine="15" />

3
src/SleepyHeadMain.cpp
View File

@ -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");

620
src/graphs/graph.cpp
View File

File diff suppressed because it is too large Load Diff

32
src/graphs/graph.h
View File

@ -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;

39
src/libs/freetype-gl/README Normal file
View File

@ -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

166
src/libs/freetype-gl/font-manager.cpp Normal file
View File

@ -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);
}

50
src/libs/freetype-gl/font-manager.h Normal file
View File

@ -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__ */

56
src/libs/freetype-gl/text-markup.cpp Normal file
View File

@ -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()
{
}

85
src/libs/freetype-gl/text-markup.h Normal file
View File

@ -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__ */

217
src/libs/freetype-gl/texture-atlas.cpp Normal file
View File

@ -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;
}

66
src/libs/freetype-gl/texture-atlas.h Normal file
View File

@ -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__ */

264
src/libs/freetype-gl/texture-font.cpp Normal file
View File

@ -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;
}

54
src/libs/freetype-gl/texture-font.h Normal file
View File

@ -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__ */

123
src/libs/freetype-gl/texture-glyph.cpp Normal file
View File

@ -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;
}

64
src/libs/freetype-gl/texture-glyph.h Normal file
View File

@ -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__ */

326
src/libs/freetype-gl/vector.cpp Normal file
View File

@ -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);
}

273
src/libs/freetype-gl/vector.h Normal file
View File

@ -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__ */

417
src/libs/freetype-gl/vertex-buffer.cpp Normal file
View File

@ -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";
}
}

99
src/libs/freetype-gl/vertex-buffer.h Normal file
View File

@ -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__ */

14
src/version.h
View File

@ -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 REVISION = 11765;
static const long BUILD = 5544;
static const long REVISION = 13556;
//Miscellaneous Version Types
static const long BUILDS_COUNT = 4917;
#define RC_FILEVERSION 0,7,5214,11765
#define RC_FILEVERSION_STRING "0, 7, 5214, 11765\0"
static const char FULLVERSION_STRING[] = "0.7.5214.11765";
static const long BUILDS_COUNT = 5634;
#define RC_FILEVERSION 0,7,5544,13556
#define RC_FILEVERSION_STRING "0, 7, 5544, 13556\0"
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;